"use client" import { useEffect, useState } from 'react' import type { ReactNode } from 'react' import ConfigurationPanel from './ConfigurationPanel' import SandboxArchivePanel from './SandboxArchivePanel' import SandboxFilesPanel from './SandboxFilesPanel' import SandboxInferencePanel from './SandboxInferencePanel' import { buildOperatorTerminalRoute } from '../lib/dashboardSession' import type { NemoClawSummary, SandboxInventoryItem } from '../hooks/useSandboxInventory' interface TelemetryData { cpu: number memory: number disk: number gpuMemoryUsed?: number gpuMemoryTotal?: number gpuTemperature?: number timestamp: string } interface SandboxListProps { sandboxes: SandboxInventoryItem[] nemoclaw: NemoClawSummary | null selectedSandboxId: string | null selectedSandbox: SandboxInventoryItem | null onSandboxSelect: (id: string | null) => void isDestroyMode: boolean onInventoryRefresh: () => Promise dashboardSessionId: string } type DrawerKey = 'operations' | 'files' | 'inference' | 'policy' | 'archive' | 'mcp' type McpServerAccess = { id: string name: string command: string args: string[] enabled: boolean accessMode: 'disabled' | 'allow_all' | 'allow_only' allowedSandboxIds: string[] } type NetworkRuleRequest = { chunkId: string status: string rule: string binary: string confidence: string rationale: string endpoints: string[] binaries: string[] } type PermissionFeed = { latest?: { status?: string; chunkId?: string; error?: string } | null pending?: NetworkRuleRequest[] recent?: NetworkRuleRequest[] pendingCount?: number rejectedCount?: number } type DismissedPermissionAlerts = Record const DISMISSED_PERMISSION_ALERTS_STORAGE_KEY = 'openshell-control-dismissed-permission-alerts' const DISMISS_PERMISSION_VALUE = '__dismiss_permission_alerts__' const OPENCLAW_SANDBOX_LOGO = '/sandbox-logos/openclaw.svg' const HERMES_SANDBOX_LOGO = '/sandbox-logos/hermes.png' function renderDashboardTruthMessage(data: any) { if (data.reachable) return 'OpenClaw dashboard opened in a new tab.' return 'OpenClaw dashboard is not reachable from this host right now.' } function openDashboardUrl(url: string, openInNewTab: boolean) { if (openInNewTab) { window.open(url, '_blank', 'noopener,noreferrer') } else { window.location.href = url } } function displaySandboxAgent(agent?: string) { if (agent === 'hermes') return 'Hermes' return 'OpenClaw' } function SandboxTypeLogo({ agent }: { agent?: string }) { const isHermes = agent === 'hermes' const label = isHermes ? 'Hermes sandbox' : 'OpenClaw sandbox' const logoSrc = isHermes ? HERMES_SANDBOX_LOGO : OPENCLAW_SANDBOX_LOGO return ( ) } function normalizeDismissedPermissionAlerts(value: unknown): DismissedPermissionAlerts { if (!value || typeof value !== 'object' || Array.isArray(value)) return {} return Object.entries(value as Record).reduce((normalized, [sandboxId, chunks]) => { if (Array.isArray(chunks)) { const ids = chunks.filter((chunk): chunk is string => typeof chunk === 'string' && chunk.length > 0) if (ids.length > 0) normalized[sandboxId] = Array.from(new Set(ids)) } return normalized }, {}) } function loadDismissedPermissionAlerts(): DismissedPermissionAlerts { if (typeof window === 'undefined') return {} try { return normalizeDismissedPermissionAlerts(JSON.parse(window.localStorage.getItem(DISMISSED_PERMISSION_ALERTS_STORAGE_KEY) || '{}')) } catch { return {} } } function saveDismissedPermissionAlerts(alerts: DismissedPermissionAlerts) { if (typeof window === 'undefined') return window.localStorage.setItem(DISMISSED_PERMISSION_ALERTS_STORAGE_KEY, JSON.stringify(alerts)) } function dismissedPermissionSet(alerts: DismissedPermissionAlerts, sandbox: SandboxInventoryItem) { return new Set([...(alerts[sandbox.id] || []), ...(alerts[sandbox.name] || [])]) } function visiblePendingRequests(feed: PermissionFeed | undefined, sandbox: SandboxInventoryItem, alerts: DismissedPermissionAlerts) { const dismissed = dismissedPermissionSet(alerts, sandbox) return (feed?.pending || []).filter((request) => !request.chunkId || !dismissed.has(request.chunkId)) } function permissionFeedNeedsAttention(feed: PermissionFeed | undefined, sandbox: SandboxInventoryItem, alerts: DismissedPermissionAlerts) { const latestStatus = feed?.latest?.status || '' const latestChunkId = feed?.latest?.chunkId || '' const dismissed = dismissedPermissionSet(alerts, sandbox) return Boolean( visiblePendingRequests(feed, sandbox, alerts).length > 0 || (/pending|fail|error|unavailable/i.test(latestStatus) && (!latestChunkId || !dismissed.has(latestChunkId))), ) } function DrawerSection({ title, summary, open, onToggle, children, }: { title: string summary: string open: boolean onToggle: () => void children: ReactNode }) { return (
{open && (
{children}
)}
) } export default function SandboxList({ sandboxes, nemoclaw: _nemoclaw, selectedSandboxId, selectedSandbox, onSandboxSelect, isDestroyMode, onInventoryRefresh, dashboardSessionId, }: SandboxListProps) { const [dashboardMessage, setDashboardMessage] = useState('') const [restartInProgress, setRestartInProgress] = useState(false) const [permissionMessage, setPermissionMessage] = useState('') const [permissionFeeds, setPermissionFeeds] = useState>({}) const [dismissedPermissionAlerts, setDismissedPermissionAlerts] = useState(() => loadDismissedPermissionAlerts()) const [grantingSandboxId, setGrantingSandboxId] = useState(null) const [mcpServers, setMcpServers] = useState([]) const [mcpMessage, setMcpMessage] = useState('') const [mcpUpdatingServerId, setMcpUpdatingServerId] = useState(null) const [mcpSyncing, setMcpSyncing] = useState(false) const [openDrawers, setOpenDrawers] = useState>({ operations: true, files: false, inference: false, policy: false, archive: false, mcp: false, }) const [telemetry, setTelemetry] = useState({ cpu: 0, memory: 0, disk: 0, timestamp: new Date().toISOString() }) useEffect(() => { if (selectedSandboxId) { fetchTelemetry() const interval = setInterval(fetchTelemetry, 5000) return () => clearInterval(interval) } }, [selectedSandboxId]) useEffect(() => { if (sandboxes.length === 0) { setPermissionFeeds({}) return } let active = true const loadPermissionFeeds = async () => { const entries = await Promise.all(sandboxes.map(async (sandbox) => { try { const response = await fetch(`/api/sandbox/${encodeURIComponent(sandbox.id)}/permissions`, { cache: 'no-store' }) const data = await response.json() return [sandbox.id, response.ok ? data.feed : { rejectedCount: 1, latest: { status: 'Unavailable', error: data.error } }] as const } catch (error) { return [sandbox.id, { rejectedCount: 1, latest: { status: 'Unavailable', error: error instanceof Error ? error.message : 'Permission feed unavailable' } }] as const } })) if (active) setPermissionFeeds(Object.fromEntries(entries)) } loadPermissionFeeds() const interval = window.setInterval(loadPermissionFeeds, 12000) return () => { active = false window.clearInterval(interval) } }, [sandboxes]) useEffect(() => { let active = true const loadMcpAccess = async () => { try { const response = await fetch('/api/mcp', { cache: 'no-store' }) const data = await response.json() if (!response.ok) throw new Error(data.error || 'Failed to load MCP access') if (active) setMcpServers(Array.isArray(data.servers) ? data.servers : []) } catch (error) { if (active) { setMcpServers([]) setMcpMessage(error instanceof Error ? error.message : 'Failed to load MCP access') } } } loadMcpAccess() const interval = window.setInterval(loadMcpAccess, 12000) return () => { active = false window.clearInterval(interval) } }, []) const fetchTelemetry = async () => { try { const response = await fetch('/api/telemetry/combined') const data = await response.json() setTelemetry(data) } catch (error) { console.error('Error fetching telemetry:', error) } } const restartSandbox = async () => { if (!selectedSandbox || restartInProgress) return try { setRestartInProgress(true) setDashboardMessage(`Restarting sandbox ${selectedSandbox.name}...`) const response = await fetch(`/api/sandbox/${encodeURIComponent(selectedSandbox.id)}/restart`, { method: 'POST', }) const data = await response.json() if (!response.ok) throw new Error(data.error || data.note || 'Failed to restart sandbox') setDashboardMessage(data.note || `Sandbox ${selectedSandbox.name} restarted.`) await onInventoryRefresh() } catch (error) { setDashboardMessage(error instanceof Error ? error.message : 'Failed to restart sandbox.') } finally { setRestartInProgress(false) } } const toggleDrawer = (key: DrawerKey) => { setOpenDrawers((current) => ({ ...current, [key]: !current[key] })) } const sandboxCanAccessMcpServer = (sandbox: SandboxInventoryItem, server: McpServerAccess) => { if (!server.enabled || server.accessMode === 'disabled') return false if (server.accessMode === 'allow_all') return true return server.allowedSandboxIds.includes(sandbox.id) || server.allowedSandboxIds.includes(sandbox.name) } const allowedMcpServersForSandbox = (sandbox: SandboxInventoryItem) => ( mcpServers.filter((server) => sandboxCanAccessMcpServer(sandbox, server)) ) const selectedSandboxIsHermes = selectedSandbox?.agent === 'hermes' const connectToHermes = (sandbox: SandboxInventoryItem) => { const route = buildOperatorTerminalRoute({ sandboxId: sandbox.name, dashboardSessionId, launch: 'hermes', }) window.open(route, '_blank', 'noopener,noreferrer') } const updateMcpServerAccess = async ( server: McpServerAccess, body: Partial>, success: string, ) => { try { setMcpUpdatingServerId(server.id) setMcpMessage('') const response = await fetch('/api/mcp', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ action: 'update-access', serverId: server.id, ...body }), }) const data = await response.json() if (!response.ok) throw new Error(data.error || 'Failed to update MCP access') setMcpServers(Array.isArray(data.servers) ? data.servers : []) setMcpMessage(success) } catch (error) { setMcpMessage(error instanceof Error ? error.message : 'Failed to update MCP access') } finally { setMcpUpdatingServerId(null) } } const syncMcpManifest = async (sandbox: SandboxInventoryItem) => { try { setMcpSyncing(true) setMcpMessage(`Issuing MCP broker config for ${sandbox.name}...`) const response = await fetch(`/api/sandbox/${encodeURIComponent(sandbox.id)}/mcp`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ sandboxName: sandbox.name }), }) const data = await response.json() if (!response.ok) throw new Error(data.error || 'Failed to issue MCP broker config') setMcpMessage(data.note || 'MCP broker config issued.') } catch (error) { setMcpMessage(error instanceof Error ? error.message : 'Failed to issue MCP broker config') } finally { setMcpSyncing(false) } } const enableMcpForSandbox = (sandbox: SandboxInventoryItem, server: McpServerAccess) => { const current = new Set(server.allowedSandboxIds) current.add(sandbox.id) return updateMcpServerAccess(server, { enabled: true, accessMode: server.accessMode === 'allow_all' ? 'allow_all' : 'allow_only', allowedSandboxIds: Array.from(current), }, `${server.name} enabled for ${sandbox.name}.`).then(() => syncMcpManifest(sandbox)) } const revokeMcpForSandbox = (sandbox: SandboxInventoryItem, server: McpServerAccess) => { const current = new Set(server.allowedSandboxIds) current.delete(sandbox.id) current.delete(sandbox.name) if (server.accessMode === 'allow_all') { for (const item of sandboxes) { if (item.id !== sandbox.id) current.add(item.id) } } return updateMcpServerAccess(server, { accessMode: 'allow_only', allowedSandboxIds: Array.from(current), }, `${server.name} revoked from ${sandbox.name}.`).then(() => syncMcpManifest(sandbox)) } const dismissPermissionAlerts = (sandbox: SandboxInventoryItem, chunkId?: string) => { const feed = permissionFeeds[sandbox.id] const visibleIds = visiblePendingRequests(feed, sandbox, dismissedPermissionAlerts) .map((request) => request.chunkId) .filter(Boolean) const idsToDismiss = chunkId ? [chunkId] : visibleIds if (idsToDismiss.length === 0) { setPermissionMessage(`No permission alerts to hide for ${sandbox.name}.`) return } setDismissedPermissionAlerts((current) => { const existing = new Set(current[sandbox.id] || []) for (const id of idsToDismiss) existing.add(id) const next = { ...current, [sandbox.id]: Array.from(existing) } saveDismissedPermissionAlerts(next) return next }) setPermissionMessage(idsToDismiss.length === 1 ? `Permission alert hidden for ${sandbox.name}.` : `Permission alerts hidden for ${sandbox.name}.`) } const clearDismissedPermissionAlert = (sandbox: SandboxInventoryItem, chunkId: string) => { setDismissedPermissionAlerts((current) => { const existing = current[sandbox.id] if (!existing?.includes(chunkId)) return current const remaining = existing.filter((id) => id !== chunkId) const next = { ...current } if (remaining.length > 0) next[sandbox.id] = remaining else delete next[sandbox.id] saveDismissedPermissionAlerts(next) return next }) } const resolvePermissionRequest = async (sandbox: SandboxInventoryItem, action: 'approve' | 'reject', chunkId: string) => { if (!chunkId) return try { setGrantingSandboxId(sandbox.id) setPermissionMessage(`${action === 'approve' ? 'Approving' : 'Rejecting'} network request for ${sandbox.name}...`) const response = await fetch(`/api/sandbox/${encodeURIComponent(sandbox.id)}/permissions`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ action, chunkId }), }) const data = await response.json() if (!response.ok) throw new Error(data.error || 'Failed to resolve permission request') if (data.result?.feed) { setPermissionFeeds((current) => ({ ...current, [sandbox.id]: data.result.feed })) } clearDismissedPermissionAlert(sandbox, chunkId) setPermissionMessage(data.note || `Network request ${action === 'approve' ? 'approved' : 'rejected'} for ${sandbox.name}.`) } catch (error) { setPermissionMessage(error instanceof Error ? error.message : 'Failed to resolve permission request') } finally { setGrantingSandboxId(null) } } return (
{sandboxes.length === 0 ? (

No Sandboxes Detected

No live OpenShell sandboxes reported yet

) : ( <>

Inventory

{isDestroyMode ? 'SELECT SANDBOX TO DESTROY' : 'ACTIVE SANDBOXES'}

REFRESH 10s
{sandboxes.map((sandbox) => (
{(() => { const feed = permissionFeeds[sandbox.id] const visiblePending = visiblePendingRequests(feed, sandbox, dismissedPermissionAlerts) return ( ) })()}
))}
{permissionMessage && (
{permissionMessage}
)} {!isDestroyMode && selectedSandbox && ( <> toggleDrawer('operations')} >
{!selectedSandboxIsHermes ? ( ) : ( )} LIVE
{dashboardMessage && (
{dashboardMessage &&
{dashboardMessage}
}
)}

CPU

{telemetry.cpu.toFixed(1)}%

MEM

{telemetry.memory.toFixed(1)}%

DISK

{telemetry.disk.toFixed(1)}%

UPDATED

{new Date(telemetry.timestamp).toLocaleTimeString()}

toggleDrawer('files')} > toggleDrawer('inference')} > toggleDrawer('mcp')} >

Sandbox Manifest

Writes /sandbox/openshell_control_mcp.md with broker URL and sandbox token only.

{mcpMessage && (
{mcpMessage}
)} {mcpServers.length === 0 ? (
No MCP servers are installed yet.
) : (
{mcpServers.map((server) => { const hasAccess = sandboxCanAccessMcpServer(selectedSandbox, server) const updating = mcpUpdatingServerId === server.id return (

{server.name}

{server.command} {server.args.join(' ')}

{hasAccess ? 'allowed' : 'blocked'}
) })}
)}
toggleDrawer('policy')} >
{(() => { const feed = permissionFeeds[selectedSandbox.id] const pending = visiblePendingRequests(feed, selectedSandbox, dismissedPermissionAlerts) if (pending.length === 0) { return (
No pending network permission requests for this sandbox.
) } return pending.map((request) => (
{request.endpoints.join(', ') || request.rule} {request.confidence ? ( {request.confidence} ) : null}

{request.rationale || 'Sandbox requested a network policy rule.'}

{request.binary || request.binaries.join(', ') || 'unknown binary'} / {request.chunkId}

)) })()}
toggleDrawer('archive')} > { await onInventoryRefresh() }} /> )} )}
) }