Add the upstream NemoClaw Deep Agents Code sandbox option and keep managed agent create args generalized. Validated with tests, build, diff check, and local read-only runtime/API smokes.
1141 lines
43 KiB
TypeScript
1141 lines
43 KiB
TypeScript
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 { recordActivity } from "@/app/lib/activityLog"
|
|
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<string | false | null | undefined>) {
|
|
return parts.filter(Boolean).join(" ")
|
|
}
|
|
|
|
async function recordCreateActivity(entry: Parameters<typeof recordActivity>[0]) {
|
|
try {
|
|
await recordActivity(entry)
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : String(error ?? "activity log write failed")
|
|
console.warn(`[sandbox/create] activity-log:error message=${message}`)
|
|
}
|
|
}
|
|
|
|
type NemoClawCreateCommand = {
|
|
file: string
|
|
args: string[]
|
|
mode: "cli-onboard" | "legacy-setup"
|
|
}
|
|
|
|
type CreateInferenceMode = "auto" | "vllm" | "nim"
|
|
type CreateGpuMode = "none" | "auto" | "required"
|
|
type NemoClawAgent = "openclaw" | "hermes" | "langchain-deepagents-code"
|
|
|
|
type CreateInferenceSettings = {
|
|
mode: CreateInferenceMode
|
|
model: string
|
|
hasApiKey: boolean
|
|
envSummary: string[]
|
|
}
|
|
|
|
type NemoClawRegistryData = {
|
|
sandboxes?: Record<string, { name?: string; createdAt?: string }>
|
|
defaultSandbox?: string | null
|
|
}
|
|
|
|
function parseCreateGpuMode(body: any): CreateGpuMode {
|
|
const raw = typeof body?.gpuMode === "string"
|
|
? body.gpuMode
|
|
: process.env.OPENSHELL_CONTROL_CREATE_GPU_MODE || "none"
|
|
return raw === "auto" || raw === "required" ? raw : "none"
|
|
}
|
|
|
|
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_INFERENCE_API_KEY = apiKey
|
|
env.NVIDIA_API_KEY = apiKey
|
|
env.NEMOCLAW_PROVIDER_KEY = apiKey
|
|
settings.envSummary.push("NVIDIA_INFERENCE_API_KEY=<provided>", "NVIDIA_API_KEY=<legacy-alias>", "NEMOCLAW_PROVIDER_KEY=<provided>")
|
|
}
|
|
}
|
|
|
|
if (settings.model) {
|
|
env.NEMOCLAW_MODEL = settings.model
|
|
settings.envSummary.push(`NEMOCLAW_MODEL=${settings.model}`)
|
|
}
|
|
|
|
return settings
|
|
}
|
|
|
|
function nemoClawGpuArgs(mode: CreateGpuMode) {
|
|
if (mode === "required") return ["--gpu"]
|
|
if (mode === "none") return ["--no-gpu"]
|
|
return []
|
|
}
|
|
|
|
function nemoClawAgentArgs(agent: NemoClawAgent) {
|
|
return agent === "openclaw" ? [] : ["--agent", agent]
|
|
}
|
|
|
|
function isNemoClawOnboardBlueprint(blueprint: string) {
|
|
return blueprint === "nemoclaw-blueprint" || blueprint === "nemoclaw-hermes" || blueprint === "nemoclaw-deepagents-code"
|
|
}
|
|
|
|
function nemoClawAgentForBlueprint(blueprint: string): NemoClawAgent {
|
|
if (blueprint === "nemoclaw-deepagents-code") return "langchain-deepagents-code"
|
|
return blueprint === "nemoclaw-hermes" ? "hermes" : "openclaw"
|
|
}
|
|
|
|
function openShellGpuArgs(mode: CreateGpuMode) {
|
|
return mode === "required" ? ["--gpu"] : []
|
|
}
|
|
|
|
function buildNemoClawCreateCommand(gpuMode: CreateGpuMode, agent: NemoClawAgent): NemoClawCreateCommand {
|
|
if (NEMOCLAW_BIN && commandExists(NEMOCLAW_BIN)) {
|
|
const args = [
|
|
"onboard",
|
|
"--non-interactive",
|
|
"--recreate-sandbox",
|
|
"--yes-i-accept-third-party-software",
|
|
...nemoClawAgentArgs(agent),
|
|
...nemoClawGpuArgs(gpuMode),
|
|
]
|
|
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 (agent !== "openclaw") {
|
|
throw new Error(`${agent} sandbox creation requires the current NemoClaw CLI with --agent support. Set NEMOCLAW_BIN in .env.local.`)
|
|
}
|
|
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<SandboxVerification> {
|
|
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
|
|
readyVerification?: SandboxVerification
|
|
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
|
|
readyVerification?: SandboxVerification
|
|
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,
|
|
readyVerification: verification,
|
|
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: "nemoclaw-hermes",
|
|
label: "Fresh Hermes Sandbox",
|
|
description: "Bootstraps a Hermes Agent sandbox using NemoClaw's Hermes workflow.",
|
|
type: "blueprint",
|
|
source: "~/NemoClaw/agents/hermes/Dockerfile",
|
|
supportsTailscale: false,
|
|
},
|
|
{
|
|
id: "nemoclaw-deepagents-code",
|
|
label: "Fresh Deep Agents Code Sandbox",
|
|
description: "Bootstraps LangChain Deep Agents Code using NemoClaw's terminal-agent workflow.",
|
|
type: "blueprint",
|
|
source: "~/NemoClaw/agents/langchain-deepagents-code/manifest.yaml",
|
|
supportsTailscale: false,
|
|
},
|
|
{
|
|
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 gpuMode = parseCreateGpuMode(body)
|
|
const createInference = parseCreateInferenceSettings(body)
|
|
console.log(`[sandbox/create] request:parsed sandbox=${sandboxName} blueprint=${blueprint} enableTailscale=${enableTailscale} gpuMode=${gpuMode} inferenceMode=${createInference.mode} elapsedMs=${elapsedMs(requestStartedAt)}`)
|
|
|
|
if (!blueprint) {
|
|
return NextResponse.json({ ok: false, error: "blueprint is required" }, { status: 400 })
|
|
}
|
|
|
|
await recordCreateActivity({
|
|
type: "sandbox.create.start",
|
|
status: "info",
|
|
sandboxName,
|
|
message: `Sandbox creation started for ${sandboxName} using ${blueprint}.`,
|
|
metadata: { blueprint, gpuMode, inferenceMode: createInference.mode },
|
|
})
|
|
|
|
if (isNemoClawOnboardBlueprint(blueprint)) {
|
|
const agent = nemoClawAgentForBlueprint(blueprint)
|
|
const isOpenClawAgent = agent === "openclaw"
|
|
const createCommand = buildNemoClawCreateCommand(gpuMode, agent)
|
|
const env: NodeJS.ProcessEnv = hostCommandEnv({
|
|
NEMOCLAW_SANDBOX_NAME: sandboxName,
|
|
NEMOCLAW_AGENT: agent,
|
|
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_INFERENCE_API_KEY = env.NVIDIA_INFERENCE_API_KEY || env.NVIDIA_API_KEY || "optional-local-mode"
|
|
env.NVIDIA_API_KEY = env.NVIDIA_API_KEY || env.NVIDIA_INFERENCE_API_KEY
|
|
}
|
|
|
|
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) {
|
|
await recordCreateActivity({
|
|
type: "sandbox.create.error",
|
|
status: "error",
|
|
sandboxName,
|
|
message: `Sandbox creation command failed for ${sandboxName}.`,
|
|
metadata: { blueprint, agent, gpuMode, inferenceMode: createInference.mode, elapsedMs: elapsedMs(requestStartedAt), error: result.error },
|
|
})
|
|
return NextResponse.json({
|
|
ok: false,
|
|
error: result.error,
|
|
stdout: result.stdout,
|
|
stderr: result.stderr,
|
|
blueprint,
|
|
agent,
|
|
sandboxName,
|
|
enableTailscale,
|
|
gpuMode,
|
|
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 && isOpenClawAgent ? 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 && isOpenClawAgent ? await approveOpenClawDeviceRequests(sandboxName) : null
|
|
console.log(
|
|
`[sandbox/create] request:complete sandbox=${sandboxName} created=${created} agent=${agent} readinessAttempts=${readiness.attempts} deviceApproval=${deviceApproval?.approved ?? false} elapsedMs=${elapsedMs(requestStartedAt)}`,
|
|
)
|
|
await recordCreateActivity({
|
|
type: created ? "sandbox.create.success" : "sandbox.create.warning",
|
|
status: created ? "success" : "warning",
|
|
sandboxId: verification.details?.id || undefined,
|
|
sandboxName,
|
|
message: created
|
|
? `Sandbox ${sandboxName} is ready after ${readiness.attempts} readiness checks.`
|
|
: `Sandbox creation command finished for ${sandboxName}, but readiness was not verified.`,
|
|
metadata: { blueprint, agent, gpuMode, inferenceMode: createInference.mode, readinessAttempts: readiness.attempts, elapsedMs: elapsedMs(requestStartedAt) },
|
|
})
|
|
|
|
return NextResponse.json({
|
|
ok: created,
|
|
blueprint,
|
|
agent,
|
|
sandboxName,
|
|
created,
|
|
verified: verification.verified,
|
|
verification,
|
|
mode: blueprint,
|
|
enableTailscale,
|
|
gpuMode,
|
|
createInference,
|
|
createCommand,
|
|
hostPath: HOST_PATH,
|
|
readiness: {
|
|
attempts: readiness.attempts,
|
|
elapsedMs: readiness.elapsedMs,
|
|
},
|
|
execApprovalsRepair,
|
|
deviceApproval,
|
|
stdout: result.stdout,
|
|
stderr: result.stderr,
|
|
note: created
|
|
? appendNote(
|
|
agent === "hermes"
|
|
? "NemoClaw Hermes workflow completed. Hermes exposes an API endpoint from the sandbox rather than an OpenClaw browser dashboard."
|
|
: 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.",
|
|
gpuMode === "none"
|
|
? "GPU passthrough was disabled for this create run."
|
|
: gpuMode === "required"
|
|
? "GPU passthrough was required for this create run."
|
|
: "NemoClaw chose GPU passthrough automatically for this create run.",
|
|
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, ...openShellGpuArgs(gpuMode)], env, 15000)
|
|
|
|
if (createAttempt.completed && createAttempt.exitCode !== 0) {
|
|
await recordCreateActivity({
|
|
type: "sandbox.create.error",
|
|
status: "error",
|
|
sandboxName,
|
|
message: `Custom sandbox creation command failed for ${sandboxName}.`,
|
|
metadata: { blueprint, gpuMode, elapsedMs: elapsedMs(requestStartedAt), error: createAttempt.error, exitCode: createAttempt.exitCode },
|
|
})
|
|
return NextResponse.json({
|
|
ok: false,
|
|
error: createAttempt.error ?? `create command failed with exit code ${createAttempt.exitCode}`,
|
|
stdout: createAttempt.stdout,
|
|
stderr: createAttempt.stderr,
|
|
blueprint,
|
|
sandboxName,
|
|
gpuMode,
|
|
}, { 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)}`,
|
|
)
|
|
await recordCreateActivity({
|
|
type: created ? "sandbox.create.success" : "sandbox.create.warning",
|
|
status: created ? "success" : "warning",
|
|
sandboxId: verification.details?.id || undefined,
|
|
sandboxName,
|
|
message: created
|
|
? `Custom sandbox ${sandboxName} is ready after ${readiness.attempts} readiness checks.`
|
|
: `Custom sandbox creation finished for ${sandboxName}, but readiness was not verified.`,
|
|
metadata: { blueprint, gpuMode, readinessAttempts: readiness.attempts, elapsedMs: elapsedMs(requestStartedAt), createTimedOut: createAttempt.timedOut },
|
|
})
|
|
return NextResponse.json({
|
|
ok: created,
|
|
blueprint,
|
|
sandboxName,
|
|
created,
|
|
verified: verification.verified,
|
|
verification,
|
|
mode: "custom-sandbox",
|
|
gpuMode,
|
|
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."),
|
|
gpuMode === "required"
|
|
? "GPU passthrough was requested for this create run."
|
|
: false,
|
|
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,
|
|
...openShellGpuArgs(gpuMode),
|
|
"--from",
|
|
sourceImage,
|
|
"--policy",
|
|
basePolicyPath,
|
|
"--auto-providers",
|
|
"--",
|
|
"nemoclaw-start",
|
|
], env, sandboxName, 120000, 2000)
|
|
|
|
const readiness = createAttempt.readyVerification?.verified
|
|
? {
|
|
verified: true as const,
|
|
verification: createAttempt.readyVerification,
|
|
attempts: 0,
|
|
elapsedMs: 0,
|
|
}
|
|
: 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
|
|
await recordCreateActivity({
|
|
type: created ? "sandbox.create.success" : createFailed ? "sandbox.create.error" : "sandbox.create.warning",
|
|
status: created ? "success" : createFailed ? "error" : "warning",
|
|
sandboxId: verification.details?.id || undefined,
|
|
sandboxName,
|
|
message: created
|
|
? `Quick deploy sandbox ${sandboxName} is ready after ${readiness.attempts} readiness checks.`
|
|
: createFailed
|
|
? `Quick deploy command failed for ${sandboxName}.`
|
|
: `Quick deploy started for ${sandboxName}, but readiness was not verified.`,
|
|
metadata: { blueprint, gpuMode, sourceSandboxName: source.name, readinessAttempts: readiness.attempts, elapsedMs: elapsedMs(requestStartedAt), createTimedOut: createAttempt.timedOut, forcedReady: createAttempt.forcedReady, error: createAttempt.error },
|
|
})
|
|
return NextResponse.json({
|
|
ok: created,
|
|
blueprint,
|
|
sandboxName,
|
|
sourceSandboxName: source.name,
|
|
sourceSandboxId: source.id,
|
|
sourceImage,
|
|
basePolicyPath,
|
|
created,
|
|
verified: verification.verified,
|
|
verification,
|
|
mode: "redeploy-image",
|
|
gpuMode,
|
|
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.`,
|
|
gpuMode === "required"
|
|
? "GPU passthrough was requested for this create run."
|
|
: false,
|
|
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 })
|
|
}
|
|
|
|
await recordCreateActivity({
|
|
type: "sandbox.create.error",
|
|
status: "error",
|
|
sandboxName,
|
|
message: `Sandbox creation failed for ${sandboxName}: unknown blueprint ${blueprint}.`,
|
|
metadata: { blueprint, gpuMode, elapsedMs: elapsedMs(requestStartedAt) },
|
|
})
|
|
return NextResponse.json({ ok: false, error: `unknown blueprint: ${blueprint}` }, { status: 400 })
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : "Sandbox creation failed"
|
|
await recordCreateActivity({
|
|
type: "sandbox.create.error",
|
|
status: "error",
|
|
message: `Sandbox creation failed: ${message}`,
|
|
metadata: { elapsedMs: elapsedMs(requestStartedAt) },
|
|
})
|
|
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 })
|
|
}
|
|
}
|