@pellux/goodvibes-tui 0.18.4 → 0.18.9

package/src/runtime/sandbox/backend.ts

@@ -1,291 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { existsSync, statSync } from 'node:fs';
-import { resolve } from 'node:path';
-import type { ConfigManager } from '../../config/manager.ts';
-import { detectSandboxHostStatus, getSandboxConfigSnapshot } from './manager.ts';
-import type {
-  SandboxBackendAvailability,
-  SandboxBackendProbe,
-  SandboxLaunchPlan,
-  SandboxProfile,
-  SandboxResolvedBackend,
-} from '@pellux/goodvibes-sdk/platform/runtime/sandbox/types';
-
-function shellQuote(value: string): string {
-  return `'${value.replace(/'/g, `'\"'\"'`)}'`;
-}
-
-function hasCommand(command: string, args: readonly string[] = ['--version']): boolean {
-  const result = spawnSync(command, [...args], {
-    stdio: 'ignore',
-    timeout: 1500,
-    windowsHide: true,
-  });
-  return result.status === 0 || result.status === 1;
-}
-
-function qemuBinaryFor(manager: ConfigManager | { get: (key: string) => unknown }): string {
-  const configured = `${manager.get('sandbox.qemuBinary' as never) ?? ''}`.trim();
-  return configured || 'qemu-system-x86_64';
-}
-
-function qemuImageFor(manager: ConfigManager | { get: (key: string) => unknown }): string {
-  return `${manager.get('sandbox.qemuImagePath' as never) ?? ''}`.trim();
-}
-
-function qemuExecWrapperFor(manager: ConfigManager | { get: (key: string) => unknown }): string {
-  return `${manager.get('sandbox.qemuExecWrapper' as never) ?? ''}`.trim();
-}
-
-function qemuGuestHostFor(manager: ConfigManager | { get: (key: string) => unknown }): string {
-  return `${manager.get('sandbox.qemuGuestHost' as never) ?? ''}`.trim();
-}
-
-function qemuGuestPortFor(manager: ConfigManager | { get: (key: string) => unknown }): string {
-  const raw = manager.get('sandbox.qemuGuestPort' as never);
-  return `${typeof raw === 'number' ? raw : Number.parseInt(`${raw ?? ''}`, 10) || 2222}`;
-}
-
-function qemuGuestUserFor(manager: ConfigManager | { get: (key: string) => unknown }): string {
-  return `${manager.get('sandbox.qemuGuestUser' as never) ?? ''}`.trim();
-}
-
-function qemuWorkspacePathFor(manager: ConfigManager | { get: (key: string) => unknown }): string {
-  return `${manager.get('sandbox.qemuWorkspacePath' as never) ?? ''}`.trim();
-}
-
-function qemuSessionModeFor(manager: ConfigManager | { get: (key: string) => unknown }): 'attach' | 'launch-per-command' {
-  const configured = `${manager.get('sandbox.qemuSessionMode' as never) ?? ''}`.trim();
-  return configured === 'launch-per-command' ? 'launch-per-command' : 'attach';
-}
-
-function isExecutableFile(path: string): boolean {
-  try {
-    const stat = statSync(path);
-    return stat.isFile() && (stat.mode & 0o111) !== 0;
-  } catch {
-    return false;
-  }
-}
-
-function buildAvailability(
-  id: SandboxResolvedBackend,
-  available: boolean,
-  detail: string,
-): SandboxBackendAvailability {
-  return Object.freeze({ id, available, detail });
-}
-
-export function probeSandboxBackends(
-  manager: ConfigManager | { get: (key: string) => unknown },
-): SandboxBackendProbe {
-  const host = detectSandboxHostStatus(manager as ConfigManager);
-  const config = getSandboxConfigSnapshot(manager as ConfigManager);
-  const qemuBinary = qemuBinaryFor(manager);
-  const qemuImage = qemuImageFor(manager);
-  const qemuExecWrapper = qemuExecWrapperFor(manager);
-  const qemuGuestHost = qemuGuestHostFor(manager);
-  const backends: readonly SandboxBackendAvailability[] = [
-    buildAvailability('local', true, 'host-local process isolation fallback is always available'),
-    buildAvailability('qemu', hasCommand(qemuBinary), `requires ${qemuBinary} on PATH`),
-  ];
-
-  const requested = config.vmBackend;
-  let resolved: SandboxResolvedBackend = 'local';
-  if (config.vmBackend === 'qemu') {
-    resolved = backends.find((entry) => entry.id === 'qemu')?.available ? 'qemu' : 'local';
-  }
-
-  const warnings: string[] = [];
-  if (config.vmBackend === 'qemu' && resolved === 'local') {
-    warnings.push(`Requested sandbox backend "${config.vmBackend}" is unavailable; falling back to local process isolation.`);
-  }
-  if (config.vmBackend === 'qemu' && !qemuImage) {
-    warnings.push('QEMU backend selected without sandbox.qemuImagePath; sessions can be planned and reviewed, but guest execution remains disabled.');
-  }
-  if (config.vmBackend === 'qemu' && qemuImage && !qemuExecWrapper) {
-    warnings.push('QEMU image is configured without sandbox.qemuExecWrapper; guest launch planning is wired, but command execution remains disabled until a host bridge is configured.');
-  }
-  if (config.vmBackend === 'qemu' && qemuExecWrapper && !qemuGuestHost) {
-    warnings.push('QEMU wrapper is configured without sandbox.qemuGuestHost; host bridge mode is available, but real guest SSH transport remains disabled until the guest host is configured.');
-  }
-  if (config.vmBackend === 'qemu' && qemuExecWrapper && !existsSync(qemuExecWrapper)) {
-    warnings.push(`Configured sandbox.qemuExecWrapper does not exist: ${qemuExecWrapper}`);
-  }
-  if (config.vmBackend === 'qemu' && qemuExecWrapper && existsSync(qemuExecWrapper) && !isExecutableFile(qemuExecWrapper)) {
-    warnings.push(`Configured sandbox.qemuExecWrapper is not executable: ${qemuExecWrapper}`);
-  }
-  if (host.windows && !host.runningInWsl && config.vmBackend === 'qemu') {
-    warnings.push('QEMU sandboxing on Windows requires running GoodVibes inside WSL.');
-  }
-
-  return Object.freeze({
-    requestedBackend: requested,
-    resolvedBackend: resolved,
-    backends,
-    warnings,
-  });
-}
-
-function buildCommandSummary(command: string, args: readonly string[]): string {
-  return [command, ...args].join(' ').trim();
-}
-
-export function buildSandboxLaunchPlan(
-  profile: SandboxProfile,
-  label: string,
-  manager: ConfigManager,
-  workspaceRoot: string,
-): SandboxLaunchPlan {
-  const backendProbe = probeSandboxBackends(manager);
-  const safeWorkspaceRoot = resolve(workspaceRoot);
-  if (backendProbe.resolvedBackend === 'qemu') {
-    const qemuBinary = qemuBinaryFor(manager);
-    const qemuImage = qemuImageFor(manager);
-    const guestPort = qemuGuestPortFor(manager);
-    const args = [
-      '-display', 'none',
-      '-nodefaults',
-      '-name', `gv-${profile.id}`,
-      '-snapshot',
-      '-m', '512',
-      '-nic', `user,hostfwd=tcp::${guestPort}-:22`,
-    ];
-    if (qemuImage) args.push('-drive', `file=${qemuImage},if=virtio,format=qcow2`);
-    return Object.freeze({
-      backend: 'qemu',
-      command: qemuBinary,
-      args,
-      workspaceRoot: safeWorkspaceRoot,
-      summary: buildCommandSummary(qemuBinary, args),
-      imagePath: qemuImage || undefined,
-    });
-  }
-  const args = ['-lc', `echo "goodvibes sandbox ${profile.id}: ${label}"`];
-  return Object.freeze({
-    backend: 'local',
-    command: process.env.SHELL || 'bash',
-    args,
-    workspaceRoot: safeWorkspaceRoot,
-    summary: buildCommandSummary(process.env.SHELL || 'bash', args),
-  });
-}
-
-export interface SandboxCommandPlan {
-  readonly command: string;
-  readonly args: readonly string[];
-  readonly summary: string;
-  readonly env?: NodeJS.ProcessEnv;
-}
-
-export function resolveSandboxCommandPlan(
-  launchPlan: SandboxLaunchPlan,
-  command: string,
-  args: readonly string[],
-  manager?: ConfigManager | { get: (key: string) => unknown },
-): SandboxCommandPlan {
-  if (launchPlan.backend === 'qemu') {
-    if (!launchPlan.imagePath) {
-      throw new Error('QEMU-backed sandbox execution requires sandbox.qemuImagePath; guest launch planning is available, but command execution stays disabled until an image is configured.');
-    }
-    const wrapper = manager ? qemuExecWrapperFor(manager) : '';
-    if (!wrapper) {
-      throw new Error('QEMU-backed sandbox execution requires sandbox.qemuExecWrapper; image-backed launch planning is wired, but guest command execution stays disabled until a wrapper is configured.');
-    }
-    if (!existsSync(wrapper)) {
-      throw new Error(`QEMU-backed sandbox execution requires an existing sandbox.qemuExecWrapper; missing: ${wrapper}`);
-    }
-    if (!isExecutableFile(wrapper)) {
-      throw new Error(`QEMU-backed sandbox execution requires an executable sandbox.qemuExecWrapper; not executable: ${wrapper}`);
-    }
-    const guestHost = manager ? qemuGuestHostFor(manager) : '';
-    const sessionMode = manager ? qemuSessionModeFor(manager) : 'attach';
-    return Object.freeze({
-      command: wrapper,
-      args: [],
-      env: {
-        GV_SANDBOX_QEMU_BINARY: launchPlan.command,
-        GV_SANDBOX_QEMU_ARGS: JSON.stringify(launchPlan.args),
-        GV_SANDBOX_QEMU_IMAGE: launchPlan.imagePath,
-        GV_SANDBOX_WORKSPACE_ROOT: launchPlan.workspaceRoot,
-        GV_SANDBOX_GUEST_COMMAND: command,
-        GV_SANDBOX_GUEST_ARGS: JSON.stringify(args),
-        GV_SANDBOX_GUEST_HOST: guestHost,
-        GV_SANDBOX_GUEST_PORT: manager ? qemuGuestPortFor(manager) : '2222',
-        GV_SANDBOX_GUEST_USER: manager ? qemuGuestUserFor(manager) : '',
-        GV_SANDBOX_GUEST_WORKSPACE: manager ? qemuWorkspacePathFor(manager) : '',
-        GV_SANDBOX_WRAPPER_MODE: guestHost ? (sessionMode === 'launch-per-command' ? 'launch-qemu-ssh' : 'ssh-guest') : '',
-        GV_SANDBOX_EXEC_MODE: 'wrapper',
-      },
-      summary: buildCommandSummary(wrapper, []),
-    });
-  }
-  return Object.freeze({
-    command,
-    args,
-    summary: buildCommandSummary(command, args),
-  });
-}
-
-export interface SandboxCommandResult {
-  readonly status: number | null;
-  readonly stdout: string;
-  readonly stderr: string;
-}
-
-function runSandboxCommand(
-  launchPlan: SandboxLaunchPlan,
-  command: string,
-  args: readonly string[],
-  managerLike: ConfigManager | { get: (key: string) => unknown } | undefined,
-  options: {
-    readonly cwd?: string;
-    readonly env?: NodeJS.ProcessEnv;
-    readonly timeoutMs?: number;
-    readonly input?: string;
-  } = {},
-): SandboxCommandResult {
-  const resolved = resolveSandboxCommandPlan(launchPlan, command, args, managerLike);
-  const result = spawnSync(resolved.command, [...resolved.args], {
-    cwd: options.cwd ?? launchPlan.workspaceRoot,
-    env: { ...process.env, ...resolved.env, ...options.env },
-    encoding: 'utf-8',
-    timeout: options.timeoutMs ?? 5000,
-    input: options.input,
-    windowsHide: true,
-  });
-  return Object.freeze({
-    status: result.status,
-    stdout: result.stdout ?? '',
-    stderr: result.stderr ?? '',
-  });
-}
-
-export function executeSandboxCommand(
-  launchPlan: SandboxLaunchPlan,
-  command: string,
-  args: readonly string[],
-  options: {
-    readonly cwd?: string;
-    readonly env?: NodeJS.ProcessEnv;
-    readonly timeoutMs?: number;
-    readonly input?: string;
-  } = {},
-): SandboxCommandResult {
-  return runSandboxCommand(launchPlan, command, args, undefined, options);
-}
-
-export function executeSandboxManagedCommand(
-  launchPlan: SandboxLaunchPlan,
-  command: string,
-  args: readonly string[],
-  manager: ConfigManager | { get: (key: string) => unknown },
-  options: {
-    readonly cwd?: string;
-    readonly env?: NodeJS.ProcessEnv;
-    readonly timeoutMs?: number;
-    readonly input?: string;
-  } = {},
-): SandboxCommandResult {
-  return runSandboxCommand(launchPlan, command, args, manager, options);
-}

