import { NextResponse } from "next/server" import { execFile, spawn } from "node:child_process" import { promisify } from "node:util" import { inspectSandbox } 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, } from "@/app/lib/hostCommands" const execFileAsync = promisify(execFile) 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[] } 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"}.`, ) } 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 approveOpenClawDeviceRequests(sandboxName: string) { const result = await runCreateCommandBounded(OPENSHELL_BIN, [ "sandbox", "exec", "-n", sandboxName, "--", "sh", "-lc", "openclaw devices approve --latest --json --timeout 10000", ], { ...process.env, PATH: HOST_PATH, OPENSHELL_GATEWAY: process.env.OPENSHELL_GATEWAY || "nemoclaw", NO_COLOR: "1", CLICOLOR: "0", CLICOLOR_FORCE: "0", }, 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: "New NemoClaw Sandbox", 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, }, ], }) } 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 = { ...process.env, PATH: HOST_PATH, 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 = { ...process.env, PATH: HOST_PATH, 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 }) } 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 }) } }