@pellux/goodvibes-sdk 0.18.14 → 0.18.16

package/dist/_internal/platform/runtime/sandbox/backend.js

@@ -0,0 +1,202 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { detectSandboxHostStatus, getSandboxConfigSnapshot } from './manager.js';
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+}
+function hasCommand(command, args = ['--version']) {
+    const result = spawnSync(command, [...args], {
+        stdio: 'ignore',
+        timeout: 1500,
+        windowsHide: true,
+    });
+    return result.status === 0 || result.status === 1;
+}
+function qemuBinaryFor(manager) {
+    const configured = `${manager.get('sandbox.qemuBinary') ?? ''}`.trim();
+    return configured || 'qemu-system-x86_64';
+}
+function qemuImageFor(manager) {
+    return `${manager.get('sandbox.qemuImagePath') ?? ''}`.trim();
+}
+function qemuExecWrapperFor(manager) {
+    return `${manager.get('sandbox.qemuExecWrapper') ?? ''}`.trim();
+}
+function qemuGuestHostFor(manager) {
+    return `${manager.get('sandbox.qemuGuestHost') ?? ''}`.trim();
+}
+function qemuGuestPortFor(manager) {
+    const raw = manager.get('sandbox.qemuGuestPort');
+    return `${typeof raw === 'number' ? raw : Number.parseInt(`${raw ?? ''}`, 10) || 2222}`;
+}
+function qemuGuestUserFor(manager) {
+    return `${manager.get('sandbox.qemuGuestUser') ?? ''}`.trim();
+}
+function qemuWorkspacePathFor(manager) {
+    return `${manager.get('sandbox.qemuWorkspacePath') ?? ''}`.trim();
+}
+function qemuSessionModeFor(manager) {
+    const configured = `${manager.get('sandbox.qemuSessionMode') ?? ''}`.trim();
+    return configured === 'launch-per-command' ? 'launch-per-command' : 'attach';
+}
+function isExecutableFile(path) {
+    try {
+        const stat = statSync(path);
+        return stat.isFile() && (stat.mode & 0o111) !== 0;
+    }
+    catch {
+        return false;
+    }
+}
+function buildAvailability(id, available, detail) {
+    return Object.freeze({ id, available, detail });
+}
+export function probeSandboxBackends(manager) {
+    const host = detectSandboxHostStatus(manager);
+    const config = getSandboxConfigSnapshot(manager);
+    const qemuBinary = qemuBinaryFor(manager);
+    const qemuImage = qemuImageFor(manager);
+    const qemuExecWrapper = qemuExecWrapperFor(manager);
+    const qemuGuestHost = qemuGuestHostFor(manager);
+    const backends = [
+        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 = 'local';
+    if (config.vmBackend === 'qemu') {
+        resolved = backends.find((entry) => entry.id === 'qemu')?.available ? 'qemu' : 'local';
+    }
+    const warnings = [];
+    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, args) {
+    return [command, ...args].join(' ').trim();
+}
+export function buildSandboxLaunchPlan(profile, label, manager, workspaceRoot) {
+    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 function resolveSandboxCommandPlan(launchPlan, command, args, manager) {
+    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),
+    });
+}
+function runSandboxCommand(launchPlan, command, args, managerLike, options = {}) {
+    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, command, args, options = {}) {
+    return runSandboxCommand(launchPlan, command, args, undefined, options);
+}
+export function executeSandboxManagedCommand(launchPlan, command, args, manager, options = {}) {
+    return runSandboxCommand(launchPlan, command, args, manager, options);
+}

package/dist/_internal/platform/runtime/sandbox/manager.d.ts

