@computesdk/workbench 3.1.4 → 3.1.6

package/README.md

@@ -316,6 +316,67 @@ BL_WORKSPACE=xxx
 - **Auto-create**: First command automatically creates a sandbox
 - **Stay in context**: Workbench maintains "current sandbox" - no IDs to track
 
+## Debugging SDK Tests
+
+The workbench is a full Node.js REPL with the ComputeSDK pre-loaded. You can reproduce any SDK test by calling the same methods interactively.
+
+### SDK to Workbench Mapping
+
+| SDK Test Code | Workbench Equivalent |
+|---------------|---------------------|
+| `sandbox.runCommand('echo hi')` | `runCommand('echo hi')` or `getInstance().runCommand(...)` |
+| `sandbox.terminal.create()` | `terminal.create()` |
+| `sandbox.filesystem.readFile(path)` | `filesystem.readFile(path)` |
+| `sandbox.getInfo()` | `sandboxInfo()` |
+| `sandbox.getUrl({ port })` | `getUrl({ port: 3000 })` |
+
+### Example: Reproducing a Failing Test
+
+If this test fails:
+
+```typescript
+// From provider-compatibility.test.ts
+it('command with streaming callbacks', async () => {
+  let stdoutCalled = false;
+  const result = await sandbox.runCommand('echo "hello"', {
+    onStdout: () => { stdoutCalled = true; },
+  });
+  expect(stdoutCalled).toBe(true);
+});
+```
+
+Reproduce it in workbench:
+
+```javascript
+> ls('/home')  // Auto-creates sandbox
+> const sandbox = getInstance()
+> let stdoutCalled = false
+> const result = await sandbox.runCommand('echo "hello"', {
+    onStdout: (data) => { console.log('STDOUT:', data); stdoutCalled = true }
+  })
+> stdoutCalled  // Should be true
+> result
+```
+
+### Verbose Mode
+
+Enable verbose mode to see full response objects and WebSocket debug info:
+
+```javascript
+> verbose()  // Toggle on - shows full results and WebSocket frames
+> ls('/home')
+> verbose()  // Toggle off
+```
+
+### Direct Shell Commands
+
+Prefix with `$` to run shell commands directly (bypasses `@computesdk/cmd`):
+
+```javascript
+> $echo "hello" | tr 'a-z' 'A-Z'
+> $for i in 1 2 3; do echo $i; done
+```
+
 ## License
 
 MIT

package/dist/bin/workbench.js

@@ -42,6 +42,7 @@ function createState() {
     useDirectMode: false,
     // Default to gateway mode
     verbose: false,
+    // Enabled automatically for local provider
     compute: null
   };
 }
@@ -118,21 +119,27 @@ __export(output_exports, {
   showInfo: () => showInfo,
   showWelcome: () => showWelcome
 });
