diff --git a/.env.example b/.env.example index 908ee0d..a4ded91 100644 --- a/.env.example +++ b/.env.example @@ -7,6 +7,14 @@ NEXT_PUBLIC_KUBERNETES_NAMESPACE=agent-sandbox-system # Docker container name running OpenShell OPEN_SHELL_CONTAINER=openshell-cluster-openshell +# OpenShell gateway name used by CLI commands +OPENSHELL_GATEWAY=nemoclaw + +# Optional gateway address override for containerized OpenShell/NemoClaw CLIs +# OPENSHELL_GATEWAY_HOST=host.docker.internal +# OPENSHELL_GATEWAY_PORT=8080 +# OPENSHELL_GATEWAY_URL=http://host.docker.internal:8080 + # Dashboard port NEXT_PUBLIC_DASHBOARD_PORT=3000 diff --git a/README.md b/README.md index 22a0572..46324ec 100644 --- a/README.md +++ b/README.md @@ -307,6 +307,10 @@ NEXT_PUBLIC_API_BASE=/api NEXT_PUBLIC_ENABLE_SANDBOX_OPERATIONS=true OPEN_SHELL_CONTAINER=openshell-cluster-nemoclaw OPENSHELL_GATEWAY=nemoclaw +# For containerized CLI runs, when supported by the installed OpenShell/NemoClaw versions: +# OPENSHELL_GATEWAY_HOST=host.docker.internal +# OPENSHELL_GATEWAY_PORT=8080 +# OPENSHELL_GATEWAY_URL=http://host.docker.internal:8080 OPENSHELL_CONTROL_PASSWORD=change-this-password OPENSHELL_CONTROL_AUTH_SECRET=change-this-random-secret OPENSHELL_CONTROL_RECOVERY_TOKEN=change-this-recovery-token @@ -314,6 +318,14 @@ MCP_BROKER_TOKEN_TTL_HOURS=168 MCP_BROKER_REQUEST_TIMEOUT_MS=45000 ``` +The controller also accepts an OpenShell config-file form at `~/.config/openshell/gateway.json` or `~/.config/openshell/config.json`: + +```json +{ "gateway": { "host": "host.docker.internal", "port": 8080 } } +``` + +Those values are translated into `OPENSHELL_GATEWAY_HOST`, `OPENSHELL_GATEWAY_PORT`, and `OPENSHELL_GATEWAY_URL` for controller-launched OpenShell/NemoClaw child processes. + ## Security Limitations This is not production hardened. diff --git a/app/api/openshell/dashboard/proxy/shared.ts b/app/api/openshell/dashboard/proxy/shared.ts index a78db6d..c1d161c 100644 --- a/app/api/openshell/dashboard/proxy/shared.ts +++ b/app/api/openshell/dashboard/proxy/shared.ts @@ -160,20 +160,49 @@ function bootstrapScriptResponse(proxyPrefix: string) { try { const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:'; - const gatewayHost = wsProxyPort ? window.location.hostname + ':' + wsProxyPort : window.location.host; - const gatewayUrl = protocol + '//' + gatewayHost + proxyPrefix; + const pageGatewayUrl = protocol + '//' + window.location.host + proxyPrefix; + const sidecarHost = wsProxyPort ? window.location.hostname + ':' + wsProxyPort : window.location.host; + const sidecarGatewayUrl = protocol + '//' + sidecarHost + proxyPrefix; const settingsKey = 'openclaw.control.settings.v1'; + const settingsPrefix = 'openclaw.control.settings.v1:'; + const tokenKey = 'openclaw.control.token.v1'; const tokenPrefix = 'openclaw.control.token.v1:'; - const tokenScope = gatewayUrl; const hashParams = new URLSearchParams(window.location.hash.startsWith('#') ? window.location.hash.slice(1) : window.location.hash); + const gatewayUrl = (hashParams.get('gatewayUrl') || '').trim() || sidecarGatewayUrl; const token = (hashParams.get('token') || '').trim(); - const rawSettings = window.localStorage.getItem(settingsKey); - const settings = rawSettings ? JSON.parse(rawSettings) : {}; + const storageScope = (value) => { + try { + const parsed = new URL(value, window.location.href); + const path = parsed.pathname === '/' ? '' : parsed.pathname.replace(/\\/+$/, '') || parsed.pathname; + return parsed.protocol + '//' + parsed.host + path; + } catch { + return value; + } + }; + const uniqueScopes = (values) => Array.from(new Set(values.map(storageScope).filter(Boolean))); + const gatewayScopes = uniqueScopes([gatewayUrl, sidecarGatewayUrl, pageGatewayUrl]); + const settingsKeys = gatewayScopes.map((scope) => settingsPrefix + scope); + const readSettings = () => { + for (const key of [...settingsKeys, settingsPrefix + 'default', settingsKey]) { + try { + const raw = window.localStorage.getItem(key); + if (!raw) continue; + const parsed = JSON.parse(raw); + if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed; + } catch {} + } + return {}; + }; + const settings = readSettings(); settings.gatewayUrl = gatewayUrl; - window.localStorage.setItem(settingsKey, JSON.stringify(settings)); - window.sessionStorage.removeItem('openclaw.control.token.v1'); - if (token) window.sessionStorage.setItem(tokenPrefix + tokenScope, token); + const serializedSettings = JSON.stringify(settings); + window.localStorage.setItem(settingsKey, serializedSettings); + for (const key of settingsKeys) window.localStorage.setItem(key, serializedSettings); + window.sessionStorage.removeItem(tokenKey); + if (token) { + for (const scope of gatewayScopes) window.sessionStorage.setItem(tokenPrefix + scope, token); + } } catch { // Best-effort compatibility bridge for OpenClaw's persisted UI settings. } diff --git a/app/api/sandbox/create/route.ts b/app/api/sandbox/create/route.ts index 0d4753d..3fde4fd 100644 --- a/app/api/sandbox/create/route.ts +++ b/app/api/sandbox/create/route.ts @@ -1,7 +1,9 @@ import { NextResponse } from "next/server" import { execFile, spawn } from "node:child_process" +import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs" +import path from "node:path" import { promisify } from "node:util" -import { inspectSandbox } from "@/app/lib/openshellHost" +import { inspectSandbox, resolveSandboxRef } from "@/app/lib/openshellHost" import { repairOpenClawExecApprovalsFile } from "@/app/lib/sandboxPrivilegedFiles" import { commandExists, @@ -13,9 +15,14 @@ import { NEMOCLAW_SETUP_CANDIDATES, NODE_BIN, OPENSHELL_BIN, + hostCommandEnv, } from "@/app/lib/hostCommands" const execFileAsync = promisify(execFile) +const DOCKER_BIN = process.env.DOCKER_BIN || "docker" +const OPENSHELL_CLUSTER_CONTAINER = process.env.OPENSHELL_CLUSTER_CONTAINER || "openshell-cluster-nemoclaw" +const OPENSHELL_NAMESPACE = process.env.OPENSHELL_SANDBOX_NAMESPACE || "openshell" +const NEMOCLAW_REGISTRY_FILE = path.join(process.env.HOME || "/tmp", ".nemoclaw", "sandboxes.json") function validateSandboxName(name: string) { if (!name || typeof name !== "string") throw new Error("sandbox name is required") @@ -67,6 +74,11 @@ type CreateInferenceSettings = { envSummary: string[] } +type NemoClawRegistryData = { + sandboxes?: Record + defaultSandbox?: string | null +} + function parseCreateInferenceSettings(body: any): CreateInferenceSettings { const raw = body?.createInference && typeof body.createInference === "object" ? body.createInference : {} const requestedMode = typeof raw.mode === "string" ? raw.mode : "vllm" @@ -127,6 +139,178 @@ function buildNemoClawCreateCommand(): NemoClawCreateCommand { ) } +function resolveNemoClawBasePolicyPath() { + const home = process.env.HOME || "" + const candidates = [ + process.env.NEMOCLAW_BASE_POLICY_PATH, + path.join(NEMOCLAW_CWD, "nemoclaw-blueprint", "policies", "openclaw-sandbox.yaml"), + home ? path.join(home, ".nemoclaw", "source", "nemoclaw-blueprint", "policies", "openclaw-sandbox.yaml") : undefined, + ].filter((candidate): candidate is string => Boolean(candidate)) + + const found = candidates.find((candidate) => existsSync(candidate)) + if (!found) { + throw new Error(`NemoClaw base policy was not found. Searched: ${candidates.join(", ")}`) + } + return found +} + +async function readPodImage(sandboxName: string, jsonpath: string) { + const { stdout } = await execFileAsync(DOCKER_BIN, [ + "exec", + OPENSHELL_CLUSTER_CONTAINER, + "kubectl", + "get", + "pod", + sandboxName, + "-n", + OPENSHELL_NAMESPACE, + "-o", + `jsonpath=${jsonpath}`, + ], { + env: hostCommandEnv(), + timeout: 10000, + maxBuffer: 1024 * 1024, + }) + + return String(stdout).trim().split(/\s+/)[0] || null +} + +function stripAnsi(value: string) { + return value.replace(/\u001b\[[0-9;]*m/g, "") +} + +function parseOpenShellSandboxNames(output: string) { + return output + .split(/\r?\n/) + .map((entry) => stripAnsi(entry).trim()) + .filter( + (entry) => + entry && + !/^name\s+/i.test(entry) && + !/^[\s\-=]+$/.test(entry) && + !/^no sandboxes found\.?$/i.test(entry) + ) + .map((entry) => entry.split(/\s{2,}/)[0]?.trim()) + .filter((entry): entry is string => Boolean(entry)) +} + +function readNemoClawRegistry(): NemoClawRegistryData { + try { + return existsSync(NEMOCLAW_REGISTRY_FILE) + ? JSON.parse(readFileSync(NEMOCLAW_REGISTRY_FILE, "utf8")) + : {} + } catch { + return {} + } +} + +async function listOpenShellSandboxNames() { + try { + const { stdout } = await execFileAsync(OPENSHELL_BIN, ["sandbox", "list"], { + env: hostCommandEnv({ + OPENSHELL_GATEWAY: process.env.OPENSHELL_GATEWAY || "nemoclaw", + }), + timeout: 10000, + maxBuffer: 1024 * 1024, + }) + return parseOpenShellSandboxNames(String(stdout)) + } catch { + return [] + } +} + +async function resolveSourcePodImageFromRef(sourceSandboxRef: string) { + const requested = sourceSandboxRef.trim() + const source = await resolveSandboxRef(requested) + const sourceName = validateSandboxName(source.name) + const sourceImage = await readPodImage(sourceName, '{.spec.containers[?(@.name=="agent")].image}') + .catch(() => null) + || await readPodImage(sourceName, "{.spec.containers[0].image}").catch(() => null) + + if (!sourceImage) { + throw new Error(`Could not resolve the running image for source sandbox '${sourceName}'.`) + } + + return { + requested, + name: sourceName, + id: source.id, + image: sourceImage, + } +} + +async function resolveSourcePodImage(sourceSandboxRef: string | null | undefined, targetSandboxName: string) { + if (sourceSandboxRef && typeof sourceSandboxRef === "string" && sourceSandboxRef.trim()) { + return await resolveSourcePodImageFromRef(sourceSandboxRef) + } + + const registry = readNemoClawRegistry() + const registeredEntries = Object.entries(registry.sandboxes ?? {}) + const newestRegisteredNames = registeredEntries + .sort(([, a], [, b]) => String(b?.createdAt ?? "").localeCompare(String(a?.createdAt ?? ""))) + .map(([key, value]) => value?.name || key) + const liveNames = await listOpenShellSandboxNames() + const candidates = Array.from(new Set([ + registry.defaultSandbox || undefined, + ...newestRegisteredNames, + ...liveNames, + ].filter((candidate): candidate is string => Boolean(candidate && candidate !== targetSandboxName)))) + + for (const candidate of candidates) { + try { + return await resolveSourcePodImageFromRef(candidate) + } catch { + // Try the next candidate; stale registry entries are common after manual cleanup. + } + } + + throw new Error("No running NemoClaw sandbox image was found for quick deploy. Create one Fresh NemoClaw Image first, or pass sourceSandboxName explicitly.") +} + +function registerNemoClawImageRedeploy(sourceName: string, sandboxName: string) { + try { + const current = existsSync(NEMOCLAW_REGISTRY_FILE) + ? JSON.parse(readFileSync(NEMOCLAW_REGISTRY_FILE, "utf8")) + : {} + const sandboxes = current && typeof current.sandboxes === "object" && current.sandboxes !== null + ? current.sandboxes + : {} + const sourceEntry = sandboxes[sourceName] && typeof sandboxes[sourceName] === "object" + ? sandboxes[sourceName] + : { name: sourceName } + + sandboxes[sandboxName] = { + ...sourceEntry, + name: sandboxName, + createdAt: new Date().toISOString(), + nimContainer: null, + policies: [], + imageTag: null, + } + + const next = { + ...current, + sandboxes, + defaultSandbox: current.defaultSandbox || sandboxName, + } + mkdirSync(path.dirname(NEMOCLAW_REGISTRY_FILE), { recursive: true }) + const tempPath = `${NEMOCLAW_REGISTRY_FILE}.tmp.${process.pid}.${Date.now()}` + writeFileSync(tempPath, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 }) + renameSync(tempPath, NEMOCLAW_REGISTRY_FILE) + return { + ok: true as const, + registryFile: NEMOCLAW_REGISTRY_FILE, + note: "Registered the image-redeployed sandbox in the local NemoClaw registry without assigning a host Docker image tag.", + } + } catch (error) { + return { + ok: false as const, + registryFile: NEMOCLAW_REGISTRY_FILE, + error: error instanceof Error ? error.message : "Failed to update the local NemoClaw registry", + } + } +} + async function verifySandboxCreation(sandboxName: string): Promise { const startedAt = Date.now() console.log(`[sandbox/create] verify:start sandbox=${sandboxName}`) @@ -285,6 +469,131 @@ async function runCreateCommandBounded(file: string, args: string[], env: NodeJS }) } +async function runCreateCommandUntilReady(file: string, args: string[], env: NodeJS.ProcessEnv, sandboxName: string, timeoutMs: number, intervalMs: number) { + const startedAt = Date.now() + console.log(`[sandbox/create] ready-command:start file=${file} args=${JSON.stringify(args)} timeoutMs=${timeoutMs}`) + + return await new Promise<{ + completed: boolean + timedOut: boolean + forcedReady: boolean + exitCode: number | null + signal: NodeJS.Signals | null + stdout: string + stderr: string + error?: string + }>((resolve) => { + const child = spawn(file, args, { + env, + stdio: ["ignore", "pipe", "pipe"], + }) + + let stdout = "" + let stderr = "" + let settled = false + let checkingReady = false + + const finish = (result: { + completed: boolean + timedOut: boolean + forcedReady: boolean + exitCode: number | null + signal: NodeJS.Signals | null + stdout: string + stderr: string + error?: string + }) => { + if (settled) return + settled = true + clearTimeout(timer) + clearInterval(readinessTimer) + resolve(result) + } + + child.stdout?.on("data", (chunk) => { + stdout += String(chunk) + }) + + child.stderr?.on("data", (chunk) => { + stderr += String(chunk) + }) + + child.on("error", (error) => { + const message = error instanceof Error ? error.message : String(error ?? "Command failed") + console.log(`[sandbox/create] ready-command:error file=${file} elapsedMs=${elapsedMs(startedAt)} message=${message}`) + finish({ + completed: false, + timedOut: false, + forcedReady: false, + exitCode: null, + signal: null, + stdout: stdout.trim(), + stderr: stderr.trim(), + error: message, + }) + }) + + child.on("close", (code, signal) => { + console.log(`[sandbox/create] ready-command:close file=${file} elapsedMs=${elapsedMs(startedAt)} code=${code} signal=${signal} stdoutBytes=${stdout.length} stderrBytes=${stderr.length}`) + finish({ + completed: true, + timedOut: false, + forcedReady: false, + exitCode: code, + signal, + stdout: stdout.trim(), + stderr: stderr.trim(), + ...(code === 0 ? {} : { error: `Command exited with code ${code}${signal ? ` signal ${signal}` : ""}` }), + }) + }) + + const readinessTimer = setInterval(() => { + if (settled || checkingReady) return + checkingReady = true + verifySandboxCreation(sandboxName) + .then((verification) => { + if (!settled && verification.verified) { + console.log(`[sandbox/create] ready-command:ready sandbox=${sandboxName} elapsedMs=${elapsedMs(startedAt)} sending=SIGTERM`) + child.kill("SIGTERM") + finish({ + completed: false, + timedOut: false, + forcedReady: true, + exitCode: null, + signal: "SIGTERM", + stdout: stdout.trim(), + stderr: stderr.trim(), + }) + } + }) + .finally(() => { + checkingReady = false + }) + }, intervalMs) + + const timer = setTimeout(() => { + console.log(`[sandbox/create] ready-command:timeout file=${file} elapsedMs=${elapsedMs(startedAt)} sending=SIGTERM`) + child.kill("SIGTERM") + setTimeout(() => { + if (!settled) { + console.log(`[sandbox/create] ready-command:timeout-escalate file=${file} elapsedMs=${elapsedMs(startedAt)} sending=SIGKILL`) + child.kill("SIGKILL") + } + }, 2000) + finish({ + completed: false, + timedOut: true, + forcedReady: false, + exitCode: null, + signal: "SIGTERM", + stdout: stdout.trim(), + stderr: stderr.trim(), + error: `Command exceeded timeout of ${timeoutMs}ms`, + }) + }, timeoutMs) + }) +} + async function approveOpenClawDeviceRequests(sandboxName: string) { const result = await runCreateCommandBounded(OPENSHELL_BIN, [ "sandbox", @@ -295,14 +604,9 @@ async function approveOpenClawDeviceRequests(sandboxName: string) { "sh", "-lc", "openclaw devices approve --latest --json --timeout 10000", - ], { - ...process.env, - PATH: HOST_PATH, + ], hostCommandEnv({ OPENSHELL_GATEWAY: process.env.OPENSHELL_GATEWAY || "nemoclaw", - NO_COLOR: "1", - CLICOLOR: "0", - CLICOLOR_FORCE: "0", - }, 15000) + }), 15000) const combinedOutput = `${result.stdout}\n${result.stderr}`.trim() const noPending = NO_PENDING_DEVICE_REQUESTS.test(combinedOutput) @@ -359,7 +663,7 @@ export async function GET() { blueprints: [ { id: "nemoclaw-blueprint", - label: "New NemoClaw Sandbox", + label: "Fresh NemoClaw Image", description: "Bootstraps a full NemoClaw sandbox using the nemoclaw-blueprint workflow.", type: "blueprint", source: "~/NemoClaw/nemoclaw-blueprint/blueprint.yaml", @@ -373,6 +677,14 @@ export async function GET() { source: "dashboard-custom", supportsTailscale: false, }, + { + id: "redeploy-image", + label: "Quick Deploy New NemoClaw Sandbox", + description: "Create a default NemoClaw sandbox from the latest available running image without rebuilding it.", + type: "image", + source: "default-running-image", + supportsTailscale: false, + }, ], }) } @@ -395,15 +707,13 @@ export async function POST(request: Request) { if (blueprint === "nemoclaw-blueprint") { const createCommand = buildNemoClawCreateCommand() - const env: NodeJS.ProcessEnv = { - ...process.env, - PATH: HOST_PATH, + const env: NodeJS.ProcessEnv = hostCommandEnv({ NEMOCLAW_SANDBOX_NAME: sandboxName, NEMOCLAW_NON_INTERACTIVE: "1", NEMOCLAW_RECREATE_SANDBOX: "1", NEMOCLAW_ACCEPT_THIRD_PARTY_SOFTWARE: "1", OPENSHELL_GATEWAY: process.env.OPENSHELL_GATEWAY || "nemoclaw", - } + }) if (!enableTailscale) { env.NVIDIA_API_KEY = env.NVIDIA_API_KEY || "optional-local-mode" @@ -482,13 +792,12 @@ export async function POST(request: Request) { } if (blueprint === "custom-sandbox") { - const env: NodeJS.ProcessEnv = { - ...process.env, - PATH: HOST_PATH, + const env: NodeJS.ProcessEnv = hostCommandEnv({ + OPENSHELL_GATEWAY: process.env.OPENSHELL_GATEWAY || "nemoclaw", NO_COLOR: "1", CLICOLOR: "0", CLICOLOR_FORCE: "0", - } + }) const createAttempt = await runCreateCommandBounded(OPENSHELL_BIN, ["sandbox", "create", "--name", sandboxName], env, 15000) if (createAttempt.completed && createAttempt.exitCode !== 0) { @@ -558,6 +867,97 @@ export async function POST(request: Request) { }, { status: created ? 200 : 502 }) } + if (blueprint === "redeploy-image") { + const sourceSandboxName = typeof body?.sourceSandboxName === "string" ? body.sourceSandboxName.trim() : "" + const source = await resolveSourcePodImage(sourceSandboxName, sandboxName) + const sourceImage = source.image + const basePolicyPath = resolveNemoClawBasePolicyPath() + const env: NodeJS.ProcessEnv = hostCommandEnv({ + OPENSHELL_GATEWAY: process.env.OPENSHELL_GATEWAY || "nemoclaw", + }) + + const createAttempt = await runCreateCommandUntilReady(OPENSHELL_BIN, [ + "sandbox", + "create", + "--name", + sandboxName, + "--from", + sourceImage, + "--policy", + basePolicyPath, + "--auto-providers", + "--", + "nemoclaw-start", + ], env, sandboxName, 120000, 2000) + + const readiness = await waitForSandboxReady(sandboxName, 90000, 2000) + const verification = readiness.verification ?? { + verified: false, + summary: "Sandbox readiness polling produced no verification result.", + error: "Sandbox readiness polling produced no verification result.", + } + const created = readiness.verified + const registry = created ? registerNemoClawImageRedeploy(source.name, sandboxName) : null + const execApprovalsRepair = created ? await repairOpenClawExecApprovalsFile(sandboxName).catch((error) => ({ + sandboxName, + path: "/sandbox/.openclaw/exec-approvals.json", + error: error instanceof Error ? error.message : "Failed to repair OpenClaw exec approvals file", + })) : null + const deviceApproval = created ? await approveOpenClawDeviceRequests(sandboxName) : null + console.log( + `[sandbox/create] request:complete sandbox=${sandboxName} created=${created} mode=redeploy-image createTimedOut=${createAttempt.timedOut} readinessAttempts=${readiness.attempts} deviceApproval=${deviceApproval?.approved ?? false} elapsedMs=${elapsedMs(requestStartedAt)}`, + ) + + const createFailed = createAttempt.completed && createAttempt.exitCode !== 0 && !created + return NextResponse.json({ + ok: created, + blueprint, + sandboxName, + sourceSandboxName: source.name, + sourceSandboxId: source.id, + sourceImage, + basePolicyPath, + created, + verified: verification.verified, + verification, + mode: "redeploy-image", + stdout: createAttempt.stdout, + stderr: createAttempt.stderr, + createCommand: { + completed: createAttempt.completed, + timedOut: createAttempt.timedOut, + forcedReady: createAttempt.forcedReady, + exitCode: createAttempt.exitCode, + signal: createAttempt.signal, + error: createAttempt.error, + }, + readiness: { + attempts: readiness.attempts, + elapsedMs: readiness.elapsedMs, + }, + registry, + execApprovalsRepair, + deviceApproval, + note: created + ? appendNote( + `Sandbox created by redeploying the running image from '${source.name}' instead of rebuilding it.`, + createAttempt.forcedReady + ? "The dashboard returned as soon as OpenShell reported the redeployed sandbox Ready." + : false, + createAttempt.timedOut + ? "The OpenShell create command stayed attached after the sandbox reached Ready, so the dashboard stopped waiting for the local command." + : false, + registry && !registry.ok ? `NemoClaw registry update failed: ${registry.error}` : false, + execApprovalsRepair && "note" in execApprovalsRepair ? execApprovalsRepair.note : false, + execApprovalsRepair && "error" in execApprovalsRepair ? `OpenClaw exec approvals repair failed: ${execApprovalsRepair.error}` : false, + deviceApproval?.note, + ) + : createFailed + ? "Image redeploy command failed and the sandbox never reached a ready verification state afterward." + : "Image redeploy started, but the sandbox never reached a ready verification state afterward.", + }, { status: created ? 200 : createFailed ? 500 : 502 }) + } + return NextResponse.json({ ok: false, error: `unknown blueprint: ${blueprint}` }, { status: 400 }) } catch (error) { const message = error instanceof Error ? error.message : "Sandbox creation failed" diff --git a/app/api/sandbox/delete/route.ts b/app/api/sandbox/delete/route.ts index e6f6837..a7f1f8b 100644 --- a/app/api/sandbox/delete/route.ts +++ b/app/api/sandbox/delete/route.ts @@ -2,7 +2,7 @@ import { NextResponse } from "next/server" import { execFile } from "node:child_process" import { promisify } from "node:util" import { resolveSandboxRef } from "@/app/lib/openshellHost" -import { HOST_PATH, NEMOCLAW_BIN, NEMOCLAW_CWD, OPENSHELL_BIN } from "@/app/lib/hostCommands" +import { OPENSHELL_BIN, hostCommandEnv } from "@/app/lib/hostCommands" const execFileAsync = promisify(execFile) @@ -54,14 +54,9 @@ async function deleteSandbox(sandboxName: string) { console.log(`[sandbox/delete] command:start sandbox=${sandboxName}`) try { const { stdout, stderr } = await execFileAsync(OPENSHELL_BIN, ["sandbox", "delete", sandboxName], { - env: { - ...process.env, - PATH: HOST_PATH, + env: hostCommandEnv({ OPENSHELL_GATEWAY: process.env.OPENSHELL_GATEWAY || "nemoclaw", - NO_COLOR: "1", - CLICOLOR: "0", - CLICOLOR_FORCE: "0", - }, + }), timeout: 60000, maxBuffer: 20 * 1024 * 1024, }) @@ -83,53 +78,6 @@ function isSandboxNotFound(output: string) { return /sandbox not found|status:\s*NotFound|not present in the live OpenShell gateway/i.test(output) } -function isNemoClawSandboxNotRegistered(output: string, sandboxName: string) { - return new RegExp(`Unknown command:\\s*${sandboxName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "i").test(output) -} - -async function cleanupNemoClawSandbox(sandboxName: string) { - const startedAt = Date.now() - console.log(`[sandbox/delete] nemoclaw-cleanup:start sandbox=${sandboxName}`) - try { - const { stdout, stderr } = await execFileAsync(NEMOCLAW_BIN, [sandboxName, "destroy", "--yes"], { - cwd: NEMOCLAW_CWD, - env: { - ...process.env, - PATH: HOST_PATH, - OPENSHELL_GATEWAY: process.env.OPENSHELL_GATEWAY || "nemoclaw", - NO_COLOR: "1", - CLICOLOR: "0", - CLICOLOR_FORCE: "0", - }, - timeout: 90000, - maxBuffer: 20 * 1024 * 1024, - }) - console.log(`[sandbox/delete] nemoclaw-cleanup:done sandbox=${sandboxName} elapsedMs=${elapsedMs(startedAt)}`) - return { ok: true as const, stdout: String(stdout).trim(), stderr: String(stderr).trim() } - } catch (error: any) { - const message = error instanceof Error ? error.message : String(error ?? "NemoClaw cleanup failed") - const stdout = String(error?.stdout || "").trim() - const stderr = String(error?.stderr || "").trim() - const output = [message, stdout, stderr].filter(Boolean).join("\n") - if (isNemoClawSandboxNotRegistered(output, sandboxName)) { - console.log(`[sandbox/delete] nemoclaw-cleanup:already-gone sandbox=${sandboxName} elapsedMs=${elapsedMs(startedAt)}`) - return { - ok: true as const, - stdout, - stderr, - note: "NemoClaw registry already had no matching sandbox.", - } - } - console.log(`[sandbox/delete] nemoclaw-cleanup:error sandbox=${sandboxName} elapsedMs=${elapsedMs(startedAt)} message=${message}`) - return { - ok: false as const, - stdout, - stderr, - error: message, - } - } -} - async function waitForSandboxDeleted(sandboxName: string, timeoutMs: number, intervalMs: number) { const startedAt = Date.now() let attempts = 0 @@ -179,7 +127,6 @@ export async function POST(request: Request) { const result = await deleteSandbox(target.sandboxName) const deleteOutput = [result.error, result.stdout, result.stderr].filter(Boolean).join("\n") const openShellAlreadyGone = !result.ok && isSandboxNotFound(deleteOutput) - const cleanup = await cleanupNemoClawSandbox(target.sandboxName) if (!result.ok && !openShellAlreadyGone) { return NextResponse.json({ @@ -193,24 +140,6 @@ export async function POST(request: Request) { error: result.error, stdout: result.stdout, stderr: result.stderr, - nemoclaw: cleanup, - }, { status: 500 }) - } - - if (!cleanup.ok) { - return NextResponse.json({ - ok: false, - deleted: false, - requested: target.requested, - sandboxName: target.sandboxName, - sandboxId: target.sandboxId, - resolved: target.resolved, - openShellAlreadyGone, - openShell: result, - error: cleanup.error, - stdout: cleanup.stdout, - stderr: cleanup.stderr, - nemoclaw: cleanup, }, { status: 500 }) } @@ -224,13 +153,12 @@ export async function POST(request: Request) { sandboxName: target.sandboxName, sandboxId: target.sandboxId, resolved: target.resolved, - stdout: [result.stdout, cleanup.stdout].filter(Boolean).join("\n\n"), - stderr: [result.stderr, cleanup.stderr].filter(Boolean).join("\n\n"), + stdout: result.stdout, + stderr: result.stderr, openShellAlreadyGone, openShell: result, - nemoclaw: cleanup, deletion, - note: deleted ? "Sandbox delete completed and NemoClaw registry cleanup ran." : "Sandbox delete command completed, but inventory still reports the sandbox.", + note: deleted ? "Sandbox delete completed." : "Sandbox delete command completed, but inventory still reports the sandbox.", }, { status: deleted ? 200 : 202 }) } catch (error) { const message = error instanceof Error ? error.message : "Sandbox delete failed" diff --git a/app/api/support-bundle/route.ts b/app/api/support-bundle/route.ts index 63422d3..1458e0c 100644 --- a/app/api/support-bundle/route.ts +++ b/app/api/support-bundle/route.ts @@ -3,7 +3,7 @@ import { promisify } from "node:util" import { NextResponse } from "next/server" import { listActivity } from "@/app/lib/activityLog" import { listBackupCatalog } from "@/app/lib/backupCatalog" -import { HOST_PATH, OPENSHELL_BIN } from "@/app/lib/hostCommands" +import { HOST_PATH, OPENSHELL_BIN, hostCommandEnv } from "@/app/lib/hostCommands" const execFileAsync = promisify(execFile) @@ -11,9 +11,12 @@ export const dynamic = "force-dynamic" async function run(command: string, args: string[]) { try { + const env = command === OPENSHELL_BIN + ? hostCommandEnv({ OPENSHELL_GATEWAY: process.env.OPENSHELL_GATEWAY || "nemoclaw" }) + : { ...process.env, PATH: HOST_PATH, NO_COLOR: "1", CLICOLOR: "0", CLICOLOR_FORCE: "0" } const { stdout, stderr } = await execFileAsync(command, args, { timeout: 10000, - env: { ...process.env, PATH: HOST_PATH, NO_COLOR: "1", CLICOLOR: "0", CLICOLOR_FORCE: "0" }, + env, }) return { ok: true, stdout: stdout.trim(), stderr: stderr.trim() } } catch (error) { diff --git a/app/api/telemetry/real/route.ts b/app/api/telemetry/real/route.ts index 1b6d419..55c68cb 100644 --- a/app/api/telemetry/real/route.ts +++ b/app/api/telemetry/real/route.ts @@ -2,7 +2,7 @@ import { NextResponse } from "next/server" import { execFile } from "node:child_process" import { hostname, networkInterfaces } from "node:os" import { promisify } from "node:util" -import { HOST_PATH, NEMOCLAW_BIN, NODE_BIN, OPENSHELL_BIN, hostCommandEnv } from "@/app/lib/hostCommands" +import { NEMOCLAW_BIN, NODE_BIN, OPENSHELL_BIN, hostCommandEnv } from "@/app/lib/hostCommands" import { resolveRuntimeAuthority } from "@/app/lib/runtimeAuthority" const execFileAsync = promisify(execFile) @@ -146,13 +146,9 @@ function buildNemoClawSummary(output: string | null, defaultSandboxNames: Set('') const [blueprints, setBlueprints] = useState([]) - const [selectedBlueprint, setSelectedBlueprint] = useState('nemoclaw-blueprint') + const [selectedBlueprint, setSelectedBlueprint] = useState('redeploy-image') const [sandboxName, setSandboxName] = useState('') const [enableTailscale, setEnableTailscale] = useState(false) const [createInferenceMode, setCreateInferenceMode] = useState("vllm") @@ -208,7 +208,7 @@ export default function ConfigurationPanel({ sandboxId, mode = 'existing', onCre @@ -216,15 +216,20 @@ export default function ConfigurationPanel({ sandboxId, mode = 'existing', onCre
- setSandboxName(e.target.value)} placeholder={selectedBlueprint === 'nemoclaw-blueprint' ? 'my-assistant' : 'custom-sandbox'} className="mt-2 w-full rounded-sm border border-[var(--border-subtle)] bg-[var(--background)] px-3 py-2 text-xs font-mono text-[var(--foreground)]" /> + setSandboxName(e.target.value)} placeholder={selectedBlueprint === 'nemoclaw-blueprint' ? 'my-assistant' : selectedBlueprint === 'redeploy-image' ? 'my-assistant-copy' : 'custom-sandbox'} className="mt-2 w-full rounded-sm border border-[var(--border-subtle)] bg-[var(--background)] px-3 py-2 text-xs font-mono text-[var(--foreground)]" />
+ {selectedBlueprint === 'redeploy-image' && ( +
+

Quick Deploy uses the default running NemoClaw image and skips the Docker rebuild. Use Fresh NemoClaw Image when you need to rebuild the image layers.

+
+ )} {activeBlueprint?.supportsTailscale && ( )} {enableTailscale &&
Tailscale-enabled creation requires NVIDIA_API_KEY in the dashboard process environment.
} -
+ {selectedBlueprint === 'nemoclaw-blueprint' &&
Inference at Create

Choose the provider NemoClaw should use while onboarding this sandbox.

@@ -257,7 +262,7 @@ export default function ConfigurationPanel({ sandboxId, mode = 'existing', onCre )}
)} -
+
}
- backup + restore + image + restore @@ -604,7 +606,7 @@ export default function WizardPanel({

Configure Target Sandbox

-

Choose the sandbox blueprint and target name.

+

Choose how the target is created and set its sandbox name.

{blueprints.map((blueprint) => ( @@ -673,7 +675,7 @@ export default function WizardPanel({ {[ ["Source", sourceSandbox?.name || "-"], ["Target", targetName || "-"], - ["Blueprint", activeBlueprint?.label || selectedBlueprint], + ["Create Path", activeBlueprint?.label || selectedBlueprint], ["Backup Path", backupPath], ["Restore Path", restorePath], ["Restore Mode", replaceTarget ? "replace" : "merge"], diff --git a/app/lib/hostCommands.ts b/app/lib/hostCommands.ts index 00ca1b4..9e826ea 100644 --- a/app/lib/hostCommands.ts +++ b/app/lib/hostCommands.ts @@ -1,4 +1,4 @@ -import { existsSync, readdirSync, statSync } from "node:fs" +import { existsSync, readFileSync, readdirSync, statSync } from "node:fs" import path from "node:path" const HOME = process.env.HOME || "" @@ -107,11 +107,72 @@ function pathEntries() { export const HOST_PATH = unique(pathEntries()).join(":") +function nonEmptyEnv(name: string) { + const value = process.env[name]?.trim() + return value || undefined +} + +function gatewayUrlFromHost(host: string, port: string) { + if (/^https?:\/\//i.test(host)) return host + if (host.includes(":")) return `http://${host}` + return `http://${host}:${port}` +} + +function stringConfigValue(value: unknown) { + if (typeof value === "string") return value.trim() || undefined + if (typeof value === "number" && Number.isFinite(value)) return String(value) + return undefined +} + +function readOpenShellGatewayAddressConfig() { + const configDir = OPENSHELL_XDG_CONFIG_HOME ? path.join(OPENSHELL_XDG_CONFIG_HOME, "openshell") : "" + const candidates = unique([ + process.env.OPENSHELL_GATEWAY_CONFIG, + configDir ? path.join(configDir, "gateway.json") : undefined, + configDir ? path.join(configDir, "config.json") : undefined, + ]) + + for (const candidate of candidates) { + if (!existsSync(candidate)) continue + try { + const parsed = JSON.parse(readFileSync(candidate, "utf8")) + const gateway = parsed?.gateway && typeof parsed.gateway === "object" ? parsed.gateway : {} + const host = stringConfigValue(parsed?.gatewayHost) || stringConfigValue(gateway.host) + const port = stringConfigValue(parsed?.gatewayPort) || stringConfigValue(gateway.port) + const url = stringConfigValue(parsed?.gatewayUrl) || stringConfigValue(gateway.url) + if (host || port || url) return { host, port, url } + } catch { + // Ignore malformed optional config; explicit env vars remain authoritative. + } + } + + return {} +} + +export function openshellGatewayAddressEnv() { + const config = readOpenShellGatewayAddressConfig() + const host = nonEmptyEnv("OPENSHELL_GATEWAY_HOST") || config.host + const configuredPort = nonEmptyEnv("OPENSHELL_GATEWAY_PORT") || config.port + const port = configuredPort || "8080" + const explicitUrl = nonEmptyEnv("OPENSHELL_GATEWAY_URL") || config.url + + return { + ...(host ? { OPENSHELL_GATEWAY_HOST: host } : {}), + ...(configuredPort || host || explicitUrl ? { OPENSHELL_GATEWAY_PORT: port } : {}), + ...(explicitUrl + ? { OPENSHELL_GATEWAY_URL: explicitUrl } + : host + ? { OPENSHELL_GATEWAY_URL: gatewayUrlFromHost(host, port) } + : {}), + } +} + export function hostCommandEnv(extra: Record = {}) { return { ...process.env, ...(OPENSHELL_HOME ? { HOME: OPENSHELL_HOME } : {}), ...(OPENSHELL_XDG_CONFIG_HOME ? { XDG_CONFIG_HOME: OPENSHELL_XDG_CONFIG_HOME } : {}), + ...openshellGatewayAddressEnv(), PATH: HOST_PATH, NO_COLOR: "1", CLICOLOR: "0", diff --git a/app/lib/mcpBrokerUrl.ts b/app/lib/mcpBrokerUrl.ts index cbd7005..61962b1 100644 --- a/app/lib/mcpBrokerUrl.ts +++ b/app/lib/mcpBrokerUrl.ts @@ -8,6 +8,10 @@ const execFileAsync = promisify(execFile) const LOCAL_HOSTNAMES = new Set(["localhost", "127.0.0.1", "0.0.0.0", "host.docker.internal", "host.openshell.internal"]) const FALLBACK_SANDBOX_PROXY_ORIGIN = "http://10.200.0.1:3128" +function shouldUseProxyWrappedBrokerUrl() { + return /^(1|true|yes|on)$/i.test(process.env.OPENSHELL_CONTROL_MCP_BROKER_PROXY_URL || "") +} + async function discoverOpenShellDockerGateway() { const container = process.env.OPEN_SHELL_CONTAINER || "openshell-cluster-nemoclaw" const { stdout } = await execFileAsync("docker", ["inspect", container], { @@ -67,10 +71,11 @@ export async function brokerBaseUrlForSandbox( } const hostBrokerUrl = `${publicOrigin.toString().replace(/\/+$/, "")}/api/mcp/broker` + if (!shouldUseProxyWrappedBrokerUrl()) return hostBrokerUrl + const proxyOrigin = sandbox ? await discoverSandboxProxyOrigin(sandbox.id, sandbox.name).catch(() => null) : null - if (proxyOrigin) return `${proxyOrigin}/${hostBrokerUrl}` if (LOCAL_HOSTNAMES.has(new URL(origin).hostname)) return `${FALLBACK_SANDBOX_PROXY_ORIGIN}/${hostBrokerUrl}` return hostBrokerUrl diff --git a/app/lib/openshellHost.ts b/app/lib/openshellHost.ts index ded30c0..1e97b03 100644 --- a/app/lib/openshellHost.ts +++ b/app/lib/openshellHost.ts @@ -1,6 +1,6 @@ import { execFile, spawn } from "node:child_process" import { promisify } from "node:util" -import { HOST_PATH, OPENCLAW_BIN, OPENSHELL_BIN } from "./hostCommands" +import { HOST_PATH, OPENCLAW_BIN, OPENSHELL_BIN, hostCommandEnv } from "./hostCommands" import { getDefaultOpenClawInstance, getOpenClawDashboardPortForSandbox, resolveOpenClawInstance } from "./openclawInstances" const execFileAsync = promisify(execFile) @@ -44,13 +44,12 @@ export type DashboardProbe = { export async function execOpenShell(args: string[]) { const { stdout, stderr } = await execFileAsync(OPENSHELL_BIN, args, { - env: { - ...process.env, - PATH: HOST_PATH, + env: hostCommandEnv({ + OPENSHELL_GATEWAY, NO_COLOR: "1", CLICOLOR: "0", CLICOLOR_FORCE: "0", - }, + }), }) return { stdout, stderr } } diff --git a/app/lib/sandboxMcpManifest.ts b/app/lib/sandboxMcpManifest.ts index f835147..65aa71a 100644 --- a/app/lib/sandboxMcpManifest.ts +++ b/app/lib/sandboxMcpManifest.ts @@ -61,6 +61,30 @@ export async function buildSandboxMcpBrokerHandoff( token, "```", "", + "## Quick Check", + "", + "Run this inside the sandbox to verify that you are using the current broker token without pasting it into your shell history:", + "", + "```sh", + "node - <<'NODE'", + "const fs = require('fs')", + `const url = ${JSON.stringify(`${brokerBaseUrl}/mcp`)}`, + "const manifest = fs.readFileSync('/sandbox/openshell_control_mcp.md', 'utf8')", + "const token = manifest.match(/```\\n(osmcp_[^\\n]+)\\n```/)?.[1]", + "if (!token) throw new Error('MCP broker token not found in /sandbox/openshell_control_mcp.md')", + "const payload = { jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} }", + "fetch(url, {", + " method: 'POST',", + " headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },", + " body: JSON.stringify(payload),", + "})", + " .then(async (response) => {", + " const body = await response.json()", + " console.log(JSON.stringify({ status: response.status, tools: body.result?.tools?.map((tool) => tool.name) || [], error: body.error || null }, null, 2))", + " })", + "NODE", + "```", + "", "## Rules", "", "- Do not assume any MCP server exists unless the broker returns it as available.", diff --git a/app/lib/sandboxPermissions.ts b/app/lib/sandboxPermissions.ts index 1694366..d9134c4 100644 --- a/app/lib/sandboxPermissions.ts +++ b/app/lib/sandboxPermissions.ts @@ -75,12 +75,40 @@ function parseNetworkRules(output: string): SandboxNetworkRule[] { .filter((rule) => rule.chunkId) } +function hostPortForUrl(parsed: URL) { + const port = parsed.port || (parsed.protocol === "https:" ? "443" : "80") + return `${parsed.hostname}:${port}` +} + +function addEndpointCandidate(candidates: Set, parsed: URL) { + const hostPort = hostPortForUrl(parsed) + candidates.add(hostPort) + if (parsed.hostname === "host.docker.internal") { + const port = parsed.port || (parsed.protocol === "https:" ? "443" : "80") + candidates.add(`0.0.0.0:${port}`) + } +} + +function extractProxiedTargetUrl(brokerBaseUrl: string) { + try { + const parsed = new URL(brokerBaseUrl) + const rawPath = parsed.pathname.replace(/^\/+/, "") + const decodedPath = decodeURIComponent(rawPath) + if (!/^https?:\/\//i.test(decodedPath)) return null + return new URL(decodedPath) + } catch { + return null + } +} + function brokerEndpointCandidates(brokerBaseUrl: string) { const parsed = new URL(brokerBaseUrl) - const port = parsed.port || (parsed.protocol === "https:" ? "443" : "80") - const hostPort = `${parsed.hostname}:${port}` - const candidates = new Set([hostPort]) - if (parsed.hostname === "host.docker.internal") candidates.add(`0.0.0.0:${port}`) + const candidates = new Set() + addEndpointCandidate(candidates, parsed) + + const proxiedTarget = extractProxiedTargetUrl(brokerBaseUrl) + if (proxiedTarget) addEndpointCandidate(candidates, proxiedTarget) + return candidates } @@ -153,13 +181,23 @@ async function probeBrokerEndpoint(sandboxName: string, brokerBaseUrl: string) { } const script = [ "node", + "--input-type=module", "-e", ` - fetch(${JSON.stringify(mcpUrl)}, { - method: "POST", - headers: { "content-type": "application/json" }, - body: ${JSON.stringify(JSON.stringify(payload))}, - }).catch(() => {}); + const controller = new AbortController(); + const timeout = setTimeout(() => controller.abort(), 8000); + try { + await fetch(${JSON.stringify(mcpUrl)}, { + method: "POST", + headers: { "content-type": "application/json" }, + body: ${JSON.stringify(JSON.stringify(payload))}, + signal: controller.signal, + }); + } catch { + // The probe only exists to let OpenShell create a policy chunk. + } finally { + clearTimeout(timeout); + } `, ] await runOpenShell(["sandbox", "exec", "-n", sandboxName, "--", ...script], 15000).catch(() => null) diff --git a/install.sh b/install.sh index bb782d2..0bd560c 100755 --- a/install.sh +++ b/install.sh @@ -403,6 +403,10 @@ NEXT_PUBLIC_API_BASE=/api NEXT_PUBLIC_ENABLE_SANDBOX_OPERATIONS=true OPEN_SHELL_CONTAINER=${OPEN_SHELL_CONTAINER_DEFAULT} OPENSHELL_GATEWAY=nemoclaw +# For containerized CLI runs, when supported by the installed OpenShell/NemoClaw versions: +# OPENSHELL_GATEWAY_HOST=host.docker.internal +# OPENSHELL_GATEWAY_PORT=8080 +# OPENSHELL_GATEWAY_URL=http://host.docker.internal:8080 EOF else log "Keeping existing $ENV_FILE" @@ -413,6 +417,9 @@ upsert_env "NEXT_PUBLIC_API_BASE" "/api" upsert_env "NEXT_PUBLIC_ENABLE_SANDBOX_OPERATIONS" "true" upsert_env "OPEN_SHELL_CONTAINER" "$OPEN_SHELL_CONTAINER_DEFAULT" upsert_env "OPENSHELL_GATEWAY" "nemoclaw" +set_env "OPENSHELL_GATEWAY_HOST" "${OPENSHELL_GATEWAY_HOST:-}" +set_env "OPENSHELL_GATEWAY_PORT" "${OPENSHELL_GATEWAY_PORT:-}" +set_env "OPENSHELL_GATEWAY_URL" "${OPENSHELL_GATEWAY_URL:-}" set_env "OPENSHELL_CONTROL_VENV" "${VIRTUAL_ENV:-$PROJECT_VENV}" set_env "OPENSHELL_HOME" "${HOME:-}" set_env "OPENSHELL_BIN" "${OPENSHELL_BIN:-}" diff --git a/install_versioned_nemoclaw_openshell.sh b/install_versioned_nemoclaw_openshell.sh index ef422f0..c5a5b41 100755 --- a/install_versioned_nemoclaw_openshell.sh +++ b/install_versioned_nemoclaw_openshell.sh @@ -54,6 +54,9 @@ Environment overrides: NEMOCLAW_NON_INTERACTIVE NEMOCLAW_EXPERIMENTAL NEMOCLAW_PROVIDER + OPENSHELL_GATEWAY_HOST + OPENSHELL_GATEWAY_PORT + OPENSHELL_GATEWAY_URL NVIDIA_API_KEY EOF } diff --git a/tests/mcp-configuration-page-check.mjs b/tests/mcp-configuration-page-check.mjs index 41cc3a5..1ba6d2b 100644 --- a/tests/mcp-configuration-page-check.mjs +++ b/tests/mcp-configuration-page-check.mjs @@ -115,6 +115,8 @@ assert.match(manifestSource, /syncSandboxMcpManifest/, 'MCP sandbox manifest mus assert.match(manifestSource, /writeSandboxFilePrivileged/, 'MCP sandbox manifest must use a privileged write path for root-owned /sandbox mounts') assert.match(manifestSource, /syncSandboxOpenClawMcpConfig/, 'MCP sandbox manifest sync must also configure OpenClaw MCP') assert.match(manifestSource, /\/mcp/, 'MCP sandbox handoff must include the protocol-compatible MCP endpoint') +assert.match(manifestSource, /Quick Check/, 'MCP sandbox handoff must include a token-safe local verification snippet') +assert.match(manifestSource, /tools\/list/, 'MCP sandbox handoff quick check should verify tool discovery') assert.match(privilegedFilesSource, /kubectl/, 'privileged sandbox file writes must use the OpenShell cluster control path') assert.doesNotMatch(manifestSource, /allowedServers|renderServer|commandLine/, 'MCP sandbox handoff must not disclose server inventory or launch specs') assert.match(manifestSource, /control plane enforces/, 'MCP sandbox handoff must explain broker-side enforcement') @@ -135,6 +137,8 @@ assert.match(sandboxMcpRouteSource, /brokerBaseUrlForSandbox/, 'Sandbox MCP brok assert.match(sandboxMcpRouteSource, /synced\.openClaw\.path/, 'Sandbox MCP sync response must report the OpenClaw config write') assert.match(brokerUrlSource, /discoverOpenShellDockerGateway/, 'Sandbox MCP broker handoff must discover the active OpenShell network gateway') assert.match(brokerUrlSource, /LOCAL_HOSTNAMES/, 'Sandbox MCP broker handoff must rewrite local-only browser origins') +assert.match(brokerUrlSource, /shouldUseProxyWrappedBrokerUrl/, 'Sandbox MCP broker handoff must make proxy-wrapped URLs opt-in') +assert.match(brokerUrlSource, /if \(!shouldUseProxyWrappedBrokerUrl\(\)\) return hostBrokerUrl/, 'Sandbox MCP broker handoff must prefer the direct gateway URL by default') assert.match(brokerUrlSource, /discoverSandboxProxyOrigin/, 'Sandbox MCP broker handoff must discover each sandbox proxy endpoint') assert.match(brokerUrlSource, /HTTP_PROXY/, 'Sandbox MCP broker handoff must derive the proxy endpoint from sandbox environment') assert.match(brokerUrlSource, /FALLBACK_SANDBOX_PROXY_ORIGIN/, 'Sandbox MCP broker handoff may keep a fallback for older OpenShell layouts') @@ -143,6 +147,11 @@ assert.match(sandboxOpenClawMcpConfigSource, /streamable-http/, 'OpenClaw MCP br assert.match(sandboxOpenClawMcpConfigSource, /Authorization: `Bearer \$\{token\}`/, 'OpenClaw MCP broker config must pass the sandbox broker token as bearer auth') assert.match(sandboxOpenClawMcpConfigSource, /restartOpenClawGatewayIfRunning/, 'OpenClaw gateway must restart after MCP config changes') assert.match(sandboxPermissionsSource, /method: "initialize"[\s\S]*method: "POST"/, 'MCP broker network sync must probe the actual streamable HTTP POST initialize path') +assert.match(sandboxPermissionsSource, /"--input-type=module"/, 'MCP broker network sync probe must support top-level await') +assert.match(sandboxPermissionsSource, /await fetch\(/, 'MCP broker network sync probe must wait for the policy-generating request') +assert.match(sandboxPermissionsSource, /extractProxiedTargetUrl/, 'MCP broker network sync must inspect proxy-wrapped target URLs') +assert.match(sandboxPermissionsSource, /const proxiedTarget = extractProxiedTargetUrl\(brokerBaseUrl\)/, 'MCP broker network sync must derive the target host behind the sandbox HTTP proxy') +assert.match(sandboxPermissionsSource, /if \(proxiedTarget\) addEndpointCandidate\(candidates, proxiedTarget\)/, 'MCP broker network sync must approve the proxied broker target host') assert.match(middlewareSource, /\/api\/mcp\/broker/, 'MCP broker endpoints must bypass dashboard cookie auth and rely on broker token auth') assert.match(routeSource, /export async function GET/, 'MCP API must list server configuration') assert.match(routeSource, /export async function POST/, 'MCP API must install and update server configuration') diff --git a/tests/openclaw-dashboard-bootstrap-token-scope-check.mjs b/tests/openclaw-dashboard-bootstrap-token-scope-check.mjs new file mode 100644 index 0000000..4e56b85 --- /dev/null +++ b/tests/openclaw-dashboard-bootstrap-token-scope-check.mjs @@ -0,0 +1,50 @@ +import assert from 'node:assert/strict' +import { readFile } from 'node:fs/promises' +import path from 'node:path' + +const root = process.cwd() +const proxyPath = path.join(root, 'app/api/openshell/dashboard/proxy/shared.ts') +const proxySource = await readFile(proxyPath, 'utf8') + +assert.match( + proxySource, + /const pageGatewayUrl = protocol \+ '\/\/' \+ window\.location\.host \+ proxyPrefix/, + 'dashboard bootstrap should know the same-origin websocket gateway scope' +) +assert.match( + proxySource, + /const sidecarGatewayUrl = protocol \+ '\/\/' \+ sidecarHost \+ proxyPrefix/, + 'dashboard bootstrap should know the dedicated websocket sidecar gateway scope' +) +assert.match( + proxySource, + /const gatewayUrl = \(hashParams\.get\('gatewayUrl'\) \|\| ''\)\.trim\(\) \|\| sidecarGatewayUrl/, + 'dashboard bootstrap should honor the tokenized launch gateway URL' +) +assert.match( + proxySource, + /const settingsPrefix = 'openclaw\.control\.settings\.v1:';/, + 'dashboard bootstrap should write OpenClaw scoped settings' +) +assert.match( + proxySource, + /const gatewayScopes = uniqueScopes\(\[gatewayUrl, sidecarGatewayUrl, pageGatewayUrl\]\)/, + 'dashboard bootstrap should seed token scopes for launch, sidecar, and page gateways' +) +assert.match( + proxySource, + /for \(const key of settingsKeys\) window\.localStorage\.setItem\(key, serializedSettings\)/, + 'dashboard bootstrap should write settings to all gateway-scoped keys' +) +assert.match( + proxySource, + /for \(const scope of gatewayScopes\) window\.sessionStorage\.setItem\(tokenPrefix \+ scope, token\)/, + 'dashboard bootstrap should write the OpenClaw token to every gateway scope' +) +assert.doesNotMatch( + proxySource, + /const tokenScope = gatewayUrl/, + 'dashboard bootstrap must not restrict the token to only one gateway scope' +) + +console.log('openclaw-dashboard-bootstrap-token-scope-check: PASS dashboard bootstrap token scope assertions') diff --git a/tests/portable-install-check.mjs b/tests/portable-install-check.mjs index 449cf81..4e7b9d5 100644 --- a/tests/portable-install-check.mjs +++ b/tests/portable-install-check.mjs @@ -95,7 +95,8 @@ assert.match(createRouteSource, /mode: "legacy-setup"/, 'NemoClaw blueprint crea assert.match(createRouteSource, /NemoClaw CLI was not found/, 'missing current CLI must produce an actionable error') assert.match(createRouteSource, /NEMOCLAW_BIN_CANDIDATES\.join/, 'missing current CLI error must list searched candidates') assert.match(createRouteSource, /from "@\/app\/lib\/hostCommands"/, 'create route must use shared command resolution') -assert.match(deleteRouteSource, /NEMOCLAW_CWD/, 'delete route must use resolved NemoClaw working directory') +assert.match(deleteRouteSource, /hostCommandEnv/, 'delete route must use shared host command environment') +assert.doesNotMatch(deleteRouteSource, /NEMOCLAW_CWD|NEMOCLAW_BIN/, 'delete route must not launch NemoClaw cleanup after OpenShell deletion') for (const [label, source] of [ ['telemetry', telemetrySource], diff --git a/tests/sandbox-lifecycle-check.mjs b/tests/sandbox-lifecycle-check.mjs index 7b9d19b..df202e7 100644 --- a/tests/sandbox-lifecycle-check.mjs +++ b/tests/sandbox-lifecycle-check.mjs @@ -60,8 +60,17 @@ assert.match( 'blueprint create response must expose readiness polling metadata', ) assert.match(createRouteSource, /"onboard", "--non-interactive", "--recreate-sandbox"/, 'blueprint create must use the Monday-era normal NemoClaw onboard flow') -assert.doesNotMatch(createRouteSource, /"--from"|resolvePreferredNemoClawDockerfile|prepareDashboardOwnedNemoClawDockerfile/, 'blueprint create must not force the explicit Dockerfile path') +assert.doesNotMatch(createRouteSource, /resolvePreferredNemoClawDockerfile|prepareDashboardOwnedNemoClawDockerfile/, 'blueprint create must not force the explicit Dockerfile path') assert.match(createRouteSource, /NEMOCLAW_SANDBOX_NAME: sandboxName/, 'blueprint create must pass the requested sandbox name to NemoClaw onboarding') +assert.match(createRouteSource, /id: "redeploy-image"/, 'create API must expose image redeploy as a sandbox creation path') +assert.match(createRouteSource, /label: "Quick Deploy New NemoClaw Sandbox"/, 'image redeploy must be labeled as the quick deploy default path') +assert.match(createRouteSource, /label: "Fresh NemoClaw Image"/, 'full rebuild path must be labeled as fresh image creation') +assert.match(createRouteSource, /readNemoClawRegistry/, 'image redeploy must discover the default NemoClaw sandbox image automatically') +assert.match(createRouteSource, /listOpenShellSandboxNames/, 'image redeploy must fall back to live OpenShell inventory when registry entries are stale') +assert.match(createRouteSource, /resolveSourcePodImage\(sourceSandboxName, sandboxName\)/, 'image redeploy must allow optional explicit source while defaulting automatically') +assert.match(createRouteSource, /"--from",\s*sourceImage/, 'image redeploy must pass the resolved image to openshell sandbox create') +assert.match(createRouteSource, /"--auto-providers"/, 'image redeploy must use OpenShell auto providers for provider-backed images') +assert.match(createRouteSource, /registerNemoClawImageRedeploy/, 'image redeploy must register the new sandbox without a full NemoClaw rebuild') assert.match(createRouteSource, /const requestedMode = typeof raw\.mode === "string" \? raw\.mode : "vllm"/, 'blueprint create must default to vLLM experimental onboarding when the UI payload is absent') assert.match(createRouteSource, /NEMOCLAW_EXPERIMENTAL = "1"/, 'blueprint create must support NemoClaw experimental provider onboarding') assert.match(createRouteSource, /NEMOCLAW_PROVIDER = "vllm"/, 'blueprint create must support the vLLM onboarding provider') @@ -105,9 +114,20 @@ assert.match(deleteRouteSource, /resolveSandboxRef/, 'delete route must resolve assert.match(deleteRouteSource, /OPENSHELL_GATEWAY: process\.env\.OPENSHELL_GATEWAY \|\| "nemoclaw"/, 'delete route must use the NemoClaw gateway context') assert.match(hostCommandsSource, /export function hostCommandEnv/, 'host commands must provide a shared environment for OpenShell child processes') assert.match(hostCommandsSource, /XDG_CONFIG_HOME/, 'shared host command environment must preserve the OpenShell config home') +assert.match(hostCommandsSource, /export function openshellGatewayAddressEnv/, 'shared host command environment must expose gateway address override variables') +assert.match(hostCommandsSource, /OPENSHELL_GATEWAY_HOST/, 'shared host command environment must pass a configurable gateway host to child processes') +assert.match(hostCommandsSource, /OPENSHELL_GATEWAY_PORT/, 'shared host command environment must pass a configurable gateway port to child processes') +assert.match(hostCommandsSource, /OPENSHELL_GATEWAY_URL/, 'shared host command environment must pass or synthesize a gateway URL for child processes') +assert.match(hostCommandsSource, /gateway\.json/, 'shared host command environment must read gateway address config from the OpenShell config directory') +assert.match(hostCommandsSource, /config\.json/, 'shared host command environment must also support the general OpenShell config file') +assert.match(hostCommandsSource, /gatewayHost/, 'OpenShell gateway address config must support a top-level gatewayHost key') +assert.match(hostCommandsSource, /gateway\.host/, 'OpenShell gateway address config must support a nested gateway host key') +assert.match(createRouteSource, /const env: NodeJS\.ProcessEnv = hostCommandEnv\(\{[\s\S]*NEMOCLAW_SANDBOX_NAME: sandboxName[\s\S]*OPENSHELL_GATEWAY: process\.env\.OPENSHELL_GATEWAY \|\| "nemoclaw"/, 'NemoClaw onboard must receive the shared host command environment') +assert.match(deleteRouteSource, /env: hostCommandEnv\(\{[\s\S]*OPENSHELL_GATEWAY: process\.env\.OPENSHELL_GATEWAY \|\| "nemoclaw"/, 'delete route must pass the shared host command environment to OpenShell') assert.match(deleteRouteSource, /waitForSandboxDeleted/, 'delete route must poll authoritative inventory until the sandbox is gone') -assert.match(deleteRouteSource, /cleanupNemoClawSandbox/, 'delete route must clean up NemoClaw registry state after deleting from OpenShell') -assert.match(deleteRouteSource, /\[sandboxName, "destroy", "--yes"\]/, 'delete route must match the Monday-era NemoClaw destroy cleanup path') +assert.doesNotMatch(deleteRouteSource, /cleanupNemoClawSandbox/, 'delete route must not run NemoClaw destroy cleanup after OpenShell deletion') +assert.doesNotMatch(deleteRouteSource, /isNemoClawSandboxNotRegistered/, 'delete route must not keep NemoClaw registry cleanup helpers') +assert.doesNotMatch(deleteRouteSource, /\[sandboxName, "destroy", "--yes"\]/, 'delete route must not call nemoclaw destroy because it can delete the gateway') assert.doesNotMatch(deleteRouteSource, /Pruned NemoClaw registry entry without destroying the shared OpenShell gateway|cleanupGatewayAfterLastSandbox/, 'delete route must not include the later registry-prune rewrite') assert.match(deleteRouteSource, /openShellAlreadyGone/, 'delete route must tolerate sandboxes that OpenShell already deleted while NemoClaw still has registry state') assert.doesNotMatch(deleteRouteSource, /isGatewayRecoverable|recoverableGateway/, 'delete route must not include the later gateway-repair branching') @@ -181,5 +201,7 @@ assert.doesNotMatch(configPanelSource, /onInventoryRefresh/, 'create panel must assert.match(configPanelSource, /Use vLLM in experimental mode/, 'create panel must expose vLLM experimental onboarding') assert.match(configPanelSource, /Use NVIDIA NIM/, 'create panel must expose NVIDIA NIM onboarding') assert.match(configPanelSource, /createInference/, 'create panel must send create-time inference settings') +assert.match(configPanelSource, /useState\('redeploy-image'\)/, 'create panel must default to quick deploy') +assert.doesNotMatch(configPanelSource, /Source Sandbox|sourceSandboxName/, 'basic create panel must not require choosing a source image') console.log('sandbox-lifecycle-check: PASS create/destroy lifecycle assertions')