@computesdk/cli 0.1.1

package/dist/index.js

@@ -0,0 +1,1281 @@
+#!/usr/bin/env node
+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.2/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.2/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// 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();
+      }
+    });
+  }
+  terminal.on("output", (data) => {
+    if (!exiting) {
+      process.stdout.write(data);
+    }
+  });
+  terminal.on("error", (error) => {
+    if (!error || error === "undefined") {
+      if (!exiting) {
+        doExit();
+      }
+      return;
+    }
+    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 {
+      }
+    }
+  };
+  process.stdout.on("resize", onResize);
+  onResize();
+  async function doExit() {
+    if (exiting) return;
+    exiting = true;
+    cleanup();
+    try {
+      await terminal.destroy();
+    } catch {
+    }
+    if (resolvePromise) {
+      resolvePromise();
+    }
+  }
+  function cleanup() {
+    process.stdin.removeListener("data", onData);
+    process.stdout.removeListener("resize", onResize);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    process.stdin.pause();
+  }
+  return new Promise((resolve) => {
+    resolvePromise = resolve;
+    terminal.on("destroyed", () => {
+      if (!exiting) {
+        cleanup();
+        resolve();
+      }
+    });
+    process.stdin.on("end", () => {
+      doExit();
+    });
+  });
+}
+var init_pty = __esm({
+  "src/pty.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/workspace-cli.ts
+var workspace_cli_exports = {};
+__export(workspace_cli_exports, {
+  loadState: () => loadState,
+  loadWorkspaceState: () => loadWorkspaceState,
+  sandboxList: () => sandboxList,
+  saveSandbox: () => saveSandbox,
+  saveState: () => saveState,
+  workspaceAttach: () => workspaceAttach,
+  workspaceCreate: () => workspaceCreate,
+  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 * as p3 from "@clack/prompts";
+import pc3 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)) {
+      return { workspaces: {} };
+    }
+    const raw = fs2.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 });
+  }
+  fs2.writeFileSync(WORKSPACE_STATE_FILE, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
+}
+function getWorkspaceId(repo, branch) {
+  return `${repo}:${branch}`;
+}
+async function workspaceCreate(options) {
+  const { repo, branch, provider } = options;
+  const id = getWorkspaceId(repo, branch);
+  const state = loadState();
+  if (state.workspaces[id]) {
+    const existing = state.workspaces[id];
+    try {
+      const sandbox2 = await compute2.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)}`);
+      return existing;
+    } catch {
+      delete state.workspaces[id];
+    }
+  }
+  p3.log.info("Creating sandbox...");
+  const spinner4 = p3.spinner();
+  spinner4.start("Provisioning via ComputeSDK...");
+  let sandbox;
+  try {
+    sandbox = await compute2.sandbox.create();
+    spinner4.stop(`Sandbox ready: ${pc3.cyan(sandbox.sandboxId)}`);
+  } catch (error) {
+    spinner4.stop(pc3.red("Failed to create sandbox"));
+    throw error;
+  }
+  spinner4.start("Bootstrapping workspace (installing gh CLI, cloning repo)...");
+  const bootstrapScript = fs2.readFileSync(
+    new URL("./bootstrap.sh", import.meta.url),
+    "utf-8"
+  );
+  try {
+    await sandbox.filesystem.writeFile("/tmp/bootstrap.sh", bootstrapScript);
+    await sandbox.runCommand("chmod +x /tmp/bootstrap.sh");
+    spinner4.stop("Running bootstrap (you may need to authenticate with GitHub)...");
+    const result = await sandbox.runCommand(
+      `/tmp/bootstrap.sh ${shellEscape(repo)} ${shellEscape(branch)}`,
+      { timeout: 3e5 }
+      // 5 min timeout for auth
+    );
+    const output = result.stdout || "";
+    const jsonMatch = output.match(/\{[\s\S]*\}/);
+    let worktreePath = `/workspaces/${path3.basename(repo)}-${branch}`;
+    if (jsonMatch) {
+      try {
+        const bootstrapInfo = JSON.parse(jsonMatch[0]);
+        worktreePath = bootstrapInfo.worktree_path || worktreePath;
+      } catch {
+      }
+    }
+    const workspace = {
+      id,
+      repo,
+      branch,
+      sandboxId: sandbox.sandboxId,
+      provider: provider || "e2b",
+      // TODO: Get actual provider
+      worktreePath,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastUsed: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    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)}`);
+    return workspace;
+  } catch (error) {
+    spinner4.stop(pc3.red("Bootstrap failed"));
+    try {
+      await sandbox.destroy();
+    } catch {
+    }
+    throw error;
+  }
+}
+async function workspaceAttach(id) {
+  const state = loadState();
+  const workspace = state.workspaces[id];
+  if (!workspace) {
+    p3.log.error(`Workspace not found: ${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);
+  if (!sandbox) {
+    p3.log.error(`Sandbox no longer exists: ${workspace.sandboxId}`);
+    delete state.workspaces[id];
+    saveState(state);
+    process.exit(1);
+  }
+  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..."));
+  try {
+    process.stdout.write("\x1B[2J\x1B[H\x1B[3J");
+    await startPTY(sandbox, { initialCommand: `cd ${shellEscape(workspace.worktreePath)}` });
+  } catch (error) {
+    p3.log.error(`Failed to attach: ${error.message}`);
+    process.exit(1);
+  }
+}
+async function sandboxList() {
+  const state = loadState();
+  const workspaces = Object.values(state.workspaces);
+  if (workspaces.length === 0) {
+    p3.log.info("No sandboxes found.");
+    p3.log.info("Create one with: compute owner/repo --branch main");
+    return;
+  }
+  console.log();
+  console.log(pc3.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)}`);
+    console.log(`    Provider: ${ws.provider}`);
+    console.log(`    Last active: ${pc3.gray(ageStr)}`);
+    console.log();
+  }
+  console.log(pc3.gray('Tip: Use "compute workspaces" to see full workspace details'));
+}
+async function workspaceList() {
+  const state = loadState();
+  const workspaces = Object.values(state.workspaces);
+  if (workspaces.length === 0) {
+    p3.log.info("No workspaces found.");
+    p3.log.info("Create one with: compute owner/repo --branch main");
+    return;
+  }
+  console.log();
+  console.log(pc3.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();
+  }
+}
+async function saveSandbox(sandbox) {
+  const state = loadState();
+  state.workspaces[sandbox.id] = {
+    id: sandbox.id,
+    repo: "(no repo)",
+    branch: "(raw sandbox)",
+    sandboxId: sandbox.sandboxId,
+    provider: sandbox.provider,
+    worktreePath: "/",
+    createdAt: sandbox.createdAt,
+    lastUsed: sandbox.lastUsed
+  };
+  saveState(state);
+}
+async function workspaceDestroy(id) {
+  const state = loadState();
+  if (id) {
+    const workspace = state.workspaces[id];
+    if (!workspace) {
+      p3.log.error(`Workspace not found: ${id}`);
+      return;
+    }
+    p3.log.info(`Destroying workspace: ${pc3.cyan(id)}`);
+    try {
+      await compute2.sandbox.destroy(workspace.sandboxId);
+      delete state.workspaces[id];
+      saveState(state);
+      p3.log.success("Workspace destroyed");
+    } catch (error) {
+      p3.log.error(`Failed to destroy: ${error.message}`);
+    }
+  } else {
+    const choices = Object.values(state.workspaces).map((ws) => ({
+      value: ws.id,
+      label: `${ws.id} (${ws.provider}, last used ${Math.round((Date.now() - new Date(ws.lastUsed).getTime()) / (1e3 * 60 * 60 * 24))}d ago)`
+    }));
+    if (choices.length === 0) {
+      p3.log.info("No workspaces to destroy");
+      return;
+    }
+    const selected = await p3.select({
+      message: "Select workspace to destroy",
+      options: choices
+    });
+    if (p3.isCancel(selected)) {
+      return;
+    }
+    await workspaceDestroy(selected);
+  }
+}
+var WORKSPACE_STATE_FILE, loadWorkspaceState;
+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");
+    loadWorkspaceState = loadState;
+  }
+});
+
+// src/index.ts
+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 { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join3 } from "path";
+import { compute as compute3 } from "computesdk";
+
+// src/providers.ts
+init_esm_shims();
+import {
+  PROVIDER_NAMES,
+  isProviderAuthComplete,
+  getMissingEnvVars,
+  getProviderConfigFromEnv
+} from "computesdk";
+var PROVIDERS_NEEDING_CREDS = [
+  "e2b",
+  "railway",
+  "modal",
+  "vercel",
+  "daytona",
+  "render",
+  "namespace",
+  "blaxel",
+  "codesandbox"
+];
+function detectAvailableProviders() {
+  const available = [];
+  if (process.env.COMPUTESDK_API_KEY) {
+    available.push("computesdk");
+  }
+  for (const provider of PROVIDER_NAMES) {
+    if (PROVIDERS_NEEDING_CREDS.includes(provider) && isProviderAuthComplete(provider)) {
+      available.push(provider);
+    }
+  }
+  return available;
+}
+function getProviderStatus() {
+  const statuses = [];
+  const hasGatewayKey = !!process.env.COMPUTESDK_API_KEY;
+  statuses.push({
+    name: "computesdk",
+    ready: hasGatewayKey,
+    missing: hasGatewayKey ? [] : ["COMPUTESDK_API_KEY"]
+  });
+  for (const provider of PROVIDER_NAMES) {
+    if (PROVIDERS_NEEDING_CREDS.includes(provider)) {
+      statuses.push({
+        name: provider,
+        ready: isProviderAuthComplete(provider),
+        missing: getMissingEnvVars(provider)
+      });
+    }
+  }
+  return statuses;
+}
+function buildProviderConfig(provider) {
+  const config = {
+    provider,
+    apiKey: process.env.COMPUTESDK_API_KEY
+    // Gateway API key (top-level)
+  };
+  if (provider === "computesdk") {
+    config.computesdk = {
+      computesdk_api_key: process.env.COMPUTESDK_API_KEY
+    };
+  }
+  if (provider !== "computesdk") {
+    const providerConfig = getProviderConfigFromEnv(provider);
+    if (Object.keys(providerConfig).length > 0) {
+      config[provider] = providerConfig;
+    }
+  }
+  return config;
+}
+
+// src/index.ts
+init_pty();
+
+// 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 p from "@clack/prompts";
+import pc from "picocolors";
+function getCredentialsDir() {
+  return path2.join(os.homedir(), ".computesdk");
+}
+function getCredentialsFile() {
+  return path2.join(getCredentialsDir(), "credentials.json");
+}
+var AUTH_TIMEOUT_MS = 5 * 60 * 1e3;
+var CONSOLE_AUTH_URL = "https://console.computesdk.com/cli/auth";
+var SUCCESS_HTML = `<!DOCTYPE html>
+<html>
+<head><title>ComputeSDK CLI</title></head>
+<body style="font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
+  <div style="text-align: center;">
+    <h1>Authenticated</h1>
+    <p>You can close this tab and return to the terminal.</p>
+  </div>
+</body>
+</html>`;
+function loadStoredCredentials() {
+  try {
+    if (!fs.existsSync(getCredentialsFile())) {
+      return null;
+    }
+    const raw = fs.readFileSync(getCredentialsFile(), "utf-8");
+    const data = JSON.parse(raw);
+    if (typeof data.apiKey === "string" && data.apiKey.length > 0) {
+      return data.apiKey;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function storeCredentials(apiKey) {
+  if (!fs.existsSync(getCredentialsDir())) {
+    fs.mkdirSync(getCredentialsDir(), { recursive: true, mode: 448 });
+  }
+  fs.writeFileSync(
+    getCredentialsFile(),
+    JSON.stringify({ apiKey }, null, 2) + "\n",
+    { mode: 384 }
+  );
+}
+function clearStoredCredentials() {
+  try {
+    if (fs.existsSync(getCredentialsFile())) {
+      fs.unlinkSync(getCredentialsFile());
+    }
+  } catch {
+  }
+}
+function openBrowser(url) {
+  const command = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+  exec(command, (err) => {
+    if (err) {
+      p.log.warn("Could not open browser automatically.");
+      p.log.info(`Open this URL manually:
+  ${pc.cyan(url)}`);
+    }
+  });
+}
+function runBrowserAuthFlow(options) {
+  const timeoutMs = options?.timeoutMs ?? AUTH_TIMEOUT_MS;
+  const state = crypto.randomBytes(32).toString("hex");
+  return new Promise((resolve, reject) => {
+    const server = http.createServer();
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(
+        new Error("Authentication timed out after 5 minutes. Please try again.")
+      );
+    }, timeoutMs);
+    server.on("request", (req, res) => {
+      const url = new URL(req.url || "/", "http://localhost");
+      if (req.method !== "GET" || url.pathname !== "/callback") {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not Found");
+        return;
+      }
+      const receivedState = url.searchParams.get("state");
+      const token = url.searchParams.get("token");
+      if (receivedState !== state) {
+        res.writeHead(403, { "Content-Type": "text/plain" });
+        res.end("Error: State mismatch. Please try authenticating again.");
+        return;
+      }
+      if (!token) {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("Error: No token received.");
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(SUCCESS_HTML);
+      clearTimeout(timeout);
+      server.close();
+      resolve(token);
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        clearTimeout(timeout);
+        server.close();
+        reject(new Error("Failed to start auth server"));
+        return;
+      }
+      const port = addr.port;
+      const authUrl = `${CONSOLE_AUTH_URL}?port=${port}&state=${state}`;
+      if (options?.onServerReady) {
+        options.onServerReady(port, state);
+      }
+      if (!options?.skipBrowserOpen) {
+        openBrowser(authUrl);
+      }
+    });
+    server.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(new Error(`Auth server error: ${err.message}`));
+    });
+  });
+}
+async function resolveApiKey(options) {
+  if (process.env.COMPUTESDK_API_KEY) {
+    return process.env.COMPUTESDK_API_KEY;
+  }
+  if (!options?.forceLogin) {
+    const stored = loadStoredCredentials();
+    if (stored) {
+      p.log.info(
+        `Using stored credentials from ${pc.dim("~/.computesdk/credentials.json")}`
+      );
+      return stored;
+    }
+  }
+  p.log.info("No API key found. Starting browser authentication...");
+  const spinner4 = p.spinner();
+  spinner4.start("Waiting for browser authentication...");
+  try {
+    const apiKey = await runBrowserAuthFlow();
+    spinner4.stop("Authentication successful");
+    try {
+      storeCredentials(apiKey);
+      p.log.success(
+        `Credentials saved to ${pc.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"));
+    throw error;
+  }
+}
+
+// src/setup.ts
+init_esm_shims();
+import * as p2 from "@clack/prompts";
+import pc2 from "picocolors";
+import { compute } 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"));
+    process.exit(1);
+  }
+}
+async function resolveProvider(providerFlag, options) {
+  const interactive = options?.interactive ?? false;
+  const available = detectAvailableProviders();
+  const providerStatus = getProviderStatus();
+  if (providerFlag) {
+    const match = providerStatus.find(
+      (s) => s.name.toLowerCase() === providerFlag.toLowerCase()
+    );
+    if (!match) {
+      p2.log.error(`Unknown provider: ${providerFlag}`);
+      p2.log.info(`Available providers: ${providerStatus.map((s) => s.name).join(", ")}`);
+      process.exit(1);
+    }
+    if (!match.ready) {
+      p2.log.error(`Provider ${providerFlag} is not configured`);
+      if (match.missing.length > 0) {
+        p2.log.info(`Missing env vars: ${match.missing.join(", ")}`);
+      }
+      process.exit(1);
+    }
+    return match.name;
+  }
+  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"));
+    process.exit(1);
+  }
+  if (available.length === 1) {
+    return available[0];
+  }
+  if (!interactive) {
+    p2.log.error("Multiple providers configured. Use --provider to specify one.");
+    p2.log.info(`Available: ${available.join(", ")}`);
+    process.exit(1);
+  }
+  const providerOptions = providerStatus.filter((status) => status.ready).map((status) => ({
+    value: status.name,
+    label: status.name
+  }));
+  const provider = await p2.select({
+    message: "Select provider",
+    options: providerOptions
+  });
+  if (p2.isCancel(provider)) {
+    p2.cancel("Cancelled");
+    process.exit(0);
+  }
+  return provider;
+}
+function configureCompute(provider) {
+  const config = buildProviderConfig(provider);
+  compute.setConfig(config);
+}
+
+// src/index.ts
+init_workspace_cli();
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+var packageJson = JSON.parse(
+  readFileSync3(join3(__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;
+var program = new Command();
+program.name("compute").description("Cloud-native workspace management").version(VERSION).enablePositionalOptions().passThroughOptions();
+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}`));
+    clearStoredCredentials();
+    p4.log.success("Logged out. Stored credentials removed.");
+    p4.outro(pc4.green("Done!"));
+    process.exit(0);
+  }
+  if (opts.login) {
+    console.log();
+    p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+    await ensureAuth({ forceLogin: true });
+    p4.outro(pc4.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}`));
+  await ensureAuth();
+  if (!repo) {
+    const state = loadWorkspaceState();
+    const workspaceIds = Object.keys(state.workspaces);
+    if (workspaceIds.length > 0) {
+      const choices = workspaceIds.map((id) => {
+        const ws = state.workspaces[id];
+        const age = Math.round(
+          (Date.now() - new Date(ws.lastUsed).getTime()) / (1e3 * 60 * 60 * 24)
+        );
+        const ageStr = age === 0 ? "today" : `${age}d ago`;
+        return {
+          value: id,
+          label: `${id} (${ws.provider}, ${ageStr})`
+        };
+      });
+      const selected = await p4.select({
+        message: "Select workspace to attach (or create new)",
+        options: [
+          ...choices,
+          { value: "__new__", label: pc4.gray("+ Create new workspace") }
+        ]
+      });
+      if (p4.isCancel(selected)) {
+        p4.cancel("Cancelled");
+        process.exit(0);
+      }
+      if (selected !== "__new__") {
+        await workspaceAttach(selected);
+        return;
+      }
+    }
+    const repoInput = await p4.text({
+      message: "Repository to work on?",
+      placeholder: "owner/repo",
+      validate: (value) => {
+        if (!value || !value.includes("/")) {
+          return "Please enter a repository in owner/repo format";
+        }
+      }
+    });
+    if (p4.isCancel(repoInput)) {
+      p4.cancel("Cancelled");
+      process.exit(0);
+    }
+    repo = repoInput;
+  }
+  if (!repo.includes("/")) {
+    p4.log.error("Invalid repository format. Use: owner/repo");
+    process.exit(1);
+  }
+  const provider = await resolveProvider(options.provider, { interactive: true });
+  configureCompute(provider);
+  const spinner4 = p4.spinner();
+  spinner4.start("Creating workspace...");
+  try {
+    const workspace = await workspaceCreate({
+      repo,
+      branch: options.branch,
+      provider
+    });
+    spinner4.stop(`Workspace ready: ${pc4.cyan(workspace.id)}`);
+    if (options.attach !== false) {
+      console.log();
+      await workspaceAttach(workspace.id);
+    } else {
+      p4.outro(pc4.green("Workspace created!"));
+    }
+  } catch (error) {
+    spinner4.stop(pc4.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) => {
+  if (!opts.silent) {
+    console.log();
+    p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  }
+  await ensureAuth();
+  const provider = await resolveProvider(opts.provider);
+  configureCompute(provider);
+  if (!opts.silent) {
+    const spinner4 = p4.spinner();
+    spinner4.start("Creating sandbox...");
+    try {
+      const sandbox = await compute3.sandbox.create(
+        buildCreateOptions(opts)
+      );
+      spinner4.stop(`Sandbox ready: ${pc4.cyan(sandbox.sandboxId)}`);
+      const { saveSandbox: saveSandbox2 } = await Promise.resolve().then(() => (init_workspace_cli(), workspace_cli_exports));
+      await saveSandbox2({
+        id: sandbox.sandboxId,
+        sandboxId: sandbox.sandboxId,
+        provider,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        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);
+      }
+    } catch (error) {
+      spinner4.stop(pc4.red("Failed to create sandbox"));
+      p4.log.error(error.message);
+      process.exit(1);
+    }
+  } else {
+    try {
+      const sandbox = await compute3.sandbox.create(
+        buildCreateOptions(opts)
+      );
+      process.stdout.write(sandbox.sandboxId);
+      const { saveSandbox: saveSandbox2 } = await Promise.resolve().then(() => (init_workspace_cli(), workspace_cli_exports));
+      await saveSandbox2({
+        id: sandbox.sandboxId,
+        sandboxId: sandbox.sandboxId,
+        provider,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        lastUsed: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (opts.connect) {
+        console.log();
+        process.stdout.write("\x1B[2J\x1B[H\x1B[3J");
+        await startPTY(sandbox);
+      }
+    } catch (error) {
+      process.stderr.write(error.message + "\n");
+      process.exit(1);
+    }
+  }
+});
+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}`));
+  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!"));
+      return;
+    }
+    const choices = workspaces.map((ws) => {
+      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 ? pc4.red("stale") : age > 1 ? pc4.yellow("idle") : pc4.green("active");
+      return {
+        value: ws.sandboxId,
+        label: `${status} ${ws.sandboxId} (${ws.provider}, last active ${ageStr})`
+      };
+    });
+    const selected = await p4.multiselect({
+      message: "Select sandboxes to destroy (space to select, enter to confirm)",
+      options: choices
+    });
+    if (p4.isCancel(selected) || selected.length === 0) {
+      p4.cancel("Cancelled");
+      process.exit(0);
+    }
+    sandboxIds = selected;
+  }
+  await ensureAuth();
+  const provider = await resolveProvider(opts.provider);
+  configureCompute(provider);
+  const results = await Promise.allSettled(
+    sandboxIds.map(async (id) => {
+      await compute3.sandbox.destroy(id);
+      return id;
+    })
+  );
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      const sandboxId = result.value;
+      console.log(pc4.green(`Destroyed ${sandboxId}`));
+      const workspaceId = Object.keys(state.workspaces).find(
+        (key) => state.workspaces[key].sandboxId === sandboxId
+      );
+      if (workspaceId) {
+        delete state.workspaces[workspaceId];
+      }
+    } else {
+      console.error(pc4.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}`));
+  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) => {
+  console.log();
+  p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  await ensureAuth();
+  const provider = await resolveProvider(opts.provider);
+  configureCompute(provider);
+  if (!sandboxId) {
+    const { loadState: loadState2 } = await Promise.resolve().then(() => (init_workspace_cli(), workspace_cli_exports));
+    const state = loadState2();
+    const workspaces = Object.values(state.workspaces);
+    if (workspaces.length === 0) {
+      p4.log.info("No sandboxes found.");
+      p4.log.info("Create one with: compute sandbox create");
+      p4.outro(pc4.green("Done!"));
+      return;
+    }
+    const choices = workspaces.map((ws) => {
+      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 ? pc4.red("stale") : age > 1 ? pc4.yellow("idle") : pc4.green("active");
+      return {
+        value: ws.sandboxId,
+        label: `${status} ${ws.sandboxId} (${ws.provider}, last active ${ageStr})`
+      };
+    });
+    const selected = await p4.select({
+      message: "Select sandbox to connect",
+      options: choices
+    });
+    if (p4.isCancel(selected)) {
+      p4.cancel("Cancelled");
+      process.exit(0);
+    }
+    sandboxId = selected;
+  }
+  const spinner4 = p4.spinner();
+  spinner4.start("Connecting...");
+  const sandbox = await compute3.sandbox.getById(sandboxId);
+  if (!sandbox) {
+    spinner4.stop(pc4.red(`Sandbox not found: ${sandboxId}`));
+    process.exit(1);
+  }
+  spinner4.stop("");
+  process.stdout.write("\x1B[2J\x1B[H\x1B[3J");
+  await startPTY(sandbox);
+});
+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);
+  if (!sandbox) {
+    console.error(pc4.red(`Sandbox not found: ${sandboxId}`));
+    process.exit(1);
+  }
+  const cmd = buildExecCommand(command, opts);
+  const result = await sandbox.runCommand(cmd);
+  if (result.stdout) {
+    process.stdout.write(result.stdout);
+  }
+  if (result.stderr) {
+    process.stderr.write(result.stderr);
+  }
+  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) => {
+  console.log();
+  p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  await ensureAuth();
+  const provider = await resolveProvider(opts.provider);
+  configureCompute(provider);
+  if (!sandboxId) {
+    const { loadState: loadState2 } = await Promise.resolve().then(() => (init_workspace_cli(), workspace_cli_exports));
+    const state = loadState2();
+    const workspaces = Object.values(state.workspaces);
+    if (workspaces.length === 0) {
+      p4.log.info("No sandboxes found.");
+      p4.log.info("Create one with: compute sandbox create");
+      p4.outro(pc4.green("Done!"));
+      return;
+    }
+    const choices = workspaces.map((ws) => {
+      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 ? pc4.red("stale") : age > 1 ? pc4.yellow("idle") : pc4.green("active");
+      return {
+        value: ws.sandboxId,
+        label: `${status} ${ws.sandboxId} (${ws.provider}, last active ${ageStr})`
+      };
+    });
+    const selected = await p4.select({
+      message: "Select sandbox to connect",
+      options: choices
+    });
+    if (p4.isCancel(selected)) {
+      p4.cancel("Cancelled");
+      process.exit(0);
+    }
+    sandboxId = selected;
+  }
+  const spinner4 = p4.spinner();
+  spinner4.start("Connecting...");
+  const sandbox = await compute3.sandbox.getById(sandboxId);
+  if (!sandbox) {
+    spinner4.stop(pc4.red(`Sandbox not found: ${sandboxId}`));
+    process.exit(1);
+  }
+  spinner4.stop("");
+  process.stdout.write("\x1B[2J\x1B[H\x1B[3J");
+  await startPTY(sandbox);
+});
+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}`));
+  await ensureAuth();
+  if (!repo) {
+    p4.log.info("Usage: compute workspace create owner/repo --branch main");
+    p4.outro(pc4.green("Done!"));
+    return;
+  }
+  const provider = await resolveProvider(options.provider, { interactive: true });
+  configureCompute(provider);
+  const spinner4 = p4.spinner();
+  spinner4.start("Creating workspace...");
+  try {
+    const workspace = await workspaceCreate({
+      repo,
+      branch: options.branch,
+      provider
+    });
+    spinner4.stop(`Workspace ready: ${pc4.cyan(workspace.id)}`);
+    if (options.attach !== false) {
+      console.log();
+      await workspaceAttach(workspace.id);
+    } else {
+      p4.outro(pc4.green("Workspace created!"));
+    }
+  } catch (error) {
+    spinner4.stop(pc4.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}`));
+  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}`));
+  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!"));
+      return;
+    }
+    const choices = workspaceIds.map((key) => {
+      const ws = state.workspaces[key];
+      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`;
+      return {
+        value: key,
+        label: `${pc4.cyan(key)} (${ws.provider}, last used ${ageStr})`
+      };
+    });
+    const selected = await p4.multiselect({
+      message: "Select workspaces to destroy (space to select, enter to confirm)",
+      options: choices
+    });
+    if (p4.isCancel(selected) || selected.length === 0) {
+      p4.cancel("Cancelled");
+      process.exit(0);
+    }
+    for (const workspaceId of selected) {
+      await workspaceDestroy(workspaceId);
+    }
+  } else {
+    await workspaceDestroy(id);
+  }
+});
+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}`));
+  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!"));
+      return;
+    }
+    const choices = workspaceIds.map((key) => {
+      const ws = state.workspaces[key];
+      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`;
+      return {
+        value: key,
+        label: `${pc4.cyan(key)} (${ws.provider}, last used ${ageStr})`
+      };
+    });
+    const selected = await p4.select({
+      message: "Select workspace to connect",
+      options: choices
+    });
+    if (p4.isCancel(selected)) {
+      p4.cancel("Cancelled");
+      process.exit(0);
+    }
+    id = selected;
+  }
+  await workspaceAttach(id);
+});
+program.command("run").description("Create a sandbox, run a command, then optionally destroy it").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().option("--rm", "destroy sandbox after command finishes").option("--timeout <duration>", "sandbox timeout (e.g. 5m, 1h)").option("--name <name>", "sandbox name").action(async (command, opts) => {
+  await ensureAuth();
+  const provider = await resolveProvider(opts.provider);
+  configureCompute(provider);
+  let sandbox;
+  try {
+    sandbox = await compute3.sandbox.create(
+      buildCreateOptions(opts)
+    );
+  } catch (error) {
+    console.error(pc4.red(`Failed to create sandbox: ${error.message}`));
+    process.exit(1);
+  }
+  try {
+    const cmd = buildExecCommand(command, opts);
+    const result = await sandbox.runCommand(cmd);
+    if (result.stdout) {
+      process.stdout.write(result.stdout);
+    }
+    if (result.stderr) {
+      process.stderr.write(result.stderr);
+    }
+    if (opts.rm) {
+      await sandbox.destroy();
+    }
+    process.exit(result.exitCode);
+  } catch (error) {
+    if (opts.rm) {
+      try {
+        await sandbox.destroy();
+      } catch {
+      }
+    }
+    console.error(pc4.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}`));
+  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(", ")}`);
+    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}`));
+  await ensureAuth({ forceLogin: true });
+  p4.outro(pc4.green("Authenticated!"));
+});
+program.command("logout").description("Clear stored credentials").action(() => {
+  console.log();
+  p4.intro(pc4.cyan(`@computesdk/cli v${VERSION}`));
+  clearStoredCredentials();
+  p4.log.success("Logged out. Stored credentials removed.");
+  p4.outro(pc4.green("Done!"));
+});
+function buildCreateOptions(opts) {
+  const options = {};
+  if (opts.timeout) {
+    options.timeout = parseDuration(opts.timeout);
+  }
+  if (opts.name) {
+    options.name = opts.name;
+  }
+  return options;
+}
+function shellEscape2(arg) {
+  if (/^[a-zA-Z0-9._\-/:=@]+$/.test(arg)) return arg;
+  return `'${arg.replace(/'/g, "'\\''")}'`;
+}
+function buildExecCommand(command, opts) {
+  let cmd = command.map(shellEscape2).join(" ");
+  if (opts.workdir) {
+    cmd = `cd ${shellEscape2(opts.workdir)} && ${cmd}`;
+  }
+  if (opts.env && opts.env.length > 0) {
+    const envPrefix = opts.env.map((entry) => {
+      const eqIndex = entry.indexOf("=");
+      if (eqIndex === -1) {
+        throw new Error(
+          `Invalid environment entry "${entry}". Expected format KEY=VALUE.`
+        );
+      }
+      const key = entry.slice(0, eqIndex);
+      const val = entry.slice(eqIndex + 1);
+      if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+        throw new Error(
+          `Invalid environment variable name "${key}" in entry "${entry}".`
+        );
+      }
+      return `${key}=${shellEscape2(val)}`;
+    }).join(" ");
+    cmd = `${envPrefix} ${cmd}`;
+  }
+  return cmd;
+}
+function parseDuration(input) {
+  let total = 0;
+  const pattern = /(\d+)\s*(s|m|h)/gi;
+  let match;
+  while ((match = pattern.exec(input)) !== null) {
+    const value = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+    switch (unit) {
+      case "s":
+        total += value * 1e3;
+        break;
+      case "m":
+        total += value * 60 * 1e3;
+        break;
+      case "h":
+        total += value * 60 * 60 * 1e3;
+        break;
+    }
+  }
+  if (total === 0) {
+    const num = parseInt(input, 10);
+    if (!isNaN(num)) return num * 1e3;
+    throw new Error(`Invalid duration: ${input}. Use formats like 30s, 5m, 1h`);
+  }
+  return total;
+}
+program.parseAsync(process.argv).catch((error) => {
+  console.error(pc4.red(`
+Error: ${error.message}`));
+  process.exit(1);
+});
+export {
+  shellEscape2 as shellEscape
+};
+//# sourceMappingURL=index.js.map