-function showWelcome(availableProviders, currentProvider, useDirectMode) {
+function showWelcome(availableProviders, currentProvider, useDirectMode, localDaemonRunning = false) {
   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")));
   console.log(c.dim("Prompt shows connection status: > (disconnected) or provider:sandbox> (connected)\n"));
+  if (localDaemonRunning) {
+    console.log(c.green("Local daemon detected - auto-connecting...\n"));
+  }
   if (availableProviders.length > 0) {
     const backendProviders = availableProviders.filter((p) => p !== "gateway");
     console.log(`Providers available: ${backendProviders.join(", ")}`);
     if (currentProvider) {
-      if (useDirectMode) {
-        console.log(`Current provider: ${c.green(currentProvider)} (\u{1F517} direct mode)
+      if (currentProvider === "local") {
+        console.log(`Current provider: ${c.green("local")} (local daemon)
+`);
+      } else if (useDirectMode) {
+        console.log(`Current provider: ${c.green(currentProvider)} (direct mode)
 `);
       } else {
         const backendProvider = currentProvider === "gateway" ? backendProviders[0] || "auto" : currentProvider;
-        console.log(`Current provider: ${c.green(backendProvider)} (\u{1F310} via gateway)
+        console.log(`Current provider: ${c.green(backendProvider)} (via gateway)
 `);
       }
     } else {
@@ -141,7 +148,7 @@ ${c.dim('Tip: Use "provider <name>" to select a provider')}
 `);
     }
   } else {
-    console.log(c.yellow("\u26A0\uFE0F  No providers detected.\n"));
+    console.log(c.yellow("No providers detected.\n"));
     console.log("To get started:");
     console.log("  1. Copy .env.example to .env");
     console.log("  2. Add your provider credentials");
@@ -204,10 +211,14 @@ ${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.cyan("connect <url> [token]")}        Connect to sandbox via URL
+
+${c.bold("Local Daemon:")}
+  ${c.cyan("provider local")}               Connect to local daemon's main sandbox
+  ${c.cyan("provider local list")}          List local sandboxes
+  ${c.cyan("provider local <subdomain>")}   Connect to specific local sandbox
+                                ${c.dim("Example: provider local separate-snail-qkktux")}
 
 ${c.bold("Environment:")}
   ${c.cyan("env")}                          Show environment/credentials status
@@ -262,6 +273,24 @@ ${c.bold("Running Commands:")}
     ${c.cyan("sandboxInfo()")}            ${c.dim("// Get sandbox details")}
     ${c.cyan("getInstance()")}            ${c.dim("// Get native instance")}
   
+  ${c.dim("Terminal (PTY & Exec):")}
+    ${c.cyan("terminal.create({ pty: true })")}   ${c.dim("// Create PTY terminal")}
+    ${c.cyan("terminal.create({ pty: false })")}  ${c.dim("// Create exec terminal")}
+    ${c.cyan("terminal.list()")}                  ${c.dim("// List all terminals")}
+    ${c.cyan("terminal.retrieve(id)")}            ${c.dim("// Get terminal by ID")}
+    ${c.cyan("terminal.destroy(id)")}             ${c.dim("// Close terminal by ID")}
+    
+    ${c.dim("PTY Terminal:")}
+      ${c.cyan("term = terminal.create({ pty: true })")}
+      ${c.cyan('term.on("output", (data) => console.log(data))')}
+      ${c.cyan('term.write("echo hello\\n")')}
+      ${c.cyan("term.destroy()")}
+    
+    ${c.dim("Exec Terminal:")}
+      ${c.cyan("exec = terminal.create({ pty: false })")}
+      ${c.cyan('cmd = exec.command.run("ls -la")')}
+      ${c.cyan("cmd.stdout")}  ${c.dim("// view output")}
+  
   ${c.dim('Note: No need to use "await" - promises are auto-awaited!')}
   
   ${c.dim("Compute CLI:")}
@@ -566,12 +595,15 @@ var commands_exports = {};
 __export(commands_exports, {
   cleanupOnExit: () => cleanupOnExit,
   confirmSandboxSwitch: () => confirmSandboxSwitch,
+  connectToLocal: () => connectToLocal,
   connectToSandbox: () => connectToSandbox,
   createSandbox: () => createSandbox,
   defineProviderCommand: () => defineProviderCommand,
   destroySandbox: () => destroySandbox,
   ensureSandbox: () => ensureSandbox,
   getComputeInstance: () => getComputeInstance,
+  isLocalDaemonRunning: () => isLocalDaemonRunning,
+  listLocalSandboxes: () => listLocalSandboxes,
   restartSandbox: () => restartSandbox,
   runCommand: () => runCommand,
   showMode: () => showMode,
@@ -582,31 +614,58 @@ __export(commands_exports, {
 });
 import { createCompute } from "@computesdk/provider";
 import { escapeArgs } from "@computesdk/cmd";
-import * as readline from "readline";
-async function confirm(question, defaultYes = false) {
-  return new Promise((resolve) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
+async function confirm(question, defaultYes = false, _state) {
+  const promptSuffix = defaultYes ? "(Y/n)" : "(y/N)";
+  process.stdout.write(`${question} ${promptSuffix}: `);
+  if (process.stdin.isPaused()) {
     process.stdin.resume();
-    const promptSuffix = defaultYes ? "(Y/n)" : "(y/N)";
-    rl.question(`${question} ${promptSuffix}: `, (answer) => {
-      rl.close();
-      const trimmed = answer.trim().toLowerCase();
-      if (trimmed === "") {
+  }
+  return new Promise((resolve) => {
+    const wasRaw = process.stdin.isRaw;
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    const cleanup = (restoreRaw) => {
+      process.stdin.removeListener("data", onData);
+      if (process.stdin.isTTY && restoreRaw) {
+        process.stdin.setRawMode(wasRaw || false);
+      }
+    };
+    const onData = (key) => {
+      const char = key.toString();
+      if (char === "") {
+        process.stdout.write("^C\n");
+        cleanup(true);
+        resolve(false);
+        return;
+      }
+      if (char === "\r" || char === "\n") {
+        process.stdout.write(defaultYes ? "Y\n" : "N\n");
+        cleanup(true);
         resolve(defaultYes);
-      } else {
-        resolve(trimmed === "y" || trimmed === "yes");
+        return;
       }
-    });
+      if (char === "y" || char === "Y") {
+        process.stdout.write("y\n");
+        cleanup(true);
+        resolve(true);
+        return;
+      }
+      if (char === "n" || char === "N") {
+        process.stdout.write("n\n");
+        cleanup(true);
+        resolve(false);
+        return;
+      }
+    };
+    process.stdin.on("data", onData);
   });
 }
 async function confirmSandboxSwitch(state) {
   if (!hasSandbox(state)) {
     return true;
   }
-  return await confirm("Switch to new sandbox?", true);
+  return await confirm("Switch to new sandbox?", true, state);
 }
 async function ensureSandbox(state) {
   if (hasSandbox(state)) {
@@ -768,6 +827,14 @@ function isStaleConnectionError(error) {
   return stalePhrases.some((phrase) => message.includes(phrase));
 }
 async function switchProvider(state, mode, providerName) {
+  if (mode === "local") {
+    if (providerName === "list") {
+      await listLocalSandboxes();
+      return;
+    }
+    await connectToLocal(state, providerName);
+    return;
+  }
   let useDirect = false;
   let actualProvider = mode;
   if (mode === "direct") {
@@ -792,7 +859,7 @@ async function switchProvider(state, mode, providerName) {
   }
   if (!isValidProvider(actualProvider)) {
     logError(`Unknown provider: ${actualProvider}`);
-    console.log(`Available providers: e2b, railway, daytona, modal, runloop, vercel, cloudflare, codesandbox, blaxel`);
+    console.log(`Available providers: e2b, railway, daytona, modal, runloop, vercel, cloudflare, codesandbox, blaxel, local`);
     return;
   }
   if (!useDirect && !isProviderReady("gateway")) {
@@ -806,7 +873,7 @@ async function switchProvider(state, mode, providerName) {
     return;
   }
   if (hasSandbox(state)) {
-    const shouldDestroy = await confirm("Destroy current sandbox?");
+    const shouldDestroy = await confirm("Destroy current sandbox?", false, state);
     if (shouldDestroy) {
       await destroySandbox(state);
       state.currentProvider = actualProvider;
@@ -829,7 +896,7 @@ function defineProviderCommand(state) {
   return async function provider(mode, providerName) {
     if (!mode) {
       if (state.currentProvider) {
-        const modeStr = state.useDirectMode ? "direct" : "via gateway";
+        const modeStr = state.useDirectMode ? "direct" : state.currentProvider === "local" ? "local daemon" : "via gateway";
         console.log(`
 Current provider: ${c.green(state.currentProvider)} (${modeStr})
 `);
@@ -907,8 +974,8 @@ async function connectToSandbox(state, sandboxUrl, token) {
   }
   const cleanUrl = sandboxUrl.replace(/\/$/, "");
   if (hasSandbox(state)) {
-    const shouldDestroy = await confirm("Disconnect from current sandbox?");
-    if (!shouldDestroy) {
+    const shouldDisconnect = await confirm("Disconnect from current sandbox?", false, state);
+    if (!shouldDisconnect) {
       logWarning("Keeping current sandbox. Connection cancelled.");
       return;
     }
@@ -954,6 +1021,125 @@ async function connectToSandbox(state, sandboxUrl, token) {
     throw error;
   }
 }
+async function readLocalConfig() {
+  const os2 = await import("os");
+  const fs2 = await import("fs/promises");
+  const path4 = await import("path");
+  const configPath = path4.join(os2.homedir(), ".compute", "config.json");
+  try {
+    const content = await fs2.readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function isLocalDaemonRunning() {
+  const os2 = await import("os");
+  const fs2 = await import("fs/promises");
+  const path4 = await import("path");
+  const pidPath = path4.join(os2.homedir(), ".compute", "compute.pid");
+  try {
+    const pidContent = await fs2.readFile(pidPath, "utf-8");
+    const pid = parseInt(pidContent.trim(), 10);
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listLocalSandboxes() {
+  const config2 = await readLocalConfig();
+  if (!config2) {
+    logError("No local daemon config found at ~/.compute/config.json");
+    console.log(c.dim('Run "compute start" to start the local daemon'));
+    return;
+  }
+  const isRunning = await isLocalDaemonRunning();
+  console.log("");
+  console.log(c.bold("Local Daemon Status:"), isRunning ? c.green("Running") : c.red("Stopped"));
+  console.log("");
+  if (!config2.sandboxes || config2.sandboxes.length === 0) {
+    console.log(c.dim("No sandboxes found"));
+    return;
+  }
+  console.log(c.bold("Sandboxes:"));
+  for (const sandbox of config2.sandboxes) {
+    const isMain = sandbox.subdomain === config2.main_subdomain;
+    const mainLabel = isMain ? c.green(" (main)") : "";
+    console.log(`  ${c.cyan(sandbox.subdomain)}${mainLabel}`);
+    console.log(c.dim(`    https://${sandbox.subdomain}.sandbox.computesdk.com`));
+  }
+  console.log("");
+  console.log(c.dim(`Connect with: local ${config2.main_subdomain}`));
+  console.log("");
+}
+async function connectToLocal(state, subdomain) {
+  const config2 = await readLocalConfig();
+  if (!config2) {
+    logError("No local daemon config found at ~/.compute/config.json");
+    console.log(c.dim('Run "compute start" to start the local daemon'));
+    return;
+  }
+  const isRunning = await isLocalDaemonRunning();
+  if (!isRunning) {
+    logError("Local daemon is not running");
+    console.log(c.dim('Run "compute start" to start the local daemon'));
+    return;
+  }
+  const targetSubdomain = subdomain || config2.main_subdomain;
+  const sandbox = config2.sandboxes.find((s) => s.subdomain === targetSubdomain);
+  if (!sandbox) {
+    logError(`Sandbox "${targetSubdomain}" not found`);
+    console.log(c.dim('Run "local list" to see available sandboxes'));
+    return;
+  }
+  const sandboxUrl = `https://${targetSubdomain}.sandbox.computesdk.com`;
+  const token = config2.access_token;
+  if (hasSandbox(state)) {
+    const shouldDisconnect = await confirm("Disconnect from current sandbox?", false, state);
+    if (!shouldDisconnect) {
+      logWarning("Keeping current sandbox. Connection cancelled.");
+      return;
+    }
+    clearSandbox(state);
+  }
+  const spinner = new Spinner(`Connecting to local sandbox ${targetSubdomain}...`).start();
+  const startTime = Date.now();
+  try {
+    const { Sandbox } = await import("computesdk");
+    let WebSocket;
+    try {
+      const wsModule = await import("ws");
+      WebSocket = wsModule.default;
+    } catch {
+      spinner.fail('Failed to import "ws" module');
+      logError("Please install ws: pnpm add ws");
+      throw new Error('Missing "ws" dependency');
+    }
+    const sandboxInstance = new Sandbox({
+      sandboxUrl,
+      sandboxId: targetSubdomain,
+      provider: "local",
+      token,
+      WebSocket
+    });
+    const info = await sandboxInstance.getInfo();
+    const duration = Date.now() - startTime;
+    setSandbox(state, sandboxInstance, "local");
+    state.verbose = true;
+    spinner.succeed(`Connected to local sandbox ${c.dim(`(${formatDuration(duration)})`)}`);
+    console.log(c.dim(`Sandbox: ${targetSubdomain}`));
+    console.log(c.dim(`URL: ${sandboxUrl}`));
+    console.log(c.dim(`Verbose mode: enabled (for debugging)`));
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    spinner.fail(`Failed to connect ${c.dim(`(${formatDuration(duration)})`)}`);
+    if (error instanceof Error) {
+      logError(`Error: ${error.message}`);
+    }
+    throw error;
+  }
+}
 async function cleanupOnExit(state, replServer) {
   if (!hasSandbox(state)) {
     return;
@@ -966,7 +1152,7 @@ async function cleanupOnExit(state, replServer) {
     logWarning("Disconnecting from external sandbox (not destroying).");
     return;
   }
-  const shouldDestroy = await confirm("Destroy active sandbox?");
+  const shouldDestroy = await confirm("Destroy active sandbox?", false, state);
   if (shouldDestroy) {
     await destroySandbox(state);
   } else {
@@ -1360,6 +1546,59 @@ function injectWorkbenchCommands(replServer, state) {
       };
     }
   };
+  replServer.context.terminal = {
+    get create() {
+      return async (options) => {
+        const sandbox = state.currentSandbox;
+        if (!sandbox) {
+          throw new Error("No active sandbox. Run a command to auto-create one.");
+        }
+        const term = await sandbox.terminal.create(options);
+        if (state.verbose) {
+          if (term._ws) {
+            term._ws.config.debug = true;
+          }
+          term.on("output", (data) => {
+            console.log("[terminal:output]", JSON.stringify(data));
+          });
+          term.on("error", (error) => {
+            console.log("[terminal:error]", error);
+          });
+          term.on("destroyed", () => {
+            console.log("[terminal:destroyed]");
+          });
+        }
+        return term;
+      };
+    },
+    get list() {
+      return async () => {
+        const sandbox = state.currentSandbox;
+        if (!sandbox) {
+          throw new Error("No active sandbox. Run a command to auto-create one.");
+        }
+        return sandbox.terminal.list();
+      };
+    },
+    get retrieve() {
+      return async (id) => {
+        const sandbox = state.currentSandbox;
+        if (!sandbox) {
+          throw new Error("No active sandbox. Run a command to auto-create one.");
+        }
+        return sandbox.terminal.retrieve(id);
+      };
+    },
+    get destroy() {
+      return async (id) => {
+        const sandbox = state.currentSandbox;
+        if (!sandbox) {
+          throw new Error("No active sandbox. Run a command to auto-create one.");
+        }
+        return sandbox.terminal.destroy(id);
+      };
+    }
+  };
   replServer.context.getInstance = () => {
     const sandbox = state.currentSandbox;
     if (!sandbox) {
@@ -1373,6 +1612,13 @@ function setupSmartEvaluator(replServer, state) {
   const workbenchCommands = /* @__PURE__ */ new Set(["help", "providers", "info", "env", "restart", "destroy", "mode", "verbose", "sandboxInfo", "connect"]);
   replServer.eval = function(cmd2, context, filename, callback) {
     const trimmedCmd = cmd2.trim();
+    const providerLocalMatch = trimmedCmd.match(/^provider\s+local(?:\s+(\S+))?$/);
+    if (providerLocalMatch) {
+      const arg = providerLocalMatch[1];
+      const providerCmd = arg ? `await provider('local', '${arg}')` : `await provider('local')`;
+      originalEval.call(this, providerCmd, context, filename, callback);
+      return;
+    }
     const providerMatch = trimmedCmd.match(/^provider(?:\s+(direct|gateway))?\s+(\w+)$/);
     if (providerMatch) {
       const mode = providerMatch[1] || null;
@@ -1445,8 +1691,8 @@ function setupSmartEvaluator(replServer, state) {
 function setupAutocomplete(replServer, state) {
   const originalCompleter = replServer.completer;
   const workbenchCommands = {
-    "provider": [...PROVIDER_NAMES],
-    // Use actual provider names from config
+    "provider": [...PROVIDER_NAMES, "local"],
+    // Include 'local' as a provider option
     "mode": ["gateway", "direct"],
     "providers": [],
     "restart": [],
@@ -1551,22 +1797,38 @@ init_providers();
 init_commands();
 async function startWorkbench() {
   const state = createState();
+  const localDaemonRunning = await isLocalDaemonRunning();
   state.availableProviders = getAvailableProviders();
+  if (localDaemonRunning) {
+    state.availableProviders.push("local");
+  }
   const detectedProvider = autoDetectProvider();
-  const hasGateway = state.availableProviders.includes("gateway");
-  const backendProviders = state.availableProviders.filter((p) => p !== "gateway");
-  if (hasGateway && backendProviders.length > 0) {
-    state.currentProvider = backendProviders[0] || "e2b";
+  if (localDaemonRunning) {
+    state.currentProvider = "local";
     state.useDirectMode = false;
-  } else if (backendProviders.length > 0) {
-    state.currentProvider = backendProviders[0];
-    state.useDirectMode = true;
+    state.verbose = true;
   } else {
-    state.currentProvider = detectedProvider;
-    state.useDirectMode = false;
+    const hasGateway = state.availableProviders.includes("gateway");
+    const backendProviders = state.availableProviders.filter((p) => p !== "gateway" && p !== "local");
+    if (hasGateway && backendProviders.length > 0) {
+      state.currentProvider = backendProviders[0] || "e2b";
+      state.useDirectMode = false;
+    } else if (backendProviders.length > 0) {
+      state.currentProvider = backendProviders[0];
+      state.useDirectMode = true;
+    } else {
+      state.currentProvider = detectedProvider;
+      state.useDirectMode = false;
+    }
   }
-  showWelcome(state.availableProviders, state.currentProvider, state.useDirectMode);
+  showWelcome(state.availableProviders, state.currentProvider, state.useDirectMode, localDaemonRunning);
   const replServer = createREPL(state);
+  if (localDaemonRunning) {
+    try {
+      await connectToLocal(state);
+    } catch {
+    }
+  }
   replServer.on("exit", async () => {
     await cleanupOnExit(state, replServer);
     process.exit(0);