"use client" import Link from 'next/link' import { useSearchParams } from 'next/navigation' import { useCallback, useEffect, useMemo, useState } from 'react' interface ReadinessPodSummary { containers?: string[] images?: string[] runningStatuses?: 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 TranscriptEntry { id: string command: string stdout: string stderr: string exitCode: number executionMode?: string ranAt: string } interface TerminalSessionPayload { sessionId: string sandboxId: string cwd?: string createdAt: string updatedAt: string prompt: string transcript: TranscriptEntry[] } interface CommandRunResponse { ok: boolean command?: string executionMode?: string exitCode?: number stdout?: string stderr?: string error?: string note?: string session?: TerminalSessionPayload } type LoadState = 'idle' | 'loading' | 'ready' | 'error' 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 [lastCheckedAt, setLastCheckedAt] = useState(null) const [copyMessage, setCopyMessage] = useState('') const [commandInput, setCommandInput] = useState('pwd') const [commandState, setCommandState] = useState<'idle' | 'running' | 'done' | 'error'>('idle') const [commandResult, setCommandResult] = useState(null) const [sessionState, setSessionState] = useState<'idle' | 'loading' | 'ready' | 'error'>('idle') const [terminalSession, setTerminalSession] = useState(null) const refreshReadiness = useCallback(async () => { if (!sandboxId) { setState('idle') setData(null) return } setState('loading') setCopyMessage('') try { const response = await fetch(`/api/openshell/terminal/readiness?sandboxId=${encodeURIComponent(sandboxId)}`, { cache: 'no-store', }) const result: ReadinessResponse = await response.json() setData(result) setState(response.ok && result.ok ? 'ready' : 'error') setLastCheckedAt(new Date().toLocaleTimeString()) } catch (error) { setData({ ok: false, error: error instanceof Error ? error.message : 'Failed to inspect sandbox readiness.', }) setState('error') setLastCheckedAt(new Date().toLocaleTimeString()) } }, [sandboxId]) const ensureTerminalSession = useCallback(async () => { if (!sandboxId) { setTerminalSession(null) setSessionState('idle') return } setSessionState('loading') try { const currentSessionId = terminalSession?.sessionId const url = currentSessionId ? `/api/openshell/terminal?sandboxId=${encodeURIComponent(sandboxId)}&sessionId=${encodeURIComponent(currentSessionId)}` : `/api/openshell/terminal?sandboxId=${encodeURIComponent(sandboxId)}` const response = await fetch(url, { cache: 'no-store' }) const result = await response.json() if (!response.ok || !result.ok || !result.session) { throw new Error(result.error || 'Failed to initialize dashboard terminal session.') } setTerminalSession(result.session) setSessionState('ready') } catch (error) { setSessionState('error') setTerminalSession(null) setCommandResult({ ok: false, error: error instanceof Error ? error.message : 'Failed to initialize terminal session.' }) } }, [sandboxId, terminalSession?.sessionId]) useEffect(() => { refreshReadiness() }, [refreshReadiness]) useEffect(() => { ensureTerminalSession() }, [ensureTerminalSession]) const readiness = useMemo(() => { if (!sandboxId) { return { tone: 'border-[var(--status-pending)] text-[var(--status-pending)]', label: 'NO SANDBOX SELECTED', detail: 'Return to the dashboard and choose a sandbox before opening Operator Terminal.', } } if (state === 'loading') { return { tone: 'border-[var(--status-pending)] text-[var(--status-pending)]', label: 'CHECKING READINESS', detail: 'Verifying pod metadata and bounded shell reachability so the page can report terminal truth in one pass.', } } 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 backend confirmed pod readiness and shell reachability. The dashboard terminal below is session-backed and preserves transcript plus working directory across commands.', } } 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. You can still inspect the terminal panel below, but local SSH remains the stronger recovery path.', } } if (state === 'ready' && data?.ok && data?.podExists) { return { tone: 'border-[var(--status-running)] text-[var(--status-running)]', label: 'READY FOR DASHBOARD TERMINAL', detail: 'Pod metadata is present and the dashboard terminal session can be used for command-scoped work.', } } return { tone: 'border-[var(--status-stopped)] text-[var(--status-stopped)]', label: 'READINESS CHECK FAILED', detail: 'The dashboard could not confirm pod metadata or shell reachability. Use the recovery commands below, then retry.', } }, [sandboxId, state, data]) const copyCommand = useCallback(async (command: string) => { try { await navigator.clipboard.writeText(command) setCopyMessage(`Copied: ${command}`) } catch { setCopyMessage(`Copy failed. Use: ${command}`) } }, []) 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, sessionId: terminalSession?.sessionId, command: commandInput, }), }) const result: CommandRunResponse = await response.json() setCommandResult(result) if (result.session) { setTerminalSession(result.session) setSessionState('ready') } 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, terminalSession?.sessionId]) 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 const transcript = terminalSession?.transcript || [] return (

Operator path

Operator Terminal

Dashboard terminal for the selected sandbox. This is not pretending to be a raw PTY: it is a session-backed shell view that keeps working directory and transcript across commands so you can actually use the dashboard as a terminal surface.

Back to Dashboard

Sandbox

{sandboxId || 'UNSELECTED'}

Status

{readiness.label}

{lastCheckedAt &&

Last checked {lastCheckedAt}

}

{readiness.detail}

Dashboard Terminal

Session-backed shell surface. Each command runs through the backend against the sandbox, and the page keeps transcript plus cwd so the experience behaves like a terminal instead of isolated one-shot boxes.

{sessionState === 'loading' ? 'Initializing session…' : sessionState === 'ready' ? terminalSession?.prompt : sessionState === 'error' ? 'Session unavailable' : 'Idle'}
{terminalSession?.prompt || `${sandboxId || 'sandbox'}:~$`}
{terminalSession?.sessionId ? `session ${terminalSession.sessionId.slice(0, 8)}` : 'no session'}
{transcript.length === 0 ? (
No terminal transcript yet. Run a command below to start the session.
) : ( transcript.map((entry) => (
{terminalSession?.prompt || `${sandboxId || 'sandbox'}:~$`} {entry.command}
{entry.stdout || ''}
{entry.stderr && (
{entry.stderr}
)}
exit {entry.exitCode}{entry.executionMode ? ` · ${entry.executionMode}` : ''} · {new Date(entry.ranAt).toLocaleTimeString()}
)) )}