Files
openshell_controller/scripts/inter-sandbox-chat-sidecar.mjs

465 lines
15 KiB
JavaScript

#!/usr/bin/env node
import { spawn } from "node:child_process"
import { readFile } from "node:fs/promises"
import { fileURLToPath } from "node:url"
import os from "node:os"
import path from "node:path"
import {
ackChatMessage,
claimOperatorMessages,
claimTargetedMessages,
cleanText,
listRooms,
postChatMessage,
recordChatMessageReceipt,
} from "./inter-sandbox-chat-core.mjs"
const STATE_DIR = process.env.NEMOCLAW_DASHBOARD_STATE_DIR || path.join(os.homedir(), ".nemoclaw-dashboard")
const MCP_SERVER_STORE_PATH = path.join(STATE_DIR, "mcp-servers.json")
const MCP_BROKER_SESSIONS_PATH = path.join(STATE_DIR, "mcp-broker-sessions.json")
const DEFAULT_OPENCLAW_DISPATCH_SCRIPT = fileURLToPath(new URL("./inter-sandbox-chat-openclaw-dispatch.mjs", import.meta.url))
const CHAT_SERVER_ID = "inter-sandbox-chat"
const SIDECAR_AGENT_PREFIX = "inter-sandbox-chat-sidecar"
const MAX_DISPATCH_OUTPUT_BYTES = 64 * 1024
function parsePositiveInt(value, fallback, max = Number.MAX_SAFE_INTEGER) {
const parsed = Number.parseInt(String(value || ""), 10)
if (!Number.isFinite(parsed) || parsed < 1) return fallback
return Math.min(parsed, max)
}
function parseBoolean(value, fallback = false) {
if (typeof value !== "string") return fallback
const normalized = value.trim().toLowerCase()
if (!normalized) return fallback
if (["1", "true", "yes", "on"].includes(normalized)) return true
if (["0", "false", "no", "off"].includes(normalized)) return false
return fallback
}
function parseDispatchArgs() {
const raw = process.env.INTER_SANDBOX_CHAT_DISPATCH_ARGS_JSON?.trim()
if (!raw) return []
try {
const parsed = JSON.parse(raw)
if (!Array.isArray(parsed)) return []
return parsed.map((entry) => String(entry))
} catch {
return []
}
}
const POLL_MS = parsePositiveInt(process.env.INTER_SANDBOX_CHAT_SIDECAR_POLL_MS, 5000)
const CLAIM_LIMIT = parsePositiveInt(process.env.INTER_SANDBOX_CHAT_SIDECAR_LIMIT, 5, 50)
const DISPATCH_TIMEOUT_MS = parsePositiveInt(process.env.INTER_SANDBOX_CHAT_DISPATCH_TIMEOUT_MS, 120000)
const CUSTOM_DISPATCH_COMMAND = cleanText(process.env.INTER_SANDBOX_CHAT_DISPATCH_COMMAND)
const DISPATCH_COMMAND = CUSTOM_DISPATCH_COMMAND || process.execPath
const DISPATCH_ARGS = CUSTOM_DISPATCH_COMMAND ? parseDispatchArgs() : [DEFAULT_OPENCLAW_DISPATCH_SCRIPT]
const DISPATCH_KIND = CUSTOM_DISPATCH_COMMAND ? "custom-command" : "openclaw-chat"
const POST_REPLIES = parseBoolean(process.env.INTER_SANDBOX_CHAT_SIDECAR_POST_REPLIES, true)
const PROCESS_BROADCAST = parseBoolean(process.env.INTER_SANDBOX_CHAT_SIDECAR_PROCESS_BROADCAST, false)
const RELAY_SANDBOX_MESSAGES = parseBoolean(process.env.INTER_SANDBOX_CHAT_SIDECAR_RELAY_SANDBOX_MESSAGES, true)
const SANDBOX_RELAY_LATEST_ONLY = parseBoolean(process.env.INTER_SANDBOX_CHAT_SIDECAR_SANDBOX_LATEST_ONLY, true)
let stopping = false
let timer = null
let lastIdleKey = ""
const activeDispatches = new Set()
function nowIso() {
return new Date().toISOString()
}
function log(event, fields = {}) {
const payload = Object.entries(fields)
.filter(([, value]) => value !== undefined && value !== null && value !== "")
.map(([key, value]) => `${key}=${JSON.stringify(value)}`)
.join(" ")
console.log(`[inter-sandbox-chat-sidecar] ts=${nowIso()} event=${event}${payload ? ` ${payload}` : ""}`)
}
function logIdle(key, event, fields = {}) {
if (lastIdleKey === key) return
lastIdleKey = key
log(event, fields)
}
function clearIdle() {
lastIdleKey = ""
}
async function readJson(pathname, fallback) {
try {
const parsed = JSON.parse(await readFile(pathname, "utf8"))
return parsed && typeof parsed === "object" ? parsed : fallback
} catch {
return fallback
}
}
function normalizeStringArray(value) {
if (!Array.isArray(value)) return []
return Array.from(new Set(value.map((entry) => cleanText(entry)).filter(Boolean)))
}
async function readChatPolicy() {
const store = await readJson(MCP_SERVER_STORE_PATH, { servers: {} })
const server = store.servers?.[CHAT_SERVER_ID]
if (!server || typeof server !== "object") {
return { active: false, reason: "not-installed", accessMode: "disabled", allowedSandboxIds: [] }
}
const accessMode = server.accessMode === "allow_all" || server.accessMode === "allow_only"
? server.accessMode
: "disabled"
const allowedSandboxIds = normalizeStringArray(server.allowedSandboxIds)
if (!server.enabled) return { active: false, reason: "disabled", accessMode, allowedSandboxIds }
if (accessMode === "disabled") return { active: false, reason: "access-disabled", accessMode, allowedSandboxIds }
if (accessMode === "allow_only" && allowedSandboxIds.length === 0) {
return { active: false, reason: "allow-list-empty", accessMode, allowedSandboxIds }
}
return { active: true, reason: "enabled", accessMode, allowedSandboxIds }
}
function sessionIsUsable(session) {
if (!session || typeof session !== "object") return false
if (!session.enabled) return false
if (!cleanText(session.sandboxId)) return false
if (session.expiresAt && Date.parse(session.expiresAt) <= Date.now()) return false
return true
}
async function readBrokerSessions() {
const store = await readJson(MCP_BROKER_SESSIONS_PATH, { sessions: {} })
return Object.values(store.sessions || {}).filter(sessionIsUsable)
}
function targetFromSession(session) {
const sandboxId = cleanText(session.sandboxId)
const sandboxName = cleanText(session.sandboxName)
return {
sandboxId,
sandboxName: sandboxName || sandboxId,
agentId: `${SIDECAR_AGENT_PREFIX}:${sandboxId}`,
source: "broker-session",
}
}
function targetFromAllowedId(id) {
const sandboxId = cleanText(id)
return {
sandboxId,
sandboxName: sandboxId,
agentId: `${SIDECAR_AGENT_PREFIX}:${sandboxId}`,
source: "allow-list",
}
}
function targetKey(target) {
return cleanText(target.sandboxId) || cleanText(target.sandboxName) || cleanText(target.agentId)
}
function sessionMatchesAllowedId(session, allowedId) {
const allowed = cleanText(allowedId)
return Boolean(
allowed &&
(allowed === cleanText(session.sandboxId) || allowed === cleanText(session.sandboxName)),
)
}
function resolveTargets(policy, sessions) {
const targets = []
if (policy.accessMode === "allow_all") {
targets.push(...sessions.map(targetFromSession))
} else {
for (const allowedId of policy.allowedSandboxIds) {
const matchingSession = sessions.find((session) => sessionMatchesAllowedId(session, allowedId))
targets.push(matchingSession ? targetFromSession(matchingSession) : targetFromAllowedId(allowedId))
}
}
const seen = new Set()
return targets.filter((target) => {
const key = targetKey(target)
if (!key || seen.has(key)) return false
seen.add(key)
return true
})
}
function appendLimited(current, chunk) {
const next = current + chunk.toString("utf8")
return next.length > MAX_DISPATCH_OUTPUT_BYTES ? next.slice(-MAX_DISPATCH_OUTPUT_BYTES) : next
}
function dispatchEnv(payload) {
return {
...process.env,
INTER_SANDBOX_CHAT_ROOM: payload.room,
INTER_SANDBOX_CHAT_MESSAGE_ID: payload.message.id,
INTER_SANDBOX_CHAT_MESSAGE: payload.message.message,
INTER_SANDBOX_CHAT_SENDER: payload.message.sender,
INTER_SANDBOX_CHAT_ACK_TOKEN: payload.message.ackToken || "",
INTER_SANDBOX_CHAT_SANDBOX_ID: payload.sandboxId || "",
INTER_SANDBOX_CHAT_SANDBOX_NAME: payload.sandboxName || "",
INTER_SANDBOX_CHAT_AGENT_ID: payload.agentId || "",
}
}
async function runDispatch(payload) {
if (!DISPATCH_COMMAND) return { ok: false, error: "dispatch command is not configured" }
return await new Promise((resolve) => {
let stdout = ""
let stderr = ""
let settled = false
let timedOut = false
const child = spawn(DISPATCH_COMMAND, DISPATCH_ARGS, {
cwd: process.cwd(),
env: dispatchEnv(payload),
stdio: ["pipe", "pipe", "pipe"],
})
activeDispatches.add(child)
const timeout = setTimeout(() => {
timedOut = true
if (child.exitCode === null && child.signalCode === null) child.kill("SIGTERM")
setTimeout(() => {
if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL")
}, 2500).unref()
}, DISPATCH_TIMEOUT_MS)
child.stdout.on("data", (chunk) => {
stdout = appendLimited(stdout, chunk)
})
child.stderr.on("data", (chunk) => {
stderr = appendLimited(stderr, chunk)
})
child.once("error", (error) => {
if (settled) return
settled = true
clearTimeout(timeout)
activeDispatches.delete(child)
resolve({ ok: false, error: error instanceof Error ? error.message : "dispatch failed", stderr })
})
child.once("exit", (code, signal) => {
if (settled) return
settled = true
clearTimeout(timeout)
activeDispatches.delete(child)
if (code === 0 && !timedOut) {
resolve({ ok: true, stdout: stdout.trim(), stderr: stderr.trim() })
return
}
const reason = timedOut
? `dispatch timed out after ${DISPATCH_TIMEOUT_MS}ms`
: `dispatch exited with code ${code ?? "null"}${signal ? ` signal ${signal}` : ""}`
resolve({ ok: false, error: reason, stderr: stderr.trim() })
})
child.stdin.end(`${JSON.stringify(payload)}\n`)
})
}
function parseDispatchOutput(output) {
const text = cleanText(output)
if (!text) return { reply: "", status: "processed", note: "dispatch completed without output" }
try {
const parsed = JSON.parse(text)
if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
const status = cleanText(parsed.status).toLowerCase()
return {
reply: cleanText(parsed.reply ?? parsed.message),
status: status === "failed" ? "failed" : "processed",
note: cleanText(parsed.note ?? parsed.summary ?? parsed.status) || "dispatch completed",
}
}
} catch {
// Plain text stdout is treated as the sandbox reply.
}
return { reply: text, status: "processed", note: "dispatch returned plain text" }
}
async function processClaimedMessage(target, room, message) {
const payload = {
room,
message,
sandboxId: target.sandboxId,
sandboxName: target.sandboxName,
agentId: target.agentId,
}
log("dispatch-start", {
room,
messageId: message.id,
sandboxId: target.sandboxId,
sandboxName: target.sandboxName,
})
const result = await runDispatch(payload)
if (!result.ok) {
const note = [result.error, result.stderr].filter(Boolean).join(": ")
const recordReceipt = message.origin === "operator" ? ackChatMessage : recordChatMessageReceipt
await recordReceipt({
room,
messageId: message.id,
ackToken: message.ackToken,
agentId: target.agentId,
sandboxId: target.sandboxId,
status: "failed",
note,
})
log("dispatch-failed", {
room,
messageId: message.id,
sandboxId: target.sandboxId,
reason: result.error,
})
return
}
const parsed = parseDispatchOutput(result.stdout)
let postedReplyId = null
if (POST_REPLIES && parsed.status !== "failed" && parsed.reply) {
const posted = await postChatMessage({
room,
sender: target.sandboxName || target.sandboxId || target.agentId,
message: parsed.reply,
origin: "sandbox",
})
postedReplyId = posted.message?.id || null
}
const recordReceipt = message.origin === "operator" ? ackChatMessage : recordChatMessageReceipt
await recordReceipt({
room,
messageId: message.id,
ackToken: message.ackToken,
agentId: target.agentId,
sandboxId: target.sandboxId,
status: parsed.status,
note: parsed.note,
})
log("dispatch-complete", {
room,
messageId: message.id,
sandboxId: target.sandboxId,
status: parsed.status,
postedReplyId,
})
}
async function pollOnce() {
const policy = await readChatPolicy()
if (!policy.active) {
logIdle(`inactive:${policy.reason}`, "inactive", { reason: policy.reason })
return
}
const sessions = await readBrokerSessions()
const targets = resolveTargets(policy, sessions)
if (targets.length === 0) {
logIdle(`no-targets:${policy.accessMode}`, "no-targets", {
accessMode: policy.accessMode,
sessionCount: sessions.length,
})
return
}
const rooms = await listRooms()
if (rooms.length === 0) {
logIdle("no-rooms", "no-rooms", { targetCount: targets.length })
return
}
clearIdle()
let claimedCount = 0
for (const target of targets) {
if (stopping) return
for (const room of rooms) {
if (stopping) return
const claimed = await claimOperatorMessages({
room: room.room,
agentId: target.agentId,
sandboxId: target.sandboxId,
sandboxName: target.sandboxName,
limit: CLAIM_LIMIT,
includeBroadcast: PROCESS_BROADCAST,
autoAck: true,
})
for (const message of claimed.messages || []) {
claimedCount += 1
await processClaimedMessage(target, room.room, message)
}
if (!RELAY_SANDBOX_MESSAGES) continue
const relayed = await claimTargetedMessages({
room: room.room,
agentId: target.agentId,
sandboxId: target.sandboxId,
sandboxName: target.sandboxName,
limit: CLAIM_LIMIT,
includeBroadcast: PROCESS_BROADCAST,
autoAck: true,
origins: ["sandbox"],
excludeSelf: true,
latestOnly: SANDBOX_RELAY_LATEST_ONLY,
cursorId: `${target.agentId}:sandbox-relay`,
receiptNote: SANDBOX_RELAY_LATEST_ONLY
? "claimed latest sandbox message by inter-sandbox chat sidecar"
: "claimed sandbox message by inter-sandbox chat sidecar",
})
for (const message of relayed.messages || []) {
claimedCount += 1
await processClaimedMessage(target, room.room, message)
}
}
}
if (claimedCount > 0) {
log("poll-complete", { claimedCount, targetCount: targets.length, roomCount: rooms.length })
}
}
async function loop() {
const startedAt = Date.now()
try {
await pollOnce()
} catch (error) {
log("poll-error", {
reason: error instanceof Error ? error.message : "unknown error",
})
}
if (stopping) return
const delay = Math.max(1000, POLL_MS - (Date.now() - startedAt))
timer = setTimeout(loop, delay)
}
function stop(exitCode = 0) {
if (stopping) return
stopping = true
process.exitCode = exitCode
if (timer) clearTimeout(timer)
for (const child of activeDispatches) {
if (!child.killed) child.kill("SIGTERM")
}
log("stopping", { exitCode, activeDispatches: activeDispatches.size })
}
process.once("SIGINT", () => stop(130))
process.once("SIGTERM", () => stop(143))
log("started", {
pollMs: POLL_MS,
claimLimit: CLAIM_LIMIT,
dispatchConfigured: Boolean(DISPATCH_COMMAND),
dispatchKind: DISPATCH_KIND,
processBroadcast: PROCESS_BROADCAST,
postReplies: POST_REPLIES,
relaySandboxMessages: RELAY_SANDBOX_MESSAGES,
sandboxRelayLatestOnly: SANDBOX_RELAY_LATEST_ONLY,
})
await loop()