@computesdk/workbench 3.0.0 → 3.1.1

package/dist/index.js

@@ -1,4 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/.pnpm/tsup@8.5.0_jiti@2.6.1_postcss@8.5.6_tsx@4.20.3_typescript@5.8.3_yaml@2.8.0/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.0_jiti@2.6.1_postcss@8.5.6_tsx@4.20.3_typescript@5.8.3_yaml@2.8.0/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
 // src/cli/state.ts
+var state_exports = {};
+__export(state_exports, {
+  clearSandbox: () => clearSandbox,
+  createState: () => createState,
+  formatUptime: () => formatUptime,
+  getCurrentSandbox: () => getCurrentSandbox,
+  getUptimeSeconds: () => getUptimeSeconds,
+  hasSandbox: () => hasSandbox,
+  setSandbox: () => setSandbox
+});
 function createState() {
   return {
     currentProvider: null,
@@ -7,7 +36,8 @@ function createState() {
     availableProviders: [],
     useDirectMode: false,
     // Default to gateway mode
-    verbose: false
+    verbose: false,
+    compute: null
   };
 }
 function getCurrentSandbox(state) {
@@ -61,36 +91,28 @@ function formatUptime(state) {
   const remainingMinutes = minutes % 60;
   return `${hours}h ${remainingMinutes}m`;
 }
-
-// src/cli/repl.ts
-import * as repl from "repl";
-import * as cmd from "@computesdk/cmd";
-
-// src/cli/commands.ts
-import { createCompute } from "computesdk";
+var init_state = __esm({
+  "src/cli/state.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
 
 // src/cli/output.ts
-var colors = {
-  reset: "\x1B[0m",
-  bright: "\x1B[1m",
-  dim: "\x1B[2m",
-  cyan: "\x1B[36m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  red: "\x1B[31m",
-  blue: "\x1B[34m",
-  magenta: "\x1B[35m"
-};
-var c = {
-  bold: (text) => `${colors.bright}${text}${colors.reset}`,
-  dim: (text) => `${colors.dim}${text}${colors.reset}`,
-  cyan: (text) => `${colors.cyan}${text}${colors.reset}`,
-  green: (text) => `${colors.green}${text}${colors.reset}`,
-  yellow: (text) => `${colors.yellow}${text}${colors.reset}`,
-  red: (text) => `${colors.red}${text}${colors.reset}`,
-  blue: (text) => `${colors.blue}${text}${colors.reset}`,
-  magenta: (text) => `${colors.magenta}${text}${colors.reset}`
-};
+var output_exports = {};
+__export(output_exports, {
+  Spinner: () => Spinner,
+  c: () => c,
+  formatDuration: () => formatDuration,
+  logCommand: () => logCommand,
+  logError: () => logError,
+  logInfo: () => logInfo,
+  logSuccess: () => logSuccess,
+  logWarning: () => logWarning,
+  showHelp: () => showHelp,
+  showInfo: () => showInfo,
+  showWelcome: () => showWelcome
+});
 function showWelcome(availableProviders, currentProvider, useDirectMode) {
   console.log(c.bold(c.cyan("\n\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")));
   console.log(c.bold(c.cyan("\u2551   ComputeSDK Workbench                               \u2551")));
@@ -139,39 +161,6 @@ function showInfo(state) {
   console.log(`  Uptime: ${formatUptime(state)}`);
   console.log("");
 }
-var Spinner = class {
-  constructor(text) {
-    this.interval = null;
-    this.frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-    this.currentFrame = 0;
-    this.text = text;
-  }
-  start() {
-    process.stdout.write("\x1B[?25l");
-    this.interval = setInterval(() => {
-      const frame = this.frames[this.currentFrame];
-      process.stdout.write(`\r${c.cyan(frame)} ${this.text}`);
-      this.currentFrame = (this.currentFrame + 1) % this.frames.length;
-    }, 80);
-    return this;
-  }
-  succeed(text) {
-    this.stop();
-    console.log(`${c.green("\u2705")} ${text || this.text}`);
-  }
-  fail(text) {
-    this.stop();
-    console.log(`${c.red("\u274C")} ${text || this.text}`);
-  }
-  stop() {
-    if (this.interval) {
-      clearInterval(this.interval);
-      this.interval = null;
-    }
-    process.stdout.write("\r\x1B[K");
-    process.stdout.write("\x1B[?25h");
-  }
-};
 function formatDuration(ms) {
   const seconds = ms / 1e3;
   if (seconds < 1) {
@@ -210,6 +199,9 @@ ${c.bold("Provider Modes:")}
 ${c.bold("Sandbox Management:")}
   ${c.cyan("restart")}                      Restart current sandbox
   ${c.cyan("destroy")}                      Destroy current sandbox
+  ${c.cyan("connect <url> [token]")}        Connect to existing sandbox via URL
+                                ${c.dim("Example: connect https://sandbox-123.localhost:8080")}
+                                ${c.dim("Example: connect https://sandbox-123.localhost:8080 your_token")}
   ${c.cyan("info")}                         Show sandbox info (provider, uptime)
 
 ${c.bold("Environment:")}
@@ -245,6 +237,20 @@ ${c.bold("Running Commands:")}
     ${c.cyan('filesystem.exists("/path")')}
     ${c.cyan('filesystem.remove("/file")')}
   
+  ${c.dim("Named Sandboxes (gateway mode only):")}
+    ${c.cyan("create()")}                          ${c.dim("// Create & switch to new sandbox")}
+    ${c.cyan('create({ namespace: "h" })')}        ${c.dim("// Create with namespace & switch")}
+    ${c.cyan('findOrCreate({ name: "my-app" })')} ${c.dim("// Find or create & switch")}
+    ${c.cyan('find({ name: "my-app" })')}          ${c.dim("// Find existing & switch")}
+    
+    ${c.dim("Note: Prompts before switching if you already have an active sandbox")}
+  
+  ${c.dim("Child Sandboxes (gateway mode only):")}
+    ${c.cyan("child.create()")}            ${c.dim("// Create child sandbox")}
+    ${c.cyan("child.list()")}              ${c.dim("// List all children")}
+    ${c.cyan('child.retrieve("sandbox-id")')} ${c.dim("// Get child info")}
+    ${c.cyan('child.destroy("sandbox-id")')} ${c.dim("// Delete child")}
+  
   ${c.dim("Sandbox Methods:")}
     ${c.cyan("getUrl({ port: 3000 })")}   ${c.dim("// Get public URL")}
     ${c.cyan(`runCode("console.log('hi')", "node")`)}
@@ -280,6 +286,71 @@ function logError(message) {
 function logWarning(message) {
   console.log(c.yellow(`\u26A0\uFE0F  ${message}`));
 }
+function logInfo(message) {
+  console.log(c.blue(`\u2139\uFE0F  ${message}`));
+}
+var colors, c, Spinner;
+var init_output = __esm({
+  "src/cli/output.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_state();
+    colors = {
+      reset: "\x1B[0m",
+      bright: "\x1B[1m",
+      dim: "\x1B[2m",
+      cyan: "\x1B[36m",
+      green: "\x1B[32m",
+      yellow: "\x1B[33m",
+      red: "\x1B[31m",
+      blue: "\x1B[34m",
+      magenta: "\x1B[35m"
+    };
+    c = {
+      bold: (text) => `${colors.bright}${text}${colors.reset}`,
+      dim: (text) => `${colors.dim}${text}${colors.reset}`,
+      cyan: (text) => `${colors.cyan}${text}${colors.reset}`,
+      green: (text) => `${colors.green}${text}${colors.reset}`,
+      yellow: (text) => `${colors.yellow}${text}${colors.reset}`,
+      red: (text) => `${colors.red}${text}${colors.reset}`,
+      blue: (text) => `${colors.blue}${text}${colors.reset}`,
+      magenta: (text) => `${colors.magenta}${text}${colors.reset}`
+    };
+    Spinner = class {
+      constructor(text) {
+        this.interval = null;
+        this.frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+        this.currentFrame = 0;
+        this.text = text;
+      }
+      start() {
+        process.stdout.write("\x1B[?25l");
+        this.interval = setInterval(() => {
+          const frame = this.frames[this.currentFrame];
+          process.stdout.write(`\r${c.cyan(frame)} ${this.text}`);
+          this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+        }, 80);
+        return this;
+      }
+      succeed(text) {
+        this.stop();
+        console.log(`${c.green("\u2705")} ${text || this.text}`);
+      }
+      fail(text) {
+        this.stop();
+        console.log(`${c.red("\u274C")} ${text || this.text}`);
+      }
+      stop() {
+        if (this.interval) {
+          clearInterval(this.interval);
+          this.interval = null;
+        }
+        process.stdout.write("\r\x1B[K");
+        process.stdout.write("\x1B[?25h");
+      }
+    };
+  }
+});
 
 // src/cli/providers.ts
 import {
@@ -287,14 +358,6 @@ import {
   PROVIDER_NAMES as SHARED_PROVIDER_NAMES,
   getProviderConfigFromEnv
 } from "computesdk";
-var PROVIDER_NAMES = [
-  "gateway",
-  ...SHARED_PROVIDER_NAMES
-];
-var PROVIDER_AUTH = {
-  gateway: [["COMPUTESDK_API_KEY"]],
-  ...SHARED_PROVIDER_AUTH
-};
 function getProviderStatus(provider) {
   const authOptions = PROVIDER_AUTH[provider];
   if (typeof process === "undefined") {
@@ -476,29 +539,102 @@ function getProviderConfig(providerName) {
   }
   return getProviderConfigFromEnv(providerName);
 }
+var PROVIDER_NAMES, PROVIDER_AUTH;
+var init_providers = __esm({
+  "src/cli/providers.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_output();
+    PROVIDER_NAMES = [
+      "gateway",
+      ...SHARED_PROVIDER_NAMES
+    ];
+    PROVIDER_AUTH = {
+      gateway: [["COMPUTESDK_API_KEY"]],
+      ...SHARED_PROVIDER_AUTH
+    };
+  }
+});
 
 // src/cli/commands.ts
+var commands_exports = {};
+__export(commands_exports, {
+  cleanupOnExit: () => cleanupOnExit,
+  confirmSandboxSwitch: () => confirmSandboxSwitch,
+  connectToSandbox: () => connectToSandbox,
+  createSandbox: () => createSandbox,
+  defineProviderCommand: () => defineProviderCommand,
+  destroySandbox: () => destroySandbox,
+  ensureSandbox: () => ensureSandbox,
+  getComputeInstance: () => getComputeInstance,
+  restartSandbox: () => restartSandbox,
+  runCommand: () => runCommand,
+  showMode: () => showMode,
+  showVerbose: () => showVerbose,
+  switchProvider: () => switchProvider,
+  toggleMode: () => toggleMode,
+  toggleVerbose: () => toggleVerbose
+});
+import { createCompute } from "@computesdk/provider";
 import * as readline from "readline";
-async function confirm(question) {
+async function confirm(question, defaultYes = false) {
   return new Promise((resolve) => {
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout
     });
     process.stdin.resume();
-    rl.question(`${question} (y/N): `, (answer) => {
+    const promptSuffix = defaultYes ? "(Y/n)" : "(y/N)";
+    rl.question(`${question} ${promptSuffix}: `, (answer) => {
       rl.close();
       const trimmed = answer.trim().toLowerCase();
-      resolve(trimmed === "y" || trimmed === "yes");
+      if (trimmed === "") {
+        resolve(defaultYes);
+      } else {
+        resolve(trimmed === "y" || trimmed === "yes");
+      }
     });
   });
 }
+async function confirmSandboxSwitch(state) {
+  if (!hasSandbox(state)) {
+    return true;
+  }
+  return await confirm("Switch to new sandbox?", true);
+}
 async function ensureSandbox(state) {
   if (hasSandbox(state)) {
     return;
   }
   await createSandbox(state);
 }
+async function getComputeInstance(state) {
+  if (state.compute) {
+    return state.compute;
+  }
+  const providerName = state.currentProvider || autoDetectProvider(false);
+  const useDirect = state.useDirectMode;
+  if (!providerName) {
+    throw new Error("No provider configured.");
+  }
+  let compute2;
+  if (useDirect) {
+    const providerModule = await loadProvider(providerName);
+    const providerFactory = providerModule[providerName];
+    if (!providerFactory) {
+      throw new Error(`Provider ${providerName} does not export a factory function`);
+    }
+    const config = getProviderConfig(providerName);
+    compute2 = createCompute({
+      defaultProvider: providerFactory(config)
+    });
+  } else {
+    const { compute: gatewayCompute } = await import("computesdk");
+    compute2 = gatewayCompute;
+  }
+  state.compute = compute2;
+  return compute2;
+}
 async function createSandbox(state) {
   const providerName = state.currentProvider || autoDetectProvider(false);
   const useDirect = state.useDirectMode;
@@ -528,55 +664,7 @@ async function createSandbox(state) {
   const spinner = new Spinner(`Creating sandbox with ${modeLabel}...`).start();
   const startTime = Date.now();
   try {
-    let compute2;
-    if (useDirect) {
-      const providerModule = await loadProvider(providerName);
-      const providerFactory = providerModule[providerName];
-      if (!providerFactory) {
-        throw new Error(`Provider ${providerName} does not export a factory function`);
-      }
-      const config = getProviderConfig(providerName);
-      compute2 = createCompute({
-        defaultProvider: providerFactory(config)
-      });
-    } else {
-      const gatewayModule = await import("computesdk");
-      const gatewayFactory = gatewayModule.gateway;
-      const providerConfig = getProviderConfig(providerName);
-      const providerHeaders = {};
-      switch (providerName) {
-        case "e2b":
-          if (providerConfig.apiKey) providerHeaders["X-E2B-API-Key"] = providerConfig.apiKey;
-          break;
-        case "railway":
-          if (providerConfig.apiKey) providerHeaders["X-Railway-API-Key"] = providerConfig.apiKey;
-          if (providerConfig.projectId) providerHeaders["X-Railway-Project-ID"] = providerConfig.projectId;
-          if (providerConfig.environmentId) providerHeaders["X-Railway-Environment-ID"] = providerConfig.environmentId;
-          break;
-        case "daytona":
-          if (providerConfig.apiKey) providerHeaders["X-Daytona-API-Key"] = providerConfig.apiKey;
-          break;
-        case "modal":
-          if (providerConfig.tokenId) providerHeaders["X-Modal-Token-ID"] = providerConfig.tokenId;
-          if (providerConfig.tokenSecret) providerHeaders["X-Modal-Token-Secret"] = providerConfig.tokenSecret;
-          break;
-        case "vercel":
-          if (providerConfig.token) providerHeaders["X-Vercel-Token"] = providerConfig.token;
-          if (providerConfig.teamId) providerHeaders["X-Vercel-Team-ID"] = providerConfig.teamId;
-          if (providerConfig.projectId) providerHeaders["X-Vercel-Project-ID"] = providerConfig.projectId;
-          break;
-      }
-      const config = {
-        apiKey: process.env.COMPUTESDK_API_KEY,
-        provider: providerName,
-        // Tell gateway which backend to use
-        providerHeaders
-        // Pass provider credentials via headers
-      };
-      compute2 = createCompute({
-        defaultProvider: gatewayFactory(config)
-      });
-    }
+    const compute2 = await getComputeInstance(state);
     const result = await compute2.sandbox.create();
     const duration = Date.now() - startTime;
     setSandbox(state, result, providerName);
@@ -600,10 +688,6 @@ Install it with: ${c.cyan(`npm install @computesdk/${providerName}`)}
   }
 }
 async function destroySandbox(state) {
-  if (!hasSandbox(state)) {
-    logWarning("No active sandbox");
-    return;
-  }
   const spinner = new Spinner("Destroying sandbox...").start();
   try {
     const sandbox = getCurrentSandbox(state);
@@ -720,6 +804,7 @@ async function switchProvider(state, mode, providerName) {
       await destroySandbox(state);
       state.currentProvider = actualProvider;
       state.useDirectMode = useDirect;
+      state.compute = null;
       const modeStr = useDirect ? `${actualProvider} (direct)` : `${actualProvider} (via gateway)`;
       logSuccess(`Switched to ${modeStr}`);
     } else {
@@ -728,11 +813,12 @@ async function switchProvider(state, mode, providerName) {
   } else {
     state.currentProvider = actualProvider;
     state.useDirectMode = useDirect;
+    state.compute = null;
     const modeStr = useDirect ? `${actualProvider} (direct)` : `${actualProvider} (via gateway)`;
     logSuccess(`Switched to ${modeStr}`);
   }
 }
-function createProviderCommand(state) {
+function defineProviderCommand(state) {
   return async function provider(mode, providerName) {
     if (!mode) {
       if (state.currentProvider) {
@@ -805,6 +891,62 @@ Verbose mode: ${status}`);
 Toggle with: ${c.cyan("verbose")}
 `);
 }
+async function connectToSandbox(state, sandboxUrl, token) {
+  if (!sandboxUrl) {
+    logError("Usage: connect <sandbox_url> [token]");
+    console.log("Example: connect https://sandbox-123.localhost:8080");
+    console.log("Example: connect https://sandbox-123.localhost:8080 your_access_token");
+    return;
+  }
+  const cleanUrl = sandboxUrl.replace(/\/$/, "");
+  if (hasSandbox(state)) {
+    const shouldDestroy = await confirm("Disconnect from current sandbox?");
+    if (!shouldDestroy) {
+      logWarning("Keeping current sandbox. Connection cancelled.");
+      return;
+    }
+    clearSandbox(state);
+  }
+  const spinner = new Spinner(`Connecting to ${cleanUrl}...`).start();
+  const startTime = Date.now();
+  try {
+    const { Sandbox } = await import("computesdk");
+    let WebSocket;
+    try {
+      const wsModule = await import("ws");
+      WebSocket = wsModule.default;
+    } catch {
+      logError('Failed to import "ws" module. Please install it: pnpm add ws');
+      throw new Error('Missing "ws" dependency');
+    }
+    const sandbox = new Sandbox({
+      sandboxUrl: cleanUrl,
+      sandboxId: "",
+      // Will be populated when we get info
+      provider: "connected",
+      // Mark as directly connected
+      token,
+      // Optional access token
+      WebSocket
+    });
+    const info = await sandbox.getInfo();
+    const duration = Date.now() - startTime;
+    setSandbox(state, sandbox, "connected");
+    spinner.succeed(`Connected to sandbox ${c.dim(`(${formatDuration(duration)})`)}`);
+    console.log(c.dim(`Provider: ${info.provider || "unknown"}`));
+    console.log(c.dim(`Sandbox ID: ${info.id || "unknown"}`));
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    spinner.fail(`Failed to connect ${c.dim(`(${formatDuration(duration)})`)}`);
+    if (error instanceof Error) {
+      logError(`Error: ${error.message}`);
+      if (error.stack) {
+        console.log(c.dim(error.stack));
+      }
+    }
+    throw error;
+  }
+}
 async function cleanupOnExit(state, replServer) {
   if (!hasSandbox(state)) {
     return;
@@ -813,6 +955,10 @@ async function cleanupOnExit(state, replServer) {
     replServer.pause();
   }
   console.log("");
+  if (state.currentProvider === "connected") {
+    logWarning("Disconnecting from external sandbox (not destroying).");
+    return;
+  }
   const shouldDestroy = await confirm("Destroy active sandbox?");
   if (shouldDestroy) {
     await destroySandbox(state);
@@ -820,14 +966,36 @@ async function cleanupOnExit(state, replServer) {
     logWarning("Sandbox left running. It may incur costs.");
   }
 }
+var init_commands = __esm({
+  "src/cli/commands.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_state();
+    init_output();
+    init_providers();
+  }
+});
+
+// src/cli/index.ts
+init_esm_shims();
+init_state();
+
+// src/cli/repl.ts
+init_esm_shims();
+init_commands();
+init_output();
+init_providers();
+import * as repl from "repl";
+import * as cmd from "@computesdk/cmd";
 
 // src/cli/types.ts
+init_esm_shims();
 function isCommand(value) {
   return Array.isArray(value) && value.length > 0 && typeof value[0] === "string";
 }
 
 // src/cli/repl.ts
-import * as path from "path";
+import * as path2 from "path";
 import * as os from "os";
 function createREPL(state) {
   const replServer = repl.start({
@@ -925,7 +1093,7 @@ function injectCmdContext(replServer) {
   replServer.context.zsh = cmd.zsh;
 }
 function injectWorkbenchCommands(replServer, state) {
-  replServer.context.provider = createProviderCommand(state);
+  replServer.context.provider = defineProviderCommand(state);
   replServer.context.providers = () => showProviders();
   replServer.context.mode = async (modeName) => {
     if (!modeName) {
@@ -940,6 +1108,9 @@ function injectWorkbenchCommands(replServer, state) {
   replServer.context.destroy = async () => {
     await destroySandbox(state);
   };
+  replServer.context.connect = async (url, token) => {
+    await connectToSandbox(state, url, token);
+  };
   replServer.context.info = () => showInfo(state);
   replServer.context.verbose = () => {
     toggleVerbose(state);
@@ -972,59 +1143,203 @@ function injectWorkbenchCommands(replServer, state) {
     }
     return sandbox.runCode(code, runtime);
   };
+  replServer.context.create = async (options) => {
+    if (state.useDirectMode) {
+      throw new Error('Named sandboxes are only available in gateway mode. Use "mode gateway" to switch.');
+    }
+    const { getComputeInstance: getComputeInstance2, confirmSandboxSwitch: confirmSandboxSwitch2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
+    const { setSandbox: setSandbox2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+    const { logSuccess: logSuccess2 } = await Promise.resolve().then(() => (init_output(), output_exports));
+    const shouldSwitch = await confirmSandboxSwitch2(state);
+    if (!shouldSwitch) {
+      const compute3 = await getComputeInstance2(state);
+      const sandbox2 = await compute3.sandbox.create(options);
+      return {
+        sandboxId: sandbox2.sandboxId,
+        provider: sandbox2.provider,
+        metadata: sandbox2.getInstance().config.metadata || {}
+      };
+    }
+    const compute2 = await getComputeInstance2(state);
+    const sandbox = await compute2.sandbox.create(options);
+    setSandbox2(state, sandbox, sandbox.provider);
+    logSuccess2(`Switched to sandbox ${sandbox.sandboxId}`);
+    return {
+      sandboxId: sandbox.sandboxId,
+      provider: sandbox.provider,
+      metadata: sandbox.getInstance().config.metadata || {}
+    };
+  };
+  replServer.context.findOrCreate = async (options) => {
+    if (state.useDirectMode) {
+      throw new Error('Named sandboxes (findOrCreate) are only available in gateway mode. Use "mode gateway" to switch.');
+    }
+    const { getComputeInstance: getComputeInstance2, confirmSandboxSwitch: confirmSandboxSwitch2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
+    const { setSandbox: setSandbox2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+    const { logSuccess: logSuccess2 } = await Promise.resolve().then(() => (init_output(), output_exports));
+    const shouldSwitch = await confirmSandboxSwitch2(state);
+    if (!shouldSwitch) {
+      const compute3 = await getComputeInstance2(state);
+      const sandbox2 = await compute3.sandbox.findOrCreate(options);
+      return {
+        sandboxId: sandbox2.sandboxId,
+        provider: sandbox2.provider,
+        name: options.name,
+        namespace: options.namespace || "default",
+        metadata: sandbox2.getInstance().config.metadata || {}
+      };
+    }
+    const compute2 = await getComputeInstance2(state);
+    const sandbox = await compute2.sandbox.findOrCreate(options);
+    setSandbox2(state, sandbox, sandbox.provider);
+    logSuccess2(`Switched to sandbox ${sandbox.sandboxId}`);
+    return {
+      sandboxId: sandbox.sandboxId,
+      provider: sandbox.provider,
+      name: options.name,
+      namespace: options.namespace || "default",
+      metadata: sandbox.getInstance().config.metadata || {}
+    };
+  };
+  replServer.context.find = async (options) => {
+    if (state.useDirectMode) {
+      throw new Error('Named sandboxes (find) are only available in gateway mode. Use "mode gateway" to switch.');
+    }
+    const { getComputeInstance: getComputeInstance2, confirmSandboxSwitch: confirmSandboxSwitch2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
+    const { setSandbox: setSandbox2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+    const { logSuccess: logSuccess2 } = await Promise.resolve().then(() => (init_output(), output_exports));
+    const compute2 = await getComputeInstance2(state);
+    const sandbox = await compute2.sandbox.find(options);
+    if (!sandbox) {
+      return null;
+    }
+    const shouldSwitch = await confirmSandboxSwitch2(state);
+    if (!shouldSwitch) {
+      return {
+        sandboxId: sandbox.sandboxId,
+        provider: sandbox.provider,
+        name: options.name,
+        namespace: options.namespace || "default",
+        metadata: sandbox.getInstance().config.metadata || {}
+      };
+    }
+    setSandbox2(state, sandbox, sandbox.provider);
+    logSuccess2(`Switched to sandbox ${sandbox.sandboxId}`);
+    return {
+      sandboxId: sandbox.sandboxId,
+      provider: sandbox.provider,
+      name: options.name,
+      namespace: options.namespace || "default",
+      metadata: sandbox.getInstance().config.metadata || {}
+    };
+  };
   replServer.context.filesystem = {
     get readFile() {
-      return async (path2) => {
+      return async (path3) => {
         const sandbox = state.currentSandbox;
         if (!sandbox) {
           throw new Error("No active sandbox. Run a command to auto-create one.");
         }
-        return sandbox.filesystem.readFile(path2);
+        return sandbox.filesystem.readFile(path3);
       };
     },
     get writeFile() {
-      return async (path2, content) => {
+      return async (path3, content) => {
         const sandbox = state.currentSandbox;
         if (!sandbox) {
           throw new Error("No active sandbox. Run a command to auto-create one.");
         }
-        return sandbox.filesystem.writeFile(path2, content);
+        return sandbox.filesystem.writeFile(path3, content);
       };
     },
     get mkdir() {
-      return async (path2) => {
+      return async (path3) => {
         const sandbox = state.currentSandbox;
         if (!sandbox) {
           throw new Error("No active sandbox. Run a command to auto-create one.");
         }
-        return sandbox.filesystem.mkdir(path2);
+        return sandbox.filesystem.mkdir(path3);
       };
     },
     get readdir() {
-      return async (path2) => {
+      return async (path3) => {
         const sandbox = state.currentSandbox;
         if (!sandbox) {
           throw new Error("No active sandbox. Run a command to auto-create one.");
         }
-        return sandbox.filesystem.readdir(path2);
+        return sandbox.filesystem.readdir(path3);
       };
     },
     get exists() {
-      return async (path2) => {
+      return async (path3) => {
         const sandbox = state.currentSandbox;
         if (!sandbox) {
           throw new Error("No active sandbox. Run a command to auto-create one.");
         }
-        return sandbox.filesystem.exists(path2);
+        return sandbox.filesystem.exists(path3);
       };
     },
     get remove() {
-      return async (path2) => {
+      return async (path3) => {
+        const sandbox = state.currentSandbox;
+        if (!sandbox) {
+          throw new Error("No active sandbox. Run a command to auto-create one.");
+        }
+        return sandbox.filesystem.remove(path3);
+      };
+    }
+  };
+  replServer.context.child = {
+    get create() {
+      return async () => {
+        if (state.useDirectMode) {
+          throw new Error('Child sandboxes are only available in gateway mode. Use "mode gateway" to switch.');
+        }
+        const sandbox = state.currentSandbox;
+        if (!sandbox) {
+          throw new Error("No active sandbox. Run a command to auto-create one.");
+        }
+        const instance = sandbox.getInstance();
+        return instance.child.create();
+      };
+    },
+    get list() {
+      return async () => {
+        if (state.useDirectMode) {
+          throw new Error('Child sandboxes are only available in gateway mode. Use "mode gateway" to switch.');
+        }
+        const sandbox = state.currentSandbox;
+        if (!sandbox) {
+          throw new Error("No active sandbox. Run a command to auto-create one.");
+        }
+        const instance = sandbox.getInstance();
+        return instance.child.list();
+      };
+    },
+    get retrieve() {
+      return async (subdomain) => {
+        if (state.useDirectMode) {
+          throw new Error('Child sandboxes are only available in gateway mode. Use "mode gateway" to switch.');
+        }
+        const sandbox = state.currentSandbox;
+        if (!sandbox) {
+          throw new Error("No active sandbox. Run a command to auto-create one.");
+        }
+        const instance = sandbox.getInstance();
+        return instance.child.retrieve(subdomain);
+      };
+    },
+    get destroy() {
+      return async (subdomain, options) => {
+        if (state.useDirectMode) {
+          throw new Error('Child sandboxes are only available in gateway mode. Use "mode gateway" to switch.');
+        }
         const sandbox = state.currentSandbox;
         if (!sandbox) {
           throw new Error("No active sandbox. Run a command to auto-create one.");
         }
-        return sandbox.filesystem.remove(path2);
+        const instance = sandbox.getInstance();
+        return instance.child.destroy(subdomain, options);
       };
     }
   };
@@ -1038,7 +1353,7 @@ function injectWorkbenchCommands(replServer, state) {
 }
 function setupSmartEvaluator(replServer, state) {
   const originalEval = replServer.eval;
-  const workbenchCommands = /* @__PURE__ */ new Set(["help", "providers", "info", "env", "restart", "destroy", "mode", "verbose", "sandboxInfo"]);
+  const workbenchCommands = /* @__PURE__ */ new Set(["help", "providers", "info", "env", "restart", "destroy", "mode", "verbose", "sandboxInfo", "connect"]);
   replServer.eval = function(cmd3, context, filename, callback) {
     const trimmedCmd = cmd3.trim();
     const providerMatch = trimmedCmd.match(/^provider(?:\s+(direct|gateway))?\s+(\w+)$/);
@@ -1119,6 +1434,8 @@ function setupAutocomplete(replServer, state) {
     "providers": [],
     "restart": [],
     "destroy": [],
+    "connect": [],
+    // Connect takes a URL argument
     "info": [],
     "env": [],
     "help": [],
@@ -1204,7 +1521,7 @@ function setupAutocomplete(replServer, state) {
   };
 }
 function setupHistory(replServer) {
-  const historyFile = path.join(os.homedir(), ".computesdk_workbench_history");
+  const historyFile = path2.join(os.homedir(), ".computesdk_workbench_history");
   replServer.setupHistory(historyFile, (err) => {
     if (err) {
     }
@@ -1212,6 +1529,9 @@ function setupHistory(replServer) {
 }
 
 // src/cli/index.ts
+init_output();
+init_providers();
+init_commands();
 async function startWorkbench() {
   const state = createState();
   state.availableProviders = getAvailableProviders();