@computesdk/cli 0.1.2 → 1.0.1

package/dist/index.js

@@ -18,95 +18,310 @@ var init_esm_shims = __esm({
   }
 });
 
-// src/pty.ts
-async function startPTY(sandbox, options = {}) {
-  const terminal = await sandbox.terminal.create({ pty: true, shell: "/bin/bash" });
-  await new Promise((resolve) => setTimeout(resolve, 100));
-  if (process.stdin.isTTY) {
-    process.stdin.setRawMode(true);
-  }
-  process.stdin.resume();
-  let exiting = false;
-  let resolvePromise;
-  if (options.initialCommand) {
-    terminal.write(options.initialCommand + "\n");
-    await new Promise((resolve) => setTimeout(resolve, 50));
-  }
-  const ws = terminal._ws;
-  if (ws) {
-    ws.on("close", () => {
-      if (!exiting) {
-        doExit();
+// src/repl.ts
+import * as readline from "readline";
+import * as path2 from "path";
+import * as os from "os";
+import * as fs from "fs";
+import pc from "picocolors";
+import { compute } from "computesdk";
+async function startREPL(sandbox, provider) {
+  void provider;
+  const ctx = {
+    sandboxes: /* @__PURE__ */ new Map([[sandbox.sandboxId, sandbox]]),
+    activeSandboxId: sandbox.sandboxId
+  };
+  await runSession(ctx);
+}
+function buildPrompt(sandboxId) {
+  if (!sandboxId) return pc.gray("[no sandbox] ") + pc.bold("$ ");
+  return pc.cyan(`[${sandboxId}] `) + pc.bold("$ ");
+}
+function runSession(ctx) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: buildPrompt(ctx.activeSandboxId),
+    terminal: true,
+    historySize: 1e3
+  });
+  loadHistory(rl);
+  return new Promise((resolve) => {
+    let resolved = false;
+    const done = (result) => {
+      if (resolved) return;
+      resolved = true;
+      rl.close();
+      resolve(result);
+    };
+    rl.on("SIGINT", () => {
+      console.log();
+      rl.prompt();
+    });
+    rl.on("close", () => {
+      done("exit");
+    });
+    rl.on("line", async (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        rl.prompt();
+        return;
+      }
+      if (trimmed === ".exit") {
+        done("exit");
+        return;
+      }
+      saveToHistory(trimmed);
+      try {
+        if (trimmed.startsWith("/")) {
+          const result = await handleSpecialCommand(ctx, trimmed, rl);
+          if (result === "exit") {
+            done(result);
+            return;
+          }
+        } else if (ctx.sandboxes.size === 0) {
+          console.log(pc.yellow("No active sandbox. Use /new to create one."));
+        } else {
+          const sandbox = ctx.sandboxes.get(ctx.activeSandboxId);
+          await executeCommand(sandbox, trimmed);
+        }
+      } catch (error) {
+        console.log(pc.red(`\u2717 ${error.message}`));
+      }
+      if (!resolved) {
+        rl.prompt();
       }
     });
+    rl.prompt();
+  });
+}
+async function executeCommand(sandbox, command) {
+  const result = await sandbox.runCommand(command);
+  if (result.stdout) {
+    process.stdout.write(result.stdout);
+    if (!result.stdout.endsWith("\n")) {
+      console.log();
+    }
   }
-  terminal.on("output", (data) => {
-    if (!exiting) {
-      process.stdout.write(data);
+  if (result.stderr) {
+    process.stderr.write(pc.red(result.stderr));
+    if (!result.stderr.endsWith("\n")) {
+      console.log();
     }
-  });
-  terminal.on("error", (error) => {
-    if (!error || error === "undefined") {
-      if (!exiting) {
-        doExit();
+  }
+  if (result.exitCode !== 0) {
+    console.log(pc.gray(`exit code: ${result.exitCode}`));
+  }
+}
+async function handleSpecialCommand(ctx, input, rl) {
+  const [cmd, ...args] = input.slice(1).split(/\s+/);
+  switch (cmd.toLowerCase()) {
+    case "help":
+    case "h":
+    case "?":
+      showHelp();
+      return null;
+    case "info":
+    case "i": {
+      if (ctx.sandboxes.size === 0) {
+        console.log(pc.yellow("No active sandbox. Use /new to create one."));
+        return null;
       }
-      return;
+      const activeSandbox = ctx.sandboxes.get(ctx.activeSandboxId);
+      console.log();
+      console.log(pc.bold("  Sandbox Info"));
+      console.log(`  ID: ${pc.cyan(activeSandbox.sandboxId)}`);
+      console.log();
+      return null;
     }
-    process.stderr.write(`\r
-Terminal error: ${error}\r
-`);
-  });
-  const onData = (data) => {
-    terminal.write(data.toString());
-  };
-  process.stdin.on("data", onData);
-  const onResize = () => {
-    if (process.stdout.columns && process.stdout.rows) {
-      try {
-        terminal.resize(process.stdout.columns, process.stdout.rows);
-      } catch {
+    case "url":
+    case "u": {
+      if (ctx.sandboxes.size === 0) {
+        console.log(pc.yellow("No active sandbox. Use /new to create one."));
+        return null;
       }
+      const activeSandbox = ctx.sandboxes.get(ctx.activeSandboxId);
+      if (args.length === 0) {
+        console.log(pc.gray("Usage: /url <port>"));
+      } else {
+        const port = parseInt(args[0], 10);
+        if (isNaN(port)) {
+          console.log(pc.red("Invalid port number"));
+        } else {
+          const url = await activeSandbox.getUrl({ port });
+          console.log(pc.cyan(url));
+        }
+      }
+      return null;
     }
-  };
-  process.stdout.on("resize", onResize);
-  onResize();
-  async function doExit() {
-    if (exiting) return;
-    exiting = true;
-    cleanup();
-    try {
-      await terminal.destroy();
-    } catch {
+    case "new": {
+      console.log(pc.gray("  Creating new sandbox..."));
+      const newSandbox = await compute.sandbox.create();
+      ctx.sandboxes.set(newSandbox.sandboxId, newSandbox);
+      ctx.activeSandboxId = newSandbox.sandboxId;
+      rl.setPrompt(buildPrompt(ctx.activeSandboxId));
+      console.log(`  Sandbox ready: ${pc.cyan(newSandbox.sandboxId)}`);
+      console.log(`  ${pc.gray(`Active sandboxes: ${ctx.sandboxes.size}`)}`);
+      return null;
+    }
+    case "destroy": {
+      if (args.length === 0) {
+        console.log(pc.gray("Usage: /destroy <sandbox-id> or /destroy --all"));
+        console.log(pc.gray("Use /list to see all sandboxes"));
+        return null;
+      }
+      if (args[0] === "--all") {
+        if (ctx.sandboxes.size === 0) {
+          console.log(pc.yellow("  No sandboxes to destroy."));
+          return null;
+        }
+        const count = ctx.sandboxes.size;
+        console.log(pc.gray(`  Destroying ${count} sandbox${count > 1 ? "es" : ""}...`));
+        await Promise.all(
+          Array.from(ctx.sandboxes.values()).map((s) => s.destroy())
+        );
+        ctx.sandboxes.clear();
+        ctx.activeSandboxId = "";
+        rl.setPrompt(buildPrompt(ctx.activeSandboxId));
+        console.log(`  Destroyed ${pc.cyan(String(count))} sandbox${count > 1 ? "es" : ""}`);
+        console.log(pc.yellow("  No sandboxes remaining. Use /new to create one or /exit to quit."));
+        return null;
+      }
+      const targetId = args[0];
+      const target = ctx.sandboxes.get(targetId);
+      if (!target) {
+        const matches = Array.from(ctx.sandboxes.keys()).filter((id) => id.startsWith(targetId));
+        if (matches.length === 1) {
+          return destroySandbox(ctx, matches[0], rl);
+        } else if (matches.length > 1) {
+          console.log(pc.yellow("  Ambiguous ID. Matches:"));
+          for (const id of matches) {
+            console.log(`    ${pc.cyan(id)}`);
+          }
+        } else {
+          console.log(pc.red(`  Sandbox not found: ${targetId}`));
+          console.log(pc.gray("  Use /list to see all sandboxes"));
+        }
+        return null;
+      }
+      return destroySandbox(ctx, targetId, rl);
     }
-    if (resolvePromise) {
-      resolvePromise();
+    case "list":
+    case "ls": {
+      console.log();
+      console.log(pc.bold("  Sandboxes"));
+      for (const id of ctx.sandboxes.keys()) {
+        const marker = id === ctx.activeSandboxId ? pc.green(" \u25CF") : "  ";
+        console.log(`  ${marker} ${pc.cyan(id)}`);
+      }
+      console.log();
+      return null;
     }
-  }
-  function cleanup() {
-    process.stdin.removeListener("data", onData);
-    process.stdout.removeListener("resize", onResize);
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(false);
+    case "switch":
+    case "sw": {
+      if (args.length === 0) {
+        console.log(pc.gray("Usage: /switch <sandbox-id>"));
+        console.log(pc.gray("Use /list to see all sandboxes"));
+        return null;
+      }
+      const switchId = args[0];
+      if (ctx.sandboxes.has(switchId)) {
+        ctx.activeSandboxId = switchId;
+        rl.setPrompt(buildPrompt(ctx.activeSandboxId));
+        console.log(`  Switched to ${pc.cyan(switchId)}`);
+        return null;
+      }
+      const matches = Array.from(ctx.sandboxes.keys()).filter((id) => id.startsWith(switchId));
+      if (matches.length === 1) {
+        ctx.activeSandboxId = matches[0];
+        rl.setPrompt(buildPrompt(ctx.activeSandboxId));
+        console.log(`  Switched to ${pc.cyan(matches[0])}`);
+      } else if (matches.length > 1) {
+        console.log(pc.yellow("  Ambiguous ID. Matches:"));
+        for (const id of matches) {
+          console.log(`    ${pc.cyan(id)}`);
+        }
+      } else {
+        console.log(pc.red(`  Sandbox not found: ${switchId}`));
+        console.log(pc.gray("  Use /list to see all sandboxes"));
+      }
+      return null;
     }
-    process.stdin.pause();
+    case "exit":
+    case "quit":
+    case "q":
+      return "exit";
+    default:
+      console.log(pc.yellow(`Unknown command: /${cmd}`));
+      console.log(pc.gray("Type /help for available commands"));
+      return null;
   }
-  return new Promise((resolve) => {
-    resolvePromise = resolve;
-    terminal.on("destroyed", () => {
-      if (!exiting) {
-        cleanup();
-        resolve();
+}
+async function destroySandbox(ctx, sandboxId, rl) {
+  const target = ctx.sandboxes.get(sandboxId);
+  console.log(pc.gray(`  Destroying ${sandboxId}...`));
+  await target.destroy();
+  ctx.sandboxes.delete(sandboxId);
+  console.log(`  Destroyed ${pc.cyan(sandboxId)}`);
+  if (ctx.activeSandboxId === sandboxId && ctx.sandboxes.size > 0) {
+    ctx.activeSandboxId = ctx.sandboxes.keys().next().value;
+    rl.setPrompt(buildPrompt(ctx.activeSandboxId));
+    console.log(`  Switched to ${pc.cyan(ctx.activeSandboxId)}`);
+  } else if (ctx.sandboxes.size === 0) {
+    ctx.activeSandboxId = "";
+    rl.setPrompt(buildPrompt(ctx.activeSandboxId));
+    console.log(pc.yellow("  No sandboxes remaining. Use /new to create one or /exit to quit."));
+  }
+  return null;
+}
+function showHelp() {
+  console.log();
+  console.log(pc.bold("  Shell Mode"));
+  console.log(pc.gray("  Just type commands - they run in the active sandbox"));
+  console.log();
+  console.log(pc.white("    ls -la"));
+  console.log(pc.white("    cat /etc/os-release"));
+  console.log(pc.white("    npm install lodash"));
+  console.log();
+  console.log(pc.bold("  Sandbox Commands") + pc.gray(" (prefix with /)"));
+  console.log();
+  console.log(pc.cyan("    /new") + pc.gray("              Create a new sandbox and switch to it"));
+  console.log(pc.cyan("    /list") + pc.gray("             List all sandboxes"));
+  console.log(pc.cyan("    /switch <id>") + pc.gray("      Switch active sandbox"));
+  console.log(pc.cyan("    /destroy <id>") + pc.gray("     Destroy a sandbox by ID"));
+  console.log(pc.cyan("    /destroy --all") + pc.gray("    Destroy all sandboxes"));
+  console.log();
+  console.log(pc.bold("  Other Commands"));
+  console.log();
+  console.log(pc.cyan("    /info") + pc.gray("             Show active sandbox info"));
+  console.log(pc.cyan("    /url <port>") + pc.gray("       Get public URL for port"));
+  console.log(pc.cyan("    /help") + pc.gray("             Show this help"));
+  console.log(pc.cyan("    /exit") + pc.gray("             Exit the REPL"));
+  console.log();
+}
+function loadHistory(rl) {
+  try {
+    if (fs.existsSync(HISTORY_FILE)) {
+      const history = fs.readFileSync(HISTORY_FILE, "utf-8").split("\n").filter((line) => line.trim()).reverse();
+      for (const line of history.slice(0, 1e3)) {
+        rl.history?.push(line);
       }
-    });
-    process.stdin.on("end", () => {
-      doExit();
-    });
-  });
+    }
+  } catch {
+  }
 }
-var init_pty = __esm({
-  "src/pty.ts"() {
+function saveToHistory(line) {
+  try {
+    fs.appendFileSync(HISTORY_FILE, line + "\n");
+  } catch {
+  }
+}
+var HISTORY_FILE;
+var init_repl = __esm({
+  "src/repl.ts"() {
     "use strict";
     init_esm_shims();
+    HISTORY_FILE = path2.join(os.homedir(), ".create_compute_history");
   }
 });
 
@@ -123,33 +338,33 @@ __export(workspace_cli_exports, {
   workspaceDestroy: () => workspaceDestroy,
   workspaceList: () => workspaceList
 });
-import { compute as compute2 } from "computesdk";
-import * as fs2 from "fs";
-import * as path3 from "path";
-import * as os2 from "os";
+import { compute as compute3 } from "computesdk";
+import * as fs3 from "fs";
+import * as path4 from "path";
+import * as os3 from "os";
 import * as p3 from "@clack/prompts";
-import pc3 from "picocolors";
+import pc4 from "picocolors";
 function shellEscape(arg) {
   if (/^[a-zA-Z0-9._\-/:=@]+$/.test(arg)) return arg;
   return `'${arg.replace(/'/g, "'\\''")}'`;
 }
 function loadState() {
   try {
-    if (!fs2.existsSync(WORKSPACE_STATE_FILE)) {
+    if (!fs3.existsSync(WORKSPACE_STATE_FILE)) {
       return { workspaces: {} };
     }
-    const raw = fs2.readFileSync(WORKSPACE_STATE_FILE, "utf-8");
+    const raw = fs3.readFileSync(WORKSPACE_STATE_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { workspaces: {} };
   }
 }
 function saveState(state) {
-  const dir = path3.dirname(WORKSPACE_STATE_FILE);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true, mode: 448 });
+  const dir = path4.dirname(WORKSPACE_STATE_FILE);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true, mode: 448 });
   }
-  fs2.writeFileSync(WORKSPACE_STATE_FILE, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
+  fs3.writeFileSync(WORKSPACE_STATE_FILE, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
 }
 function getWorkspaceId(repo, branch) {
   return `${repo}:${branch}`;
@@ -161,13 +376,13 @@ async function workspaceCreate(options) {
   if (state.workspaces[id]) {
     const existing = state.workspaces[id];
     try {
-      const sandbox2 = await compute2.sandbox.getById(existing.sandboxId);
+      const sandbox2 = await compute3.sandbox.getById(existing.sandboxId);
       if (!sandbox2) {
         throw new Error("Sandbox not found");
       }
       existing.lastUsed = (/* @__PURE__ */ new Date()).toISOString();
       saveState(state);
-      p3.log.info(`Attaching to existing workspace: ${pc3.cyan(id)}`);
+      p3.log.info(`Attaching to existing workspace: ${pc4.cyan(id)}`);
       return existing;
     } catch {
       delete state.workspaces[id];
@@ -178,14 +393,14 @@ async function workspaceCreate(options) {
   spinner4.start("Provisioning via ComputeSDK...");
   let sandbox;
   try {
-    sandbox = await compute2.sandbox.create();
-    spinner4.stop(`Sandbox ready: ${pc3.cyan(sandbox.sandboxId)}`);
+    sandbox = await compute3.sandbox.create();
+    spinner4.stop(`Sandbox ready: ${pc4.cyan(sandbox.sandboxId)}`);
   } catch (error) {
-    spinner4.stop(pc3.red("Failed to create sandbox"));
+    spinner4.stop(pc4.red("Failed to create sandbox"));
     throw error;
   }
   spinner4.start("Bootstrapping workspace (installing gh CLI, cloning repo)...");
-  const bootstrapScript = fs2.readFileSync(
+  const bootstrapScript = fs3.readFileSync(
     new URL("./bootstrap.sh", import.meta.url),
     "utf-8"
   );
@@ -200,7 +415,7 @@ async function workspaceCreate(options) {
     );
     const output = result.stdout || "";
     const jsonMatch = output.match(/\{[\s\S]*\}/);
-    let worktreePath = `/workspaces/${path3.basename(repo)}-${branch}`;
+    let worktreePath = `/workspaces/${path4.basename(repo)}-${branch}`;
     if (jsonMatch) {
       try {
         const bootstrapInfo = JSON.parse(jsonMatch[0]);
@@ -221,12 +436,12 @@ async function workspaceCreate(options) {
     };
     state.workspaces[id] = workspace;
     saveState(state);
-    p3.log.success(`Workspace ready: ${pc3.cyan(id)}`);
-    p3.log.info(`Sandbox: ${pc3.dim(sandbox.sandboxId)}`);
-    p3.log.info(`Worktree: ${pc3.dim(worktreePath)}`);
+    p3.log.success(`Workspace ready: ${pc4.cyan(id)}`);
+    p3.log.info(`Sandbox: ${pc4.dim(sandbox.sandboxId)}`);
+    p3.log.info(`Worktree: ${pc4.dim(worktreePath)}`);
     return workspace;
   } catch (error) {
-    spinner4.stop(pc3.red("Bootstrap failed"));
+    spinner4.stop(pc4.red("Bootstrap failed"));
     try {
       await sandbox.destroy();
     } catch {
@@ -242,7 +457,7 @@ async function workspaceAttach(id) {
     p3.log.info(`Run: compute workspace create --repo owner/repo --branch ${id.split(":")[1] || "main"}`);
     process.exit(1);
   }
-  const sandbox = await compute2.sandbox.getById(workspace.sandboxId);
+  const sandbox = await compute3.sandbox.getById(workspace.sandboxId);
   if (!sandbox) {
     p3.log.error(`Sandbox no longer exists: ${workspace.sandboxId}`);
     delete state.workspaces[id];
@@ -251,12 +466,11 @@ async function workspaceAttach(id) {
   }
   workspace.lastUsed = (/* @__PURE__ */ new Date()).toISOString();
   saveState(state);
-  p3.log.info(`Attaching to workspace: ${pc3.cyan(id)}`);
-  p3.log.info(`Changing to: ${pc3.dim(workspace.worktreePath)}`);
-  console.log(pc3.gray("Starting shell..."));
+  p3.log.info(`Attaching to workspace: ${pc4.cyan(id)}`);
+  p3.log.info(`Worktree: ${pc4.dim(workspace.worktreePath)}`);
+  console.log(pc4.gray(`Tip: commands run at sandbox root; use { cwd: "${workspace.worktreePath}" } on runCommand to scope them.`));
   try {
-    process.stdout.write("\x1B[2J\x1B[H\x1B[3J");
-    await startPTY(sandbox, { initialCommand: `cd ${shellEscape(workspace.worktreePath)}` });
+    await startREPL(sandbox, workspace.provider);
   } catch (error) {
     p3.log.error(`Failed to attach: ${error.message}`);
     process.exit(1);
@@ -271,19 +485,19 @@ async function sandboxList() {
     return;
   }
   console.log();
-  console.log(pc3.bold("Sandboxes"));
+  console.log(pc4.bold("Sandboxes"));
   console.log();
   for (const ws of workspaces) {
     const age = Math.round((Date.now() - new Date(ws.lastUsed).getTime()) / (1e3 * 60 * 60 * 24));
     const ageStr = age === 0 ? "today" : age === 1 ? "1 day ago" : `${age} days ago`;
-    const status = age > 7 ? pc3.red("stale") : age > 1 ? pc3.yellow("idle") : pc3.green("active");
-    console.log(`  ${status} ${pc3.cyan(ws.sandboxId)}`);
-    console.log(`    Workspace: ${pc3.dim(ws.id)}`);
+    const status = age > 7 ? pc4.red("stale") : age > 1 ? pc4.yellow("idle") : pc4.green("active");
+    console.log(`  ${status} ${pc4.cyan(ws.sandboxId)}`);
+    console.log(`    Workspace: ${pc4.dim(ws.id)}`);
     console.log(`    Provider: ${ws.provider}`);
-    console.log(`    Last active: ${pc3.gray(ageStr)}`);
+    console.log(`    Last active: ${pc4.gray(ageStr)}`);
     console.log();
   }
-  console.log(pc3.gray('Tip: Use "compute workspaces" to see full workspace details'));
+  console.log(pc4.gray('Tip: Use "compute workspaces" to see full workspace details'));
 }
 async function workspaceList() {
   const state = loadState();
@@ -294,15 +508,15 @@ async function workspaceList() {
     return;
   }
   console.log();
-  console.log(pc3.bold("Workspaces"));
+  console.log(pc4.bold("Workspaces"));
   console.log();
   for (const ws of workspaces) {
     const age = Math.round((Date.now() - new Date(ws.lastUsed).getTime()) / (1e3 * 60 * 60 * 24));
     const ageStr = age === 0 ? "today" : `${age}d ago`;
-    console.log(`  ${pc3.cyan(ws.id)}`);
-    console.log(`    Sandbox: ${pc3.dim(ws.sandboxId)} (${ws.provider})`);
-    console.log(`    Path: ${pc3.dim(ws.worktreePath)}`);
-    console.log(`    Last used: ${pc3.gray(ageStr)}`);
+    console.log(`  ${pc4.cyan(ws.id)}`);
+    console.log(`    Sandbox: ${pc4.dim(ws.sandboxId)} (${ws.provider})`);
+    console.log(`    Path: ${pc4.dim(ws.worktreePath)}`);
+    console.log(`    Last used: ${pc4.gray(ageStr)}`);
     console.log();
   }
 }
@@ -328,9 +542,9 @@ async function workspaceDestroy(id) {
       p3.log.error(`Workspace not found: ${id}`);
       return;
     }
-    p3.log.info(`Destroying workspace: ${pc3.cyan(id)}`);
+    p3.log.info(`Destroying workspace: ${pc4.cyan(id)}`);
     try {
-      await compute2.sandbox.destroy(workspace.sandboxId);
+      await compute3.sandbox.destroy(workspace.sandboxId);
       delete state.workspaces[id];
       saveState(state);
       p3.log.success("Workspace destroyed");
@@ -361,8 +575,8 @@ var init_workspace_cli = __esm({
   "src/workspace-cli.ts"() {
     "use strict";
     init_esm_shims();
-    init_pty();
-    WORKSPACE_STATE_FILE = path3.join(os2.homedir(), ".computesdk", "workspaces.json");
+    init_repl();
+    WORKSPACE_STATE_FILE = path4.join(os3.homedir(), ".computesdk", "workspaces.json");
     loadWorkspaceState = loadState;
   }
 });
@@ -372,11 +586,11 @@ init_esm_shims();
 import "dotenv/config";
 import { Command } from "commander";
 import * as p4 from "@clack/prompts";
-import pc4 from "picocolors";
-import { readFileSync as readFileSync3 } from "fs";
+import pc5 from "picocolors";
+import { readFileSync as readFileSync4 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname2, join as join3 } from "path";
-import { compute as compute3 } from "computesdk";
+import { dirname as dirname2, join as join4 } from "path";
+import { compute as compute4 } from "computesdk";
 
 // src/providers.ts
 init_esm_shims();
@@ -449,23 +663,23 @@ function buildProviderConfig(provider) {
 }
 
 // src/index.ts
-init_pty();
+init_repl();
 
 // src/auth.ts
 init_esm_shims();
 import * as http from "http";
 import * as crypto from "crypto";
 import { exec } from "child_process";
-import * as fs from "fs";
-import * as path2 from "path";
-import * as os from "os";
+import * as fs2 from "fs";
+import * as path3 from "path";
+import * as os2 from "os";
 import * as p from "@clack/prompts";
-import pc from "picocolors";
+import pc2 from "picocolors";
 function getCredentialsDir() {
-  return path2.join(os.homedir(), ".computesdk");
+  return path3.join(os2.homedir(), ".computesdk");
 }
 function getCredentialsFile() {
-  return path2.join(getCredentialsDir(), "credentials.json");
+  return path3.join(getCredentialsDir(), "credentials.json");
 }
 var AUTH_TIMEOUT_MS = 5 * 60 * 1e3;
 var CONSOLE_AUTH_URL = "https://console.computesdk.com/cli/auth";
@@ -481,10 +695,10 @@ var SUCCESS_HTML = `<!DOCTYPE html>
 </html>`;
 function loadStoredCredentials() {
   try {
-    if (!fs.existsSync(getCredentialsFile())) {
+    if (!fs2.existsSync(getCredentialsFile())) {
       return null;
     }
-    const raw = fs.readFileSync(getCredentialsFile(), "utf-8");
+    const raw = fs2.readFileSync(getCredentialsFile(), "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.apiKey === "string" && data.apiKey.length > 0) {
       return data.apiKey;
@@ -495,10 +709,10 @@ function loadStoredCredentials() {
   }
 }
 function storeCredentials(apiKey) {
-  if (!fs.existsSync(getCredentialsDir())) {
-    fs.mkdirSync(getCredentialsDir(), { recursive: true, mode: 448 });
+  if (!fs2.existsSync(getCredentialsDir())) {
+    fs2.mkdirSync(getCredentialsDir(), { recursive: true, mode: 448 });
   }
-  fs.writeFileSync(
+  fs2.writeFileSync(
     getCredentialsFile(),
     JSON.stringify({ apiKey }, null, 2) + "\n",
     { mode: 384 }
@@ -506,8 +720,8 @@ function storeCredentials(apiKey) {
 }
 function clearStoredCredentials() {
   try {
-    if (fs.existsSync(getCredentialsFile())) {
-      fs.unlinkSync(getCredentialsFile());
+    if (fs2.existsSync(getCredentialsFile())) {
+      fs2.unlinkSync(getCredentialsFile());
     }
   } catch {
   }
@@ -518,7 +732,7 @@ function openBrowser(url) {
     if (err) {
       p.log.warn("Could not open browser automatically.");
       p.log.info(`Open this URL manually:
-  ${pc.cyan(url)}`);
+  ${pc2.cyan(url)}`);
     }
   });
 }
@@ -589,7 +803,7 @@ async function resolveApiKey(options) {
     const stored = loadStoredCredentials();
     if (stored) {
       p.log.info(
-        `Using stored credentials from ${pc.dim("~/.computesdk/credentials.json")}`
+        `Using stored credentials from ${pc2.dim("~/.computesdk/credentials.json")}`
       );
       return stored;
     }
@@ -603,14 +817,14 @@ async function resolveApiKey(options) {
     try {
       storeCredentials(apiKey);
       p.log.success(
-        `Credentials saved to ${pc.dim("~/.computesdk/credentials.json")}`
+        `Credentials saved to ${pc2.dim("~/.computesdk/credentials.json")}`
       );
     } catch {
       p.log.warn("Could not save credentials to disk. You may need to authenticate again next time.");
     }
     return apiKey;
   } catch (error) {
-    spinner4.stop(pc.red("Authentication failed"));
+    spinner4.stop(pc2.red("Authentication failed"));
     throw error;
   }
 }
@@ -618,16 +832,16 @@ async function resolveApiKey(options) {
 // src/setup.ts
 init_esm_shims();
 import * as p2 from "@clack/prompts";
-import pc2 from "picocolors";
-import { compute } from "computesdk";
+import pc3 from "picocolors";
+import { compute as compute2 } from "computesdk";
 async function ensureAuth(options) {
   try {
     const apiKey = await resolveApiKey({ forceLogin: options?.forceLogin });
     process.env.COMPUTESDK_API_KEY = apiKey;
   } catch (error) {
     p2.log.error(error.message);
-    p2.log.info(`Get your API key at ${pc2.cyan("https://console.computesdk.com")}`);
-    p2.outro(pc2.red("Setup incomplete"));
+    p2.log.info(`Get your API key at ${pc3.cyan("https://console.computesdk.com")}`);
+    p2.outro(pc3.red("Setup incomplete"));
     process.exit(1);
   }
 }
@@ -656,7 +870,7 @@ async function resolveProvider(providerFlag, options) {
   if (available.length === 0) {
     p2.log.error("No provider credentials detected");
     p2.log.info("Set one of: E2B_API_KEY, MODAL_TOKEN_ID, RAILWAY_API_KEY, etc.");
-    p2.outro(pc2.red("Setup incomplete"));
+    p2.outro(pc3.red("Setup incomplete"));
     process.exit(1);
   }
   if (available.length === 1) {
@@ -683,7 +897,7 @@ async function resolveProvider(providerFlag, options) {
 }
 function configureCompute(provider) {
   const config = buildProviderConfig(provider);
-  compute.setConfig(config);
+  compute2.setConfig(config);
 }
 
 // src/index.ts
@@ -691,7 +905,7 @@ init_workspace_cli();
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname2(__filename2);
 var packageJson = JSON.parse(
-  readFileSync3(join3(__dirname2, "..", "package.json"), "utf-8")
+  readFileSync4(join4(__dirname2, "..", "package.json"), "utf-8")
 );
 var isDevBuild = import.meta.url.includes("worktrees") || import.meta.url.includes("/packages/cli/");
 var VERSION = isDevBuild ? `${packageJson.version}-dev` : packageJson.version;
@@ -700,24 +914,24 @@ program.name("compute").description("Cloud-native workspace management").version
 program.option("--login", "force re-authentication").option("--logout", "clear stored credentials").action(async (opts) => {
   if (opts.logout) {
     console.log();
-    p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+    p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
     clearStoredCredentials();
     p4.log.success("Logged out. Stored credentials removed.");
-    p4.outro(pc4.green("Done!"));
+    p4.outro(pc5.green("Done!"));
     process.exit(0);
   }
   if (opts.login) {
     console.log();
-    p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+    p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
     await ensureAuth({ forceLogin: true });
-    p4.outro(pc4.green("Authenticated!"));
+    p4.outro(pc5.green("Authenticated!"));
     process.exit(0);
   }
   program.help();
 });
 program.command("create").description("Create a new workspace (same as create-compute)").argument("[repo]", "Repository in owner/repo format").option("-b, --branch <branch>", "Branch name", "main").option("-p, --provider <provider>", "provider to use").option("--no-attach", "Create workspace but do not attach").action(async (repo, options) => {
   console.log();
-  p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
   await ensureAuth();
   if (!repo) {
     const state = loadWorkspaceState();
@@ -738,7 +952,7 @@ program.command("create").description("Create a new workspace (same as create-co
         message: "Select workspace to attach (or create new)",
         options: [
           ...choices,
-          { value: "__new__", label: pc4.gray("+ Create new workspace") }
+          { value: "__new__", label: pc5.gray("+ Create new workspace") }
         ]
       });
       if (p4.isCancel(selected)) {
@@ -779,24 +993,24 @@ program.command("create").description("Create a new workspace (same as create-co
       branch: options.branch,
       provider
     });
-    spinner4.stop(`Workspace ready: ${pc4.cyan(workspace.id)}`);
+    spinner4.stop(`Workspace ready: ${pc5.cyan(workspace.id)}`);
     if (options.attach !== false) {
       console.log();
       await workspaceAttach(workspace.id);
     } else {
-      p4.outro(pc4.green("Workspace created!"));
+      p4.outro(pc5.green("Workspace created!"));
     }
   } catch (error) {
-    spinner4.stop(pc4.red("Failed to create workspace"));
+    spinner4.stop(pc5.red("Failed to create workspace"));
     p4.log.error(error.message);
     process.exit(1);
   }
 });
 var sandboxCmd = program.command("sandbox").alias("sb").description("Manage raw sandboxes (VMs without git/worktree)");
-sandboxCmd.command("create").description("Create a new sandbox").option("-p, --provider <provider>", "provider to use").option("--timeout <duration>", "sandbox timeout (e.g. 5m, 1h)").option("--name <name>", "sandbox name for findOrCreate").option("--connect", "start interactive shell after creation").option("--silent", "only output the sandbox ID").action(async (opts) => {
+sandboxCmd.command("create").description("Create a new sandbox").option("-p, --provider <provider>", "provider to use").option("--timeout <duration>", "sandbox timeout (e.g. 5m, 1h)").option("--name <name>", "sandbox name").option("--connect", "drop into the REPL after creation").option("--silent", "only output the sandbox ID").action(async (opts) => {
   if (!opts.silent) {
     console.log();
-    p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+    p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
   }
   await ensureAuth();
   const provider = await resolveProvider(opts.provider);
@@ -805,10 +1019,10 @@ sandboxCmd.command("create").description("Create a new sandbox").option("-p, --p
     const spinner4 = p4.spinner();
     spinner4.start("Creating sandbox...");
     try {
-      const sandbox = await compute3.sandbox.create(
+      const sandbox = await compute4.sandbox.create(
         buildCreateOptions(opts)
       );
-      spinner4.stop(`Sandbox ready: ${pc4.cyan(sandbox.sandboxId)}`);
+      spinner4.stop(`Sandbox ready: ${pc5.cyan(sandbox.sandboxId)}`);
       const { saveSandbox: saveSandbox2 } = await Promise.resolve().then(() => (init_workspace_cli(), workspace_cli_exports));
       await saveSandbox2({
         id: sandbox.sandboxId,
@@ -818,19 +1032,16 @@ sandboxCmd.command("create").description("Create a new sandbox").option("-p, --p
         lastUsed: (/* @__PURE__ */ new Date()).toISOString()
       });
       if (opts.connect) {
-        console.log(pc4.gray("  Entering shell... (.exit or Ctrl+D to return)"));
-        console.log();
-        process.stdout.write("\x1B[2J\x1B[H\x1B[3J");
-        await startPTY(sandbox);
+        await startREPL(sandbox, provider);
       }
     } catch (error) {
-      spinner4.stop(pc4.red("Failed to create sandbox"));
+      spinner4.stop(pc5.red("Failed to create sandbox"));
       p4.log.error(error.message);
       process.exit(1);
     }
   } else {
     try {
-      const sandbox = await compute3.sandbox.create(
+      const sandbox = await compute4.sandbox.create(
         buildCreateOptions(opts)
       );
       process.stdout.write(sandbox.sandboxId);
@@ -843,9 +1054,7 @@ sandboxCmd.command("create").description("Create a new sandbox").option("-p, --p
         lastUsed: (/* @__PURE__ */ new Date()).toISOString()
       });
       if (opts.connect) {
-        console.log();
-        process.stdout.write("\x1B[2J\x1B[H\x1B[3J");
-        await startPTY(sandbox);
+        await startREPL(sandbox, provider);
       }
     } catch (error) {
       process.stderr.write(error.message + "\n");
@@ -855,14 +1064,14 @@ sandboxCmd.command("create").description("Create a new sandbox").option("-p, --p
 });
 sandboxCmd.command("destroy").description("Destroy one or more sandboxes").aliases(["rm", "stop"]).argument("[sandbox_id...]", "sandbox IDs to destroy (optional - will show picker if not provided)").option("-p, --provider <provider>", "provider to use").action(async (sandboxIds, opts) => {
   console.log();
-  p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
   const { loadState: loadState2, saveState: saveState2 } = await Promise.resolve().then(() => (init_workspace_cli(), workspace_cli_exports));
   const state = loadState2();
   if (!sandboxIds || sandboxIds.length === 0) {
     const workspaces = Object.values(state.workspaces);
     if (workspaces.length === 0) {
       p4.log.info("No sandboxes to destroy.");
-      p4.outro(pc4.green("Done!"));
+      p4.outro(pc5.green("Done!"));
       return;
     }
     const choices = workspaces.map((ws) => {
@@ -870,7 +1079,7 @@ sandboxCmd.command("destroy").description("Destroy one or more sandboxes").alias
         (Date.now() - new Date(ws.lastUsed).getTime()) / (1e3 * 60 * 60 * 24)
       );
       const ageStr = age === 0 ? "today" : age === 1 ? "1 day ago" : `${age} days ago`;
-      const status = age > 7 ? pc4.red("stale") : age > 1 ? pc4.yellow("idle") : pc4.green("active");
+      const status = age > 7 ? pc5.red("stale") : age > 1 ? pc5.yellow("idle") : pc5.green("active");
       return {
         value: ws.sandboxId,
         label: `${status} ${ws.sandboxId} (${ws.provider}, last active ${ageStr})`
@@ -891,14 +1100,14 @@ sandboxCmd.command("destroy").description("Destroy one or more sandboxes").alias
   configureCompute(provider);
   const results = await Promise.allSettled(
     sandboxIds.map(async (id) => {
-      await compute3.sandbox.destroy(id);
+      await compute4.sandbox.destroy(id);
       return id;
     })
   );
   for (const result of results) {
     if (result.status === "fulfilled") {
       const sandboxId = result.value;
-      console.log(pc4.green(`Destroyed ${sandboxId}`));
+      console.log(pc5.green(`Destroyed ${sandboxId}`));
       const workspaceId = Object.keys(state.workspaces).find(
         (key) => state.workspaces[key].sandboxId === sandboxId
       );
@@ -906,19 +1115,19 @@ sandboxCmd.command("destroy").description("Destroy one or more sandboxes").alias
         delete state.workspaces[workspaceId];
       }
     } else {
-      console.error(pc4.red(`Failed to destroy: ${result.reason?.message || result.reason}`));
+      console.error(pc5.red(`Failed to destroy: ${result.reason?.message || result.reason}`));
     }
   }
   saveState2(state);
 });
 sandboxCmd.command("list").alias("ls").description("List all sandboxes").action(async () => {
   console.log();
-  p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
   await sandboxList();
 });
-sandboxCmd.command("connect").description("Connect to a sandbox via PTY (same as compute connect)").aliases(["ssh", "shell"]).argument("[sandbox_id]", "sandbox ID (optional - will show picker if not provided)").option("-p, --provider <provider>", "provider to use").action(async (sandboxId, opts) => {
+sandboxCmd.command("connect").description("Connect to a sandbox (opens REPL; same as compute connect)").aliases(["ssh", "shell"]).argument("[sandbox_id]", "sandbox ID (optional - will show picker if not provided)").option("-p, --provider <provider>", "provider to use").action(async (sandboxId, opts) => {
   console.log();
-  p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
   await ensureAuth();
   const provider = await resolveProvider(opts.provider);
   configureCompute(provider);
@@ -929,7 +1138,7 @@ sandboxCmd.command("connect").description("Connect to a sandbox via PTY (same as
     if (workspaces.length === 0) {
       p4.log.info("No sandboxes found.");
       p4.log.info("Create one with: compute sandbox create");
-      p4.outro(pc4.green("Done!"));
+      p4.outro(pc5.green("Done!"));
       return;
     }
     const choices = workspaces.map((ws) => {
@@ -937,7 +1146,7 @@ sandboxCmd.command("connect").description("Connect to a sandbox via PTY (same as
         (Date.now() - new Date(ws.lastUsed).getTime()) / (1e3 * 60 * 60 * 24)
       );
       const ageStr = age === 0 ? "today" : age === 1 ? "1 day ago" : `${age} days ago`;
-      const status = age > 7 ? pc4.red("stale") : age > 1 ? pc4.yellow("idle") : pc4.green("active");
+      const status = age > 7 ? pc5.red("stale") : age > 1 ? pc5.yellow("idle") : pc5.green("active");
       return {
         value: ws.sandboxId,
         label: `${status} ${ws.sandboxId} (${ws.provider}, last active ${ageStr})`
@@ -955,22 +1164,21 @@ sandboxCmd.command("connect").description("Connect to a sandbox via PTY (same as
   }
   const spinner4 = p4.spinner();
   spinner4.start("Connecting...");
-  const sandbox = await compute3.sandbox.getById(sandboxId);
+  const sandbox = await compute4.sandbox.getById(sandboxId);
   if (!sandbox) {
-    spinner4.stop(pc4.red(`Sandbox not found: ${sandboxId}`));
+    spinner4.stop(pc5.red(`Sandbox not found: ${sandboxId}`));
     process.exit(1);
   }
   spinner4.stop("");
-  process.stdout.write("\x1B[2J\x1B[H\x1B[3J");
-  await startPTY(sandbox);
+  await startREPL(sandbox, provider);
 });
 sandboxCmd.command("exec").description("Execute a command in a sandbox").argument("<sandbox_id>", "sandbox ID").argument("<command...>", "command to run").option("-p, --provider <provider>", "provider to use").option("-e, --env <key=value...>", "environment variables").option("-w, --workdir <directory>", "working directory").passThroughOptions().action(async (sandboxId, command, opts) => {
   await ensureAuth();
   const provider = await resolveProvider(opts.provider);
   configureCompute(provider);
-  const sandbox = await compute3.sandbox.getById(sandboxId);
+  const sandbox = await compute4.sandbox.getById(sandboxId);
   if (!sandbox) {
-    console.error(pc4.red(`Sandbox not found: ${sandboxId}`));
+    console.error(pc5.red(`Sandbox not found: ${sandboxId}`));
     process.exit(1);
   }
   const cmd = buildExecCommand(command, opts);
@@ -983,9 +1191,9 @@ sandboxCmd.command("exec").description("Execute a command in a sandbox").argumen
   }
   process.exit(result.exitCode);
 });
-program.command("connect").description("Connect to a sandbox via PTY").aliases(["ssh", "shell"]).argument("[sandbox_id]", "sandbox ID (optional - will show picker if not provided)").option("-p, --provider <provider>", "provider to use").action(async (sandboxId, opts) => {
+program.command("connect").description("Connect to a sandbox (opens REPL)").aliases(["ssh", "shell"]).argument("[sandbox_id]", "sandbox ID (optional - will show picker if not provided)").option("-p, --provider <provider>", "provider to use").action(async (sandboxId, opts) => {
   console.log();
-  p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
   await ensureAuth();
   const provider = await resolveProvider(opts.provider);
   configureCompute(provider);
@@ -996,7 +1204,7 @@ program.command("connect").description("Connect to a sandbox via PTY").aliases([
     if (workspaces.length === 0) {
       p4.log.info("No sandboxes found.");
       p4.log.info("Create one with: compute sandbox create");
-      p4.outro(pc4.green("Done!"));
+      p4.outro(pc5.green("Done!"));
       return;
     }
     const choices = workspaces.map((ws) => {
@@ -1004,7 +1212,7 @@ program.command("connect").description("Connect to a sandbox via PTY").aliases([
         (Date.now() - new Date(ws.lastUsed).getTime()) / (1e3 * 60 * 60 * 24)
       );
       const ageStr = age === 0 ? "today" : age === 1 ? "1 day ago" : `${age} days ago`;
-      const status = age > 7 ? pc4.red("stale") : age > 1 ? pc4.yellow("idle") : pc4.green("active");
+      const status = age > 7 ? pc5.red("stale") : age > 1 ? pc5.yellow("idle") : pc5.green("active");
       return {
         value: ws.sandboxId,
         label: `${status} ${ws.sandboxId} (${ws.provider}, last active ${ageStr})`
@@ -1022,23 +1230,22 @@ program.command("connect").description("Connect to a sandbox via PTY").aliases([
   }
   const spinner4 = p4.spinner();
   spinner4.start("Connecting...");
-  const sandbox = await compute3.sandbox.getById(sandboxId);
+  const sandbox = await compute4.sandbox.getById(sandboxId);
   if (!sandbox) {
-    spinner4.stop(pc4.red(`Sandbox not found: ${sandboxId}`));
+    spinner4.stop(pc5.red(`Sandbox not found: ${sandboxId}`));
     process.exit(1);
   }
   spinner4.stop("");
-  process.stdout.write("\x1B[2J\x1B[H\x1B[3J");
-  await startPTY(sandbox);
+  await startREPL(sandbox, provider);
 });
 var workspaceCmd = program.command("workspace").alias("ws").description("Manage workspaces (sandbox + git + worktree)");
 workspaceCmd.command("create").description("Create a new workspace").argument("[repo]", "Repository in owner/repo format").option("-b, --branch <branch>", "Branch name", "main").option("-p, --provider <provider>", "provider to use").option("--no-attach", "Create workspace but do not attach").action(async (repo, options) => {
   console.log();
-  p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
   await ensureAuth();
   if (!repo) {
     p4.log.info("Usage: compute workspace create owner/repo --branch main");
-    p4.outro(pc4.green("Done!"));
+    p4.outro(pc5.green("Done!"));
     return;
   }
   const provider = await resolveProvider(options.provider, { interactive: true });
@@ -1051,33 +1258,33 @@ workspaceCmd.command("create").description("Create a new workspace").argument("[
       branch: options.branch,
       provider
     });
-    spinner4.stop(`Workspace ready: ${pc4.cyan(workspace.id)}`);
+    spinner4.stop(`Workspace ready: ${pc5.cyan(workspace.id)}`);
     if (options.attach !== false) {
       console.log();
       await workspaceAttach(workspace.id);
     } else {
-      p4.outro(pc4.green("Workspace created!"));
+      p4.outro(pc5.green("Workspace created!"));
     }
   } catch (error) {
-    spinner4.stop(pc4.red("Failed to create workspace"));
+    spinner4.stop(pc5.red("Failed to create workspace"));
     p4.log.error(error.message);
     process.exit(1);
   }
 });
 workspaceCmd.command("list").alias("ls").description("List all workspaces").action(async () => {
   console.log();
-  p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
   await workspaceList();
 });
 workspaceCmd.command("destroy").alias("rm").description("Destroy a workspace").argument("[id]", "Workspace ID (repo:branch format, optional - will show picker if not provided)").action(async (id) => {
   console.log();
-  p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
   if (!id) {
     const state = loadWorkspaceState();
     const workspaceIds = Object.keys(state.workspaces);
     if (workspaceIds.length === 0) {
       p4.log.info("No workspaces to destroy.");
-      p4.outro(pc4.green("Done!"));
+      p4.outro(pc5.green("Done!"));
       return;
     }
     const choices = workspaceIds.map((key) => {
@@ -1088,7 +1295,7 @@ workspaceCmd.command("destroy").alias("rm").description("Destroy a workspace").a
       const ageStr = age === 0 ? "today" : age === 1 ? "1 day ago" : `${age} days ago`;
       return {
         value: key,
-        label: `${pc4.cyan(key)} (${ws.provider}, last used ${ageStr})`
+        label: `${pc5.cyan(key)} (${ws.provider}, last used ${ageStr})`
       };
     });
     const selected = await p4.multiselect({
@@ -1108,14 +1315,14 @@ workspaceCmd.command("destroy").alias("rm").description("Destroy a workspace").a
 });
 workspaceCmd.command("connect").alias("attach").description("Connect to an existing workspace (with git context)").argument("[id]", "Workspace ID (optional - will show picker if not provided)").action(async (id) => {
   console.log();
-  p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
   if (!id) {
     const state = loadWorkspaceState();
     const workspaceIds = Object.keys(state.workspaces);
     if (workspaceIds.length === 0) {
       p4.log.info("No workspaces found.");
       p4.log.info("Create one with: compute create owner/repo");
-      p4.outro(pc4.green("Done!"));
+      p4.outro(pc5.green("Done!"));
       return;
     }
     const choices = workspaceIds.map((key) => {
@@ -1126,7 +1333,7 @@ workspaceCmd.command("connect").alias("attach").description("Connect to an exist
       const ageStr = age === 0 ? "today" : age === 1 ? "1 day ago" : `${age} days ago`;
       return {
         value: key,
-        label: `${pc4.cyan(key)} (${ws.provider}, last used ${ageStr})`
+        label: `${pc5.cyan(key)} (${ws.provider}, last used ${ageStr})`
       };
     });
     const selected = await p4.select({
@@ -1147,11 +1354,11 @@ program.command("run").description("Create a sandbox, run a command, then option
   configureCompute(provider);
   let sandbox;
   try {
-    sandbox = await compute3.sandbox.create(
+    sandbox = await compute4.sandbox.create(
       buildCreateOptions(opts)
     );
   } catch (error) {
-    console.error(pc4.red(`Failed to create sandbox: ${error.message}`));
+    console.error(pc5.red(`Failed to create sandbox: ${error.message}`));
     process.exit(1);
   }
   try {
@@ -1174,35 +1381,35 @@ program.command("run").description("Create a sandbox, run a command, then option
       } catch {
       }
     }
-    console.error(pc4.red(error.message));
+    console.error(pc5.red(error.message));
     process.exit(1);
   }
 });
 program.command("providers").description("List all providers and their configuration status").action(async () => {
   console.log();
-  p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
   const statuses = getProviderStatus();
   console.log();
   for (const status of statuses) {
-    const icon = status.ready ? pc4.green("\u25CF") : pc4.gray("\u25CB");
-    const name = status.ready ? pc4.white(status.name) : pc4.gray(status.name);
-    const detail = status.ready ? pc4.green("ready") : pc4.gray(`missing: ${status.missing.join(", ")}`);
+    const icon = status.ready ? pc5.green("\u25CF") : pc5.gray("\u25CB");
+    const name = status.ready ? pc5.white(status.name) : pc5.gray(status.name);
+    const detail = status.ready ? pc5.green("ready") : pc5.gray(`missing: ${status.missing.join(", ")}`);
     console.log(`  ${icon} ${name}  ${detail}`);
   }
   console.log();
 });
 program.command("login").description("Authenticate with ComputeSDK").action(async () => {
   console.log();
-  p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
   await ensureAuth({ forceLogin: true });
-  p4.outro(pc4.green("Authenticated!"));
+  p4.outro(pc5.green("Authenticated!"));
 });
 program.command("logout").description("Clear stored credentials").action(() => {
   console.log();
-  p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
   clearStoredCredentials();
   p4.log.success("Logged out. Stored credentials removed.");
-  p4.outro(pc4.green("Done!"));
+  p4.outro(pc5.green("Done!"));
 });
 function buildCreateOptions(opts) {
   const options = {};
@@ -1271,7 +1478,7 @@ function parseDuration(input) {
   return total;
 }
 program.parseAsync(process.argv).catch((error) => {
-  console.error(pc4.red(`
+  console.error(pc5.red(`
 Error: ${error.message}`));
   process.exit(1);
 });