"use client" import { useEffect, useState } from 'react' import type { ReactNode } from 'react' import ConfigurationPanel from './ConfigurationPanel' import SandboxFilesPanel from './SandboxFilesPanel' import SandboxInferencePanel from './SandboxInferencePanel' 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 } type DrawerKey = 'operations' | 'files' | 'inference' | 'policy' 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 } 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 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, }: SandboxListProps) { const [dashboardMessage, setDashboardMessage] = useState('') const [restartInProgress, setRestartInProgress] = useState(false) const [permissionMessage, setPermissionMessage] = useState('') const [permissionFeeds, setPermissionFeeds] = useState>({}) const [grantingSandboxId, setGrantingSandboxId] = useState(null) const [openDrawers, setOpenDrawers] = useState>({ operations: true, files: false, inference: false, policy: 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]) 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 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 })) } 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

) : ( <>

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

REFRESH: 10s
{sandboxes.map((sandbox) => (
))}
{permissionMessage && (
{permissionMessage}
)} {!isDestroyMode && selectedSandbox && ( <> toggleDrawer('operations')} >
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('policy')} >
{(() => { const feed = permissionFeeds[selectedSandbox.id] const pending = feed?.pending || [] 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}

)) })()}
)} )}
) }