@@ -0,0 +1,20 @@
+import type { SandboxConfigSnapshot, SandboxBundle, SandboxHostStatus, SandboxProbe, SandboxPreset, SandboxProfile, SandboxReview, SandboxSession, SandboxSessionArtifact } from './types.js';
+export interface ConfigManagerLike {
+    get(key: string): unknown;
+}
+export declare function isRunningInWsl(): boolean;
+export declare function getSandboxConfigSnapshot(manager: ConfigManagerLike): SandboxConfigSnapshot;
+export declare function detectSandboxHostStatus(manager: ConfigManagerLike): SandboxHostStatus;
+export declare function listSandboxProfiles(manager: ConfigManagerLike): SandboxProfile[];
+export declare function listSandboxPresets(): readonly SandboxPreset[];
+export declare function getSandboxPreset(id: string): SandboxPreset | null;
+export declare function buildSandboxReview(manager: ConfigManagerLike): SandboxReview;
+export declare function renderSandboxReview(manager: ConfigManagerLike): string;
+export declare function renderSandboxRecommendation(manager: ConfigManagerLike): string;
+export declare function renderSandboxProfiles(manager: ConfigManagerLike): string;
+export declare function renderSandboxPresets(): string;
+export declare function inspectSandboxProbe(probe: SandboxProbe): string;
+export declare function inspectSandboxBundle(bundle: SandboxBundle): string;
+export declare function renderSandboxSessions(sessions: readonly SandboxSession[]): string;
+export declare function inspectSandboxSessionArtifact(artifact: SandboxSessionArtifact): string;
+//# sourceMappingURL=manager.d.ts.map

package/dist/_internal/platform/runtime/sandbox/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/sandbox/manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,qBAAqB,EACrB,aAAa,EAEb,iBAAiB,EACjB,YAAY,EAGZ,aAAa,EACb,cAAc,EACd,aAAa,EACb,cAAc,EACd,sBAAsB,EAGvB,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,iBAAiB;IAChC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AASD,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,iBAAiB,GACzB,qBAAqB,CAevB;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,iBAAiB,GACzB,iBAAiB,CAoBnB;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,iBAAiB,GACzB,cAAc,EAAE,CA6DlB;AAED,wBAAgB,kBAAkB,IAAI,SAAS,aAAa,EAAE,CAmF7D;AAED,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAEjE;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,iBAAiB,GACzB,aAAa,CAOf;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,iBAAiB,GACzB,MAAM,CAsBR;AAED,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,iBAAiB,GACzB,MAAM,CAeR;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,iBAAiB,GACzB,MAAM,CAQR;AAED,wBAAgB,oBAAoB,IAAI,MAAM,CAO7C;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAY/D;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAQlE;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,GAAG,MAAM,CAoBjF;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,sBAAsB,GAAG,MAAM,CAWtF"}

package/dist/_internal/platform/runtime/sandbox/manager.js

