@pellux/goodvibes-tui 0.18.4 → 0.18.9

package/src/runtime/sandbox/session-registry.ts

@@ -1,289 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { spawn } from 'node:child_process';
-import { dirname } from 'node:path';
-import net from 'node:net';
-import type { ConfigManager } from '../../config/manager.ts';
-import { buildSandboxLaunchPlan, executeSandboxCommand, executeSandboxManagedCommand, resolveSandboxCommandPlan } from './backend.ts';
-import { getSandboxConfigSnapshot, listSandboxProfiles, renderSandboxReview } from './manager.ts';
-import type {
-  SandboxProfile,
-  SandboxSession,
-  SandboxSessionArtifact,
-  SandboxSessionKind,
-} from '@pellux/goodvibes-sdk/platform/runtime/sandbox/types';
-import type { SandboxCommandResult } from './backend.ts';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-
-function createSandboxSessionId(): string {
-  return `sandbox_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-}
-
-function inferShared(profile: SandboxProfile): boolean {
-  return profile.isolation === 'shared';
-}
-
-function inferKind(profile: SandboxProfile): SandboxSessionKind {
-  return profile.kind;
-}
-
-function readManagerString(manager: ConfigManager, key: string): string {
-  return `${manager.get(key as never) ?? ''}`.trim();
-}
-
-function readManagerPort(manager: ConfigManager, key: string, fallback: number): number {
-  const raw = manager.get(key as never);
-  const parsed = typeof raw === 'number' ? raw : Number.parseInt(`${raw ?? ''}`, 10);
-  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
-}
-
-function waitForTcp(host: string, port: number, timeoutMs: number): Promise<boolean> {
-  const deadline = Date.now() + timeoutMs;
-  return new Promise((resolve) => {
-    const attempt = () => {
-      const socket = net.createConnection({ host, port });
-      const finish = (ok: boolean) => {
-        socket.removeAllListeners();
-        socket.destroy();
-        resolve(ok);
-      };
-      socket.once('connect', () => finish(true));
-      socket.once('error', () => {
-        socket.destroy();
-        if (Date.now() >= deadline) {
-          resolve(false);
-          return;
-        }
-        setTimeout(attempt, 250);
-      });
-      socket.setTimeout(1000, () => {
-        socket.destroy();
-        if (Date.now() >= deadline) {
-          resolve(false);
-          return;
-        }
-        setTimeout(attempt, 250);
-      });
-    };
-    attempt();
-  });
-}
-
-async function launchManagedQemuGuest(
-  launchPlan: SandboxSession['launchPlan'],
-  configManager: ConfigManager,
-): Promise<{ pid: number; host: string; port: number } | null> {
-  if (!launchPlan || launchPlan.backend !== 'qemu') return null;
-  const host = readManagerString(configManager, 'sandbox.qemuGuestHost');
-  const sessionMode = readManagerString(configManager, 'sandbox.qemuSessionMode');
-  if (!host || sessionMode !== 'attach') return null;
-  const port = readManagerPort(configManager, 'sandbox.qemuGuestPort', 2222);
-  const proc = spawn(launchPlan.command, [...launchPlan.args], {
-    cwd: launchPlan.workspaceRoot,
-    detached: true,
-    stdio: 'ignore',
-    windowsHide: true,
-  });
-  proc.unref();
-  if (!proc.pid) {
-    return null;
-  }
-  const ready = await waitForTcp(host, port, 15000);
-  if (!ready) {
-    try {
-      process.kill(proc.pid, 'SIGTERM');
-    } catch {
-      // ignore cleanup failure
-    }
-    throw new Error(`Timed out waiting for QEMU guest SSH on ${host}:${port}.`);
-  }
-  return { pid: proc.pid, host, port };
-}
-
-export class SandboxSessionRegistry {
-  private readonly sessions = new Map<string, SandboxSession>();
-  private readonly workspaceRoot: string;
-
-  constructor(workspaceRoot: string) {
-    this.workspaceRoot = workspaceRoot;
-  }
-
-  private updateSession(sessionId: string, updater: (session: SandboxSession) => SandboxSession): SandboxSession {
-    const existing = this.sessions.get(sessionId);
-    if (!existing) {
-      throw new Error(`Unknown sandbox session: ${sessionId}`);
-    }
-    const next = Object.freeze(updater(existing));
-    this.sessions.set(sessionId, next);
-    return next;
-  }
-
-  public list(): SandboxSession[] {
-    return [...this.sessions.values()].sort((a, b) => b.startedAt - a.startedAt);
-  }
-
-  public async start(profileId: SandboxProfile['id'], label: string | undefined, configManager: ConfigManager): Promise<SandboxSession> {
-    const profile = listSandboxProfiles(configManager).find((entry) => entry.id === profileId);
-    if (!profile) {
-      throw new Error(`Unknown sandbox profile: ${profileId}`);
-    }
-    if (inferShared(profile)) {
-      const existing = [...this.sessions.values()].find((session) => session.profileId === profileId && session.state === 'running');
-      if (existing) return existing;
-    }
-    const config = getSandboxConfigSnapshot(configManager);
-    const launchPlan = buildSandboxLaunchPlan(profile, label?.trim() || profile.label, configManager, this.workspaceRoot);
-    let state: SandboxSession['state'] = 'running';
-    let startupStatus: SandboxSession['startupStatus'] = 'verified';
-    let startupDetail = launchPlan.summary;
-    let managedGuestPid: number | undefined;
-    let managedGuestHost: string | undefined;
-    let managedGuestPort: number | undefined;
-    if (launchPlan.backend === 'qemu') {
-      if (launchPlan.imagePath && config.qemuExecWrapper) {
-        try {
-          const managedGuest = await launchManagedQemuGuest(launchPlan, configManager);
-          managedGuestPid = managedGuest?.pid;
-          managedGuestHost = managedGuest?.host;
-          managedGuestPort = managedGuest?.port;
-          const startupProbe = executeSandboxManagedCommand(launchPlan, 'bash', ['-lc', 'printf sandbox-ready'], configManager, {
-            timeoutMs: 4000,
-          });
-          if (startupProbe.status !== 0 || !startupProbe.stdout.includes('sandbox-ready')) {
-            state = 'failed';
-            startupStatus = 'failed';
-            startupDetail = (startupProbe.stderr || startupProbe.stdout || 'QEMU sandbox wrapper startup probe failed.').trim();
-          } else {
-            state = 'running';
-            startupStatus = 'verified';
-            startupDetail = managedGuestPid
-              ? `QEMU guest launched and verified via ${config.qemuExecWrapper} on ${managedGuestHost}:${managedGuestPort} using image ${launchPlan.imagePath}.`
-              : `QEMU backend verified via ${config.qemuExecWrapper} using image ${launchPlan.imagePath}.`;
-          }
-        } catch (error) {
-          state = 'failed';
-          startupStatus = 'failed';
-          startupDetail = summarizeError(error);
-        }
-      } else {
-        state = 'planned';
-        startupStatus = 'planned';
-        startupDetail = launchPlan.imagePath
-          ? `QEMU backend resolved with image ${launchPlan.imagePath}. Guest launch planning is wired, but command execution still requires sandbox.qemuExecWrapper.`
-          : 'QEMU backend resolved. Guest launch planning is available, but full guest execution still requires sandbox.qemuImagePath and sandbox.qemuExecWrapper.';
-      }
-    } else {
-      const startupProbe = executeSandboxCommand(launchPlan, 'bash', ['-lc', 'printf sandbox-ready'], {
-        timeoutMs: 2000,
-      });
-      if (startupProbe.status !== 0 || !startupProbe.stdout.includes('sandbox-ready')) {
-        state = 'failed';
-        startupStatus = 'failed';
-        startupDetail = (startupProbe.stderr || startupProbe.stdout || 'Sandbox backend startup probe failed.').trim();
-      }
-    }
-    const session: SandboxSession = Object.freeze({
-      id: createSandboxSessionId(),
-      profileId: profile.id,
-      kind: inferKind(profile),
-      label: label?.trim() || profile.label,
-      shared: inferShared(profile),
-      startedAt: Date.now(),
-      state,
-      backend: config.vmBackend,
-      resolvedBackend: launchPlan.backend,
-      launchPlan,
-      startupStatus,
-      startupDetail,
-      managedGuestPid,
-      managedGuestHost,
-      managedGuestPort,
-      notes: profile.notes,
-    });
-    this.sessions.set(session.id, session);
-    return session;
-  }
-
-  public stop(sessionId: string): SandboxSession | null {
-    const existing = this.sessions.get(sessionId);
-    if (!existing) return null;
-    if (existing.managedGuestPid) {
-      try {
-        process.kill(existing.managedGuestPid, 'SIGTERM');
-      } catch {
-        // already gone
-      }
-    }
-    return this.updateSession(sessionId, (session) => ({
-      ...session,
-      state: 'stopped',
-    }));
-  }
-
-  public get(sessionId: string): SandboxSession | null {
-    return this.sessions.get(sessionId) ?? null;
-  }
-
-  public execute(
-    sessionId: string,
-    command: string,
-    args: readonly string[],
-    configManager: ConfigManager,
-    options: {
-      readonly cwd?: string;
-      readonly env?: NodeJS.ProcessEnv;
-      readonly timeoutMs?: number;
-      readonly input?: string;
-    } = {},
-  ): SandboxCommandResult {
-    const session = this.get(sessionId);
-    if (!session) {
-      throw new Error(`Unknown sandbox session: ${sessionId}`);
-    }
-    if (!session.launchPlan) {
-      throw new Error(`Sandbox session ${sessionId} does not have a launch plan.`);
-    }
-
-    const resolvedPlan = resolveSandboxCommandPlan(session.launchPlan, command, args, configManager);
-    const result = session.launchPlan.backend === 'qemu'
-      ? executeSandboxManagedCommand(session.launchPlan, command, args, configManager, options)
-      : executeSandboxCommand(session.launchPlan, command, args, options);
-    const stdoutPreview = (result.stdout || '').trim().slice(0, 200);
-    const stderrPreview = (result.stderr || '').trim().slice(0, 200);
-    const nextState: SandboxSession['state'] = result.status === 0
-      ? (session.state === 'stopped' ? 'stopped' : 'running')
-      : 'failed';
-
-    this.updateSession(sessionId, (current) => ({
-      ...current,
-      state: nextState,
-      lastRunAt: Date.now(),
-      lastCommandSummary: resolvedPlan.summary,
-      lastExitStatus: result.status,
-      lastStdoutPreview: stdoutPreview || undefined,
-      lastStderrPreview: stderrPreview || undefined,
-      executionCount: (current.executionCount ?? 0) + 1,
-    }));
-
-    return result;
-  }
-
-  public exportArtifact(sessionId: string, targetPath: string, configManager: ConfigManager): SandboxSessionArtifact {
-    const session = this.get(sessionId);
-    if (!session) {
-      throw new Error(`Unknown sandbox session: ${sessionId}`);
-    }
-    const artifact: SandboxSessionArtifact = {
-      version: 1,
-      exportedAt: Date.now(),
-      session,
-      reviewText: renderSandboxReview(configManager),
-    };
-    mkdirSync(dirname(targetPath), { recursive: true });
-    writeFileSync(targetPath, `${JSON.stringify(artifact, null, 2)}\n`, 'utf-8');
-    return artifact;
-  }
-
-  public inspectArtifact(targetPath: string): SandboxSessionArtifact {
-    return JSON.parse(readFileSync(targetPath, 'utf-8')) as SandboxSessionArtifact;
-  }
-}

package/src/tools/repl/index.ts

@@ -1,318 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import ts from 'typescript';
-import type { ConfigManager } from '../../config/manager.ts';
-import type { SandboxSessionRegistry } from '../../runtime/sandbox/session-registry.ts';
-import { executeSandboxCommand } from '../../runtime/sandbox/backend.ts';
-import type { SandboxLaunchPlan } from '@pellux/goodvibes-sdk/platform/runtime/sandbox/types';
-import type { Tool } from '@pellux/goodvibes-sdk/platform/types/tools';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-import { REPL_TOOL_SCHEMA, type ReplToolInput } from '@pellux/goodvibes-sdk/platform/tools/repl/schema';
-
-interface ReplHistoryEntry {
-  readonly ts: number;
-  readonly runtime: 'javascript' | 'typescript' | 'python' | 'sql' | 'graphql';
-  readonly expression: string;
-  readonly sessionId?: string;
-  readonly backend?: string;
-  readonly launchSummary?: string;
-  readonly result?: string;
-  readonly error?: string;
-}
-
-type ReplExecutionInput = ReplToolInput & {
-  readonly workspaceRoot?: string;
-};
-
-function resolveHistoryPath(workspaceRoot: string): string {
-  return join(workspaceRoot, '.goodvibes', 'tui', 'repl-history.json');
-}
-
-function createLocalExecPlan(workspaceRoot: string): SandboxLaunchPlan {
-  return {
-    backend: 'local',
-    command: process.env.SHELL || 'bash',
-    args: ['-lc', 'true'],
-    workspaceRoot,
-    summary: 'local process exec',
-  };
-}
-
-function loadHistory(historyPath: string): ReplHistoryEntry[] {
-  try {
-    return JSON.parse(readFileSync(historyPath, 'utf-8')) as ReplHistoryEntry[];
-  } catch {
-    return [];
-  }
-}
-
-function saveHistory(historyPath: string, entries: readonly ReplHistoryEntry[]): void {
-  mkdirSync(dirname(historyPath), { recursive: true });
-  writeFileSync(historyPath, `${JSON.stringify(entries, null, 2)}\n`, 'utf-8');
-}
-
-function mapRuntimeToSandboxProfile(runtime: NonNullable<ReplToolInput['runtime']>) {
-  switch (runtime) {
-    case 'javascript': return 'eval-js' as const;
-    case 'typescript': return 'eval-ts' as const;
-    case 'python': return 'eval-py' as const;
-    case 'sql': return 'eval-sql' as const;
-    case 'graphql': return 'eval-graphql' as const;
-  }
-}
-
-async function evalJavaScriptInSandbox(
-  expression: string,
-  bindings: Record<string, unknown>,
-  launchPlan: SandboxLaunchPlan,
-  configManager: ConfigManager,
-  sandboxSessionRegistry: SandboxSessionRegistry,
-  sessionId?: string,
-): Promise<string> {
-  const payload = JSON.stringify({ expression, bindings });
-  const runner = `
-const payload = JSON.parse(process.env.GV_REPL_PAYLOAD ?? '{}');
-const bindings = payload.bindings ?? {};
-for (const [key, value] of Object.entries(bindings)) {
-  globalThis[key] = value;
-}
-const value = eval(payload.expression);
-process.stdout.write(typeof value === 'string' ? value : JSON.stringify(value));
-`;
-  const result = sessionId
-    ? sandboxSessionRegistry.execute(sessionId, process.execPath, ['-e', runner], configManager, {
-        timeoutMs: 1000,
-        env: {
-          ...process.env,
-          GV_REPL_PAYLOAD: payload,
-        },
-      })
-    : executeSandboxCommand(launchPlan, process.execPath, ['-e', runner], {
-        timeoutMs: 1000,
-        env: {
-          ...process.env,
-          GV_REPL_PAYLOAD: payload,
-        },
-      });
-  if (result.status !== 0) {
-    throw new Error((result.stderr || result.stdout || 'JavaScript eval failed.').trim());
-  }
-  return result.stdout.trim();
-}
-
-async function evalTypeScript(
-  expression: string,
-  bindings: Record<string, unknown>,
-  configManager: ConfigManager,
-  sandboxSessionRegistry: SandboxSessionRegistry,
-  launchPlan: SandboxLaunchPlan,
-  sessionId?: string,
-): Promise<string> {
-  const transpiled = ts.transpileModule(expression, {
-    compilerOptions: {
-      target: ts.ScriptTarget.ES2022,
-      module: ts.ModuleKind.ES2022,
-    },
-  }).outputText;
-  return evalJavaScriptInSandbox(transpiled, bindings, launchPlan, configManager, sandboxSessionRegistry, sessionId);
-}
-
-function evalPython(
-  expression: string,
-  configManager: ConfigManager,
-  sandboxSessionRegistry: SandboxSessionRegistry,
-  launchPlan: SandboxLaunchPlan,
-  sessionId?: string,
-): string {
-  const tempRoot = mkdtempSync(join(tmpdir(), 'gv-repl-py-'));
-  const venvPath = join(tempRoot, 'venv');
-  const pythonLaunchPlan = launchPlan.backend === 'local' ? {
-    ...createLocalExecPlan(tempRoot),
-    workspaceRoot: tempRoot,
-  } : launchPlan;
-  const create = sessionId
-    ? sandboxSessionRegistry.execute(sessionId, 'python3', ['-m', 'venv', venvPath], configManager, { cwd: tempRoot })
-    : executeSandboxCommand(pythonLaunchPlan, 'python3', ['-m', 'venv', venvPath], { cwd: tempRoot });
-  if (create.status !== 0) {
-    rmSync(tempRoot, { recursive: true, force: true });
-    throw new Error(create.stderr || create.stdout || 'Failed to create ephemeral Python venv.');
-  }
-  const pythonBin = join(venvPath, 'bin', 'python');
-  const run = sessionId
-    ? sandboxSessionRegistry.execute(sessionId, pythonBin, ['-I', '-S', '-c', `import json\nresult = (${expression})\nprint(json.dumps(result))`], configManager, {
-        cwd: tempRoot,
-        timeoutMs: 5000,
-      })
-    : executeSandboxCommand(pythonLaunchPlan, pythonBin, ['-I', '-S', '-c', `import json\nresult = (${expression})\nprint(json.dumps(result))`], {
-        cwd: tempRoot,
-        timeoutMs: 5000,
-      });
-  rmSync(tempRoot, { recursive: true, force: true });
-  if (run.status !== 0) {
-    throw new Error((run.stderr || run.stdout || 'Python eval failed.').trim());
-  }
-  return run.stdout.trim();
-}
-
-async function evalSql(
-  expression: string,
-  configManager: ConfigManager,
-  sandboxSessionRegistry: SandboxSessionRegistry,
-  launchPlan: SandboxLaunchPlan,
-  sessionId?: string,
-): Promise<string> {
-  const payload = JSON.stringify({ expression });
-  const script = `
-import { Database } from 'bun:sqlite';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-const payload = JSON.parse(process.env.GV_REPL_PAYLOAD ?? '{}');
-const db = new Database(':memory:');
-db.exec("CREATE TABLE sandbox_eval (id INTEGER PRIMARY KEY, value TEXT);");
-db.exec("INSERT INTO sandbox_eval (value) VALUES ('alpha'), ('beta');");
-const rows = db.query(payload.expression).all();
-process.stdout.write(JSON.stringify(rows));
-`;
-  const result = sessionId
-    ? sandboxSessionRegistry.execute(sessionId, process.execPath, ['-e', script], configManager, {
-        timeoutMs: 5000,
-        env: {
-          ...process.env,
-          GV_REPL_PAYLOAD: payload,
-        },
-      })
-    : executeSandboxCommand(launchPlan, process.execPath, ['-e', script], {
-        timeoutMs: 5000,
-        env: {
-          ...process.env,
-          GV_REPL_PAYLOAD: payload,
-        },
-      });
-  if (result.status !== 0) {
-    throw new Error((result.stderr || result.stdout || 'SQL eval failed.').trim());
-  }
-  return result.stdout.trim();
-}
-
-function evalGraphql(
-  expression: string,
-  configManager: ConfigManager,
-  sandboxSessionRegistry: SandboxSessionRegistry,
-  launchPlan: SandboxLaunchPlan,
-  sessionId?: string,
-): string {
-  const payload = JSON.stringify({ expression });
-  const script = `
-const payload = JSON.parse(process.env.GV_REPL_PAYLOAD ?? '{}');
-const normalized = String(payload.expression ?? '').replace(/\\s+/g, ' ').trim();
-const opMatch = normalized.match(/^(query|mutation|subscription)\\s+([A-Za-z0-9_]+)?/i);
-const fields = [...normalized.matchAll(/\\b([A-Za-z_][A-Za-z0-9_]*)\\b/g)].map((match) => match[1]).slice(0, 12);
-process.stdout.write(JSON.stringify({
-  operation: opMatch?.[1]?.toLowerCase() ?? 'query',
-  name: opMatch?.[2] ?? null,
-  fields,
-  normalized,
-}));
-`;
-  const result = sessionId
-    ? sandboxSessionRegistry.execute(sessionId, process.execPath, ['-e', script], configManager, {
-        timeoutMs: 2000,
-        env: {
-          ...process.env,
-          GV_REPL_PAYLOAD: payload,
-        },
-      })
-    : executeSandboxCommand(launchPlan, process.execPath, ['-e', script], {
-        timeoutMs: 2000,
-        env: {
-          ...process.env,
-          GV_REPL_PAYLOAD: payload,
-        },
-      });
-  if (result.status !== 0) {
-    throw new Error((result.stderr || result.stdout || 'GraphQL eval failed.').trim());
-  }
-  return result.stdout.trim();
-}
-
-export function createReplTool(
-  configManager: ConfigManager,
-  sandboxSessionRegistry: SandboxSessionRegistry,
-): Tool {
-  return {
-    definition: {
-    name: 'repl',
-    description: 'Evaluate bounded JavaScript, TypeScript, Python, SQL, and GraphQL snippets through controlled sandbox profiles.',
-    parameters: REPL_TOOL_SCHEMA.parameters,
-    sideEffects: ['exec', 'state'],
-    concurrency: 'serial',
-  },
-
-    async execute(args: Record<string, unknown>) {
-    if (!args || typeof args !== 'object' || typeof args.mode !== 'string') {
-      return { success: false, error: 'Invalid args: mode is required.' };
-    }
-    const input = args as unknown as ReplExecutionInput;
-    if (!input.workspaceRoot || input.workspaceRoot.trim().length === 0) {
-      return { success: false, error: 'repl requires workspaceRoot.' };
-    }
-    const historyPath = resolveHistoryPath(input.workspaceRoot);
-    const history = loadHistory(historyPath);
-    const localExecPlan = createLocalExecPlan(input.workspaceRoot);
-
-    if (input.mode === 'history') {
-      return { success: true, output: JSON.stringify({ count: history.length, history }) };
-    }
-
-    if (!input.expression) return { success: false, error: 'eval requires expression.' };
-      const runtime = input.runtime ?? 'javascript';
-    const sandboxSession = await sandboxSessionRegistry.start(
-      mapRuntimeToSandboxProfile(runtime),
-      `repl:${runtime}`,
-      configManager,
-    );
-    try {
-      let rendered = '';
-      switch (runtime) {
-        case 'javascript':
-          rendered = await evalJavaScriptInSandbox(input.expression, input.bindings ?? {}, sandboxSession.launchPlan ?? localExecPlan, configManager, sandboxSessionRegistry, sandboxSession.id);
-          break;
-        case 'typescript':
-          rendered = await evalTypeScript(input.expression, input.bindings ?? {}, configManager, sandboxSessionRegistry, sandboxSession.launchPlan ?? localExecPlan, sandboxSession.id);
-          break;
-        case 'python':
-          rendered = evalPython(input.expression, configManager, sandboxSessionRegistry, sandboxSession.launchPlan ?? localExecPlan, sandboxSession.id);
-          break;
-        case 'sql':
-          rendered = await evalSql(input.expression, configManager, sandboxSessionRegistry, sandboxSession.launchPlan ?? localExecPlan, sandboxSession.id);
-          break;
-        case 'graphql':
-          rendered = evalGraphql(input.expression, configManager, sandboxSessionRegistry, sandboxSession.launchPlan ?? localExecPlan, sandboxSession.id);
-          break;
-      }
-      saveHistory(historyPath, [...history, {
-        ts: Date.now(),
-        runtime,
-        expression: input.expression,
-        sessionId: sandboxSession.id,
-        backend: sandboxSession.resolvedBackend ?? sandboxSession.backend,
-        launchSummary: sandboxSession.launchPlan?.summary,
-        result: rendered,
-      }]);
-      return { success: true, output: rendered };
-    } catch (error) {
-      saveHistory(historyPath, [...history, {
-        ts: Date.now(),
-        runtime,
-        expression: input.expression,
-        sessionId: sandboxSession.id,
-        backend: sandboxSession.resolvedBackend ?? sandboxSession.backend,
-        launchSummary: sandboxSession.launchPlan?.summary,
-        error: summarizeError(error),
-      }]);
-      return { success: false, error: summarizeError(error) };
-    }
-    },
-  };
-}