Add chat sidecar and verified inference routes

This commit is contained in:
mmckeen-nv
2026-05-13 11:02:26 -07:00
parent 2f51629324
commit b3c4df18ea
13 changed files with 1766 additions and 137 deletions
@@ -0,0 +1,314 @@
#!/usr/bin/env node
import { spawn, execFile } from "node:child_process"
import { randomUUID } from "node:crypto"
import { existsSync } from "node:fs"
import net from "node:net"
import os from "node:os"
import path from "node:path"
import { promisify } from "node:util"
import { WebSocket } from "ws"
const execFileAsync = promisify(execFile)
const DASHBOARD_PORT_BASE = Number.parseInt(process.env.OPENCLAW_SANDBOX_DASHBOARD_PORT_BASE || "19000", 10)
const DASHBOARD_PORT_RANGE = Number.parseInt(process.env.OPENCLAW_SANDBOX_DASHBOARD_PORT_RANGE || "2000", 10)
const REMOTE_DASHBOARD_PORT = Number.parseInt(process.env.OPENCLAW_SANDBOX_DASHBOARD_REMOTE_PORT || "18789", 10)
const OPENSHELL_GATEWAY = process.env.OPENSHELL_GATEWAY || "nemoclaw"
const CONTROL_UI_ORIGIN = process.env.OPENCLAW_SANDBOX_CONTROL_UI_ORIGIN || "http://127.0.0.1:18789"
const CONNECT_TIMEOUT_MS = Number.parseInt(process.env.INTER_SANDBOX_CHAT_OPENCLAW_CONNECT_TIMEOUT_MS || "15000", 10)
const SEND_TIMEOUT_MS = Number.parseInt(process.env.INTER_SANDBOX_CHAT_OPENCLAW_SEND_TIMEOUT_MS || "120000", 10)
const SESSION_KEY = process.env.INTER_SANDBOX_CHAT_OPENCLAW_SESSION_KEY || "inter-sandbox-chat"
function firstExisting(candidates, fallback) {
return candidates.find((candidate) => candidate && existsSync(candidate)) || fallback
}
const OPENSHELL_BIN = firstExisting([
process.env.OPENSHELL_BIN,
path.join(os.homedir(), ".local/bin/openshell"),
"/usr/local/bin/openshell",
"/opt/homebrew/bin/openshell",
], "openshell")
function cleanText(value, fallback = "") {
return String(value ?? fallback).trim()
}
function cleanSandboxName(value) {
const sandboxName = cleanText(value)
if (!/^[A-Za-z0-9._-]{1,128}$/.test(sandboxName)) {
throw new Error("sandbox name is required for OpenClaw dispatch")
}
return sandboxName
}
function hashSandboxId(value) {
let hash = 0
for (let index = 0; index < value.length; index += 1) {
hash = ((hash << 5) - hash + value.charCodeAt(index)) | 0
}
return Math.abs(hash)
}
function getDashboardPort(sandboxName) {
return DASHBOARD_PORT_BASE + (hashSandboxId(sandboxName) % DASHBOARD_PORT_RANGE)
}
function buildSandboxSshArgs(sandboxName, extraArgs) {
return [
"-o", "BatchMode=yes",
"-o", "StrictHostKeyChecking=no",
"-o", "UserKnownHostsFile=/dev/null",
"-o", "GlobalKnownHostsFile=/dev/null",
"-o", "LogLevel=ERROR",
"-o", `ProxyCommand=${OPENSHELL_BIN} ssh-proxy --gateway-name ${OPENSHELL_GATEWAY} --name ${sandboxName}`,
`sandbox@openshell-${sandboxName}`,
...extraArgs,
]
}
async function execSandboxSsh(sandboxName, command, timeoutMs = 10000) {
return await execFileAsync("ssh", buildSandboxSshArgs(sandboxName, [command]), {
timeout: timeoutMs,
maxBuffer: 2 * 1024 * 1024,
env: process.env,
})
}
function canConnectPort(port, timeoutMs = 750) {
return new Promise((resolve) => {
const socket = net.connect({ host: "127.0.0.1", port })
const done = (ok) => {
socket.removeAllListeners()
socket.destroy()
resolve(ok)
}
socket.setTimeout(timeoutMs)
socket.once("connect", () => done(true))
socket.once("timeout", () => done(false))
socket.once("error", () => done(false))
})
}
async function waitForPort(port, timeoutMs = 8000) {
const deadline = Date.now() + timeoutMs
while (Date.now() < deadline) {
if (await canConnectPort(port)) return true
await new Promise((resolve) => setTimeout(resolve, 250))
}
return false
}
async function ensureRemoteDashboard(sandboxName) {
const command = [
`curl -fsS --max-time 2 http://127.0.0.1:${REMOTE_DASHBOARD_PORT}/ >/dev/null 2>&1`,
"||",
`(nohup /usr/local/bin/openclaw gateway run --allow-unconfigured --bind loopback --port ${REMOTE_DASHBOARD_PORT} >/tmp/gateway.log 2>&1 &)`,
].join(" ")
await execSandboxSsh(sandboxName, command, 15000).catch(() => null)
}
async function ensureDashboardTunnel(sandboxName, port) {
if (await canConnectPort(port)) return true
await ensureRemoteDashboard(sandboxName)
const child = spawn("ssh", buildSandboxSshArgs(sandboxName, [
"-N",
"-L", `127.0.0.1:${port}:127.0.0.1:${REMOTE_DASHBOARD_PORT}`,
]), {
detached: true,
env: process.env,
stdio: "ignore",
})
child.unref()
return await waitForPort(port, 8000)
}
async function readGatewayToken(sandboxName) {
const script = [
'const fs=require("fs")',
'const cfg=JSON.parse(fs.readFileSync("/sandbox/.openclaw/openclaw.json","utf8"))',
'const token=cfg?.gateway?.auth?.token||cfg?.gateway?.token||""',
'if(token) process.stdout.write(String(token))',
].join(";")
const { stdout } = await execSandboxSsh(sandboxName, `node -e '${script}'`, 8000)
const token = cleanText(stdout)
if (!token) throw new Error("OpenClaw gateway token was not found in sandbox config")
return token
}
async function readStdinJson() {
const chunks = []
for await (const chunk of process.stdin) chunks.push(chunk)
const raw = Buffer.concat(chunks).toString("utf8").trim()
if (!raw) throw new Error("dispatch payload is required on stdin")
return JSON.parse(raw)
}
function randomId() {
return randomUUID()
}
class GatewayClient {
constructor({ url, token, sessionKey }) {
this.url = url
this.token = token
this.sessionKey = sessionKey
this.ws = null
this.pending = new Map()
}
async connect() {
this.ws = new WebSocket(this.url, {
headers: { origin: CONTROL_UI_ORIGIN },
})
await new Promise((resolve, reject) => {
const timeout = setTimeout(() => reject(new Error(`OpenClaw websocket connect timed out after ${CONNECT_TIMEOUT_MS}ms`)), CONNECT_TIMEOUT_MS)
this.ws.once("open", () => {
clearTimeout(timeout)
resolve()
})
this.ws.once("error", (error) => {
clearTimeout(timeout)
reject(error)
})
})
this.ws.on("message", (data) => this.handleMessage(data))
await this.request("connect", {
minProtocol: 3,
maxProtocol: 3,
client: {
id: "openclaw-control-ui",
version: "openshell-inter-sandbox-chat-sidecar",
platform: "node",
mode: "webchat",
instanceId: "openshell-inter-sandbox-chat-sidecar",
},
role: "operator",
scopes: ["operator.admin", "operator.read", "operator.write", "operator.approvals", "operator.pairing"],
caps: ["tool-events"],
auth: { token: this.token },
userAgent: "openshell-controller/inter-sandbox-chat-sidecar",
locale: "en-US",
}, CONNECT_TIMEOUT_MS)
}
handleMessage(data) {
let message
try {
message = JSON.parse(String(data))
} catch {
return
}
if (message.type !== "res") return
const pending = this.pending.get(message.id)
if (!pending) return
this.pending.delete(message.id)
if (message.ok) pending.resolve(message.payload)
else {
const detail = message.error?.message || message.error?.code || "OpenClaw request failed"
const error = new Error(detail)
error.details = message.error
pending.reject(error)
}
}
request(method, params, timeoutMs = SEND_TIMEOUT_MS) {
if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
return Promise.reject(new Error("OpenClaw websocket is not connected"))
}
const id = randomId()
const promise = new Promise((resolve, reject) => {
const timeout = setTimeout(() => {
this.pending.delete(id)
reject(new Error(`${method} timed out after ${timeoutMs}ms`))
}, timeoutMs)
this.pending.set(id, {
resolve: (value) => {
clearTimeout(timeout)
resolve(value)
},
reject: (error) => {
clearTimeout(timeout)
reject(error)
},
})
})
this.ws.send(JSON.stringify({ type: "req", id, method, params }))
return promise
}
async sendChat(message, idempotencyKey) {
return await this.request("chat.send", {
sessionKey: this.sessionKey,
message,
deliver: false,
idempotencyKey,
}, SEND_TIMEOUT_MS)
}
close() {
this.ws?.close(1000, "done")
this.ws = null
}
}
function buildOpenClawMessage(payload) {
const rawMessage = cleanText(payload?.message?.message)
if (process.env.INTER_SANDBOX_CHAT_OPENCLAW_RAW_MESSAGE === "1") return rawMessage
const room = cleanText(payload?.room || payload?.message?.room, "lobby")
const sender = cleanText(payload?.message?.sender, "operator")
const sandboxLabel = cleanText(payload?.sandboxName || payload?.sandboxId, "this sandbox")
return [
"Inter-Sandbox Chat message",
`Room: ${room}`,
`From: ${sender}`,
`Origin: ${cleanText(payload?.message?.origin, "sandbox")}`,
"",
rawMessage,
"",
`Please handle this as a direct message for ${sandboxLabel}. This dispatch contains only the newest claimed chat message, not the whole room history. If the Inter-Sandbox Chat MCP server is available and a shared-room reply is appropriate, post your reply with post_message to room "${room}" and target the intended sandbox.`,
].join("\n")
}
async function main() {
const payload = await readStdinJson()
const sandboxName = cleanSandboxName(payload.sandboxName || payload.sandboxId)
const message = buildOpenClawMessage(payload)
if (!message) throw new Error("message text is required")
const port = getDashboardPort(sandboxName)
const tunnelReady = await ensureDashboardTunnel(sandboxName, port)
if (!tunnelReady) throw new Error(`OpenClaw dashboard tunnel did not become ready on 127.0.0.1:${port}`)
const token = await readGatewayToken(sandboxName)
const client = new GatewayClient({
url: `ws://127.0.0.1:${port}/`,
token,
sessionKey: SESSION_KEY,
})
try {
await client.connect()
const result = await client.sendChat(message, payload.message?.id || randomId())
process.stdout.write(`${JSON.stringify({
status: "processed",
note: `sent to OpenClaw chat session ${SESSION_KEY}`,
openclaw: {
sessionKey: SESSION_KEY,
runId: result?.runId || null,
port,
},
})}\n`)
} finally {
client.close()
}
}
main().catch((error) => {
process.stdout.write(`${JSON.stringify({
status: "failed",
note: error instanceof Error ? error.message : "OpenClaw dispatch failed",
})}\n`)
})