@@ -0,0 +1,307 @@
+import { probeSandboxBackends } from './backend.js';
+function readConfigValue(manager, key) {
+    return manager.get(key);
+}
+export function isRunningInWsl() {
+    return Boolean(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP);
+}
+export function getSandboxConfigSnapshot(manager) {
+    return Object.freeze({
+        replIsolation: readConfigValue(manager, 'sandbox.replIsolation'),
+        mcpIsolation: readConfigValue(manager, 'sandbox.mcpIsolation'),
+        windowsMode: readConfigValue(manager, 'sandbox.windowsMode'),
+        vmBackend: readConfigValue(manager, 'sandbox.vmBackend'),
+        qemuBinary: readConfigValue(manager, 'sandbox.qemuBinary'),
+        qemuImagePath: readConfigValue(manager, 'sandbox.qemuImagePath'),
+        qemuExecWrapper: readConfigValue(manager, 'sandbox.qemuExecWrapper'),
+        qemuGuestHost: readConfigValue(manager, 'sandbox.qemuGuestHost'),
+        qemuGuestPort: readConfigValue(manager, 'sandbox.qemuGuestPort'),
+        qemuGuestUser: readConfigValue(manager, 'sandbox.qemuGuestUser'),
+        qemuWorkspacePath: readConfigValue(manager, 'sandbox.qemuWorkspacePath'),
+        qemuSessionMode: readConfigValue(manager, 'sandbox.qemuSessionMode'),
+    });
+}
+export function detectSandboxHostStatus(manager) {
+    const config = getSandboxConfigSnapshot(manager);
+    const runningInWsl = isRunningInWsl();
+    const windows = process.platform === 'win32';
+    const secureSandboxReady = !windows || runningInWsl;
+    const warnings = [];
+    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) {
+    const config = getSandboxConfigSnapshot(manager);
+    const profiles = [
+        {
+            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() {
+    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'],
+        }),
+        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'],
+        }),
+        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'],
+        }),
+        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'],
+        }),
+    ];
+}
+export function getSandboxPreset(id) {
+    return listSandboxPresets().find((preset) => preset.id === id) ?? null;
+}
+export function buildSandboxReview(manager) {
+    return Object.freeze({
+        config: getSandboxConfigSnapshot(manager),
+        host: detectSandboxHostStatus(manager),
+        profiles: listSandboxProfiles(manager),
+        backendProbe: probeSandboxBackends(manager),
+    });
+}
+export function renderSandboxReview(manager) {
+    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) {
+    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) {
+    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() {
+    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) {
+    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) {
+    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) {
+    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) {
+    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');
+}

package/dist/_internal/platform/runtime/sandbox/provisioning.d.ts

@@ -0,0 +1,73 @@
+import type { ConfigManager } from '../../config/manager.js';
+export interface SandboxDoctorCheck {
+    readonly label: string;
+    readonly ok: boolean;
+    readonly detail: string;
+}
+export interface SandboxGuestBundle {
+    readonly version: 1;
+    readonly exportedAt: number;
+    readonly guest: {
+        readonly qemuBinary: string;
+        readonly imagePath: string;
+        readonly wrapperPath: string;
+        readonly host: string;
+        readonly port: number;
+        readonly user: string;
+        readonly workspacePath: string;
+        readonly sessionMode: string;
+    };
+    readonly nextSteps: readonly string[];
+}
+export interface SandboxQemuInitBundle {
+    readonly directory: string;
+    readonly wrapperPath: string;
+    readonly guestBundlePath: string;
+    readonly readmePath: string;
+}
+export interface SandboxQemuSetupBundle extends SandboxQemuInitBundle {
+    readonly imagePath: string;
+    readonly imageCreateScriptPath: string;
+    readonly guestBootstrapScriptPath: string;
+    readonly projectionPolicyPath: string;
+    readonly sshConfigPath: string;
+    readonly manifestPath: string;
+}
+export interface SandboxQemuSetupManifest {
+    readonly version: 1;
+    readonly createdAt: number;
+    readonly wrapperPath: string;
+    readonly imagePath: string;
+    readonly imageCreateScriptPath: string;
+    readonly guestBootstrapScriptPath: string;
+    readonly projectionPolicyPath: string;
+    readonly sshConfigPath: string;
+    readonly recommendedSettings: {
+        readonly backend: 'qemu';
+        readonly wrapperPath: string;
+        readonly imagePath: string;
+        readonly guestHost: string;
+        readonly guestPort: number;
+        readonly guestUser: string;
+        readonly guestWorkspacePath: string;
+        readonly sessionMode: string;
+    };
+}
+export declare function buildSandboxDoctorChecks(manager: ConfigManager): SandboxDoctorCheck[];
+export declare function renderSandboxDoctor(manager: ConfigManager): string;
+export declare function exportSandboxGuestBundle(manager: ConfigManager, workspaceRoot: string, pathArg: string): {
+    path: string;
+    bundle: SandboxGuestBundle;
+};
+export declare function inspectSandboxGuestBundle(bundle: SandboxGuestBundle): string;
+export declare function scaffoldSandboxQemuInitBundle(manager: ConfigManager, workspaceRoot: string, pathArg: string): SandboxQemuInitBundle;
+export declare function scaffoldSandboxQemuSetupBundle(manager: ConfigManager, workspaceRoot: string, pathArg: string): SandboxQemuSetupBundle;
+export declare function createSandboxQemuImage(workspaceRoot: string, imagePathArg: string, sizeGb: number, qemuImgBinary?: string): {
+    path: string;
+    sizeGb: number;
+};
+export declare function bootstrapSandboxQemuSetupBundle(manager: ConfigManager, workspaceRoot: string, pathArg: string, sizeGb: number): SandboxQemuSetupBundle;
+export declare function inspectSandboxQemuSetupManifest(manifest: SandboxQemuSetupManifest): string;
+export declare function loadSandboxQemuSetupManifest(workspaceRoot: string, pathArg: string): SandboxQemuSetupManifest;
+export declare function applySandboxQemuSetupManifest(manager: ConfigManager, manifest: SandboxQemuSetupManifest): void;
+//# sourceMappingURL=provisioning.d.ts.map

package/dist/_internal/platform/runtime/sandbox/provisioning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provisioning.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/sandbox/provisioning.ts"],"names":[],"mappings":"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"}