@computesdk/workbench 0.1.0

package/dist/index.js

@@ -0,0 +1,883 @@
+// src/cli/state.ts
+function createState() {
+  return {
+    currentProvider: null,
+    currentSandbox: null,
+    sandboxCreatedAt: null,
+    availableProviders: [],
+    forceGatewayMode: false,
+    verbose: false
+  };
+}
+function getCurrentSandbox(state) {
+  if (!state.currentSandbox) {
+    throw new Error("No active sandbox");
+  }
+  return state.currentSandbox;
+}
+function setSandbox(state, sandbox, provider) {
+  state.currentSandbox = sandbox;
+  state.currentProvider = provider;
+  state.sandboxCreatedAt = /* @__PURE__ */ new Date();
+}
+function clearSandbox(state) {
+  state.currentSandbox = null;
+  state.sandboxCreatedAt = null;
+}
+function hasSandbox(state) {
+  return state.currentSandbox !== null;
+}
+function getUptimeSeconds(state) {
+  if (!state.sandboxCreatedAt) return 0;
+  return Math.floor((Date.now() - state.sandboxCreatedAt.getTime()) / 1e3);
+}
+function formatUptime(state) {
+  const seconds = getUptimeSeconds(state);
+  if (seconds < 60) {
+    return `${seconds} second${seconds === 1 ? "" : "s"}`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    return `${minutes} minute${minutes === 1 ? "" : "s"}`;
+  }
+  const hours = Math.floor(minutes / 60);
+  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";
+
+// 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}`
+};
+function showWelcome(availableProviders, currentProvider) {
+  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")));
+  console.log(c.bold(c.cyan("\u255A\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\u255D\n")));
+  if (availableProviders.length > 0) {
+    console.log(`Providers available: ${availableProviders.join(", ")}`);
+    if (currentProvider) {
+      const mode = currentProvider === "gateway" ? "\u{1F310} gateway mode" : "\u{1F517} direct mode";
+      console.log(`Current provider: ${c.green(currentProvider)} (${mode})
+`);
+    } else {
+      console.log(`
+${c.dim('Tip: Use "provider <name>" to select a provider')}
+`);
+    }
+  } else {
+    console.log(c.yellow("\u26A0\uFE0F  No providers detected.\n"));
+    console.log("To get started:");
+    console.log("  1. Copy .env.example to .env");
+    console.log("  2. Add your provider credentials");
+    console.log("  3. Restart workbench\n");
+    console.log(c.dim('Type "env" to see required environment variables\n'));
+  }
+  console.log(c.dim('Type "help" for available commands\n'));
+}
+function showHelp() {
+  console.log(`
+${c.bold("Workbench Commands:")}
+  ${c.cyan("provider <name>")}      Switch provider (gateway, e2b, railway, etc.)
+  ${c.cyan("providers")}            List all providers with status
+  ${c.cyan("mode")}                 Show current mode (gateway vs direct)
+  ${c.cyan("mode gateway")}         Force gateway mode
+  ${c.cyan("mode direct")}          Force direct mode (auto-detect provider)
+  ${c.cyan("restart")}              Restart current sandbox
+  ${c.cyan("destroy")}              Destroy current sandbox  
+  ${c.cyan("info")}                 Show sandbox info
+  ${c.cyan("env")}                  Show environment/credentials status
+  ${c.cyan("verbose")}              Toggle verbose output (show full results)
+  ${c.cyan("help")}                 Show this help
+  ${c.cyan("exit")} or ${c.cyan(".exit")}       Exit workbench
+
+${c.bold("Provider Modes:")}
+  ${c.cyan("gateway")}              \u{1F310} Routes through ComputeSDK API (COMPUTESDK_API_KEY)
+  ${c.cyan("e2b, railway, etc.")}   \u{1F517} Direct connection to provider (requires provider package)
+
+${c.bold("Running Commands:")}
+  Just type any ${c.cyan("@computesdk/cmd")} function:
+    ${c.dim('npm.install("express")')}
+    ${c.dim('git.clone("https://github.com/user/repo")')}
+    ${c.dim('python("script.py")')}
+    ${c.dim('mkdir("/app/src")')}
+    ${c.dim('ls("/home")')}
+  
+  ${c.green("\u2728 Tab autocomplete works for all functions!")}
+
+${c.bold("Background Execution:")}
+  Run commands in the background (returns immediately):
+    ${c.dim('sh("sleep 10", { background: true })')}
+    ${c.dim('sh("npm start", { background: true })')}
+
+${c.bold("Examples:")}
+  ${c.dim("# Install a package")}
+  ${c.cyan('npm.install("express")')}
+  
+  ${c.dim("# Clone a repo")}
+  ${c.cyan('git.clone("https://github.com/user/repo")')}
+  
+  ${c.dim("# Run Python code")}
+  ${c.cyan(`python("-c", "print('hello')")`)}
+  
+  ${c.dim("# Start a server in background")}
+  ${c.cyan('sh("python -m http.server 8000", { background: true })')}
+  
+  ${c.dim("# Switch providers")}
+  ${c.cyan("provider railway")}
+`);
+}
+function showInfo(state) {
+  if (!state.currentSandbox) {
+    console.log(c.yellow("\nNo active sandbox\n"));
+    return;
+  }
+  console.log("\n" + c.bold("Current Sandbox:"));
+  console.log(`  Provider: ${c.green(state.currentProvider || "unknown")}`);
+  console.log(`  Created: ${state.sandboxCreatedAt?.toLocaleString() || "unknown"}`);
+  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) {
+    return `${ms}ms`;
+  }
+  return `${seconds.toFixed(1)}s`;
+}
+function logCommand(command) {
+  console.log(c.dim(`Running: ${command.join(" ")}`));
+}
+function logSuccess(message, duration) {
+  const durationStr = duration ? ` (${formatDuration(duration)})` : "";
+  console.log(c.green(`\u2705 ${message}${durationStr}`));
+}
+function logError(message) {
+  console.log(c.red(`\u274C ${message}`));
+}
+function logWarning(message) {
+  console.log(c.yellow(`\u26A0\uFE0F  ${message}`));
+}
+
+// src/cli/providers.ts
+var PROVIDER_NAMES = [
+  "gateway",
+  "e2b",
+  "railway",
+  "daytona",
+  "modal",
+  "runloop",
+  "vercel",
+  "cloudflare",
+  "codesandbox",
+  "blaxel"
+];
+var PROVIDER_ENV_VARS = {
+  gateway: ["COMPUTESDK_API_KEY"],
+  e2b: ["E2B_API_KEY"],
+  railway: ["RAILWAY_API_KEY", "RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID"],
+  daytona: ["DAYTONA_API_KEY"],
+  modal: ["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"],
+  runloop: ["RUNLOOP_API_KEY"],
+  vercel: ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"],
+  cloudflare: ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"],
+  codesandbox: ["CSB_API_KEY"],
+  blaxel: ["BL_API_KEY", "BL_WORKSPACE"]
+};
+function getProviderStatus(provider) {
+  if (typeof process === "undefined") {
+    return {
+      name: provider,
+      isComplete: false,
+      present: [],
+      missing: [...PROVIDER_ENV_VARS[provider]]
+    };
+  }
+  const requiredVars = PROVIDER_ENV_VARS[provider];
+  const present = requiredVars.filter((varName) => !!process.env?.[varName]);
+  const missing = requiredVars.filter((varName) => !process.env?.[varName]);
+  return {
+    name: provider,
+    isComplete: missing.length === 0,
+    present: [...present],
+    missing: [...missing]
+  };
+}
+function getAvailableProviders() {
+  return PROVIDER_NAMES.filter((provider) => {
+    const status = getProviderStatus(provider);
+    return status.isComplete;
+  });
+}
+function showProviders() {
+  console.log("\n" + c.bold("Provider Status:"));
+  for (const provider of PROVIDER_NAMES) {
+    const status = getProviderStatus(provider);
+    if (status.isComplete) {
+      console.log(`  ${c.green("\u2705")} ${provider} - Ready`);
+    } else if (status.present.length > 0) {
+      const ratio = `${status.present.length}/${status.present.length + status.missing.length}`;
+      console.log(`  ${c.yellow("\u26A0\uFE0F ")} ${provider} - Incomplete (${ratio} credentials)`);
+      console.log(`      ${c.dim("Missing:")} ${status.missing.join(", ")}`);
+    } else {
+      console.log(`  ${c.dim("\u274C")} ${c.dim(provider)} - Not configured`);
+    }
+  }
+  console.log("");
+}
+function showEnv() {
+  console.log("\n" + c.bold("Environment Configuration:"));
+  console.log("");
+  for (const provider of PROVIDER_NAMES) {
+    const status = getProviderStatus(provider);
+    console.log(c.bold(`${provider}:`));
+    if (status.isComplete) {
+      console.log(`  ${c.green("\u2705")} All credentials present`);
+      status.present.forEach((varName) => {
+        console.log(`     ${c.dim("\u2022")} ${varName}`);
+      });
+    } else {
+      if (status.present.length > 0) {
+        console.log(c.dim("  Present:"));
+        status.present.forEach((varName) => {
+          console.log(`    ${c.green("\u2713")} ${varName}`);
+        });
+      }
+      if (status.missing.length > 0) {
+        console.log(c.dim("  Missing:"));
+        status.missing.forEach((varName) => {
+          console.log(`    ${c.red("\u2717")} ${varName}`);
+        });
+      }
+    }
+    console.log("");
+  }
+  console.log(c.dim("Tip: Set credentials in your .env file"));
+  console.log("");
+}
+function autoDetectProvider(forceGatewayMode = false) {
+  const explicit = process.env.COMPUTESDK_PROVIDER?.toLowerCase();
+  if (explicit && isValidProvider(explicit) && isProviderReady(explicit)) {
+    return explicit;
+  }
+  if (forceGatewayMode) {
+    return isProviderReady("gateway") ? "gateway" : null;
+  }
+  for (const provider of PROVIDER_NAMES) {
+    if (isProviderReady(provider)) {
+      return provider;
+    }
+  }
+  return null;
+}
+function isValidProvider(name) {
+  return PROVIDER_NAMES.includes(name);
+}
+function isProviderReady(provider) {
+  if (!isValidProvider(provider)) return false;
+  const status = getProviderStatus(provider);
+  return status.isComplete;
+}
+function getProviderSetupHelp(provider) {
+  if (!isValidProvider(provider)) {
+    return `Unknown provider: ${provider}
+Available: ${PROVIDER_NAMES.join(", ")}`;
+  }
+  const status = getProviderStatus(provider);
+  if (status.isComplete) {
+    return `Provider ${provider} is already configured`;
+  }
+  const lines = [
+    `Provider ${provider} requires these environment variables:`,
+    "",
+    ...status.missing.map((varName) => `  ${varName}`),
+    "",
+    "Add them to your .env file or export them in your shell."
+  ];
+  return lines.join("\n");
+}
+async function loadProvider(providerName) {
+  try {
+    switch (providerName) {
+      case "gateway":
+        return await import("computesdk");
+      case "e2b":
+        return await import("@computesdk/e2b");
+      case "railway":
+        return await import("@computesdk/railway");
+      case "daytona":
+        return await import("@computesdk/daytona");
+      case "modal":
+        return await import("@computesdk/modal");
+      case "runloop":
+        return await import("@computesdk/runloop");
+      case "vercel":
+        return await import("@computesdk/vercel");
+      case "cloudflare":
+        return await import("@computesdk/cloudflare");
+      case "codesandbox":
+        return await import("@computesdk/codesandbox");
+      case "blaxel":
+        return await import("@computesdk/blaxel");
+      default:
+        throw new Error(`Unknown provider: ${providerName}`);
+    }
+  } catch (error) {
+    if (providerName === "gateway") {
+      throw new Error(`Failed to load gateway provider from computesdk package.`);
+    }
+    throw new Error(
+      `Failed to load provider ${providerName}. Make sure to install it: npm install @computesdk/${providerName}`
+    );
+  }
+}
+function getProviderConfig(providerName) {
+  const config = {};
+  const requiredVars = PROVIDER_ENV_VARS[providerName];
+  for (const varName of requiredVars) {
+    const value = process.env[varName];
+    if (value) {
+      config[varName] = value;
+    }
+  }
+  return config;
+}
+
+// src/cli/commands.ts
+import * as readline from "readline";
+async function confirm(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    process.stdin.resume();
+    rl.question(`${question} (y/N): `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      resolve(trimmed === "y" || trimmed === "yes");
+    });
+  });
+}
+async function ensureSandbox(state) {
+  if (hasSandbox(state)) {
+    return;
+  }
+  await createSandbox(state);
+}
+async function createSandbox(state) {
+  const providerName = state.currentProvider || autoDetectProvider(state.forceGatewayMode);
+  if (!providerName) {
+    logError('No provider configured. Run "env" to see setup instructions.');
+    throw new Error("No provider available");
+  }
+  if (!isProviderReady(providerName)) {
+    logError(`Provider ${providerName} is not fully configured.`);
+    console.log(getProviderSetupHelp(providerName));
+    throw new Error("Provider not ready");
+  }
+  const spinner = new Spinner(`Creating sandbox with ${providerName}...`).start();
+  const startTime = Date.now();
+  try {
+    let compute;
+    if (providerName === "gateway") {
+      compute = createCompute();
+    } else {
+      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);
+      compute = createCompute({
+        defaultProvider: providerFactory(config)
+      });
+    }
+    const result = await compute.sandbox.create();
+    const duration = Date.now() - startTime;
+    setSandbox(state, result, providerName);
+    spinner.succeed(`Sandbox ready ${c.dim(`(${formatDuration(duration)})`)}`);
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    spinner.fail(`Failed to create sandbox ${c.dim(`(${formatDuration(duration)})`)}`);
+    if (error instanceof Error && error.message.includes("Cannot find module")) {
+      logError(`Provider package @computesdk/${providerName} is not installed.`);
+      console.log(`
+Install it with: ${c.cyan(`npm install @computesdk/${providerName}`)}
+`);
+    }
+    throw error;
+  }
+}
+async function destroySandbox(state) {
+  if (!hasSandbox(state)) {
+    logWarning("No active sandbox");
+    return;
+  }
+  const spinner = new Spinner("Destroying sandbox...").start();
+  try {
+    const sandbox = getCurrentSandbox(state);
+    await sandbox.destroy();
+    clearSandbox(state);
+    spinner.succeed("Destroyed");
+  } catch (error) {
+    spinner.fail(`Failed to destroy: ${error instanceof Error ? error.message : String(error)}`);
+    throw error;
+  }
+}
+async function restartSandbox(state) {
+  const provider = state.currentProvider;
+  if (hasSandbox(state)) {
+    await destroySandbox(state);
+  }
+  if (provider) {
+    state.currentProvider = provider;
+  }
+  await createSandbox(state);
+}
+async function runCommand(state, command) {
+  await ensureSandbox(state);
+  const sandbox = getCurrentSandbox(state);
+  const startTime = Date.now();
+  logCommand(command);
+  try {
+    const result = await sandbox.runCommand(command[0], command.slice(1));
+    const duration = Date.now() - startTime;
+    if (result.stdout) {
+      console.log(result.stdout.trimEnd());
+    }
+    if (result.stderr) {
+      console.error(c.red(result.stderr.trimEnd()));
+    }
+    const exitCodeInfo = result.exitCode !== 0 ? c.yellow(` (exit ${result.exitCode})`) : "";
+    logSuccess(`${c.dim(`${formatDuration(duration)}`)}${exitCodeInfo}`);
+    if (state.verbose) {
+      return result;
+    }
+    return void 0;
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    logError(`Failed ${c.dim(`(${formatDuration(duration)})`)} - ${error instanceof Error ? error.message : String(error)}`);
+    throw error;
+  }
+}
+async function switchProvider(state, newProvider) {
+  if (!isValidProvider(newProvider)) {
+    logError(`Unknown provider: ${newProvider}`);
+    console.log(`Available providers: e2b, railway, daytona, modal, runloop, vercel, cloudflare, codesandbox, blaxel`);
+    return;
+  }
+  if (!isProviderReady(newProvider)) {
+    logError(`Provider ${newProvider} is not fully configured.`);
+    console.log(getProviderSetupHelp(newProvider));
+    return;
+  }
+  if (hasSandbox(state)) {
+    const shouldDestroy = await confirm("Destroy current sandbox?");
+    if (shouldDestroy) {
+      await destroySandbox(state);
+      state.currentProvider = newProvider;
+      logSuccess(`Switched to ${newProvider}`);
+    } else {
+      logWarning("Keeping current sandbox. Provider remains unchanged.");
+    }
+  } else {
+    state.currentProvider = newProvider;
+    logSuccess(`Switched to ${newProvider}`);
+  }
+}
+function createProviderCommand(state) {
+  return async function provider(name) {
+    if (!name) {
+      if (state.currentProvider) {
+        console.log(`
+Current provider: ${c.green(state.currentProvider)}
+`);
+      } else {
+        console.log(c.yellow("\nNo provider selected\n"));
+      }
+      return;
+    }
+    await switchProvider(state, name);
+  };
+}
+async function toggleMode(state, mode) {
+  const newMode = mode || (state.forceGatewayMode ? "direct" : "gateway");
+  if (newMode === "gateway") {
+    state.forceGatewayMode = true;
+    logSuccess("Switched to gateway mode \u{1F310}");
+    console.log(c.dim("Next sandbox will use gateway (requires COMPUTESDK_API_KEY)\n"));
+    if (hasSandbox(state) && state.currentProvider !== "gateway") {
+      console.log(c.yellow("Current sandbox is in direct mode."));
+      console.log(c.dim('Run "restart" to switch to gateway mode\n'));
+    }
+  } else {
+    state.forceGatewayMode = false;
+    logSuccess("Switched to direct mode \u{1F517}");
+    console.log(c.dim("Next sandbox will use direct provider packages\n"));
+    if (hasSandbox(state) && state.currentProvider === "gateway") {
+      console.log(c.yellow("Current sandbox is in gateway mode."));
+      console.log(c.dim('Run "restart" to switch to direct mode\n'));
+    }
+  }
+}
+function showMode(state) {
+  const mode = state.forceGatewayMode || state.currentProvider === "gateway" ? "gateway" : "direct";
+  const icon = mode === "gateway" ? "\u{1F310}" : "\u{1F517}";
+  console.log(`
+Current mode: ${c.green(mode)} ${icon}`);
+  if (mode === "gateway") {
+    console.log(c.dim("Routes through ComputeSDK API (requires COMPUTESDK_API_KEY)"));
+  } else {
+    console.log(c.dim("Direct connection to providers (requires provider packages)"));
+  }
+  console.log(`
+Toggle with: ${c.cyan("mode gateway")} or ${c.cyan("mode direct")}
+`);
+}
+function toggleVerbose(state) {
+  state.verbose = !state.verbose;
+  if (state.verbose) {
+    logSuccess("Verbose mode enabled - will show full command results");
+    console.log(c.dim("Commands will return full result objects with metadata\n"));
+  } else {
+    logSuccess("Verbose mode disabled - showing clean output only");
+    console.log(c.dim("Commands will only show stdout/stderr\n"));
+  }
+}
+function showVerbose(state) {
+  const status = state.verbose ? c.green("enabled") : c.dim("disabled");
+  console.log(`
+Verbose mode: ${status}`);
+  if (state.verbose) {
+    console.log(c.dim("Commands return full result objects with metadata"));
+  } else {
+    console.log(c.dim("Commands show only stdout/stderr"));
+  }
+  console.log(`
+Toggle with: ${c.cyan("verbose")}
+`);
+}
+async function cleanupOnExit(state, replServer) {
+  if (!hasSandbox(state)) {
+    return;
+  }
+  if (replServer) {
+    replServer.pause();
+  }
+  console.log("");
+  const shouldDestroy = await confirm("Destroy active sandbox?");
+  if (shouldDestroy) {
+    await destroySandbox(state);
+  } else {
+    logWarning("Sandbox left running. It may incur costs.");
+  }
+}
+
+// src/cli/types.ts
+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 os from "os";
+function createREPL(state) {
+  const replServer = repl.start({
+    prompt: "workbench> ",
+    useColors: true,
+    terminal: true,
+    useGlobal: false,
+    ignoreUndefined: true
+  });
+  injectCmdContext(replServer);
+  injectWorkbenchCommands(replServer, state);
+  setupSmartEvaluator(replServer, state);
+  setupAutocomplete(replServer, state);
+  setupHistory(replServer);
+  return replServer;
+}
+function injectCmdContext(replServer) {
+  replServer.context.npm = cmd.npm;
+  replServer.context.pnpm = cmd.pnpm;
+  replServer.context.yarn = cmd.yarn;
+  replServer.context.bun = cmd.bun;
+  replServer.context.pip = cmd.pip;
+  replServer.context.uv = cmd.uv;
+  replServer.context.poetry = cmd.poetry;
+  replServer.context.pipx = cmd.pipx;
+  replServer.context.npx = cmd.npx;
+  replServer.context.bunx = cmd.bunx;
+  replServer.context.deno = cmd.deno;
+  replServer.context.git = cmd.git;
+  replServer.context.mkdir = cmd.mkdir;
+  replServer.context.rm = cmd.rm;
+  replServer.context.cp = cmd.cp;
+  replServer.context.mv = cmd.mv;
+  replServer.context.ls = cmd.ls;
+  replServer.context.pwd = cmd.pwd;
+  replServer.context.chmod = cmd.chmod;
+  replServer.context.chown = cmd.chown;
+  replServer.context.touch = cmd.touch;
+  replServer.context.cat = cmd.cat;
+  replServer.context.ln = cmd.ln;
+  replServer.context.readlink = cmd.readlink;
+  replServer.context.test = cmd.test;
+  replServer.context.rsync = cmd.rsync;
+  replServer.context.node = cmd.node;
+  replServer.context.python = cmd.python;
+  replServer.context.kill = cmd.kill;
+  replServer.context.pkill = cmd.pkill;
+  replServer.context.ps = cmd.ps;
+  replServer.context.timeout = cmd.timeout;
+  replServer.context.curl = cmd.curl;
+  replServer.context.wget = cmd.wget;
+  replServer.context.port = cmd.port;
+  replServer.context.net = cmd.net;
+  replServer.context.grep = cmd.grep;
+  replServer.context.sed = cmd.sed;
+  replServer.context.head = cmd.head;
+  replServer.context.tail = cmd.tail;
+  replServer.context.wc = cmd.wc;
+  replServer.context.sort = cmd.sort;
+  replServer.context.uniq = cmd.uniq;
+  replServer.context.jq = cmd.jq;
+  replServer.context.xargs = cmd.xargs;
+  replServer.context.awk = cmd.awk;
+  replServer.context.cut = cmd.cut;
+  replServer.context.tr = cmd.tr;
+  replServer.context.tar = cmd.tar;
+  replServer.context.unzip = cmd.unzip;
+  replServer.context.echo = cmd.echo;
+  replServer.context.env = cmd.env;
+  replServer.context.printenv = cmd.printenv;
+  replServer.context.which = cmd.which;
+  replServer.context.whoami = cmd.whoami;
+  replServer.context.uname = cmd.uname;
+  replServer.context.hostname = cmd.hostname;
+  replServer.context.df = cmd.df;
+  replServer.context.du = cmd.du;
+  replServer.context.sleep = cmd.sleep;
+  replServer.context.date = cmd.date;
+  replServer.context.find = cmd.find;
+  replServer.context.tee = cmd.tee;
+  replServer.context.diff = cmd.diff;
+  replServer.context.parallel = cmd.parallel;
+  replServer.context.raw = cmd.raw;
+  replServer.context.base64 = cmd.base64;
+  replServer.context.md5sum = cmd.md5sum;
+  replServer.context.sha256sum = cmd.sha256sum;
+  replServer.context.sha1sum = cmd.sha1sum;
+  replServer.context.cmd = cmd.cmd;
+  replServer.context.shell = cmd.shell;
+  replServer.context.sh = cmd.sh;
+  replServer.context.bash = cmd.bash;
+  replServer.context.zsh = cmd.zsh;
+}
+function injectWorkbenchCommands(replServer, state) {
+  replServer.context.provider = createProviderCommand(state);
+  replServer.context.providers = () => showProviders();
+  replServer.context.mode = async (modeName) => {
+    if (!modeName) {
+      showMode(state);
+    } else {
+      await toggleMode(state, modeName);
+    }
+  };
+  replServer.context.restart = async () => {
+    await restartSandbox(state);
+  };
+  replServer.context.destroy = async () => {
+    await destroySandbox(state);
+  };
+  replServer.context.info = () => showInfo(state);
+  replServer.context.verbose = () => {
+    toggleVerbose(state);
+    showVerbose(state);
+  };
+  replServer.context.bg = (command) => {
+    const cmdArray = typeof command === "string" ? ["sh", "-c", command] : command;
+    return cmd.sh(cmdArray, { background: true });
+  };
+  replServer.context.env = () => showEnv();
+  replServer.context.help = showHelp;
+}
+function setupSmartEvaluator(replServer, state) {
+  const originalEval = replServer.eval;
+  const workbenchCommands = /* @__PURE__ */ new Set(["help", "providers", "info", "env", "restart", "destroy", "mode", "verbose"]);
+  replServer.eval = function(cmd3, context, filename, callback) {
+    const trimmedCmd = cmd3.trim();
+    const providerMatch = trimmedCmd.match(/^provider\s+(\w+)$/);
+    if (providerMatch) {
+      const providerName = providerMatch[1];
+      const providerCmd = `await provider('${providerName}')`;
+      originalEval.call(this, providerCmd, context, filename, callback);
+      return;
+    }
+    const modeMatch = trimmedCmd.match(/^mode\s+(gateway|direct)$/);
+    if (modeMatch) {
+      const modeName = modeMatch[1];
+      const modeCmd = `await mode('${modeName}')`;
+      originalEval.call(this, modeCmd, context, filename, callback);
+      return;
+    }
+    originalEval.call(this, cmd3, context, filename, async (err, result) => {
+      if (err) {
+        callback(err, void 0);
+        return;
+      }
+      if (isCommand(result)) {
+        try {
+          const output = await runCommand(state, result);
+          callback(null, output);
+        } catch (error) {
+          callback(error, void 0);
+        }
+        return;
+      }
+      if (typeof result === "function" && workbenchCommands.has(trimmedCmd)) {
+        try {
+          const output = await result();
+          callback(null, output);
+        } catch (error) {
+          callback(error, void 0);
+        }
+        return;
+      }
+      callback(null, result);
+    });
+  };
+}
+function setupAutocomplete(replServer, state) {
+  const originalCompleter = replServer.completer;
+  const workbenchCommands = {
+    "provider": [...PROVIDER_NAMES],
+    // Use actual provider names from config
+    "mode": ["gateway", "direct"],
+    "providers": [],
+    "restart": [],
+    "destroy": [],
+    "info": [],
+    "env": [],
+    "help": [],
+    "verbose": [],
+    "exit": [],
+    ".exit": []
+  };
+  replServer.completer = function(line, callback) {
+    const trimmed = line.trim();
+    if (!trimmed.includes(" ") && !trimmed.includes(".")) {
+      const commands = Object.keys(workbenchCommands);
+      const hits = commands.filter((cmd3) => cmd3.startsWith(trimmed));
+      if (originalCompleter) {
+        originalCompleter.call(replServer, line, (err, [contextHits, partial]) => {
+          if (err) {
+            callback(null, [hits, trimmed]);
+            return;
+          }
+          const allHits = [.../* @__PURE__ */ new Set([...hits, ...contextHits])].sort();
+          callback(null, [allHits, partial]);
+        });
+        return;
+      }
+      callback(null, [hits.length ? hits : commands, trimmed]);
+      return;
+    }
+    const parts = trimmed.split(/\s+/);
+    if (parts.length === 2 && !trimmed.includes(".")) {
+      const [command, partial] = parts;
+      const suggestions = workbenchCommands[command];
+      if (suggestions && suggestions.length > 0) {
+        const hits = suggestions.filter((s) => s.startsWith(partial)).map((s) => `${command} ${s}`);
+        callback(null, [hits.length ? hits : suggestions.map((s) => `${command} ${s}`), trimmed]);
+        return;
+      }
+    }
+    if (originalCompleter) {
+      originalCompleter.call(replServer, line, callback);
+    } else {
+      callback(null, [[], line]);
+    }
+  };
+}
+function setupHistory(replServer) {
+  const historyFile = path.join(os.homedir(), ".computesdk_workbench_history");
+  replServer.setupHistory(historyFile, (err) => {
+    if (err) {
+    }
+  });
+}
+
+// src/cli/index.ts
+async function startWorkbench() {
+  const state = createState();
+  state.availableProviders = getAvailableProviders();
+  state.currentProvider = autoDetectProvider();
+  showWelcome(state.availableProviders, state.currentProvider);
+  const replServer = createREPL(state);
+  replServer.on("exit", async () => {
+    await cleanupOnExit(state, replServer);
+    process.exit(0);
+  });
+}
+export {
+  startWorkbench
+};
+//# sourceMappingURL=index.js.map