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, resolveSandboxRef } from "@/app/lib/openshellHost" import { repairOpenClawExecApprovalsFile } from "@/app/lib/sandboxPrivilegedFiles" import { commandExists, HOST_PATH, NEMOCLAW_BIN, NEMOCLAW_BIN_CANDIDATES, NEMOCLAW_CWD, NEMOCLAW_SETUP, 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") if (name.length > 63) throw new Error("sandbox name too long (max 63 chars)") if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(name)) { throw new Error("sandbox name must be lowercase alphanumeric with optional internal hyphens") } return name } type SandboxVerification = { verified: boolean summary: string details?: { name: string id: string | null phase: string | null namespace: string | null sshHostAlias: string rawPhase: string | null rawDetails: string } error?: string } const AUTHORITATIVE_SUCCESS_PHASE = "Ready" const NO_PENDING_DEVICE_REQUESTS = /no pending device pairing requests/i function elapsedMs(start: number) { return Date.now() - start } function appendNote(...parts: Array) { return parts.filter(Boolean).join(" ") } type NemoClawCreateCommand = { file: string args: string[] mode: "cli-onboard" | "legacy-setup" } type CreateInferenceMode = "auto" | "vllm" | "nim" type CreateInferenceSettings = { mode: CreateInferenceMode model: string hasApiKey: boolean 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" const mode: CreateInferenceMode = requestedMode === "vllm" || requestedMode === "nim" ? requestedMode : "auto" const model = typeof raw.model === "string" ? raw.model.trim() : "" const apiKey = typeof raw.apiKey === "string" ? raw.apiKey.trim() : "" return { mode, model, hasApiKey: Boolean(apiKey), envSummary: [], } } function applyCreateInferenceEnv(env: NodeJS.ProcessEnv, settings: CreateInferenceSettings, body: any) { if (settings.mode === "auto") return settings env.NEMOCLAW_EXPERIMENTAL = "1" settings.envSummary.push("NEMOCLAW_EXPERIMENTAL=1") if (settings.mode === "vllm") { env.NEMOCLAW_PROVIDER = "vllm" settings.envSummary.push("NEMOCLAW_PROVIDER=vllm") } if (settings.mode === "nim") { env.NEMOCLAW_PROVIDER = "nim-local" settings.envSummary.push("NEMOCLAW_PROVIDER=nim-local") const apiKey = typeof body?.createInference?.apiKey === "string" ? body.createInference.apiKey.trim() : "" if (apiKey) { env.NVIDIA_API_KEY = apiKey env.NEMOCLAW_PROVIDER_KEY = apiKey settings.envSummary.push("NVIDIA_API_KEY=", "NEMOCLAW_PROVIDER_KEY=") } } if (settings.model) { env.NEMOCLAW_MODEL = settings.model settings.envSummary.push(`NEMOCLAW_MODEL=${settings.model}`) } return settings } function buildNemoClawCreateCommand(): NemoClawCreateCommand { if (NEMOCLAW_BIN && commandExists(NEMOCLAW_BIN)) { const args = ["onboard", "--non-interactive", "--recreate-sandbox", "--yes-i-accept-third-party-software"] return /\.(?:c?m?js|ts)$/i.test(NEMOCLAW_BIN) ? { file: NODE_BIN, args: [NEMOCLAW_BIN, ...args], mode: "cli-onboard" } : { file: NEMOCLAW_BIN, args, mode: "cli-onboard" } } if (NEMOCLAW_SETUP && commandExists(NEMOCLAW_SETUP)) { return { file: "/bin/bash", args: [NEMOCLAW_SETUP], mode: "legacy-setup" } } throw new Error( `NemoClaw CLI was not found. Install the current NemoClaw CLI under your Linux home directory, or set NEMOCLAW_BIN in .env.local. Searched CLI: ${NEMOCLAW_BIN_CANDIDATES.join(", ") || "no candidates"}. Legacy setup candidates: ${NEMOCLAW_SETUP_CANDIDATES.join(", ") || "none"}.`, ) } 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}`) try { const sandbox = await inspectSandbox(sandboxName) const phase = sandbox.phase ?? "Unknown" const rawPhase = sandbox.rawPhase ?? "Unknown" const verified = rawPhase === AUTHORITATIVE_SUCCESS_PHASE console.log( `[sandbox/create] verify:done sandbox=${sandboxName} rawPhase=${rawPhase} normalizedPhase=${phase} verified=${verified} elapsedMs=${elapsedMs(startedAt)}`, ) return { verified, summary: verified ? `Verified via openshell sandbox get with authoritative phase (${rawPhase}).` : `Sandbox lookup succeeded, but authoritative phase was not ready (${rawPhase}); normalized phase=${phase}.`, details: { name: sandbox.name, id: sandbox.id, phase: sandbox.phase, namespace: sandbox.namespace, sshHostAlias: sandbox.sshHostAlias, rawPhase: sandbox.rawPhase, rawDetails: sandbox.rawDetails, }, ...(verified ? {} : { error: `Sandbox authoritative phase ${rawPhase} is not the required success state ${AUTHORITATIVE_SUCCESS_PHASE}.` }), } } catch (error) { const message = error instanceof Error ? error.message : String(error ?? "Sandbox verification failed") console.log(`[sandbox/create] verify:error sandbox=${sandboxName} elapsedMs=${elapsedMs(startedAt)} message=${message}`) return { verified: false, summary: "Create command returned success, but post-create authoritative verification failed.", error: message, } } } async function runCommand(file: string, args: string[], env: NodeJS.ProcessEnv, cwd?: string) { const startedAt = Date.now() console.log(`[sandbox/create] command:start file=${file} args=${JSON.stringify(args)}`) try { const { stdout, stderr } = await execFileAsync(file, args, { cwd, env, maxBuffer: 20 * 1024 * 1024, }) console.log(`[sandbox/create] command:done file=${file} elapsedMs=${elapsedMs(startedAt)} stdoutBytes=${String(stdout).length} stderrBytes=${String(stderr).length}`) 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 ?? "Command failed") console.log( `[sandbox/create] command:error file=${file} elapsedMs=${elapsedMs(startedAt)} message=${message} stdoutBytes=${String(error?.stdout || "").length} stderrBytes=${String(error?.stderr || "").length}`, ) return { ok: false as const, stdout: String(error?.stdout || "").trim(), stderr: String(error?.stderr || "").trim(), error: message, } } } async function runCreateCommandBounded(file: string, args: string[], env: NodeJS.ProcessEnv, timeoutMs: number) { const startedAt = Date.now() console.log(`[sandbox/create] bounded-command:start file=${file} args=${JSON.stringify(args)} timeoutMs=${timeoutMs}`) return await new Promise<{ completed: boolean timedOut: 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 const finish = (result: { completed: boolean timedOut: boolean exitCode: number | null signal: NodeJS.Signals | null stdout: string stderr: string error?: string }) => { if (settled) return settled = true clearTimeout(timer) 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] bounded-command:error file=${file} elapsedMs=${elapsedMs(startedAt)} message=${message}`) finish({ completed: false, timedOut: false, exitCode: null, signal: null, stdout: stdout.trim(), stderr: stderr.trim(), error: message, }) }) child.on("close", (code, signal) => { console.log(`[sandbox/create] bounded-command:close file=${file} elapsedMs=${elapsedMs(startedAt)} code=${code} signal=${signal} stdoutBytes=${stdout.length} stderrBytes=${stderr.length}`) finish({ completed: true, timedOut: false, exitCode: code, signal, stdout: stdout.trim(), stderr: stderr.trim(), ...(code === 0 ? {} : { error: `Command exited with code ${code}${signal ? ` signal ${signal}` : ""}` }), }) }) const timer = setTimeout(() => { console.log(`[sandbox/create] bounded-command:timeout file=${file} elapsedMs=${elapsedMs(startedAt)} sending=SIGTERM`) child.kill("SIGTERM") setTimeout(() => { if (!settled) { console.log(`[sandbox/create] bounded-command:timeout-escalate file=${file} elapsedMs=${elapsedMs(startedAt)} sending=SIGKILL`) child.kill("SIGKILL") } }, 2000) finish({ completed: false, timedOut: true, exitCode: null, signal: "SIGTERM", stdout: stdout.trim(), stderr: stderr.trim(), error: `Command exceeded timeout of ${timeoutMs}ms`, }) }, timeoutMs) }) } 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", "exec", "-n", sandboxName, "--", "sh", "-lc", "openclaw devices approve --latest --json --timeout 10000", ], hostCommandEnv({ OPENSHELL_GATEWAY: process.env.OPENSHELL_GATEWAY || "nemoclaw", }), 15000) const combinedOutput = `${result.stdout}\n${result.stderr}`.trim() const noPending = NO_PENDING_DEVICE_REQUESTS.test(combinedOutput) return { attempted: true, approved: result.completed && result.exitCode === 0, noPending, completed: result.completed, timedOut: result.timedOut, exitCode: result.exitCode, signal: result.signal, stdout: result.stdout, stderr: result.stderr, error: noPending ? undefined : result.error, note: result.completed && result.exitCode === 0 ? "Ran openclaw devices approve --latest inside the sandbox." : noPending ? "Ran openclaw devices approve --latest inside the sandbox; no pending device pairing requests were present." : "Attempted openclaw device approval inside the sandbox, but it did not complete successfully.", } } async function waitForSandboxReady(sandboxName: string, timeoutMs: number, intervalMs: number) { const startedAt = Date.now() let lastVerification: SandboxVerification | null = null let attempts = 0 while (elapsedMs(startedAt) < timeoutMs) { attempts += 1 lastVerification = await verifySandboxCreation(sandboxName) console.log(`[sandbox/create] readiness:attempt sandbox=${sandboxName} attempt=${attempts} verified=${lastVerification.verified} elapsedMs=${elapsedMs(startedAt)}`) if (lastVerification.verified) { return { verified: true as const, verification: lastVerification, attempts, elapsedMs: elapsedMs(startedAt), } } await new Promise((resolve) => setTimeout(resolve, intervalMs)) } return { verified: false as const, verification: lastVerification, attempts, elapsedMs: elapsedMs(startedAt), } } export async function GET() { return NextResponse.json({ ok: true, blueprints: [ { id: "nemoclaw-blueprint", label: "Fresh NemoClaw Image", description: "Bootstraps a full NemoClaw sandbox using the nemoclaw-blueprint workflow.", type: "blueprint", source: "~/NemoClaw/nemoclaw-blueprint/blueprint.yaml", supportsTailscale: true, }, { id: "custom-sandbox", label: "New Custom Sandbox", description: "Create a generic OpenShell sandbox with a custom policy path.", type: "custom", 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, }, ], }) } export async function POST(request: Request) { const requestStartedAt = Date.now() console.log(`[sandbox/create] request:start elapsedMs=0`) try { const body = await request.json() const blueprint = typeof body?.blueprint === "string" ? body.blueprint : "" const sandboxName = validateSandboxName(typeof body?.sandboxName === "string" ? body.sandboxName.trim() : "") const policy = body?.policy && typeof body.policy === "object" ? body.policy : null const enableTailscale = Boolean(body?.enableTailscale) const createInference = parseCreateInferenceSettings(body) console.log(`[sandbox/create] request:parsed sandbox=${sandboxName} blueprint=${blueprint} enableTailscale=${enableTailscale} inferenceMode=${createInference.mode} elapsedMs=${elapsedMs(requestStartedAt)}`) if (!blueprint) { return NextResponse.json({ ok: false, error: "blueprint is required" }, { status: 400 }) } if (blueprint === "nemoclaw-blueprint") { const createCommand = buildNemoClawCreateCommand() 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" } applyCreateInferenceEnv(env, createInference, body) const result = await runCommand( createCommand.file, createCommand.mode === "legacy-setup" ? [...createCommand.args, sandboxName] : createCommand.args, env, NEMOCLAW_CWD, ) if (!result.ok) { return NextResponse.json({ ok: false, error: result.error, stdout: result.stdout, stderr: result.stderr, blueprint, sandboxName, enableTailscale, createInference, }, { status: 500 }) } 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 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} readinessAttempts=${readiness.attempts} deviceApproval=${deviceApproval?.approved ?? false} elapsedMs=${elapsedMs(requestStartedAt)}`, ) return NextResponse.json({ ok: created, blueprint, sandboxName, created, verified: verification.verified, verification, mode: "nemoclaw-blueprint", enableTailscale, createInference, createCommand, hostPath: HOST_PATH, readiness: { attempts: readiness.attempts, elapsedMs: readiness.elapsedMs, }, execApprovalsRepair, deviceApproval, stdout: result.stdout, stderr: result.stderr, note: created ? appendNote( enableTailscale ? "NemoClaw blueprint workflow completed with Tailscale-enabled prerequisites. Existing healthy OpenShell gateways are reused before any new gateway start is attempted." : "NemoClaw blueprint workflow completed in local/default mode. Existing healthy OpenShell gateways are reused before any new gateway start is attempted.", execApprovalsRepair && "note" in execApprovalsRepair ? execApprovalsRepair.note : false, execApprovalsRepair && "error" in execApprovalsRepair ? `OpenClaw exec approvals repair failed: ${execApprovalsRepair.error}` : false, deviceApproval?.note, ) : "Blueprint command reported success, but the sandbox never reached a ready verification state afterward.", }, { status: created ? 200 : 502 }) } if (blueprint === "custom-sandbox") { 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) { return NextResponse.json({ ok: false, error: createAttempt.error ?? `create command failed with exit code ${createAttempt.exitCode}`, stdout: createAttempt.stdout, stderr: createAttempt.stderr, blueprint, sandboxName, }, { status: 500 }) } 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 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 const policyPrepared = Boolean(policy) console.log( `[sandbox/create] request:complete sandbox=${sandboxName} created=${created} createTimedOut=${createAttempt.timedOut} readinessAttempts=${readiness.attempts} deviceApproval=${deviceApproval?.approved ?? false} elapsedMs=${elapsedMs(requestStartedAt)}`, ) return NextResponse.json({ ok: created, blueprint, sandboxName, created, verified: verification.verified, verification, mode: "custom-sandbox", stdout: createAttempt.stdout, stderr: createAttempt.stderr, createCommand: { completed: createAttempt.completed, timedOut: createAttempt.timedOut, exitCode: createAttempt.exitCode, signal: createAttempt.signal, error: createAttempt.error, }, readiness: { attempts: readiness.attempts, elapsedMs: readiness.elapsedMs, }, execApprovalsRepair, deviceApproval, policyPrepared, note: created ? appendNote( createAttempt.timedOut ? "Custom sandbox reached Ready even though the create CLI did not exit promptly." : (policyPrepared ? "Custom sandbox created. Policy draft is prepared, but applying it live should be a follow-up action." : "Custom sandbox created."), execApprovalsRepair && "note" in execApprovalsRepair ? execApprovalsRepair.note : false, execApprovalsRepair && "error" in execApprovalsRepair ? `OpenClaw exec approvals repair failed: ${execApprovalsRepair.error}` : false, deviceApproval?.note, ) : "Create command started, but the sandbox never reached a ready verification state afterward.", }, { 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" const status = /required|must be|too long|unknown blueprint/.test(message) ? 400 : 500 console.log(`[sandbox/create] request:error elapsedMs=${elapsedMs(requestStartedAt)} message=${message}`) return NextResponse.json({ ok: false, error: message }, { status }) } }