package/src/runtime/sandbox/manager.ts

@@ -1,364 +0,0 @@
-import type { ConfigManager } from '../../config/manager.ts';
-import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config/schema';
-import type {
-  SandboxBackendProbe,
-  SandboxConfigSnapshot,
-  SandboxBundle,
-  SandboxEvalIsolationMode,
-  SandboxHostStatus,
-  SandboxProbe,
-  SandboxQemuSessionMode,
-  SandboxMcpIsolationMode,
-  SandboxPreset,
-  SandboxProfile,
-  SandboxReview,
-  SandboxSession,
-  SandboxSessionArtifact,
-  SandboxVmBackend,
-  SandboxWindowsMode,
-} from '@pellux/goodvibes-sdk/platform/runtime/sandbox/types';
-import { probeSandboxBackends } from './backend.ts';
-
-function readConfigValue<K extends ConfigKey>(
-  manager: ConfigManager | { get: (key: K) => unknown },
-  key: K,
-): unknown {
-  return manager.get(key);
-}
-
-export function isRunningInWsl(): boolean {
-  return Boolean(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP);
-}
-
-export function getSandboxConfigSnapshot(
-  manager: ConfigManager | { get: (key: ConfigKey) => unknown },
-): SandboxConfigSnapshot {
-  return Object.freeze({
-    replIsolation: readConfigValue(manager, 'sandbox.replIsolation') as SandboxEvalIsolationMode,
-    mcpIsolation: readConfigValue(manager, 'sandbox.mcpIsolation') as SandboxMcpIsolationMode,
-    windowsMode: readConfigValue(manager, 'sandbox.windowsMode') as SandboxWindowsMode,
-    vmBackend: readConfigValue(manager, 'sandbox.vmBackend') as SandboxVmBackend,
-    qemuBinary: readConfigValue(manager, 'sandbox.qemuBinary') as string,
-    qemuImagePath: readConfigValue(manager, 'sandbox.qemuImagePath') as string,
-    qemuExecWrapper: readConfigValue(manager, 'sandbox.qemuExecWrapper') as string,
-    qemuGuestHost: readConfigValue(manager, 'sandbox.qemuGuestHost') as string,
-    qemuGuestPort: readConfigValue(manager, 'sandbox.qemuGuestPort') as number,
-    qemuGuestUser: readConfigValue(manager, 'sandbox.qemuGuestUser') as string,
-    qemuWorkspacePath: readConfigValue(manager, 'sandbox.qemuWorkspacePath') as string,
-    qemuSessionMode: readConfigValue(manager, 'sandbox.qemuSessionMode') as SandboxQemuSessionMode,
-  });
-}
-
-export function detectSandboxHostStatus(
-  manager: ConfigManager | { get: (key: ConfigKey) => unknown },
-): SandboxHostStatus {
-  const config = getSandboxConfigSnapshot(manager);
-  const runningInWsl = isRunningInWsl();
-  const windows = process.platform === 'win32';
-  const secureSandboxReady = !windows || runningInWsl;
-  const warnings: string[] = [];
-  if (windows && !runningInWsl) {
-    warnings.push('Virtualized sandboxing on Windows requires running GoodVibes inside WSL.');
-  }
-  if (config.vmBackend === 'qemu' && windows && !runningInWsl) {
-    warnings.push('QEMU backend requested on native Windows without WSL.');
-  }
-  return Object.freeze({
-    platform: process.platform,
-    runningInWsl,
-    windows,
-    secureSandboxReady,
-    recommendedBackend: 'qemu',
-    warnings,
-  });
-}
-
-export function listSandboxProfiles(
-  manager: ConfigManager | { get: (key: ConfigKey) => unknown },
-): SandboxProfile[] {
-  const config = getSandboxConfigSnapshot(manager);
-  const profiles: SandboxProfile[] = [
-    {
-      id: 'eval-js',
-      label: 'JavaScript Eval',
-      kind: 'eval',
-      isolation: config.replIsolation === 'shared-vm' ? 'shared' : 'dedicated',
-      requiresVm: true,
-      notes: ['bounded expression/runtime eval', 'records history and evidence'],
-    },
-    {
-      id: 'eval-ts',
-      label: 'TypeScript Eval',
-      kind: 'eval',
-      isolation: config.replIsolation === 'shared-vm' ? 'shared' : 'dedicated',
-      requiresVm: true,
-      notes: ['shares eval sandbox substrate', 'planned typed transpile/eval path'],
-    },
-    {
-      id: 'eval-py',
-      label: 'Python Eval',
-      kind: 'eval',
-      isolation: 'dedicated',
-      requiresVm: true,
-      notes: ['ephemeral venv', '.pth scan before launch'],
-    },
-    {
-      id: 'eval-sql',
-      label: 'SQL Eval',
-      kind: 'eval',
-      isolation: config.replIsolation === 'shared-vm' ? 'shared' : 'dedicated',
-      requiresVm: true,
-      notes: ['policy-scoped query execution', 'read-only by default'],
-    },
-    {
-      id: 'eval-graphql',
-      label: 'GraphQL Eval',
-      kind: 'eval',
-      isolation: config.replIsolation === 'shared-vm' ? 'shared' : 'dedicated',
-      requiresVm: true,
-      notes: ['schema-aware request validation', 'endpoint-scoped egress'],
-    },
-    {
-      id: 'mcp-shared',
-      label: 'Shared MCP Sandbox',
-      kind: 'mcp',
-      isolation: 'shared',
-      requiresVm: config.mcpIsolation !== 'disabled',
-      notes: ['lower overhead', 'weaker cross-server isolation'],
-    },
-    {
-      id: 'mcp-per-server',
-      label: 'Per-Server MCP Sandbox',
-      kind: 'mcp',
-      isolation: 'dedicated',
-      requiresVm: config.mcpIsolation === 'per-server-vm' || config.mcpIsolation === 'hybrid',
-      notes: ['strongest isolation', 'higher memory and startup cost'],
-    },
-  ];
-  return profiles.map((profile) => Object.freeze(profile));
-}
-
-export function listSandboxPresets(): readonly SandboxPreset[] {
-  return [
-    Object.freeze({
-      id: 'secure-balanced',
-      label: 'Secure Balanced',
-      summary: 'Dedicated REPL VMs with hybrid MCP isolation and WSL-gated Windows secure mode.',
-      config: {
-        replIsolation: 'per-runtime-vm',
-        mcpIsolation: 'hybrid',
-        windowsMode: 'require-wsl',
-        vmBackend: 'qemu',
-        qemuBinary: 'qemu-system-x86_64',
-        qemuImagePath: '',
-        qemuExecWrapper: '',
-        qemuGuestHost: '',
-        qemuGuestPort: 2222,
-        qemuGuestUser: 'goodvibes',
-        qemuWorkspacePath: '/workspace',
-        qemuSessionMode: 'attach',
-      },
-      notes: ['recommended default', 'strong isolation without forcing per-server MCP for every case'],
-    } satisfies SandboxPreset),
-    Object.freeze({
-      id: 'secure-isolated',
-      label: 'Secure Isolated',
-      summary: 'Dedicated REPL VMs and per-server MCP VMs with the strongest local isolation posture.',
-      config: {
-        replIsolation: 'per-runtime-vm',
-        mcpIsolation: 'per-server-vm',
-        windowsMode: 'require-wsl',
-        vmBackend: 'qemu',
-        qemuBinary: 'qemu-system-x86_64',
-        qemuImagePath: '',
-        qemuExecWrapper: '',
-        qemuGuestHost: '',
-        qemuGuestPort: 2222,
-        qemuGuestUser: 'goodvibes',
-        qemuWorkspacePath: '/workspace',
-        qemuSessionMode: 'attach',
-      },
-      notes: ['strongest isolation', 'higher startup and memory cost'],
-    } satisfies SandboxPreset),
-    Object.freeze({
-      id: 'shared-performance',
-      label: 'Shared Performance',
-      summary: 'Shared REPL VM and shared MCP VM for lower overhead while preserving a sandbox boundary.',
-      config: {
-        replIsolation: 'shared-vm',
-        mcpIsolation: 'shared-vm',
-        windowsMode: 'native-basic',
-        vmBackend: 'qemu',
-        qemuBinary: 'qemu-system-x86_64',
-        qemuImagePath: '',
-        qemuExecWrapper: '',
-        qemuGuestHost: '',
-        qemuGuestPort: 2222,
-        qemuGuestUser: 'goodvibes',
-        qemuWorkspacePath: '/workspace',
-        qemuSessionMode: 'attach',
-      },
-      notes: ['best latency', 'weaker cross-runtime isolation than dedicated profiles'],
-    } satisfies SandboxPreset),
-    Object.freeze({
-      id: 'windows-basic',
-      label: 'Windows Basic',
-      summary: 'Native Windows Bun/TUI with secure sandbox mode disabled until WSL is available.',
-      config: {
-        replIsolation: 'shared-vm',
-        mcpIsolation: 'disabled',
-        windowsMode: 'native-basic',
-        vmBackend: 'local',
-        qemuBinary: 'qemu-system-x86_64',
-        qemuImagePath: '',
-        qemuExecWrapper: '',
-        qemuGuestHost: '',
-        qemuGuestPort: 2222,
-        qemuGuestUser: 'goodvibes',
-        qemuWorkspacePath: '/workspace',
-        qemuSessionMode: 'attach',
-      },
-      notes: ['intended for native Windows without WSL', 'core runtime only; not secure sandbox mode'],
-    } satisfies SandboxPreset),
-  ] as const;
-}
-
-export function getSandboxPreset(id: string): SandboxPreset | null {
-  return listSandboxPresets().find((preset) => preset.id === id) ?? null;
-}
-
-export function buildSandboxReview(
-  manager: ConfigManager | { get: (key: ConfigKey) => unknown },
-): SandboxReview {
-  return Object.freeze({
-    config: getSandboxConfigSnapshot(manager),
-    host: detectSandboxHostStatus(manager),
-    profiles: listSandboxProfiles(manager),
-    backendProbe: probeSandboxBackends(manager as ConfigManager),
-  });
-}
-
-export function renderSandboxReview(
-  manager: ConfigManager | { get: (key: ConfigKey) => unknown },
-): string {
-  const review = buildSandboxReview(manager);
-  return [
-    'Sandbox Review',
-    `  repl isolation: ${review.config.replIsolation}`,
-    `  mcp isolation: ${review.config.mcpIsolation}`,
-    `  windows mode: ${review.config.windowsMode}`,
-    `  vm backend: ${review.config.vmBackend}`,
-    `  qemu binary: ${review.config.qemuBinary || '(default)'}`,
-    `  qemu image: ${review.config.qemuImagePath || '(not configured)'}`,
-    `  qemu wrapper: ${review.config.qemuExecWrapper || '(not configured)'}`,
-    `  qemu guest host: ${review.config.qemuGuestHost || '(not configured)'}`,
-    `  qemu guest port: ${review.config.qemuGuestPort}`,
-    `  qemu guest user: ${review.config.qemuGuestUser || '(not configured)'}`,
-    `  qemu workspace: ${review.config.qemuWorkspacePath || '(not configured)'}`,
-    `  qemu session mode: ${review.config.qemuSessionMode}`,
-    `  resolved backend: ${review.backendProbe?.resolvedBackend ?? 'local'}`,
-    `  platform: ${review.host.platform}${review.host.runningInWsl ? ' (WSL)' : ''}`,
-    `  secure sandbox mode: ${review.host.secureSandboxReady ? 'available' : 'unavailable on this host'}`,
-    ...((review.backendProbe?.warnings ?? []).map((warning) => `  backend warning: ${warning}`)),
-    ...review.host.warnings.map((warning) => `  warning: ${warning}`),
-  ].join('\n');
-}
-
-export function renderSandboxRecommendation(
-  manager: ConfigManager | { get: (key: ConfigKey) => unknown },
-): string {
-  const review = buildSandboxReview(manager);
-  const lines = [
-    'Sandbox Recommendation',
-    `  current repl isolation: ${review.config.replIsolation}`,
-    `  current mcp isolation: ${review.config.mcpIsolation}`,
-  ];
-  if (review.host.windows && !review.host.runningInWsl) {
-    lines.push('  recommendation: run GoodVibes inside WSL before enabling QEMU sandboxing');
-    lines.push('  recommendation: keep backend=local until WSL is available');
-  } else {
-    lines.push('  recommendation: keep REPLs in per-runtime-vm mode');
-    lines.push('  recommendation: use hybrid or per-server-vm for MCP isolation');
-  }
-  return lines.join('\n');
-}
-
-export function renderSandboxProfiles(
-  manager: ConfigManager | { get: (key: ConfigKey) => unknown },
-): string {
-  const profiles = listSandboxProfiles(manager);
-  return [
-    'Sandbox Profiles',
-    ...profiles.map((profile) => (
-      `  ${profile.id}  [${profile.kind}/${profile.isolation}]  vm=${profile.requiresVm ? 'yes' : 'no'}  ${profile.label}`
-    )),
-  ].join('\n');
-}
-
-export function renderSandboxPresets(): string {
-  return [
-    'Sandbox Presets',
-    ...listSandboxPresets().map((preset) => (
-      `  ${preset.id}  ${preset.label}  repl=${preset.config.replIsolation}  mcp=${preset.config.mcpIsolation}  windows=${preset.config.windowsMode}  backend=${preset.config.vmBackend}`
-    )),
-  ].join('\n');
-}
-
-export function inspectSandboxProbe(probe: SandboxProbe): string {
-  return [
-    'Sandbox Probe',
-    `  checkedAt: ${new Date(probe.checkedAt).toISOString()}`,
-    `  host: ${probe.host}`,
-    `  backend: ${probe.currentBackend}`,
-    `  repl isolation: ${probe.replIsolation}`,
-    `  mcp isolation: ${probe.mcpIsolation}`,
-    `  windows mode: ${probe.windowsMode}`,
-    `  secure sandbox: ${probe.secureSandboxReady ? 'ready' : 'not ready'}`,
-    `  next: ${probe.recommendedCommand}`,
-  ].join('\n');
-}
-
-export function inspectSandboxBundle(bundle: SandboxBundle): string {
-  return [
-    'Sandbox Bundle Review',
-    `  exportedAt: ${new Date(bundle.exportedAt).toISOString()}`,
-    `  reviewText: ${bundle.review.reviewText.length} chars`,
-    `  recommendationText: ${bundle.review.recommendationText.length} chars`,
-    `  profilesText: ${bundle.review.profilesText.length} chars`,
-  ].join('\n');
-}
-
-export function renderSandboxSessions(sessions: readonly SandboxSession[]): string {
-  return [
-    'Sandbox Sessions',
-    ...(sessions.length > 0
-      ? sessions.flatMap((session) => {
-        const lines = [
-          `  ${session.id}  ${session.profileId}  ${session.state}  ${session.shared ? 'shared' : 'dedicated'}  ${session.backend}  ${session.label}${session.startupStatus ? `  startup=${session.startupStatus}` : ''}`,
-        ];
-        if (session.managedGuestPid || session.managedGuestHost || session.managedGuestPort) {
-          lines.push(
-            `    guest: ${session.managedGuestHost ?? '(unset)'}:${session.managedGuestPort ?? 0}  pid=${session.managedGuestPid ?? 'n/a'}`,
-          );
-        }
-        if (session.lastCommandSummary) {
-          lines.push(`    last: ${session.lastCommandSummary}`);
-        }
-        return lines;
-      })
-      : ['  No active sandbox sessions.']),
-  ].join('\n');
-}
-
-export function inspectSandboxSessionArtifact(artifact: SandboxSessionArtifact): string {
-  return [
-    'Sandbox Session Artifact',
-    `  exportedAt: ${new Date(artifact.exportedAt).toISOString()}`,
-    `  session: ${artifact.session.id}`,
-    `  profile: ${artifact.session.profileId}`,
-    `  state: ${artifact.session.state}`,
-    `  backend: ${artifact.session.backend}`,
-    `  startup: ${artifact.session.startupStatus ?? 'n/a'}`,
-    `  reviewText: ${artifact.reviewText.length} chars`,
-  ].join('\n');
-}