diff --git a/app/api/openshell/terminal/readiness/route.ts b/app/api/openshell/terminal/readiness/route.ts new file mode 100644 index 0000000..bfbea37 --- /dev/null +++ b/app/api/openshell/terminal/readiness/route.ts @@ -0,0 +1,131 @@ +import { NextResponse } from 'next/server' +import { dockerExecInOpenShell, OPENSHELL_NAMESPACE, probeSandboxShell, validateSandboxId } from '../../../../lib/openshellHost' + +interface PodSummary { + containers: string[] + images: string[] + runningStatuses: string[] + phase?: string + readyCondition?: string +} + +const EMPTY_POD_SUMMARY: PodSummary = { + containers: [], + images: [], + runningStatuses: [], +} + +async function inspectPod(sandboxId: string): Promise { + const result = await dockerExecInOpenShell( + `kubectl -n ${OPENSHELL_NAMESPACE} get pod ${sandboxId} -o json` + ) + + if (result.exitCode !== 0) { + const failureText = `${result.stderr}\n${result.stdout}`.toLowerCase() + if (failureText.includes('(notfound)') || failureText.includes('not found')) { + return EMPTY_POD_SUMMARY + } + throw new Error(result.stderr.trim() || result.stdout.trim() || `kubectl get pod failed with exit code ${result.exitCode}`) + } + + if (!result.stdout.trim()) { + throw new Error('kubectl get pod returned empty stdout') + } + + const pod = JSON.parse(result.stdout) + return { + containers: Array.isArray(pod?.spec?.containers) ? pod.spec.containers.map((c: any) => c.name) : [], + images: Array.isArray(pod?.spec?.containers) ? pod.spec.containers.map((c: any) => c.image) : [], + runningStatuses: Array.isArray(pod?.status?.containerStatuses) ? pod.status.containerStatuses.map((c: any) => c.name) : [], + phase: pod?.status?.phase, + readyCondition: Array.isArray(pod?.status?.conditions) + ? pod.status.conditions.find((c: any) => c.type === 'Ready')?.status + : undefined, + } +} + +function buildAttachContract(sandboxId: string) { + const alias = `openshell-${sandboxId}` + return { + alias, + aliasCommand: `ssh ${alias}`, + fallbackCommand: `ssh -i ~/.ssh/id_ed25519_openclaw_labmac ${alias}`, + loginShellCommand: `env PATH=/opt/homebrew/bin:$PATH zsh -l -c 'ssh ${alias}'`, + shellHint: 'If a non-interactive shell misses Homebrew tooling, retry from a login shell or prepend PATH=/opt/homebrew/bin:$PATH before ssh.', + } +} + +export async function GET(request: Request) { + try { + const { searchParams } = new URL(request.url) + const sandboxId = validateSandboxId(searchParams.get('sandboxId') || '') + + const attach = buildAttachContract(sandboxId) + const pod = await inspectPod(sandboxId) + + let shellProbe: { + ok: boolean + output?: string + stderr?: string + error?: string + } = { ok: false } + + const podExists = Boolean(pod.containers.length || pod.images.length || pod.phase) + + if (podExists) { + try { + const probe = await probeSandboxShell(sandboxId) + shellProbe = { + ok: true, + output: probe.stdout.trim(), + stderr: probe.stderr.trim(), + } + } catch (error) { + shellProbe = { + ok: false, + error: error instanceof Error ? error.message : 'Shell probe failed', + } + } + } else { + shellProbe = { + ok: false, + error: `Sandbox pod ${sandboxId} was not found in ${OPENSHELL_NAMESPACE}.`, + } + } + + const podReady = pod.readyCondition === 'True' || pod.phase === 'Running' + const sshReachable = shellProbe.ok + + return NextResponse.json({ + ok: true, + sandboxId, + podExists, + podReady, + sshReachable, + degraded: podExists && !sshReachable, + attach, + pod, + shellProbe, + note: !podExists + ? `Sandbox pod ${sandboxId} is not present in ${OPENSHELL_NAMESPACE}.` + : sshReachable + ? 'Pod introspection and bounded shell probe both succeeded.' + : 'Pod introspection succeeded, but bounded shell probe did not. Treat this as degraded dashboard reachability until direct SSH is confirmed.', + }) + } catch (error) { + const message = error instanceof Error ? error.message : 'Failed to build readiness contract' + const status = message === 'sandboxId is required' + || message.includes('sandboxId must be a valid lowercase DNS-style identifier') + ? 400 + : 500 + + return NextResponse.json({ + ok: false, + podExists: false, + podReady: false, + sshReachable: false, + degraded: false, + error: message, + }, { status }) + } +} diff --git a/app/api/openshell/terminal/route.ts b/app/api/openshell/terminal/route.ts index 80c9c2e..e6eec27 100644 --- a/app/api/openshell/terminal/route.ts +++ b/app/api/openshell/terminal/route.ts @@ -1,4 +1,5 @@ import { NextResponse } from 'next/server' +import { DEFAULT_EXEC_TIMEOUT_MS, MAX_COMMAND_LENGTH, runSandboxCommand, validateSandboxId, validateTerminalCommand } from '../../../lib/openshellHost' export async function GET(request: Request) { const { searchParams } = new URL(request.url) @@ -8,7 +9,63 @@ export async function GET(request: Request) { ok: true, sandboxId, attached: false, - note: 'Embedded terminal transport is not live yet. This route is the integration point for attaching to an OpenShell terminal session.', - suggestedCommand: `openshell sandbox exec ${sandboxId} -- /bin/sh` + interactive: false, + mode: 'bounded-command-runner', + note: 'Embedded PTY transport is still not live. This route now supports bounded one-shot command execution via POST while interactive terminal attach remains pending.', + suggestedCommand: `openshell sandbox exec ${sandboxId} -- /bin/sh`, + limits: { + timeoutMs: DEFAULT_EXEC_TIMEOUT_MS, + maxCommandLength: MAX_COMMAND_LENGTH, + }, }) } + +export async function POST(request: Request) { + try { + const body = await request.json() + const sandboxInput = typeof body?.sandboxId === 'string' ? body.sandboxId : '' + const commandInput = typeof body?.command === 'string' ? body.command : '' + + const sandboxId = validateSandboxId(sandboxInput) + const command = validateTerminalCommand(commandInput) + const result = await runSandboxCommand(sandboxId, command) + + const ok = result.exitCode === 0 + + return NextResponse.json({ + ok, + sandboxId, + interactive: false, + mode: 'bounded-command-runner', + executionMode: result.mode, + command, + exitCode: result.exitCode, + stdout: result.stdout.trim(), + stderr: result.stderr.trim(), + note: ok + ? result.mode === 'shell' + ? 'Bounded sandbox command execution succeeded. Interactive PTY transport is still pending.' + : 'Sandbox reachability fallback succeeded, but command execution still requires a shell-capable image.' + : `Bounded sandbox command exited non-zero (${result.exitCode}). Interactive PTY transport is still pending, but stderr/stdout below reflect the real sandbox response.`, + limits: { + timeoutMs: DEFAULT_EXEC_TIMEOUT_MS, + maxCommandLength: MAX_COMMAND_LENGTH, + }, + }, { status: ok ? 200 : 502 }) + } catch (error) { + const message = error instanceof Error ? error.message : 'Failed to run sandbox command' + const status = message === 'sandboxId is required' + || message === 'command is required' + || message.includes('sandboxId must be a valid lowercase DNS-style identifier') + || message.includes('command exceeds') + ? 400 + : 500 + + return NextResponse.json({ + ok: false, + interactive: false, + mode: 'bounded-command-runner', + error: message, + }, { status }) + } +} diff --git a/app/lib/openshellHost.ts b/app/lib/openshellHost.ts index 2bfc453..6b2f122 100644 --- a/app/lib/openshellHost.ts +++ b/app/lib/openshellHost.ts @@ -1,4 +1,5 @@ import { execFile } from 'node:child_process' +import type { ExecFileException } from 'node:child_process' import { promisify } from 'node:util' const execFileAsync = promisify(execFile) @@ -7,38 +8,153 @@ const DOCKER_BIN = '/Applications/Docker.app/Contents/Resources/bin/docker' const OPENSHELL_CONTAINER = 'openshell-cluster-openshell' const OPENSHELL_NAMESPACE = 'agent-sandbox-system' const OPENCLAW_DASHBOARD_URL = 'http://127.0.0.1:18789/' +const DEFAULT_EXEC_TIMEOUT_MS = 10000 +const MAX_COMMAND_LENGTH = 400 +const SANDBOX_ID_PATTERN = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/ -export async function dockerExecInOpenShell(command: string) { - const { stdout, stderr } = await execFileAsync(DOCKER_BIN, [ - 'exec', - OPENSHELL_CONTAINER, - 'sh', - '-lc', - command, - ]) - return { stdout, stderr } +type ExecResult = { + stdout: string + stderr: string + exitCode: number +} + +function normalizeExecError(error: unknown): ExecResult { + const execError = error as ExecFileException & { stdout?: string, stderr?: string, code?: number | string | null } + return { + stdout: typeof execError?.stdout === 'string' ? execError.stdout : '', + stderr: typeof execError?.stderr === 'string' ? execError.stderr : '', + exitCode: typeof execError?.code === 'number' ? execError.code : -1, + } +} + +export async function dockerExecInOpenShell(command: string, timeoutMs = DEFAULT_EXEC_TIMEOUT_MS): Promise { + try { + const { stdout, stderr } = await execFileAsync( + DOCKER_BIN, + [ + 'exec', + OPENSHELL_CONTAINER, + 'sh', + '-lc', + command, + ], + { + timeout: timeoutMs, + maxBuffer: 1024 * 1024, + } + ) + return { stdout, stderr, exitCode: 0 } + } catch (error) { + const normalized = normalizeExecError(error) + if (normalized.exitCode !== -1 || normalized.stdout || normalized.stderr) { + return normalized + } + throw error + } +} + +type SandboxExecPlan = { + command: string + mode: 'shell' | 'env' +} + +function buildSandboxExecPlans(podName: string, shellCommand: string, options?: { allowEnvFallback?: boolean }): SandboxExecPlan[] { + const escaped = quoteForSingleQuotedShell(shellCommand) + const attempts: SandboxExecPlan[] = [ + { + command: `kubectl -n ${OPENSHELL_NAMESPACE} exec ${podName} -- /bin/sh -lc '${escaped}'`, + mode: 'shell', + }, + { + command: `kubectl -n ${OPENSHELL_NAMESPACE} exec ${podName} -- /busybox/sh -lc '${escaped}'`, + mode: 'shell', + }, + ] + + if (options?.allowEnvFallback) { + attempts.push({ + command: `kubectl -n ${OPENSHELL_NAMESPACE} exec ${podName} -- env`, + mode: 'env', + }) + } + + return attempts +} + +async function execInSandboxWithFallback(podName: string, shellCommand: string, options?: { allowEnvFallback?: boolean }) { + const attempts = buildSandboxExecPlans(podName, shellCommand, options) + + let lastFailure: ({ mode: SandboxExecPlan['mode'] } & ExecResult) | undefined + for (const plan of attempts) { + const result = await dockerExecInOpenShell(plan.command) + if (result.exitCode === 0) { + return { + ...result, + mode: plan.mode, + } + } + + lastFailure = { + ...result, + mode: plan.mode, + } + } + + if (lastFailure) { + return lastFailure + } + + throw new Error('Failed to probe sandbox shell') } export async function probeSandboxShell(podName: string) { - const attempts = [ - `kubectl -n ${OPENSHELL_NAMESPACE} exec ${podName} -- /bin/sh -lc 'echo OPENSHELL_OK && pwd && whoami'`, - `kubectl -n ${OPENSHELL_NAMESPACE} exec ${podName} -- /busybox/sh -lc 'echo OPENSHELL_OK && pwd && whoami'`, - `kubectl -n ${OPENSHELL_NAMESPACE} exec ${podName} -- env`, - ] - - let lastError: unknown - for (const command of attempts) { - try { - return await dockerExecInOpenShell(command) - } catch (error) { - lastError = error - } + const result = await execInSandboxWithFallback(podName, 'echo OPENSHELL_OK && pwd && whoami', { allowEnvFallback: true }) + if (result.exitCode !== 0) { + throw new Error(result.stderr.trim() || result.stdout.trim() || `Shell probe failed with exit code ${result.exitCode}`) } - throw lastError instanceof Error ? lastError : new Error('Failed to probe sandbox shell') + return result +} + +function quoteForSingleQuotedShell(command: string) { + return command.replace(/'/g, `'"'"'`) +} + +export function validateSandboxId(sandboxId: string) { + const trimmed = sandboxId.trim() + + if (!trimmed) { + throw new Error('sandboxId is required') + } + + if (!SANDBOX_ID_PATTERN.test(trimmed)) { + throw new Error('sandboxId must be a valid lowercase DNS-style identifier') + } + + return trimmed +} + +export function validateTerminalCommand(command: string) { + const trimmed = command.trim() + + if (!trimmed) { + throw new Error('command is required') + } + + if (trimmed.length > MAX_COMMAND_LENGTH) { + throw new Error(`command exceeds ${MAX_COMMAND_LENGTH} characters`) + } + + return trimmed +} + +export async function runSandboxCommand(podName: string, command: string) { + const trimmed = validateTerminalCommand(command) + + return await execInSandboxWithFallback(podName, trimmed) } export function getOpenClawDashboardUrl() { return OPENCLAW_DASHBOARD_URL } -export { DOCKER_BIN, OPENSHELL_CONTAINER, OPENSHELL_NAMESPACE } +export { DEFAULT_EXEC_TIMEOUT_MS, DOCKER_BIN, MAX_COMMAND_LENGTH, OPENSHELL_CONTAINER, OPENSHELL_NAMESPACE } diff --git a/app/operator-terminal/page.tsx b/app/operator-terminal/page.tsx index 5868cc1..ea3ff55 100644 --- a/app/operator-terminal/page.tsx +++ b/app/operator-terminal/page.tsx @@ -4,29 +4,67 @@ import Link from 'next/link' import { useSearchParams } from 'next/navigation' import { useCallback, useEffect, useMemo, useState } from 'react' -interface IntrospectResponse { - ok: boolean - sandboxId?: string +interface ReadinessPodSummary { containers?: string[] images?: string[] runningStatuses?: string[] - stderr?: string + phase?: string + readyCondition?: string +} + +interface ReadinessResponse { + ok: boolean + sandboxId?: string + podExists?: boolean + podReady?: boolean + sshReachable?: boolean + degraded?: boolean + attach?: { + alias?: string + aliasCommand?: string + fallbackCommand?: string + loginShellCommand?: string + shellHint?: string + } + pod?: ReadinessPodSummary + shellProbe?: { + ok?: boolean + output?: string + stderr?: string + error?: string + } note?: string error?: string } +interface CommandRunResponse { + ok: boolean + command?: string + executionMode?: string + exitCode?: number + stdout?: string + stderr?: string + error?: string + note?: string +} + type LoadState = 'idle' | 'loading' | 'ready' | 'error' -const SSH_ALIAS = 'ssh openshell-my-assistant' -const SSH_FALLBACK = 'ssh -i ~/.ssh/id_ed25519_openclaw_labmac openshell-my-assistant' +const defaultAlias = (sandboxId: string | null) => `ssh openshell-${sandboxId || 'my-assistant'}` +const defaultFallback = (sandboxId: string | null) => `ssh -i ~/.ssh/id_ed25519_openclaw_labmac openshell-${sandboxId || 'my-assistant'}` +const defaultLoginShell = (sandboxId: string | null) => `env PATH=/opt/homebrew/bin:$PATH zsh -l -c 'ssh openshell-${sandboxId || 'my-assistant'}'` +const DEFAULT_SHELL_HINT = 'If your non-interactive shell misses Homebrew tooling, retry from a login shell or prepend PATH=/opt/homebrew/bin:$PATH before ssh.' export default function OperatorTerminalPage() { const searchParams = useSearchParams() const sandboxId = searchParams.get('sandboxId') const [state, setState] = useState(sandboxId ? 'loading' : 'idle') - const [data, setData] = useState(null) + const [data, setData] = useState(null) const [lastCheckedAt, setLastCheckedAt] = useState(null) const [copyMessage, setCopyMessage] = useState('') + const [commandInput, setCommandInput] = useState('pwd && whoami') + const [commandState, setCommandState] = useState<'idle' | 'running' | 'done' | 'error'>('idle') + const [commandResult, setCommandResult] = useState(null) const refreshReadiness = useCallback(async () => { if (!sandboxId) { @@ -39,10 +77,10 @@ export default function OperatorTerminalPage() { setCopyMessage('') try { - const response = await fetch(`/api/openshell/terminal/introspect?sandboxId=${encodeURIComponent(sandboxId)}`, { + const response = await fetch(`/api/openshell/terminal/readiness?sandboxId=${encodeURIComponent(sandboxId)}`, { cache: 'no-store', }) - const result: IntrospectResponse = await response.json() + const result: ReadinessResponse = await response.json() setData(result) setState(response.ok && result.ok ? 'ready' : 'error') setLastCheckedAt(new Date().toLocaleTimeString()) @@ -73,22 +111,38 @@ export default function OperatorTerminalPage() { return { tone: 'border-[var(--status-pending)] text-[var(--status-pending)]', label: 'CHECKING READINESS', - detail: 'Verifying pod metadata so the page can show a truthful operator handoff.', + detail: 'Verifying pod metadata and bounded shell reachability so the page can report terminal truth in one pass.', } } - if (state === 'ready' && data?.ok) { + if (state === 'ready' && data?.ok && data?.podReady && data?.sshReachable) { + return { + tone: 'border-[var(--status-running)] text-[var(--status-running)]', + label: 'TERMINAL PATH VERIFIED', + detail: 'The dashboard confirmed the pod is ready and a bounded backend shell exec succeeded. Interactive PTY embedding is still not wired up, but this path now proves command execution reachability without requiring a second manual probe.', + } + } + + if (state === 'ready' && data?.ok && data?.podExists && data?.degraded) { + return { + tone: 'border-[var(--status-pending)] text-[var(--status-pending)]', + label: 'DEGRADED: POD UP, SHELL UNCONFIRMED', + detail: 'The pod exists, but the bounded shell probe did not succeed from the dashboard backend. Treat the page as degraded and try the local SSH attach path.', + } + } + + if (state === 'ready' && data?.ok && data?.podExists) { return { tone: 'border-[var(--status-running)] text-[var(--status-running)]', label: 'READY FOR LOCAL SSH ATTACH', - detail: 'This page confirms the sandbox exists. Interactive PTY embedding is not wired up yet, so attach from your local terminal.', + detail: 'The dashboard confirmed pod metadata. Use the attach commands below while persistent PTY transport is still pending.', } } return { tone: 'border-[var(--status-stopped)] text-[var(--status-stopped)]', label: 'READINESS CHECK FAILED', - detail: 'The dashboard could not confirm pod metadata. Use the recovery commands below, then retry.', + detail: 'The dashboard could not confirm pod metadata or shell reachability. Use the recovery commands below, then retry.', } }, [sandboxId, state, data]) @@ -101,6 +155,44 @@ export default function OperatorTerminalPage() { } }, []) + const runCommand = useCallback(async () => { + if (!sandboxId) { + setCommandState('error') + setCommandResult({ ok: false, error: 'Select a sandbox before running a command.' }) + return + } + + setCommandState('running') + setCommandResult(null) + + try { + const response = await fetch('/api/openshell/terminal', { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + body: JSON.stringify({ + sandboxId, + command: commandInput, + }), + }) + const result: CommandRunResponse = await response.json() + setCommandResult(result) + setCommandState(response.ok && result.ok ? 'done' : 'error') + } catch (error) { + setCommandResult({ + ok: false, + error: error instanceof Error ? error.message : 'Failed to run dashboard command.', + }) + setCommandState('error') + } + }, [commandInput, sandboxId]) + + const aliasCommand = data?.attach?.aliasCommand || defaultAlias(sandboxId) + const fallbackCommand = data?.attach?.fallbackCommand || defaultFallback(sandboxId) + const loginShellCommand = data?.attach?.loginShellCommand || defaultLoginShell(sandboxId) + const shellHint = data?.attach?.shellHint || DEFAULT_SHELL_HINT + return (
@@ -109,7 +201,7 @@ export default function OperatorTerminalPage() {

Operator path

Operator Terminal

- Truthful first render for the current terminal path. This page does not pretend to host an embedded shell; it verifies readiness and tells the operator exactly how to attach. + Truthful operator render for the current terminal path. This page still does not pretend to host an embedded PTY, but it now checks pod readiness and bounded shell reachability together before telling you how to attach.

Attach Instructions

- Preferred path is the SSH alias. If your shell environment is missing the alias or key wiring, use the explicit fallback. + Preferred path is the SSH alias. If your shell environment is missing the alias or key wiring, use the explicit fallback. The readiness check below is now the page's single preflight source.

Preferred attach command

- {SSH_ALIAS} + {aliasCommand}
-
-

Fallback if alias or agent config is missing

- {SSH_FALLBACK} -

- If your non-interactive shell misses Homebrew tooling, retry from a login shell or prepend PATH=/opt/homebrew/bin:$PATH before related helper commands. -

+
+
+

Fallback if alias or agent config is missing

+ {fallbackCommand} +

{shellHint}

+ +
+ +
+

Login-shell retry for Homebrew/path issues

+ {loginShellCommand} + +
+
+
+ +
+
+
+

Bounded shell reachability

+

+ This is now captured as part of the readiness contract, so the page can show command execution reachability immediately on load. +

+
+
+ {data?.shellProbe?.ok ? 'Probe passed' : 'Probe not confirmed'} +
+
+ +
+

Probe stdout

+
{data?.shellProbe?.output || 'No backend shell output captured yet.'}
+
+ +
+

Probe stderr / status

+
{data?.shellProbe?.error || data?.shellProbe?.stderr || data?.note || 'No stderr.'}
+
+
+ +
+
+
+

Bounded dashboard command runner

+

+ Minimal in-dashboard execution while PTY transport is still pending. Runs a single bounded command through the dashboard backend against the selected sandbox. +

+
+
+ {commandState === 'running' ? 'Running…' : commandState === 'done' ? 'Last run succeeded' : commandState === 'error' ? 'Last run failed' : 'Idle'} +
+
+ +