Harden controller node deploy wizard

This commit is contained in:
mmckeen
2026-04-28 15:29:18 +00:00
parent 401b646561
commit 38b651d460
9 changed files with 712 additions and 179 deletions
+166
View File
@@ -0,0 +1,166 @@
import { NextResponse } from "next/server"
import { Client } from "ssh2"
import { buildControllerNodePlan, type ControllerPlanRequest } from "@/app/lib/controllerNodePlan"
export const runtime = "nodejs"
type DeployRequest = ControllerPlanRequest & {
remoteHost?: unknown
remotePort?: unknown
remoteUser?: unknown
remotePassword?: unknown
allowSudo?: unknown
acceptUnknownHostKey?: unknown
expectedHostKeySha256?: unknown
}
const SAFE_REMOTE_USER = /^[a-z_][a-z0-9_-]{0,31}$/i
const MAX_OUTPUT_BYTES = 160_000
function text(value: unknown, fallback = "") {
return typeof value === "string" ? value.trim() : fallback
}
function port(value: unknown) {
const parsed = Number.parseInt(String(value ?? "22"), 10)
return Number.isFinite(parsed) && parsed > 0 && parsed <= 65535 ? parsed : 22
}
function appendBounded(current: string, chunk: Buffer | string) {
const next = current + String(chunk)
return next.length > MAX_OUTPUT_BYTES ? next.slice(next.length - MAX_OUTPUT_BYTES) : next
}
function normalizeFingerprint(value: string) {
return value.trim().replace(/^SHA256:/i, "")
}
function runRemoteDeploy(params: {
host: string
port: number
username: string
password: string
script: string
allowSudo: boolean
acceptUnknownHostKey: boolean
expectedHostKeySha256: string
}) {
return new Promise<{ stdout: string; stderr: string; hostKeySha256: string | null }>((resolve, reject) => {
const conn = new Client()
let stdout = ""
let stderr = ""
let hostKeySha256: string | null = null
let settled = false
const finish = (error?: Error) => {
if (settled) return
settled = true
conn.end()
if (error) reject(error)
else resolve({ stdout: stdout.trim(), stderr: stderr.trim(), hostKeySha256 })
}
const timer = setTimeout(() => {
finish(new Error("Remote deploy timed out after 10 minutes"))
}, 10 * 60 * 1000)
conn
.on("ready", () => {
const command = params.allowSudo ? "sudo -S -p '' bash -s" : "bash -s"
conn.exec(command, { pty: params.allowSudo }, (error, stream) => {
if (error) {
clearTimeout(timer)
finish(error)
return
}
stream
.on("close", (code: number | null, signal: string | null) => {
clearTimeout(timer)
if (code === 0) {
finish()
} else {
finish(new Error(`Remote deploy failed with exit code ${code ?? "unknown"}${signal ? ` signal ${signal}` : ""}`))
}
})
.on("data", (chunk: Buffer) => {
stdout = appendBounded(stdout, chunk)
})
stream.stderr.on("data", (chunk: Buffer) => {
stderr = appendBounded(stderr, chunk)
})
if (params.allowSudo) stream.write(`${params.password}\n`)
stream.end(`${params.script}\n`)
})
})
.on("error", (error) => {
clearTimeout(timer)
finish(error)
})
.connect({
host: params.host,
port: params.port,
username: params.username,
password: params.password,
readyTimeout: 30000,
hostHash: "sha256",
hostVerifier: (hashedKey: string) => {
hostKeySha256 = hashedKey
const expected = normalizeFingerprint(params.expectedHostKeySha256)
if (expected) return hashedKey === expected
return params.acceptUnknownHostKey
},
})
})
}
export async function POST(request: Request) {
try {
const body = (await request.json().catch(() => ({}))) as DeployRequest
const remoteHost = text(body.remoteHost, text(body.controllerHost))
const remoteUser = text(body.remoteUser)
const remotePassword = typeof body.remotePassword === "string" ? body.remotePassword : ""
const expectedHostKeySha256 = text(body.expectedHostKeySha256)
const acceptUnknownHostKey = Boolean(body.acceptUnknownHostKey)
const allowSudo = Boolean(body.allowSudo)
if (!remoteHost) throw new Error("remoteHost is required")
if (!remoteUser || !SAFE_REMOTE_USER.test(remoteUser)) throw new Error("remoteUser must be a valid Linux username")
if (!remotePassword) throw new Error("remotePassword is required for autodeploy")
if (!expectedHostKeySha256 && !acceptUnknownHostKey) {
throw new Error("Provide expectedHostKeySha256 or explicitly allow trust-on-first-deploy.")
}
const plan = buildControllerNodePlan({
...body,
controllerHost: text(body.controllerHost, remoteHost),
})
const deployed = await runRemoteDeploy({
host: remoteHost,
port: port(body.remotePort),
username: remoteUser,
password: remotePassword,
script: plan.commands.localBootstrap,
allowSudo,
acceptUnknownHostKey,
expectedHostKeySha256,
})
return NextResponse.json({
ok: true,
...plan,
controller: plan.controller,
hostKeySha256: deployed.hostKeySha256,
stdout: deployed.stdout,
stderr: deployed.stderr,
note: allowSudo
? "Autodeploy completed using sudo. The controller service was installed when systemd was available."
: "Autodeploy completed without sudo. Start the controller manually if systemd service installation was skipped.",
})
} catch (error) {
const message = error instanceof Error ? error.message : "Failed to autodeploy controller node"
return NextResponse.json({ ok: false, error: message }, { status: 400 })
}
}
+2 -160
View File
@@ -1,168 +1,10 @@
import { NextResponse } from "next/server"
type ControllerPlanRequest = {
controllerName?: unknown
controllerHost?: unknown
sshTarget?: unknown
installDir?: unknown
repoUrl?: unknown
dashboardPort?: unknown
terminalPort?: unknown
openClawDashboardUrl?: unknown
openshellGateway?: unknown
exposePublicly?: unknown
}
const DEFAULT_REPO_URL = process.env.OPENSHELL_CONTROL_REPO_URL || "https://github.com/NVIDIA/nemoclaw-dashboard.git"
const SAFE_NAME = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/
const SAFE_SSH_TARGET = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+(?::[0-9]{1,5})?$/
function text(value: unknown, fallback = "") {
return typeof value === "string" ? value.trim() : fallback
}
function numberValue(value: unknown, fallback: number) {
const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10)
return Number.isFinite(parsed) && parsed > 0 && parsed <= 65535 ? parsed : fallback
}
function shellSingleQuote(value: string) {
return `'${value.replaceAll("'", "'\\''")}'`
}
function validateUrl(value: string, label: string) {
try {
const parsed = new URL(value)
if (!["http:", "https:"].includes(parsed.protocol)) throw new Error()
return parsed.toString()
} catch {
throw new Error(`${label} must be an http(s) URL`)
}
}
function validateInstallDir(value: string) {
if (!value || value.includes("\n") || value.includes("\0") || value.startsWith("-") || value.includes("..")) {
throw new Error("installDir must be a safe absolute path or home-relative directory")
}
if (!value.startsWith("/") && !/^[a-zA-Z0-9._/-]+$/.test(value)) {
throw new Error("installDir can only contain letters, numbers, dots, underscores, hyphens, and slashes")
}
return value.replace(/\/+$/, "") || "openshell-control"
}
function buildEnvBlock(params: {
controllerName: string
controllerHost: string
dashboardPort: number
terminalPort: number
openClawDashboardUrl: string
openshellGateway: string
exposePublicly: boolean
}) {
const dashboardOrigin = `http://${params.controllerHost}:${params.dashboardPort}`
const registry = [
{
id: params.controllerName,
label: `${params.controllerName} controller`,
dashboardUrl: params.openClawDashboardUrl,
controlUiOrigin: dashboardOrigin,
terminalServerUrl: `http://127.0.0.1:${params.terminalPort}`,
loopbackOnly: !params.exposePublicly,
default: true,
},
]
return [
`NEXT_PUBLIC_DASHBOARD_PORT=${params.dashboardPort}`,
"NEXT_PUBLIC_API_BASE=/api",
"NEXT_PUBLIC_ENABLE_SANDBOX_OPERATIONS=true",
`OPENSHELL_GATEWAY=${params.openshellGateway}`,
"OPEN_SHELL_CONTAINER=openshell-cluster-nemoclaw",
"TERMINAL_SERVER_AUTOSTART=true",
`TERMINAL_SERVER_PORT=${params.terminalPort}`,
`OPENCLAW_DASHBOARD_URL=${params.openClawDashboardUrl}`,
`OPENCLAW_INSTANCE_REGISTRY_JSON=${JSON.stringify(registry)}`,
].join("\n")
}
import { buildControllerNodePlan, type ControllerPlanRequest } from "@/app/lib/controllerNodePlan"
export async function POST(request: Request) {
try {
const body = (await request.json().catch(() => ({}))) as ControllerPlanRequest
const controllerName = text(body.controllerName, "remote-controller").toLowerCase()
if (!SAFE_NAME.test(controllerName) || controllerName.length > 63) {
throw new Error("controllerName must be lowercase letters, numbers, and internal hyphens")
}
const controllerHost = text(body.controllerHost)
if (!controllerHost) throw new Error("controllerHost is required")
const sshTarget = text(body.sshTarget)
if (sshTarget && !SAFE_SSH_TARGET.test(sshTarget)) {
throw new Error("sshTarget must look like user@host or user@host:port")
}
const installDir = validateInstallDir(text(body.installDir, "openshell-control"))
const repoUrl = validateUrl(text(body.repoUrl, DEFAULT_REPO_URL), "repoUrl")
const dashboardPort = numberValue(body.dashboardPort, 3000)
const terminalPort = numberValue(body.terminalPort, 3011)
const openClawDashboardUrl = validateUrl(text(body.openClawDashboardUrl, "http://127.0.0.1:18789/"), "openClawDashboardUrl")
const openshellGateway = text(body.openshellGateway, "nemoclaw")
const exposePublicly = Boolean(body.exposePublicly)
const envBlock = buildEnvBlock({
controllerName,
controllerHost,
dashboardPort,
terminalPort,
openClawDashboardUrl,
openshellGateway,
exposePublicly,
})
const remoteBootstrap = [
"set -euo pipefail",
`INSTALL_DIR=${shellSingleQuote(installDir)}`,
`REPO_URL=${shellSingleQuote(repoUrl)}`,
'if ! command -v git >/dev/null 2>&1; then echo "git is required" >&2; exit 1; fi',
'if ! command -v node >/dev/null 2>&1; then echo "Node.js 20+ is required" >&2; exit 1; fi',
'if [ -d "$INSTALL_DIR/.git" ]; then git -C "$INSTALL_DIR" pull --ff-only; else mkdir -p "$(dirname "$INSTALL_DIR")"; git clone --depth=1 "$REPO_URL" "$INSTALL_DIR"; fi',
'cd "$INSTALL_DIR"',
"./install.sh --no-build --no-audit",
"cat > .env.controller-node <<'ENV'",
envBlock,
"ENV",
"cat .env.controller-node >> .env.local",
"npm run build",
`echo "Controller node ready on http://${controllerHost}:${dashboardPort}"`,
].join("\n")
const sshCommand = sshTarget
? `ssh ${sshTarget.includes(":") ? `-p ${sshTarget.split(":").pop()} ${sshTarget.split(":")[0]}` : sshTarget} 'bash -s' <<'REMOTE_CONTROLLER'\n${remoteBootstrap}\nREMOTE_CONTROLLER`
: remoteBootstrap
return NextResponse.json({
ok: true,
controller: {
name: controllerName,
url: `http://${controllerHost}:${dashboardPort}`,
host: controllerHost,
dashboardPort,
terminalPort,
installDir,
},
env: envBlock,
commands: {
ssh: sshCommand,
localBootstrap: remoteBootstrap,
start: `cd ${shellSingleQuote(installDir)} && npm run start`,
terminal: `cd ${shellSingleQuote(installDir)} && npm run terminal-server`,
},
checks: [
"OpenShell CLI is installed on the controller node and can reach the gateway.",
`The controller can reach ${openClawDashboardUrl}.`,
`Port ${dashboardPort} is reachable from your browser or through an SSH tunnel.`,
`Port ${terminalPort} stays private unless you intentionally expose terminal transport.`,
],
})
return NextResponse.json({ ok: true, ...buildControllerNodePlan(body) })
} catch (error) {
const message = error instanceof Error ? error.message : "Failed to build controller node plan"
return NextResponse.json({ ok: false, error: message }, { status: 400 })
+143 -4
View File
@@ -11,6 +11,7 @@ type BlueprintOption = {
}
type WizardStep = "source" | "target" | "options" | "review" | "run"
type ControllerDeployMode = "manual" | "auto"
type ControllerPlan = {
controller: {
@@ -20,6 +21,7 @@ type ControllerPlan = {
dashboardPort: number
terminalPort: number
installDir: string
parentControllerUrl: string
}
env: string
commands: {
@@ -73,16 +75,26 @@ export default function WizardPanel({
const [controllerName, setControllerName] = useState("remote-controller")
const [controllerHost, setControllerHost] = useState("")
const [sshTarget, setSshTarget] = useState("")
const [installDir, setInstallDir] = useState("openshell-control")
const [repoUrl, setRepoUrl] = useState("https://github.com/NVIDIA/nemoclaw-dashboard.git")
const [installDir, setInstallDir] = useState("/opt/openshell-control")
const [repoUrl, setRepoUrl] = useState("https://github.com/mmckeen-nv/openshell_controller.git")
const [dashboardPort, setDashboardPort] = useState("3000")
const [terminalPort, setTerminalPort] = useState("3011")
const [openClawDashboardUrl, setOpenClawDashboardUrl] = useState("http://127.0.0.1:18789/")
const [openshellGateway, setOpenshellGateway] = useState("nemoclaw")
const [exposePublicly, setExposePublicly] = useState(false)
const [parentControllerUrl, setParentControllerUrl] = useState("http://localhost:3000")
const [controllerDeployMode, setControllerDeployMode] = useState<ControllerDeployMode>("manual")
const [remotePort, setRemotePort] = useState("22")
const [remoteUser, setRemoteUser] = useState("")
const [remotePassword, setRemotePassword] = useState("")
const [allowSudo, setAllowSudo] = useState(false)
const [acceptUnknownHostKey, setAcceptUnknownHostKey] = useState(false)
const [expectedHostKeySha256, setExpectedHostKeySha256] = useState("")
const [controllerPlan, setControllerPlan] = useState<ControllerPlan | null>(null)
const [controllerMessage, setControllerMessage] = useState("")
const [controllerPlanning, setControllerPlanning] = useState(false)
const [controllerDeploying, setControllerDeploying] = useState(false)
const [controllerDeployLog, setControllerDeployLog] = useState("")
const sourceSandbox = useMemo(
() => sandboxes.find((sandbox) => sandbox.id === sourceSandboxId) || null,
@@ -100,6 +112,11 @@ export default function WizardPanel({
.catch(() => {})
}, [])
useEffect(() => {
if (typeof window === "undefined") return
setParentControllerUrl(window.location.origin)
}, [])
useEffect(() => {
if (!sourceSandboxId && sandboxes[0]) {
setSourceSandboxId(sandboxes[0].id)
@@ -216,6 +233,7 @@ export default function WizardPanel({
openClawDashboardUrl,
openshellGateway,
exposePublicly,
parentControllerUrl,
}),
})
const data = await response.json()
@@ -229,6 +247,49 @@ export default function WizardPanel({
}
}
async function autodeployControllerNode() {
try {
setControllerDeploying(true)
setControllerMessage("")
setControllerDeployLog("")
const response = await fetch("/api/controller-node/deploy", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
controllerName,
controllerHost,
sshTarget,
installDir,
repoUrl,
dashboardPort,
terminalPort,
openClawDashboardUrl,
openshellGateway,
exposePublicly,
parentControllerUrl,
remoteHost: controllerHost,
remotePort,
remoteUser,
remotePassword,
allowSudo,
acceptUnknownHostKey,
expectedHostKeySha256,
}),
})
const data = await response.json()
if (!response.ok) throw new Error(data.error || "Autodeploy failed")
setControllerPlan((current) => current ?? data)
setControllerDeployLog([data.note, data.hostKeySha256 ? `Host key SHA256: ${data.hostKeySha256}` : "", data.stdout, data.stderr].filter(Boolean).join("\n\n"))
setRemotePassword("")
setControllerMessage(`Autodeploy complete for ${data.controller?.url || controllerHost}.`)
} catch (error) {
setControllerMessage(error instanceof Error ? error.message : "Autodeploy failed")
} finally {
setControllerDeploying(false)
}
}
async function copyText(value: string, label: string) {
try {
await navigator.clipboard.writeText(value)
@@ -256,13 +317,29 @@ export default function WizardPanel({
<p className="mt-1 text-xs text-[var(--foreground-dim)]">Prepare a remote VPS to run OpenShell Control near another OpenShell gateway or sandbox host.</p>
</div>
<span className="status-chip border border-[var(--border-subtle)] bg-[var(--background-tertiary)] px-2.5 py-1 text-[var(--foreground-dim)]">
remote control plane
{controllerDeployMode === "auto" ? "autodeploy" : "manual deploy"}
</span>
</div>
</div>
<div className="grid grid-cols-1 gap-5 p-5 xl:grid-cols-[minmax(0,1fr)_minmax(360px,0.8fr)]">
<div className="space-y-5">
<div className="grid grid-cols-2 gap-2 rounded-sm border border-[var(--border-subtle)] bg-[var(--background-tertiary)] p-1">
{(["manual", "auto"] as ControllerDeployMode[]).map((mode) => (
<button
key={mode}
type="button"
onClick={() => setControllerDeployMode(mode)}
className={`rounded-sm px-3 py-2 text-xs font-mono uppercase tracking-wider ${
controllerDeployMode === mode
? "bg-[var(--nvidia-green)] text-black"
: "text-[var(--foreground-dim)] hover:bg-[var(--background)]"
}`}
>
{mode === "manual" ? "Manual Deploy" : "Autodeploy"}
</button>
))}
</div>
<div className="grid grid-cols-1 gap-4 md:grid-cols-2">
<label className="block space-y-2">
<span className="text-[10px] uppercase tracking-wider text-[var(--foreground-dim)]">Controller Name</span>
@@ -270,7 +347,7 @@ export default function WizardPanel({
</label>
<label className="block space-y-2">
<span className="text-[10px] uppercase tracking-wider text-[var(--foreground-dim)]">Controller Host</span>
<input value={controllerHost} onChange={(event) => setControllerHost(event.target.value)} placeholder="vps.example.com" className="w-full rounded-sm border border-[var(--border-subtle)] bg-[var(--background-tertiary)] px-3 py-2 text-xs font-mono text-[var(--foreground)]" />
<input value={controllerHost} onChange={(event) => setControllerHost(event.target.value)} placeholder="203.0.113.10 or vps.example.com" className="w-full rounded-sm border border-[var(--border-subtle)] bg-[var(--background-tertiary)] px-3 py-2 text-xs font-mono text-[var(--foreground)]" />
</label>
<label className="block space-y-2">
<span className="text-[10px] uppercase tracking-wider text-[var(--foreground-dim)]">SSH Target</span>
@@ -300,6 +377,10 @@ export default function WizardPanel({
<span className="text-[10px] uppercase tracking-wider text-[var(--foreground-dim)]">OpenShell Gateway</span>
<input value={openshellGateway} onChange={(event) => setOpenshellGateway(event.target.value)} className="w-full rounded-sm border border-[var(--border-subtle)] bg-[var(--background-tertiary)] px-3 py-2 text-xs font-mono text-[var(--foreground)]" />
</label>
<label className="block space-y-2 md:col-span-2">
<span className="text-[10px] uppercase tracking-wider text-[var(--foreground-dim)]">Parent Controller URL</span>
<input value={parentControllerUrl} onChange={(event) => setParentControllerUrl(event.target.value)} className="w-full rounded-sm border border-[var(--border-subtle)] bg-[var(--background-tertiary)] px-3 py-2 text-xs font-mono text-[var(--foreground)]" />
</label>
</div>
<label className="flex items-start gap-3 rounded-sm border border-[var(--border-subtle)] bg-[var(--background-tertiary)] p-3">
<input type="checkbox" checked={exposePublicly} onChange={(event) => setExposePublicly(event.target.checked)} className="mt-0.5 h-4 w-4 accent-[var(--nvidia-green)]" />
@@ -308,10 +389,60 @@ export default function WizardPanel({
<span className="mt-1 block text-[11px] text-[var(--foreground-dim)]">Leave this off when you access the VPS through SSH tunnels, WireGuard, or Tailscale.</span>
</span>
</label>
{controllerDeployMode === "auto" && (
<div className="space-y-4 rounded-sm border border-[var(--border-subtle)] bg-[var(--background-tertiary)] p-4">
<div>
<h3 className="text-xs font-semibold uppercase tracking-wider text-[var(--foreground)]">Autodeploy SSH</h3>
<p className="mt-1 text-xs text-[var(--foreground-dim)]">Password is used once for this SSH session and is not written into the deploy script or saved config.</p>
</div>
<div className="grid grid-cols-1 gap-4 md:grid-cols-3">
<label className="block space-y-2">
<span className="text-[10px] uppercase tracking-wider text-[var(--foreground-dim)]">SSH Port</span>
<input value={remotePort} onChange={(event) => setRemotePort(event.target.value)} className="w-full rounded-sm border border-[var(--border-subtle)] bg-[var(--background)] px-3 py-2 text-xs font-mono text-[var(--foreground)]" />
</label>
<label className="block space-y-2">
<span className="text-[10px] uppercase tracking-wider text-[var(--foreground-dim)]">SSH User</span>
<input value={remoteUser} onChange={(event) => setRemoteUser(event.target.value)} placeholder="ubuntu" className="w-full rounded-sm border border-[var(--border-subtle)] bg-[var(--background)] px-3 py-2 text-xs font-mono text-[var(--foreground)]" />
</label>
<label className="block space-y-2">
<span className="text-[10px] uppercase tracking-wider text-[var(--foreground-dim)]">SSH Password</span>
<input type="password" value={remotePassword} onChange={(event) => setRemotePassword(event.target.value)} className="w-full rounded-sm border border-[var(--border-subtle)] bg-[var(--background)] px-3 py-2 text-xs font-mono text-[var(--foreground)]" />
</label>
</div>
<label className="block space-y-2">
<span className="text-[10px] uppercase tracking-wider text-[var(--foreground-dim)]">Expected Host Key SHA256</span>
<input value={expectedHostKeySha256} onChange={(event) => setExpectedHostKeySha256(event.target.value)} placeholder="SHA256:..." className="w-full rounded-sm border border-[var(--border-subtle)] bg-[var(--background)] px-3 py-2 text-xs font-mono text-[var(--foreground)]" />
</label>
<div className="grid grid-cols-1 gap-3 md:grid-cols-2">
<label className="flex items-start gap-3 rounded-sm border border-[var(--border-subtle)] bg-[var(--background)] p-3">
<input type="checkbox" checked={acceptUnknownHostKey} onChange={(event) => setAcceptUnknownHostKey(event.target.checked)} className="mt-0.5 h-4 w-4 accent-[var(--nvidia-green)]" />
<span>
<span className="block text-xs font-mono uppercase tracking-wider text-[var(--foreground)]">Trust first host key</span>
<span className="mt-1 block text-[11px] text-[var(--foreground-dim)]">Use only on a trusted network when you do not have the fingerprint yet.</span>
</span>
</label>
<label className="flex items-start gap-3 rounded-sm border border-[var(--border-subtle)] bg-[var(--background)] p-3">
<input type="checkbox" checked={allowSudo} onChange={(event) => setAllowSudo(event.target.checked)} className="mt-0.5 h-4 w-4 accent-[var(--nvidia-green)]" />
<span>
<span className="block text-xs font-mono uppercase tracking-wider text-[var(--foreground)]">Allow sudo</span>
<span className="mt-1 block text-[11px] text-[var(--foreground-dim)]">Installs the systemd service when the remote account can sudo.</span>
</span>
</label>
</div>
</div>
)}
<button type="button" onClick={generateControllerPlan} disabled={controllerPlanning || !controllerHost.trim()} className="rounded-sm bg-[var(--nvidia-green)] px-4 py-2 text-xs font-mono uppercase tracking-wider text-black disabled:opacity-50">
{controllerPlanning ? "Preparing..." : "Generate Launch Kit"}
</button>
{controllerDeployMode === "auto" && (
<button type="button" onClick={autodeployControllerNode} disabled={controllerDeploying || !controllerHost.trim() || !remoteUser.trim() || !remotePassword} className="ml-3 rounded-sm border border-[var(--nvidia-green)] px-4 py-2 text-xs font-mono uppercase tracking-wider text-[var(--nvidia-green)] disabled:opacity-50">
{controllerDeploying ? "Deploying..." : "Autodeploy Controller"}
</button>
)}
{controllerMessage && <div className="rounded-sm border border-[var(--border-subtle)] bg-[var(--background-tertiary)] p-3 text-sm text-[var(--foreground-dim)]">{controllerMessage}</div>}
{controllerDeployLog && (
<pre className="max-h-72 overflow-auto whitespace-pre-wrap rounded-sm border border-[var(--border-subtle)] bg-[var(--background)] p-3 text-[11px] leading-5 text-[var(--foreground-dim)]">{controllerDeployLog}</pre>
)}
</div>
<div className="space-y-4">
@@ -321,6 +452,7 @@ export default function WizardPanel({
<p>Controller VPS: {controllerHost || "not set"}</p>
<p>Sandbox host/gateway: {openshellGateway || "nemoclaw"}</p>
<p>OpenClaw upstream: {openClawDashboardUrl}</p>
<p>Parent controller: {parentControllerUrl}</p>
</div>
</div>
{controllerPlan ? (
@@ -332,6 +464,13 @@ export default function WizardPanel({
</div>
<pre className="mt-3 max-h-72 overflow-auto whitespace-pre-wrap rounded-sm border border-[var(--border-subtle)] bg-[var(--background)] p-3 text-[11px] leading-5 text-[var(--foreground-dim)]">{controllerPlan.commands.ssh}</pre>
</div>
<div className="rounded-sm border border-[var(--border-subtle)] bg-[var(--background-tertiary)] p-4">
<div className="flex items-center justify-between gap-3">
<h3 className="text-xs font-semibold uppercase tracking-wider text-[var(--foreground)]">Bootstrap Script</h3>
<button type="button" onClick={() => copyText(controllerPlan.commands.localBootstrap, "Bootstrap script")} className="action-button px-3 py-1.5 text-[10px]">Copy</button>
</div>
<pre className="mt-3 max-h-72 overflow-auto whitespace-pre-wrap rounded-sm border border-[var(--border-subtle)] bg-[var(--background)] p-3 text-[11px] leading-5 text-[var(--foreground-dim)]">{controllerPlan.commands.localBootstrap}</pre>
</div>
<div className="rounded-sm border border-[var(--border-subtle)] bg-[var(--background-tertiary)] p-4">
<div className="flex items-center justify-between gap-3">
<h3 className="text-xs font-semibold uppercase tracking-wider text-[var(--foreground)]">Controller Env</h3>
+268
View File
@@ -0,0 +1,268 @@
import { randomBytes } from "node:crypto"
export type ControllerPlanRequest = {
controllerName?: unknown
controllerHost?: unknown
sshTarget?: unknown
installDir?: unknown
repoUrl?: unknown
dashboardPort?: unknown
terminalPort?: unknown
openclawUrl?: unknown
openClawDashboardUrl?: unknown
openshellGateway?: unknown
parentControllerUrl?: unknown
existingToken?: unknown
}
export type ControllerNodePlan = {
controller: {
name: string
host: string
url: string
sshTarget: string
installDir: string
repoUrl: string
parentControllerUrl: string
dashboardPort: number
terminalPort: number
}
env: string
serviceUnit: string
commands: {
ssh: string
localBootstrap: string
start: string
terminal: string
}
checks: string[]
}
const DEFAULT_REPO_URL = process.env.OPENSHELL_CONTROL_REPO_URL || "https://github.com/mmckeen-nv/openshell_controller.git"
const SAFE_NAME = /^[a-z0-9][a-z0-9-]{1,62}$/i
const SAFE_HOST = /^[a-z0-9.-]+$/i
const SAFE_SSH_TARGET = /^([a-z0-9._-]+@)?[a-z0-9.-]+(:[0-9]{1,5})?$/i
function text(value: unknown, fallback = "") {
return typeof value === "string" ? value.trim() : fallback
}
function numberValue(value: unknown, fallback: number) {
const parsed = Number.parseInt(String(value ?? ""), 10)
return Number.isFinite(parsed) && parsed > 0 && parsed <= 65535 ? parsed : fallback
}
export function shellSingleQuote(value: string) {
return `'${value.replace(/'/g, "'\\''")}'`
}
function sshBootstrapInvocation(target: string) {
const match = target.match(/^((?:[a-z0-9._-]+@)?[a-z0-9.-]+)(?::([0-9]{1,5}))?$/i)
if (!match) throw new Error("sshTarget must look like user@host or user@host:port")
const [, host, targetPort] = match
return targetPort ? `ssh -p ${targetPort} ${shellSingleQuote(host)}` : `ssh ${shellSingleQuote(host)}`
}
function validateUrl(value: string, label: string) {
if (/^git@[a-z0-9.-]+:[a-z0-9._/-]+\.git$/i.test(value)) return value
if (/^ssh:\/\/[^\s]+$/i.test(value)) return value
try {
const parsed = new URL(value)
if (parsed.protocol === "https:" || parsed.protocol === "http:") return value
} catch {
// handled below
}
throw new Error(`${label} must be an http(s), ssh, or git SSH URL`)
}
function validateHttpUrl(value: string, label: string) {
try {
const parsed = new URL(value)
if (parsed.protocol === "https:" || parsed.protocol === "http:") return value.replace(/\/$/, "")
} catch {
// handled below
}
throw new Error(`${label} must be an http(s) URL`)
}
function validateInstallDir(value: string) {
if (!value || value.includes("\0") || value.includes("\n")) throw new Error("installDir is invalid")
if (!value.startsWith("/")) throw new Error("installDir must be an absolute path")
return value.replace(/\/$/, "")
}
function controllerToken(value: unknown) {
const existing = text(value)
if (existing) {
if (!/^[a-zA-Z0-9._~:-]{20,256}$/.test(existing)) throw new Error("existingToken contains unsupported characters")
return existing
}
return randomBytes(32).toString("base64url")
}
function buildEnvBlock(input: {
controllerName: string
parentControllerUrl: string
token: string
dashboardPort: number
terminalPort: number
openclawUrl: string
openshellGateway: string
}) {
const registry = JSON.stringify({
nodes: [
{
id: input.controllerName,
name: input.controllerName,
url: `http://127.0.0.1:${input.dashboardPort}`,
role: "controller-node",
},
],
})
return [
`CONTROLLER_NODE_ID=${input.controllerName}`,
`CONTROLLER_NODE_PARENT_URL=${input.parentControllerUrl}`,
`CONTROLLER_NODE_SHARED_SECRET=${input.token}`,
`NEXT_PUBLIC_DASHBOARD_PORT=${input.dashboardPort}`,
"NEXT_PUBLIC_API_BASE=",
"NEXT_PUBLIC_ENABLE_SANDBOX_OPERATIONS=true",
`OPENSHELL_GATEWAY=${input.openshellGateway}`,
"OPEN_SHELL_CONTAINER=openshell-control",
"TERMINAL_SERVER_AUTOSTART=true",
`TERMINAL_SERVER_PORT=${input.terminalPort}`,
`OPENCLAW_DASHBOARD_URL=${input.openclawUrl}`,
`OPENCLAW_INSTANCE_REGISTRY_JSON=${registry}`,
].join("\n")
}
function serviceUnit(installDir: string) {
return `[Unit]
Description=OpenShell Controller Node
After=network-online.target
Wants=network-online.target
[Service]
Type=simple
WorkingDirectory=${installDir}
EnvironmentFile=${installDir}/.env.local
ExecStart=/usr/bin/npm run start
Restart=always
RestartSec=5
User=root
[Install]
WantedBy=multi-user.target
`
}
export function buildControllerNodePlan(input: ControllerPlanRequest = {}): ControllerNodePlan {
const controllerName = text(input.controllerName, "remote-controller-01").toLowerCase()
if (!SAFE_NAME.test(controllerName)) throw new Error("controllerName must be 2-63 letters, numbers, or hyphens")
const host = text(input.controllerHost)
if (!host || !SAFE_HOST.test(host)) throw new Error("controllerHost must be a hostname or IP address")
const installDir = validateInstallDir(text(input.installDir, "/opt/openshell-control"))
const repoUrl = validateUrl(text(input.repoUrl, DEFAULT_REPO_URL), "repoUrl")
const dashboardPort = numberValue(input.dashboardPort, 3000)
const terminalPort = numberValue(input.terminalPort, 3011)
const openclawUrl = validateHttpUrl(text(input.openclawUrl, text(input.openClawDashboardUrl, "http://localhost:3002")), "openclawUrl")
const openshellGateway = text(input.openshellGateway, "local")
if (!/^[a-z0-9._:-]+$/i.test(openshellGateway)) throw new Error("openshellGateway contains unsupported characters")
const parentControllerUrl = validateHttpUrl(text(input.parentControllerUrl, "http://localhost:3000"), "parentControllerUrl")
const token = controllerToken(input.existingToken)
const sshTarget = text(input.sshTarget, host)
if (!SAFE_SSH_TARGET.test(sshTarget)) throw new Error("sshTarget must look like user@host or user@host:port")
const envBlock = buildEnvBlock({
controllerName,
parentControllerUrl,
token,
dashboardPort,
terminalPort,
openclawUrl,
openshellGateway,
})
const unit = serviceUnit(installDir)
const remoteBootstrap = `#!/usr/bin/env bash
set -euo pipefail
INSTALL_DIR=${shellSingleQuote(installDir)}
REPO_URL=${shellSingleQuote(repoUrl)}
DASHBOARD_PORT=${dashboardPort}
TERMINAL_PORT=${terminalPort}
for binary in git node npm; do
if ! command -v "$binary" >/dev/null 2>&1; then
echo "Missing required binary: $binary" >&2
echo "Install Node.js 20+, npm, and git before running this bootstrap." >&2
exit 1
fi
done
mkdir -p "$(dirname "$INSTALL_DIR")"
if [ -d "$INSTALL_DIR/.git" ]; then
git -C "$INSTALL_DIR" fetch --depth=1 origin
git -C "$INSTALL_DIR" pull --ff-only
else
git clone --depth=1 "$REPO_URL" "$INSTALL_DIR"
fi
cd "$INSTALL_DIR"
./install.sh --no-build --no-audit
cat > .env.controller-node <<'ENV_CONTROLLER_NODE'
${envBlock}
ENV_CONTROLLER_NODE
touch .env.local
TMP_ENV="$(mktemp)"
grep -Ev '^(CONTROLLER_NODE_ID|CONTROLLER_NODE_PARENT_URL|CONTROLLER_NODE_SHARED_SECRET|NEXT_PUBLIC_DASHBOARD_PORT|NEXT_PUBLIC_API_BASE|NEXT_PUBLIC_ENABLE_SANDBOX_OPERATIONS|OPENSHELL_GATEWAY|OPEN_SHELL_CONTAINER|TERMINAL_SERVER_AUTOSTART|TERMINAL_SERVER_PORT|OPENCLAW_DASHBOARD_URL|OPENCLAW_INSTANCE_REGISTRY_JSON)=' .env.local > "$TMP_ENV" || true
cat "$TMP_ENV" .env.controller-node > .env.local
rm -f "$TMP_ENV"
chmod 600 .env.local .env.controller-node
npm run build
if command -v systemctl >/dev/null 2>&1 && [ -w /etc/systemd/system ]; then
cat > /etc/systemd/system/openshell-controller-node.service <<'SYSTEMD'
${unit}
SYSTEMD
systemctl daemon-reload
systemctl enable --now openshell-controller-node.service
systemctl restart openshell-controller-node.service
else
echo "Systemd service was not installed. Start manually with: npm run start -- --hostname 0.0.0.0 --port $DASHBOARD_PORT"
fi
echo "Controller node ready at http://${host}:$DASHBOARD_PORT"
echo "OpenShell CLI is installed in $INSTALL_DIR and can manage sandboxes reachable from this VPS."
`
return {
controller: {
name: controllerName,
host,
url: `http://${host}:${dashboardPort}`,
sshTarget,
installDir,
repoUrl,
parentControllerUrl,
dashboardPort,
terminalPort,
},
env: envBlock,
serviceUnit: unit,
commands: {
ssh: `${sshBootstrapInvocation(sshTarget)} 'bash -s' <<'REMOTE_CONTROLLER'\n${remoteBootstrap}\nREMOTE_CONTROLLER`,
localBootstrap: remoteBootstrap,
start: `cd ${shellSingleQuote(installDir)} && npm run start -- --hostname 0.0.0.0 --port ${dashboardPort}`,
terminal: `TERMINAL_SERVER_PORT=${terminalPort} npm run terminal-server`,
},
checks: [
`curl -fsS http://${host}:${dashboardPort}/api/controller-node/health`,
`curl -fsS ${openclawUrl}/api/instances`,
`ssh ${host} 'cd ${shellSingleQuote(installDir)} && npm run status'`,
],
}
}