@computesdk/cli 1.0.8 → 1.0.10

package/dist/index.js

@@ -23,7 +23,7 @@ import * as readline from "readline";
 import * as path2 from "path";
 import * as os from "os";
 import * as fs from "fs";
-import pc from "picocolors";
+import pc2 from "picocolors";
 import { compute } from "computesdk";
 async function startREPL(sandbox, provider) {
   void provider;
@@ -34,8 +34,8 @@ async function startREPL(sandbox, provider) {
   await runSession(ctx);
 }
 function buildPrompt(sandboxId) {
-  if (!sandboxId) return pc.gray("[no sandbox] ") + pc.bold("$ ");
-  return pc.cyan(`[${sandboxId}] `) + pc.bold("$ ");
+  if (!sandboxId) return pc2.gray("[no sandbox] ") + pc2.bold("$ ");
+  return pc2.cyan(`[${sandboxId}] `) + pc2.bold("$ ");
 }
 function runSession(ctx) {
   const rl = readline.createInterface({
@@ -80,13 +80,13 @@ function runSession(ctx) {
             return;
           }
         } else if (ctx.sandboxes.size === 0) {
-          console.log(pc.yellow("No active sandbox. Use /new to create one."));
+          console.log(pc2.yellow("No active sandbox. Use /new to create one."));
         } else {
           const sandbox = ctx.sandboxes.get(ctx.activeSandboxId);
           await executeCommand(sandbox, trimmed);
         }
       } catch (error) {
-        console.log(pc.red(`\u2717 ${error.message}`));
+        console.log(pc2.red(`\u2717 ${error.message}`));
       }
       if (!resolved) {
         rl.prompt();
@@ -104,13 +104,13 @@ async function executeCommand(sandbox, command) {
     }
   }
   if (result.stderr) {
-    process.stderr.write(pc.red(result.stderr));
+    process.stderr.write(pc2.red(result.stderr));
     if (!result.stderr.endsWith("\n")) {
       console.log();
     }
   }
   if (result.exitCode !== 0) {
-    console.log(pc.gray(`exit code: ${result.exitCode}`));
+    console.log(pc2.gray(`exit code: ${result.exitCode}`));
   }
 }
 async function handleSpecialCommand(ctx, input, rl) {
@@ -124,67 +124,67 @@ async function handleSpecialCommand(ctx, input, rl) {
     case "info":
     case "i": {
       if (ctx.sandboxes.size === 0) {
-        console.log(pc.yellow("No active sandbox. Use /new to create one."));
+        console.log(pc2.yellow("No active sandbox. Use /new to create one."));
         return null;
       }
       const activeSandbox = ctx.sandboxes.get(ctx.activeSandboxId);
       console.log();
-      console.log(pc.bold("  Sandbox Info"));
-      console.log(`  ID: ${pc.cyan(activeSandbox.sandboxId)}`);
+      console.log(pc2.bold("  Sandbox Info"));
+      console.log(`  ID: ${pc2.cyan(activeSandbox.sandboxId)}`);
       console.log();
       return null;
     }
     case "url":
     case "u": {
       if (ctx.sandboxes.size === 0) {
-        console.log(pc.yellow("No active sandbox. Use /new to create one."));
+        console.log(pc2.yellow("No active sandbox. Use /new to create one."));
         return null;
       }
       const activeSandbox = ctx.sandboxes.get(ctx.activeSandboxId);
       if (args.length === 0) {
-        console.log(pc.gray("Usage: /url <port>"));
+        console.log(pc2.gray("Usage: /url <port>"));
       } else {
         const port = parseInt(args[0], 10);
         if (isNaN(port)) {
-          console.log(pc.red("Invalid port number"));
+          console.log(pc2.red("Invalid port number"));
         } else {
           const url = await activeSandbox.getUrl({ port });
-          console.log(pc.cyan(url));
+          console.log(pc2.cyan(url));
         }
       }
       return null;
     }
     case "new": {
-      console.log(pc.gray("  Creating new sandbox..."));
+      console.log(pc2.gray("  Creating new sandbox..."));
       const newSandbox = await compute.sandbox.create();
       ctx.sandboxes.set(newSandbox.sandboxId, newSandbox);
       ctx.activeSandboxId = newSandbox.sandboxId;
       rl.setPrompt(buildPrompt(ctx.activeSandboxId));
-      console.log(`  Sandbox ready: ${pc.cyan(newSandbox.sandboxId)}`);
-      console.log(`  ${pc.gray(`Active sandboxes: ${ctx.sandboxes.size}`)}`);
+      console.log(`  Sandbox ready: ${pc2.cyan(newSandbox.sandboxId)}`);
+      console.log(`  ${pc2.gray(`Active sandboxes: ${ctx.sandboxes.size}`)}`);
       return null;
     }
     case "destroy": {
       if (args.length === 0) {
-        console.log(pc.gray("Usage: /destroy <sandbox-id> or /destroy --all"));
-        console.log(pc.gray("Use /list to see all sandboxes"));
+        console.log(pc2.gray("Usage: /destroy <sandbox-id> or /destroy --all"));
+        console.log(pc2.gray("Use /list to see all sandboxes"));
         return null;
       }
       if (args[0] === "--all") {
         if (ctx.sandboxes.size === 0) {
-          console.log(pc.yellow("  No sandboxes to destroy."));
+          console.log(pc2.yellow("  No sandboxes to destroy."));
           return null;
         }
         const count = ctx.sandboxes.size;
-        console.log(pc.gray(`  Destroying ${count} sandbox${count > 1 ? "es" : ""}...`));
+        console.log(pc2.gray(`  Destroying ${count} sandbox${count > 1 ? "es" : ""}...`));
         await Promise.all(
           Array.from(ctx.sandboxes.values()).map((s) => s.destroy())
         );
         ctx.sandboxes.clear();
         ctx.activeSandboxId = "";
         rl.setPrompt(buildPrompt(ctx.activeSandboxId));
-        console.log(`  Destroyed ${pc.cyan(String(count))} sandbox${count > 1 ? "es" : ""}`);
-        console.log(pc.yellow("  No sandboxes remaining. Use /new to create one or /exit to quit."));
+        console.log(`  Destroyed ${pc2.cyan(String(count))} sandbox${count > 1 ? "es" : ""}`);
+        console.log(pc2.yellow("  No sandboxes remaining. Use /new to create one or /exit to quit."));
         return null;
       }
       const targetId = args[0];
@@ -194,13 +194,13 @@ async function handleSpecialCommand(ctx, input, rl) {
         if (matches.length === 1) {
           return destroySandbox(ctx, matches[0], rl);
         } else if (matches.length > 1) {
-          console.log(pc.yellow("  Ambiguous ID. Matches:"));
+          console.log(pc2.yellow("  Ambiguous ID. Matches:"));
           for (const id of matches) {
-            console.log(`    ${pc.cyan(id)}`);
+            console.log(`    ${pc2.cyan(id)}`);
           }
         } else {
-          console.log(pc.red(`  Sandbox not found: ${targetId}`));
-          console.log(pc.gray("  Use /list to see all sandboxes"));
+          console.log(pc2.red(`  Sandbox not found: ${targetId}`));
+          console.log(pc2.gray("  Use /list to see all sandboxes"));
         }
         return null;
       }
@@ -209,10 +209,10 @@ async function handleSpecialCommand(ctx, input, rl) {
     case "list":
     case "ls": {
       console.log();
-      console.log(pc.bold("  Sandboxes"));
+      console.log(pc2.bold("  Sandboxes"));
       for (const id of ctx.sandboxes.keys()) {
-        const marker = id === ctx.activeSandboxId ? pc.green(" \u25CF") : "  ";
-        console.log(`  ${marker} ${pc.cyan(id)}`);
+        const marker = id === ctx.activeSandboxId ? pc2.green(" \u25CF") : "  ";
+        console.log(`  ${marker} ${pc2.cyan(id)}`);
       }
       console.log();
       return null;
@@ -220,30 +220,30 @@ async function handleSpecialCommand(ctx, input, rl) {
     case "switch":
     case "sw": {
       if (args.length === 0) {
-        console.log(pc.gray("Usage: /switch <sandbox-id>"));
-        console.log(pc.gray("Use /list to see all sandboxes"));
+        console.log(pc2.gray("Usage: /switch <sandbox-id>"));
+        console.log(pc2.gray("Use /list to see all sandboxes"));
         return null;
       }
       const switchId = args[0];
       if (ctx.sandboxes.has(switchId)) {
         ctx.activeSandboxId = switchId;
         rl.setPrompt(buildPrompt(ctx.activeSandboxId));
-        console.log(`  Switched to ${pc.cyan(switchId)}`);
+        console.log(`  Switched to ${pc2.cyan(switchId)}`);
         return null;
       }
       const matches = Array.from(ctx.sandboxes.keys()).filter((id) => id.startsWith(switchId));
       if (matches.length === 1) {
         ctx.activeSandboxId = matches[0];
         rl.setPrompt(buildPrompt(ctx.activeSandboxId));
-        console.log(`  Switched to ${pc.cyan(matches[0])}`);
+        console.log(`  Switched to ${pc2.cyan(matches[0])}`);
       } else if (matches.length > 1) {
-        console.log(pc.yellow("  Ambiguous ID. Matches:"));
+        console.log(pc2.yellow("  Ambiguous ID. Matches:"));
         for (const id of matches) {
-          console.log(`    ${pc.cyan(id)}`);
+          console.log(`    ${pc2.cyan(id)}`);
         }
       } else {
-        console.log(pc.red(`  Sandbox not found: ${switchId}`));
-        console.log(pc.gray("  Use /list to see all sandboxes"));
+        console.log(pc2.red(`  Sandbox not found: ${switchId}`));
+        console.log(pc2.gray("  Use /list to see all sandboxes"));
       }
       return null;
     }
@@ -252,51 +252,51 @@ async function handleSpecialCommand(ctx, input, rl) {
     case "q":
       return "exit";
     default:
-      console.log(pc.yellow(`Unknown command: /${cmd}`));
-      console.log(pc.gray("Type /help for available commands"));
+      console.log(pc2.yellow(`Unknown command: /${cmd}`));
+      console.log(pc2.gray("Type /help for available commands"));
       return null;
   }
 }
 async function destroySandbox(ctx, sandboxId, rl) {
   const target = ctx.sandboxes.get(sandboxId);
-  console.log(pc.gray(`  Destroying ${sandboxId}...`));
+  console.log(pc2.gray(`  Destroying ${sandboxId}...`));
   await target.destroy();
   ctx.sandboxes.delete(sandboxId);
-  console.log(`  Destroyed ${pc.cyan(sandboxId)}`);
+  console.log(`  Destroyed ${pc2.cyan(sandboxId)}`);
   if (ctx.activeSandboxId === sandboxId && ctx.sandboxes.size > 0) {
     ctx.activeSandboxId = ctx.sandboxes.keys().next().value;
     rl.setPrompt(buildPrompt(ctx.activeSandboxId));
-    console.log(`  Switched to ${pc.cyan(ctx.activeSandboxId)}`);
+    console.log(`  Switched to ${pc2.cyan(ctx.activeSandboxId)}`);
   } else if (ctx.sandboxes.size === 0) {
     ctx.activeSandboxId = "";
     rl.setPrompt(buildPrompt(ctx.activeSandboxId));
-    console.log(pc.yellow("  No sandboxes remaining. Use /new to create one or /exit to quit."));
+    console.log(pc2.yellow("  No sandboxes remaining. Use /new to create one or /exit to quit."));
   }
   return null;
 }
 function showHelp() {
   console.log();
-  console.log(pc.bold("  Shell Mode"));
-  console.log(pc.gray("  Just type commands - they run in the active sandbox"));
+  console.log(pc2.bold("  Shell Mode"));
+  console.log(pc2.gray("  Just type commands - they run in the active sandbox"));
   console.log();
-  console.log(pc.white("    ls -la"));
-  console.log(pc.white("    cat /etc/os-release"));
-  console.log(pc.white("    npm install lodash"));
+  console.log(pc2.white("    ls -la"));
+  console.log(pc2.white("    cat /etc/os-release"));
+  console.log(pc2.white("    npm install lodash"));
   console.log();
-  console.log(pc.bold("  Sandbox Commands") + pc.gray(" (prefix with /)"));
+  console.log(pc2.bold("  Sandbox Commands") + pc2.gray(" (prefix with /)"));
   console.log();
-  console.log(pc.cyan("    /new") + pc.gray("              Create a new sandbox and switch to it"));
-  console.log(pc.cyan("    /list") + pc.gray("             List all sandboxes"));
-  console.log(pc.cyan("    /switch <id>") + pc.gray("      Switch active sandbox"));
-  console.log(pc.cyan("    /destroy <id>") + pc.gray("     Destroy a sandbox by ID"));
-  console.log(pc.cyan("    /destroy --all") + pc.gray("    Destroy all sandboxes"));
+  console.log(pc2.cyan("    /new") + pc2.gray("              Create a new sandbox and switch to it"));
+  console.log(pc2.cyan("    /list") + pc2.gray("             List all sandboxes"));
+  console.log(pc2.cyan("    /switch <id>") + pc2.gray("      Switch active sandbox"));
+  console.log(pc2.cyan("    /destroy <id>") + pc2.gray("     Destroy a sandbox by ID"));
+  console.log(pc2.cyan("    /destroy --all") + pc2.gray("    Destroy all sandboxes"));
   console.log();
-  console.log(pc.bold("  Other Commands"));
+  console.log(pc2.bold("  Other Commands"));
   console.log();
-  console.log(pc.cyan("    /info") + pc.gray("             Show active sandbox info"));
-  console.log(pc.cyan("    /url <port>") + pc.gray("       Get public URL for port"));
-  console.log(pc.cyan("    /help") + pc.gray("             Show this help"));
-  console.log(pc.cyan("    /exit") + pc.gray("             Exit the REPL"));
+  console.log(pc2.cyan("    /info") + pc2.gray("             Show active sandbox info"));
+  console.log(pc2.cyan("    /url <port>") + pc2.gray("       Get public URL for port"));
+  console.log(pc2.cyan("    /help") + pc2.gray("             Show this help"));
+  console.log(pc2.cyan("    /exit") + pc2.gray("             Exit the REPL"));
   console.log();
 }
 function loadHistory(rl) {
@@ -343,7 +343,7 @@ import * as fs3 from "fs";
 import * as path4 from "path";
 import * as os3 from "os";
 import * as p3 from "@clack/prompts";
-import pc4 from "picocolors";
+import pc5 from "picocolors";
 function shellEscape(arg) {
   if (/^[a-zA-Z0-9._\-/:=@]+$/.test(arg)) return arg;
   return `'${arg.replace(/'/g, "'\\''")}'`;
@@ -382,7 +382,7 @@ async function workspaceCreate(options) {
       }
       existing.lastUsed = (/* @__PURE__ */ new Date()).toISOString();
       saveState(state);
-      p3.log.info(`Attaching to existing workspace: ${pc4.cyan(id)}`);
+      p3.log.info(`Attaching to existing workspace: ${pc5.cyan(id)}`);
       return existing;
     } catch {
       delete state.workspaces[id];
@@ -394,9 +394,9 @@ async function workspaceCreate(options) {
   let sandbox;
   try {
     sandbox = await compute3.sandbox.create();
-    spinner4.stop(`Sandbox ready: ${pc4.cyan(sandbox.sandboxId)}`);
+    spinner4.stop(`Sandbox ready: ${pc5.cyan(sandbox.sandboxId)}`);
   } catch (error) {
-    spinner4.stop(pc4.red("Failed to create sandbox"));
+    spinner4.stop(pc5.red("Failed to create sandbox"));
     throw error;
   }
   spinner4.start("Bootstrapping workspace (installing gh CLI, cloning repo)...");
@@ -413,8 +413,8 @@ async function workspaceCreate(options) {
       { timeout: 3e5 }
       // 5 min timeout for auth
     );
-    const output = result.stdout || "";
-    const jsonMatch = output.match(/\{[\s\S]*\}/);
+    const output2 = result.stdout || "";
+    const jsonMatch = output2.match(/\{[\s\S]*\}/);
     let worktreePath = `/workspaces/${path4.basename(repo)}-${branch}`;
     if (jsonMatch) {
       try {
@@ -436,12 +436,12 @@ async function workspaceCreate(options) {
     };
     state.workspaces[id] = workspace;
     saveState(state);
-    p3.log.success(`Workspace ready: ${pc4.cyan(id)}`);
-    p3.log.info(`Sandbox: ${pc4.dim(sandbox.sandboxId)}`);
-    p3.log.info(`Worktree: ${pc4.dim(worktreePath)}`);
+    p3.log.success(`Workspace ready: ${pc5.cyan(id)}`);
+    p3.log.info(`Sandbox: ${pc5.dim(sandbox.sandboxId)}`);
+    p3.log.info(`Worktree: ${pc5.dim(worktreePath)}`);
     return workspace;
   } catch (error) {
-    spinner4.stop(pc4.red("Bootstrap failed"));
+    spinner4.stop(pc5.red("Bootstrap failed"));
     try {
       await sandbox.destroy();
     } catch {
@@ -466,9 +466,9 @@ async function workspaceAttach(id) {
   }
   workspace.lastUsed = (/* @__PURE__ */ new Date()).toISOString();
   saveState(state);
-  p3.log.info(`Attaching to workspace: ${pc4.cyan(id)}`);
-  p3.log.info(`Worktree: ${pc4.dim(workspace.worktreePath)}`);
-  console.log(pc4.gray(`Tip: commands run at sandbox root; use { cwd: "${workspace.worktreePath}" } on runCommand to scope them.`));
+  p3.log.info(`Attaching to workspace: ${pc5.cyan(id)}`);
+  p3.log.info(`Worktree: ${pc5.dim(workspace.worktreePath)}`);
+  console.log(pc5.gray(`Tip: commands run at sandbox root; use { cwd: "${workspace.worktreePath}" } on runCommand to scope them.`));
   try {
     await startREPL(sandbox, workspace.provider);
   } catch (error) {
@@ -485,19 +485,19 @@ async function sandboxList() {
     return;
   }
   console.log();
-  console.log(pc4.bold("Sandboxes"));
+  console.log(pc5.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 ? pc4.red("stale") : age > 1 ? pc4.yellow("idle") : pc4.green("active");
-    console.log(`  ${status} ${pc4.cyan(ws.sandboxId)}`);
-    console.log(`    Workspace: ${pc4.dim(ws.id)}`);
+    const status = age > 7 ? pc5.red("stale") : age > 1 ? pc5.yellow("idle") : pc5.green("active");
+    console.log(`  ${status} ${pc5.cyan(ws.sandboxId)}`);
+    console.log(`    Workspace: ${pc5.dim(ws.id)}`);
     console.log(`    Provider: ${ws.provider}`);
-    console.log(`    Last active: ${pc4.gray(ageStr)}`);
+    console.log(`    Last active: ${pc5.gray(ageStr)}`);
     console.log();
   }
-  console.log(pc4.gray('Tip: Use "compute workspaces" to see full workspace details'));
+  console.log(pc5.gray('Tip: Use "compute workspaces" to see full workspace details'));
 }
 async function workspaceList() {
   const state = loadState();
@@ -508,15 +508,15 @@ async function workspaceList() {
     return;
   }
   console.log();
-  console.log(pc4.bold("Workspaces"));
+  console.log(pc5.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(`  ${pc4.cyan(ws.id)}`);
-    console.log(`    Sandbox: ${pc4.dim(ws.sandboxId)} (${ws.provider})`);
-    console.log(`    Path: ${pc4.dim(ws.worktreePath)}`);
-    console.log(`    Last used: ${pc4.gray(ageStr)}`);
+    console.log(`  ${pc5.cyan(ws.id)}`);
+    console.log(`    Sandbox: ${pc5.dim(ws.sandboxId)} (${ws.provider})`);
+    console.log(`    Path: ${pc5.dim(ws.worktreePath)}`);
+    console.log(`    Last used: ${pc5.gray(ageStr)}`);
     console.log();
   }
 }
@@ -542,7 +542,7 @@ async function workspaceDestroy(id) {
       p3.log.error(`Workspace not found: ${id}`);
       return;
     }
-    p3.log.info(`Destroying workspace: ${pc4.cyan(id)}`);
+    p3.log.info(`Destroying workspace: ${pc5.cyan(id)}`);
     try {
       await compute3.sandbox.destroy(workspace.sandboxId);
       delete state.workspaces[id];
@@ -586,38 +586,63 @@ init_esm_shims();
 import "dotenv/config";
 import { Command } from "commander";
 import * as p4 from "@clack/prompts";
-import pc5 from "picocolors";
+import pc6 from "picocolors";
 import { readFileSync as readFileSync4 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname2, join as join4 } from "path";
+import { dirname as dirname2, join as join5 } from "path";
 import { compute as compute4 } 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"
-];
+var PROVIDER_ENV = {
+  e2b: { authOptions: [["E2B_API_KEY"]], configKeys: { E2B_API_KEY: "apiKey" } },
+  railway: { authOptions: [["RAILWAY_API_TOKEN"]], configKeys: { RAILWAY_API_TOKEN: "token" } },
+  modal: {
+    authOptions: [["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"]],
+    configKeys: { MODAL_TOKEN_ID: "tokenId", MODAL_TOKEN_SECRET: "tokenSecret" }
+  },
+  vercel: {
+    authOptions: [["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"], ["VERCEL_OIDC_TOKEN"]],
+    configKeys: {
+      VERCEL_TOKEN: "token",
+      VERCEL_TEAM_ID: "teamId",
+      VERCEL_PROJECT_ID: "projectId"
+    }
+  },
+  daytona: { authOptions: [["DAYTONA_API_KEY"]], configKeys: { DAYTONA_API_KEY: "apiKey" } },
+  namespace: {
+    authOptions: [["NSC_TOKEN"], ["NSC_TOKEN_FILE"]],
+    configKeys: { NSC_TOKEN: "token", NSC_TOKEN_FILE: "tokenFile" }
+  },
+  blaxel: {
+    authOptions: [["BL_API_KEY", "BL_WORKSPACE"]],
+    configKeys: { BL_API_KEY: "apiKey", BL_WORKSPACE: "workspace" }
+  },
+  codesandbox: { authOptions: [["CSB_API_KEY"]], configKeys: { CSB_API_KEY: "apiKey" } },
+  render: { authOptions: [["RENDER_API_KEY"]], configKeys: { RENDER_API_KEY: "apiKey" } }
+};
+var PROVIDER_NAMES = Object.keys(PROVIDER_ENV);
+function missingEnvVars(provider) {
+  const spec = PROVIDER_ENV[provider];
+  if (!spec) return [];
+  let best = null;
+  for (const option of spec.authOptions) {
+    const missing = option.filter((name) => !process.env[name]);
+    if (missing.length === 0) return [];
+    if (!best || missing.length < best.length) best = missing;
+  }
+  return best ?? [];
+}
+function isProviderAuthComplete(provider) {
+  return missingEnvVars(provider).length === 0;
+}
 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)) {
+    if (isProviderAuthComplete(provider)) {
       available.push(provider);
     }
   }
@@ -632,13 +657,11 @@ function getProviderStatus() {
     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)
-      });
-    }
+    statuses.push({
+      name: provider,
+      ready: isProviderAuthComplete(provider),
+      missing: missingEnvVars(provider)
+    });
   }
   return statuses;
 }
@@ -652,9 +675,15 @@ function buildProviderConfig(provider) {
     config.computesdk = {
       computesdk_api_key: process.env.COMPUTESDK_API_KEY
     };
-  }
-  if (provider !== "computesdk") {
-    const providerConfig = getProviderConfigFromEnv(provider);
+    return config;
+  }
+  const spec = PROVIDER_ENV[provider];
+  if (spec) {
+    const providerConfig = {};
+    for (const [envVar, key] of Object.entries(spec.configKeys)) {
+      const value = process.env[envVar];
+      if (value) providerConfig[key] = value;
+    }
     if (Object.keys(providerConfig).length > 0) {
       config[provider] = providerConfig;
     }
@@ -662,6 +691,742 @@ function buildProviderConfig(provider) {
   return config;
 }
 
+// src/actions.ts
+init_esm_shims();
+import pc from "picocolors";
+import { mkdirSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+
+// src/actions-client.ts
+init_esm_shims();
+var DEFAULT_BASE_URL = "https://platform.computesdk.com";
+var ActionsApiError = class extends Error {
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "ActionsApiError";
+  }
+};
+var ActionsClient = class {
+  constructor(auth, fetchImpl = fetch) {
+    this.auth = auth;
+    this.fetchImpl = fetchImpl;
+    this.orgPromise = null;
+  }
+  get baseUrl() {
+    return this.auth.baseUrl;
+  }
+  /** The credential's org — fetched once, needed for dashboard URLs. */
+  org() {
+    this.orgPromise ?? (this.orgPromise = this.get("/api/v1/actions/org"));
+    return this.orgPromise;
+  }
+  async get(path5, params) {
+    const url = new URL(`${this.auth.baseUrl}${path5}`);
+    for (const [key, value] of Object.entries(params ?? {})) {
+      if (value === void 0) continue;
+      for (const v of Array.isArray(value) ? value : [value]) url.searchParams.append(key, v);
+    }
+    const res = await this.fetchImpl(url, { headers: this.headers() });
+    return this.parse(res);
+  }
+  async post(path5, body = {}) {
+    const res = await this.fetchImpl(`${this.auth.baseUrl}${path5}`, {
+      method: "POST",
+      headers: { ...this.headers(), "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    return this.parse(res);
+  }
+  async put(path5, body = {}) {
+    const res = await this.fetchImpl(`${this.auth.baseUrl}${path5}`, {
+      method: "PUT",
+      headers: { ...this.headers(), "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    return this.parse(res);
+  }
+  async del(path5) {
+    const res = await this.fetchImpl(`${this.auth.baseUrl}${path5}`, {
+      method: "DELETE",
+      headers: this.headers()
+    });
+    return this.parse(res);
+  }
+  /**
+   * One `data:` JSON payload per SSE event. `next()` resolves to the payload,
+   * or null when the stream ends. Call `close()` to abort.
+   */
+  async *sse(path5, params) {
+    const url = new URL(`${this.auth.baseUrl}${path5}`);
+    for (const [key, value] of Object.entries(params ?? {})) {
+      if (value === void 0) continue;
+      for (const v of Array.isArray(value) ? value : [value]) url.searchParams.append(key, v);
+    }
+    const res = await this.fetchImpl(url, { headers: this.headers() });
+    if (!res.ok) {
+      await this.parse(res);
+    }
+    if (!res.body) throw new Error("SSE response has no body");
+    yield* readSseEvents(res.body);
+  }
+  /** Download bytes following redirects (artifact URLs 302 to storage). */
+  async download(path5) {
+    const res = await this.fetchImpl(`${this.auth.baseUrl}${path5}`, {
+      headers: this.headers(),
+      redirect: "follow"
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => void 0);
+      throw new ActionsApiError(res.status, errorMessage(body, res.status), body);
+    }
+    return new Uint8Array(await res.arrayBuffer());
+  }
+  headers() {
+    return { authorization: `Bearer ${this.auth.apiKey}` };
+  }
+  async parse(res) {
+    const body = await res.json().catch(() => void 0);
+    if (!res.ok) throw new ActionsApiError(res.status, errorMessage(body, res.status), body);
+    return body;
+  }
+};
+function errorMessage(body, status) {
+  if (body && typeof body === "object" && "error" in body && typeof body.error === "string") {
+    return body.error;
+  }
+  return `Request failed with status ${status}`;
+}
+async function* readSseEvents(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let idx;
+      while ((idx = buffer.indexOf("\n\n")) !== -1) {
+        const event = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + 2);
+        for (const line of event.split("\n")) {
+          if (line.startsWith("data: ")) {
+            yield JSON.parse(line.slice(6));
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function encodeWatchCursor(id, jobId, step, offset) {
+  const stepPart = step === null ? "-" : step === "runner" ? "runner" : String(step);
+  return `${id}:${jobId}:${stepPart}:${offset}`;
+}
+function resolveActionsAuth(opts) {
+  const apiKey = opts.apiKey || process.env.COMPUTE_API_KEY || process.env.BENCHMARKS_PLATFORM_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "No API key. Set COMPUTE_API_KEY or pass --api-key."
+    );
+  }
+  const baseUrl = (opts.baseUrl || process.env.COMPUTE_PLATFORM_URL || process.env.BENCHMARKS_PLATFORM_URL || // legacy name
+  DEFAULT_BASE_URL).replace(/\/+$/, "");
+  if (!opts.allowUntrustedHost && !isTrustedActionsHost(baseUrl)) {
+    throw new Error(
+      `Refusing to send the API key to ${baseUrl} \u2014 it is not a computesdk.com or localhost host. If this is a self-hosted/dev deployment you trust, pass --allow-untrusted-host.`
+    );
+  }
+  return { apiKey, baseUrl };
+}
+function isTrustedActionsHost(baseUrl) {
+  let host;
+  try {
+    host = new URL(baseUrl).hostname;
+  } catch {
+    return false;
+  }
+  return host === "computesdk.com" || host.endsWith(".computesdk.com") || host === "localhost" || host === "127.0.0.1" || host === "::1";
+}
+
+// src/actions.ts
+function sanitizePathPart(name) {
+  const base = basename(name);
+  if (base === "" || base === "." || base === "..") return "artifact";
+  return base;
+}
+function client(opts) {
+  return new ActionsClient(resolveActionsAuth(opts));
+}
+function output(opts, data, render) {
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+  } else {
+    render(data);
+  }
+}
+async function listRunJobs(c, runId) {
+  try {
+    const run = await c.get(`/api/v1/actions/runs/${runId}`);
+    return run.jobs;
+  } catch (e) {
+    if (!(e instanceof ActionsApiError) || e.status !== 404) throw e;
+  }
+  const state = await c.get(`/api/v1/actions/runs/${runId}/state`);
+  return state.jobs.map((j) => ({
+    id: j.id,
+    name: j.id.slice(0, 8),
+    // the live-state route does not carry job names
+    needs: [],
+    workflowJobId: null,
+    matrix: null,
+    state: j.state,
+    provider: j.provider,
+    region: j.region,
+    sandboxId: j.sandboxId,
+    placementAttempts: j.placementAttempts,
+    durationMs: null,
+    steps: []
+  }));
+}
+function fail(error) {
+  if (error instanceof ActionsApiError) {
+    console.error(pc.red(`Error (${error.status}): ${error.message}`));
+  } else {
+    console.error(pc.red(`Error: ${error.message}`));
+  }
+  process.exit(1);
+}
+function formatDuration(ms) {
+  if (ms === null || ms === void 0) return "-";
+  if (ms < 1e3) return `${ms}ms`;
+  const s = Math.round(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m${s % 60}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h${m % 60}m`;
+}
+function shortSha(sha) {
+  return sha.slice(0, 8);
+}
+function conclusionLabel(conclusion) {
+  switch (conclusion) {
+    case "passed":
+      return pc.green("passed");
+    case "failed":
+      return pc.red("failed");
+    case "running":
+      return pc.yellow("running");
+    case "cancelled":
+      return pc.gray("cancelled");
+    case "none":
+      return pc.yellow("queued");
+    default:
+      return conclusion;
+  }
+}
+function formatRunRow(run) {
+  const num = run.runNumber === null ? "-" : `#${run.runNumber}`;
+  return [
+    run.id,
+    pc.dim(num),
+    run.workflowName || run.workflowPath,
+    conclusionLabel(run.conclusion),
+    pc.dim(`${run.repoFullName}@${run.ref}`),
+    shortSha(run.headSha),
+    formatDuration(run.durationMs),
+    run.startedAt
+  ].join("  ");
+}
+function formatRunDetail(run, runUrl) {
+  const lines = [];
+  lines.push(`${pc.bold(run.workflowName || run.workflowPath)}  ${conclusionLabel(run.conclusion)}`);
+  lines.push(pc.dim(`run ${run.id}${run.runNumber === null ? "" : `  #${run.runNumber}`}`));
+  lines.push(`${run.repoFullName} @ ${run.ref}  ${shortSha(run.headSha)}  ${run.event}${run.prNumber ? `  PR #${run.prNumber}` : ""}`);
+  lines.push(`title: ${run.title}`);
+  lines.push(`started: ${run.startedAt}  duration: ${formatDuration(run.durationMs)}`);
+  if (run.cancellationReason) lines.push(`cancelled: ${run.cancellationReason}`);
+  if (run.providerOverride) lines.push(`dispatched to: ${run.providerOverride}`);
+  if (run.supersededByRunId) lines.push(`superseded by: ${run.supersededByRunId}`);
+  if (runUrl) lines.push(`url: ${runUrl}`);
+  if (run.jobs.length > 0) {
+    lines.push("");
+    lines.push(pc.bold("jobs"));
+    for (const job of run.jobs) {
+      const placement = job.provider ? `${job.provider}${job.region ? `:${job.region}` : ""}` : "-";
+      lines.push(`  ${job.id}  ${job.name}  ${conclusionLabel(job.state)}  ${placement}  ${formatDuration(job.durationMs)}`);
+      for (const attempt of job.placementAttempts) {
+        lines.push(pc.dim(`    placement failed on ${attempt.provider}${attempt.region ? `:${attempt.region}` : ""}: ${attempt.error}`));
+      }
+      for (const step of job.steps) {
+        const exit = step.exitCode === null ? "" : ` (exit ${step.exitCode})`;
+        lines.push(pc.dim(`    ${step.name}  ${step.state}${exit}  ${formatDuration(step.durationMs)}`));
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function parseInputs(pairs) {
+  const inputs = {};
+  for (const pair of pairs ?? []) {
+    const eq = pair.indexOf("=");
+    if (eq === -1) {
+      throw new Error(`Invalid --inputs entry "${pair}". Expected key=value.`);
+    }
+    inputs[pair.slice(0, eq)] = pair.slice(eq + 1);
+  }
+  return inputs;
+}
+function matchWorkflow(workflows, selector) {
+  return workflows.find((w) => w.path === selector) ?? workflows.find((w) => w.name === selector) ?? workflows.find((w) => w.id === selector);
+}
+function matchJob(jobs, selector) {
+  return jobs.find((j) => j.id === selector) ?? jobs.find((j) => j.name === selector);
+}
+async function readWholeJobLog(client2, jobId, step) {
+  const segments = [];
+  let offset = 0;
+  let slice;
+  do {
+    slice = await client2.get(`/api/v1/actions/jobs/${jobId}/logs`, {
+      offset: String(offset),
+      step
+    });
+    segments.push(...slice.segments);
+    offset = slice.nextOffset;
+  } while (slice.truncated);
+  return { ...slice, segments };
+}
+async function* followJobLog(client2, jobId, step) {
+  let offset = 0;
+  for (; ; ) {
+    let terminal = false;
+    for await (const raw of client2.sse(`/api/v1/actions/jobs/${jobId}/logs`, {
+      offset: String(offset),
+      follow: "1",
+      step
+    })) {
+      const slice = raw;
+      offset = slice.nextOffset;
+      if (slice.segments.length > 0 || slice.state !== "running") yield slice;
+      if (slice.state !== "running" && slice.state !== "pending" && !slice.truncated) {
+        terminal = true;
+      }
+    }
+    if (terminal) return;
+  }
+}
+function parseStep(step) {
+  if (step === void 0) return null;
+  if (step === "runner") return "runner";
+  const n = Number(step);
+  if (!Number.isInteger(n) || n < 0) {
+    throw new Error(`Invalid --step "${step}". Expected a step ordinal or "runner".`);
+  }
+  return n;
+}
+async function* followRunLogs(client2, runId, jobs, step) {
+  const cursorStep = parseStep(step);
+  const offsets = new Map(jobs.map((j) => [j.id, 0]));
+  const byCursor = new Map(jobs.map((j, i) => [`j${i}`, j]));
+  for (; ; ) {
+    let done = false;
+    const watch = jobs.map(
+      (j, i) => encodeWatchCursor(`j${i}`, j.id, cursorStep, offsets.get(j.id) ?? 0)
+    );
+    for await (const raw of client2.sse(`/api/v1/actions/runs/${runId}/stream`, { watch })) {
+      const msg = raw;
+      if (msg.type === "log") {
+        const job = byCursor.get(msg.cursor);
+        if (job) {
+          offsets.set(msg.slice.jobId, msg.slice.nextOffset);
+          yield { job, slice: msg.slice };
+        }
+      } else if (msg.type === "done") {
+        done = true;
+        break;
+      } else if (msg.type === "reconnect") {
+        break;
+      }
+    }
+    if (done) return;
+    await new Promise((r) => setTimeout(r, 1e3));
+  }
+}
+function safeTerm(s) {
+  return s.replace(/[\u0000-\u001F\u007F-\u009F]/g, "\uFFFD");
+}
+function formatRunHistory(history) {
+  const lines = [];
+  const parts = Object.entries(history.conclusions).map(([c, n]) => `${n} ${c}`).join(", ");
+  lines.push(`last ${history.runCount} runs: ${parts || "none"}`);
+  if (history.jobs.length > 0) {
+    lines.push("");
+    lines.push(pc.bold("jobs"));
+    for (const job of history.jobs) {
+      const rate = job.runs > 0 ? Math.round(job.failedRuns / job.runs * 100) : 0;
+      const platform = job.failedBeforeSteps > 0 ? pc.dim(`  (${job.failedBeforeSteps} failed before steps)`) : "";
+      const count = `${job.failedRuns}/${job.runs} runs failed`;
+      const label = job.failedRuns > 0 ? pc.red(count) : pc.green(count);
+      lines.push(`  ${safeTerm(job.job)}  ${label}  ${rate}%${platform}`);
+      for (const step of job.steps) {
+        lines.push(pc.dim(`    step "${safeTerm(step.step)}" failed in ${step.failedRuns} run${step.failedRuns === 1 ? "" : "s"}`));
+      }
+    }
+  }
+  const failed = history.runs.filter(
+    (r) => r.conclusion === "failed" || r.failedJobs.length > 0
+  );
+  if (failed.length > 0) {
+    lines.push("");
+    lines.push(pc.bold("failed runs"));
+    for (const run of failed) {
+      const blame = run.failedJobs.length > 0 ? run.failedJobs.map((j) => safeTerm(j.step === null ? j.job : `${j.job}:${j.step}`)).join(", ") : pc.dim("(no failed job recorded)");
+      lines.push(`  ${shortSha(run.headSha)}  ${pc.dim(run.startedAt)}  ${blame}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatProviderRow(p5) {
+  const icon = p5.usable ? pc.green("\u25CF") : pc.gray("\u25CB");
+  const name = p5.usable ? pc.white(p5.provider) : pc.gray(p5.provider);
+  const flags = [
+    p5.credential,
+    p5.actCapable ? pc.green("act") : pc.gray("no-act"),
+    p5.regions.length > 0 ? `regions: ${p5.regions.join(",")}` : "no region choice",
+    p5.position === null ? pc.gray("not in provider order") : `order #${p5.position}`
+  ].join("  ");
+  return `  ${icon} ${name}  ${flags}`;
+}
+function formatVerifyResult(r) {
+  const ok = r.verified === true;
+  const head = ok ? pc.green("verified") : pc.red("not verified");
+  const detail = r.key.statusDetail ? pc.dim(`  ${r.key.statusDetail}`) : "";
+  const act = r.key.actCapable ? pc.green("  act-capable") : "";
+  return `${head}  ${r.key.provider}${act}${detail}`;
+}
+function registerActionsCommands(program2) {
+  const actions = program2.command("actions").alias("ci").description("Drive the benchmarks-platform Actions API");
+  const common = (cmd) => cmd.option("--api-key <key>", "API key (default: $COMPUTE_API_KEY)").option("--base-url <url>", "API base URL (default: https://platform.computesdk.com)").option("--allow-untrusted-host", "send the API key to a non-computesdk, non-localhost --base-url").option("--json", "print machine-readable JSON");
+  common(
+    actions.command("dispatch").description("Dispatch a workflow_dispatch run").argument("<repo>", "repository in owner/repo format").requiredOption("--workflow <path|name>", "workflow path or name").option("--ref <ref>", "git ref to run (default: the workflow's first watched ref)").option("--inputs <pairs...>", "workflow inputs as key=value").option("--provider <id>", "place the run on one provider (e.g. namespace, vercel:sfo1) instead of the org provider order").option("--provider-region <region>", "region for --provider (same as --provider <id>:<region>)")
+  ).action(async (repo, opts) => {
+    try {
+      const c = client(opts);
+      const { workflows } = await c.get(
+        "/api/v1/actions/workflows",
+        { repo }
+      );
+      const workflow = matchWorkflow(workflows, opts.workflow);
+      if (!workflow) {
+        const choices = workflows.map((w) => `${w.path} (${w.name})`).join(", ") || "none";
+        throw new Error(
+          `No dispatchable workflow "${opts.workflow}" in ${repo}. Available: ${choices}`
+        );
+      }
+      const ref = opts.ref ?? workflow.refs[0];
+      if (!ref) throw new Error("No --ref given and the workflow has no watched refs.");
+      if (opts.providerRegion !== void 0 && opts.provider === void 0) {
+        throw new Error("--provider-region requires --provider.");
+      }
+      const result = await c.post(
+        "/api/v1/actions/dispatch",
+        {
+          workflowId: workflow.id,
+          ref,
+          inputs: parseInputs(opts.inputs),
+          ...opts.provider !== void 0 && {
+            provider: opts.provider,
+            ...opts.providerRegion !== void 0 && { providerRegion: opts.providerRegion }
+          }
+        }
+      );
+      const org = await c.org();
+      const url = `${c.baseUrl}/${org.slug}/actions/runs/${result.runId}`;
+      output(opts, { ...result, url }, (r) => {
+        console.log(`${r.created ? "dispatched" : "already running"}  ${pc.cyan(r.runId)}`);
+        console.log(`sha: ${r.headSha}`);
+        console.log(`url: ${r.url}`);
+      });
+    } catch (e) {
+      fail(e);
+    }
+  });
+  common(
+    actions.command("runs").description("List recent runs for a repo").argument("<repo>", "repository in owner/repo format").option("--status <status...>", "filter by conclusion: passed, failed, running, cancelled, none").option("--branch <branch...>", "filter by branch/ref")
+  ).action(async (repo, opts) => {
+    try {
+      const { runs } = await client(opts).get(
+        "/api/v1/actions/runs",
+        { repo, status: opts.status, branch: opts.branch }
+      );
+      output(opts, runs, (rs) => {
+        if (rs.length === 0) {
+          console.log("No runs found.");
+          return;
+        }
+        for (const run of rs) console.log(formatRunRow(run));
+      });
+    } catch (e) {
+      fail(e);
+    }
+  });
+  common(
+    actions.command("history").description("Recent run history for a workflow \u2014 per-job/step failure rates (is this failure flaky?)").argument("<repo>", "repository in owner/repo format").requiredOption("--workflow <path|name>", "workflow path or name").option("--branch <branch...>", "narrow the window to branches/refs").option("--job <job>", "narrow the rollup to one job name or workflow job id").option("--limit <n>", "runs in the window (default 10, max 50)")
+  ).action(async (repo, opts) => {
+    try {
+      const c = client(opts);
+      const { workflows } = await c.get(
+        "/api/v1/actions/workflows",
+        { repo }
+      );
+      const workflow = matchWorkflow(workflows, opts.workflow) ?? workflows.find((w) => w.path === opts.workflow);
+      const workflowPath = workflow?.path ?? opts.workflow;
+      const history = await c.get("/api/v1/actions/history", {
+        repo,
+        workflow: workflowPath,
+        branch: opts.branch,
+        job: opts.job,
+        limit: opts.limit
+      });
+      output(opts, history, (h) => console.log(formatRunHistory(h)));
+    } catch (e) {
+      fail(e);
+    }
+  });
+  common(
+    actions.command("run").description("Show a run: jobs, provider:region placement, placement attempts").argument("<run-id>", "run ID")
+  ).action(async (runId, opts) => {
+    try {
+      const c = client(opts);
+      const run = await c.get(`/api/v1/actions/runs/${runId}`);
+      const org = await c.org();
+      const url = `${c.baseUrl}/${org.slug}/actions/runs/${run.id}`;
+      output(opts, { ...run, url }, (r) => console.log(formatRunDetail(r, r.url)));
+    } catch (e) {
+      fail(e);
+    }
+  });
+  common(
+    actions.command("logs").description("Print or follow a run's job logs").argument("<run-id>", "run ID").option("--job <job>", "job ID or name (default: all jobs)").option("--step <step>", 'step ordinal or "runner" (default: whole job)').option("--follow", "stream logs while the run is live")
+  ).action(async (runId, opts) => {
+    try {
+      const c = client(opts);
+      let jobs = await listRunJobs(c, runId);
+      if (opts.job) {
+        const job = matchJob(jobs, opts.job);
+        if (!job) {
+          throw new Error(
+            `No job "${opts.job}" in run ${runId}. Jobs: ${jobs.map((j) => j.name).join(", ") || "none"}`
+          );
+        }
+        jobs = [job];
+      }
+      if (jobs.length === 0) {
+        if (opts.json) output(opts, { segments: [] }, () => {
+        });
+        else console.error("Run has no jobs yet.");
+        return;
+      }
+      if (!opts.follow) {
+        for (const job of jobs) {
+          const slice = await readWholeJobLog(c, job.id, opts.step);
+          if (opts.json) {
+            process.stdout.write(JSON.stringify({ jobId: job.id, name: job.name, slice }) + "\n");
+          } else {
+            if (jobs.length > 1) console.log(pc.bold(`\u2500\u2500 ${job.name} \u2500\u2500`));
+            for (const seg of slice.segments) process.stdout.write(seg.text);
+          }
+        }
+        return;
+      }
+      if (jobs.length === 1) {
+        for await (const slice of followJobLog(c, jobs[0].id, opts.step)) {
+          if (opts.json) {
+            process.stdout.write(JSON.stringify(slice) + "\n");
+          } else {
+            for (const seg of slice.segments) process.stdout.write(seg.text);
+          }
+        }
+        return;
+      }
+      for await (const { job, slice } of followRunLogs(c, runId, jobs, opts.step)) {
+        if (opts.json) {
+          process.stdout.write(JSON.stringify({ jobId: job.id, name: job.name, slice }) + "\n");
+        } else {
+          for (const seg of slice.segments) {
+            const text2 = seg.text.replace(/\n/g, `
+[${job.name}] `);
+            process.stdout.write(`[${job.name}] ${text2}`);
+          }
+        }
+      }
+    } catch (e) {
+      fail(e);
+    }
+  });
+  const providers = actions.command("providers").description("List the org's registered compute providers (regions, act/usable status)");
+  common(providers).action(async (opts) => {
+    try {
+      const data = await client(opts).get("/api/v1/actions/providers");
+      output(opts, data, (d) => {
+        for (const p5 of d.providers) console.log(formatProviderRow(p5));
+      });
+    } catch (e) {
+      fail(e);
+    }
+  });
+  common(
+    providers.command("configure").description("Save the org's credential for a provider (owner/admin API key)").argument("<provider>", "provider id (e.g. tensorlake, blaxel)").option("--key <key>", "provider API key (single-field credentials)").option("--field <pair...>", "credential fields as name=value (multi-field providers)").option("--verify", "run the placement probe after saving")
+  ).action(async (provider, opts) => {
+    try {
+      const c = client(opts);
+      let body;
+      if (opts.field !== void 0) {
+        if (opts.key !== void 0) throw new Error("Pass either --key or --field, not both.");
+        body = { fields: parseInputs(opts.field) };
+      } else if (opts.key !== void 0) {
+        body = { key: opts.key };
+      } else {
+        throw new Error("Pass --key <key> or --field name=value.");
+      }
+      const saved = await c.put(
+        `/api/v1/actions/providers/${provider}/key`,
+        body
+      );
+      const verification = opts.verify ? await c.post(
+        `/api/v1/actions/providers/${provider}/verify`
+      ) : void 0;
+      output(opts, verification ? { key: saved.key, verification } : saved, () => {
+        console.log(`saved  ${saved.key.provider}  ${pc.dim(saved.key.keyHint)}  ${saved.key.status}`);
+        if (verification) console.log(formatVerifyResult(verification));
+      });
+      if (verification?.verified === false) process.exitCode = 1;
+    } catch (e) {
+      fail(e);
+    }
+  });
+  common(
+    providers.command("verify").description('Probe the stored provider key with a real sandbox ("Test" in Settings)').argument("<provider>", "provider id")
+  ).action(async (provider, opts) => {
+    try {
+      const result = await client(opts).post(
+        `/api/v1/actions/providers/${provider}/verify`
+      );
+      output(opts, result, (r) => console.log(formatVerifyResult(r)));
+      if (result.verified === false) process.exitCode = 1;
+    } catch (e) {
+      fail(e);
+    }
+  });
+  common(
+    providers.command("remove").description("Delete the org's stored credential for a provider").argument("<provider>", "provider id")
+  ).action(async (provider, opts) => {
+    try {
+      const result = await client(opts).del(
+        `/api/v1/actions/providers/${provider}/key`
+      );
+      output(opts, result, (r) => {
+        console.log(r.deleted ? `deleted  ${r.provider}` : `no key stored for ${r.provider}`);
+      });
+    } catch (e) {
+      fail(e);
+    }
+  });
+  common(
+    actions.command("cancel").description("Cancel a run").argument("<run-id>", "run ID")
+  ).action(async (runId, opts) => {
+    try {
+      const result = await client(opts).post(
+        `/api/v1/actions/runs/${runId}/cancel`
+      );
+      output(opts, result, (r) => {
+        console.log(r.cancelled ? `Cancelled ${runId}` : `Run ${runId} was already finished`);
+      });
+    } catch (e) {
+      fail(e);
+    }
+  });
+  common(
+    actions.command("rerun").description("Re-run a finished run at the same commit").argument("<run-id>", "run ID")
+  ).action(async (runId, opts) => {
+    try {
+      const c = client(opts);
+      const result = await c.post(
+        `/api/v1/actions/runs/${runId}/rerun`
+      );
+      const org = await c.org();
+      const url = `${c.baseUrl}/${org.slug}/actions/runs/${result.runId}`;
+      output(opts, { ...result, url }, (r) => {
+        console.log(`${r.created ? "rerun dispatched" : "rerun already running"}  ${pc.cyan(r.runId)}`);
+        console.log(`url: ${r.url}`);
+      });
+    } catch (e) {
+      fail(e);
+    }
+  });
+  common(
+    actions.command("artifacts").description("List or download a run's artifacts").argument("<run-id>", "run ID").option("--job <job>", "job ID or name (default: all jobs)").option("--out <dir>", "download artifacts into this directory instead of listing")
+  ).action(async (runId, opts) => {
+    try {
+      const c = client(opts);
+      let jobs = await listRunJobs(c, runId);
+      if (opts.job) {
+        const job = matchJob(jobs, opts.job);
+        if (!job) throw new Error(`No job "${opts.job}" in run ${runId}.`);
+        jobs = [job];
+      }
+      const entries = [];
+      for (const job of jobs) {
+        const artifacts = await c.get(
+          `/api/v1/actions/jobs/${job.id}/artifacts`
+        );
+        entries.push({ job, artifacts });
+      }
+      if (opts.out) {
+        const written = [];
+        for (const { job, artifacts } of entries) {
+          const jobDir = join(opts.out, sanitizePathPart(job.name || job.id));
+          mkdirSync(jobDir, { recursive: true });
+          for (const artifact of artifacts) {
+            if (artifact.expired || artifact.skippedReason) continue;
+            const bytes = await c.download(
+              `/api/v1/actions/jobs/${job.id}/artifacts/${artifact.id}`
+            );
+            const file = join(jobDir, sanitizePathPart(artifact.fileName || artifact.name));
+            writeFileSync(file, bytes);
+            written.push({ jobId: job.id, id: artifact.id, file });
+          }
+        }
+        output(opts, written, (ws) => {
+          for (const w of ws) console.log(`wrote ${w.file}`);
+          if (ws.length === 0) console.log("No downloadable artifacts.");
+        });
+        return;
+      }
+      output(opts, entries.map((e) => ({ jobId: e.job.id, job: e.job.name, artifacts: e.artifacts })), (es) => {
+        let any = false;
+        for (const { job, artifacts } of es) {
+          for (const a of artifacts) {
+            any = true;
+            const flags = a.expired ? "  expired" : a.skippedReason ? `  skipped: ${a.skippedReason}` : "";
+            console.log(
+              `${job}  ${a.id}  ${a.name}  ${a.contentType}  ${a.byteLength}B${flags}`
+            );
+          }
+        }
+        if (!any) console.log("No artifacts.");
+      });
+    } catch (e) {
+      fail(e);
+    }
+  });
+}
+
 // src/index.ts
 init_repl();
 
@@ -674,7 +1439,7 @@ import * as fs2 from "fs";
 import * as path3 from "path";
 import * as os2 from "os";
 import * as p from "@clack/prompts";
-import pc2 from "picocolors";
+import pc3 from "picocolors";
 function getCredentialsDir() {
   return path3.join(os2.homedir(), ".computesdk");
 }
@@ -732,7 +1497,7 @@ function openBrowser(url) {
     if (err) {
       p.log.warn("Could not open browser automatically.");
       p.log.info(`Open this URL manually:
-  ${pc2.cyan(url)}`);
+  ${pc3.cyan(url)}`);
     }
   });
 }
@@ -803,7 +1568,7 @@ async function resolveApiKey(options) {
     const stored = loadStoredCredentials();
     if (stored) {
       p.log.info(
-        `Using stored credentials from ${pc2.dim("~/.computesdk/credentials.json")}`
+        `Using stored credentials from ${pc3.dim("~/.computesdk/credentials.json")}`
       );
       return stored;
     }
@@ -817,14 +1582,14 @@ async function resolveApiKey(options) {
     try {
       storeCredentials(apiKey);
       p.log.success(
-        `Credentials saved to ${pc2.dim("~/.computesdk/credentials.json")}`
+        `Credentials saved to ${pc3.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(pc2.red("Authentication failed"));
+    spinner4.stop(pc3.red("Authentication failed"));
     throw error;
   }
 }
@@ -832,7 +1597,7 @@ async function resolveApiKey(options) {
 // src/setup.ts
 init_esm_shims();
 import * as p2 from "@clack/prompts";
-import pc3 from "picocolors";
+import pc4 from "picocolors";
 import { compute as compute2 } from "computesdk";
 async function ensureAuth(options) {
   try {
@@ -840,8 +1605,8 @@ async function ensureAuth(options) {
     process.env.COMPUTESDK_API_KEY = apiKey;
   } catch (error) {
     p2.log.error(error.message);
-    p2.log.info(`Get your API key at ${pc3.cyan("https://console.computesdk.com")}`);
-    p2.outro(pc3.red("Setup incomplete"));
+    p2.log.info(`Get your API key at ${pc4.cyan("https://console.computesdk.com")}`);
+    p2.outro(pc4.red("Setup incomplete"));
     process.exit(1);
   }
 }
@@ -870,7 +1635,7 @@ async function resolveProvider(providerFlag, options) {
   if (available.length === 0) {
     p2.log.error("No provider credentials detected");
     p2.log.info("Set one of: E2B_API_KEY, MODAL_TOKEN_ID, RAILWAY_API_KEY, etc.");
-    p2.outro(pc3.red("Setup incomplete"));
+    p2.outro(pc4.red("Setup incomplete"));
     process.exit(1);
   }
   if (available.length === 1) {
@@ -905,7 +1670,7 @@ init_workspace_cli();
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname2(__filename2);
 var packageJson = JSON.parse(
-  readFileSync4(join4(__dirname2, "..", "package.json"), "utf-8")
+  readFileSync4(join5(__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;
@@ -914,24 +1679,24 @@ program.name("compute").description("Cloud-native workspace management").version
 program.option("--login", "force re-authentication").option("--logout", "clear stored credentials").action(async (opts) => {
   if (opts.logout) {
     console.log();
-    p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
+    p4.intro(pc6.cyan(`@computesdk/cli v${VERSION}`));
     clearStoredCredentials();
     p4.log.success("Logged out. Stored credentials removed.");
-    p4.outro(pc5.green("Done!"));
+    p4.outro(pc6.green("Done!"));
     process.exit(0);
   }
   if (opts.login) {
     console.log();
-    p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
+    p4.intro(pc6.cyan(`@computesdk/cli v${VERSION}`));
     await ensureAuth({ forceLogin: true });
-    p4.outro(pc5.green("Authenticated!"));
+    p4.outro(pc6.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(pc5.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc6.cyan(`@computesdk/cli v${VERSION}`));
   await ensureAuth();
   if (!repo) {
     const state = loadWorkspaceState();
@@ -952,7 +1717,7 @@ program.command("create").description("Create a new workspace (same as create-co
         message: "Select workspace to attach (or create new)",
         options: [
           ...choices,
-          { value: "__new__", label: pc5.gray("+ Create new workspace") }
+          { value: "__new__", label: pc6.gray("+ Create new workspace") }
         ]
       });
       if (p4.isCancel(selected)) {
@@ -993,15 +1758,15 @@ program.command("create").description("Create a new workspace (same as create-co
       branch: options.branch,
       provider
     });
-    spinner4.stop(`Workspace ready: ${pc5.cyan(workspace.id)}`);
+    spinner4.stop(`Workspace ready: ${pc6.cyan(workspace.id)}`);
     if (options.attach !== false) {
       console.log();
       await workspaceAttach(workspace.id);
     } else {
-      p4.outro(pc5.green("Workspace created!"));
+      p4.outro(pc6.green("Workspace created!"));
     }
   } catch (error) {
-    spinner4.stop(pc5.red("Failed to create workspace"));
+    spinner4.stop(pc6.red("Failed to create workspace"));
     p4.log.error(error.message);
     process.exit(1);
   }
@@ -1010,7 +1775,7 @@ var sandboxCmd = program.command("sandbox").alias("sb").description("Manage raw
 sandboxCmd.command("create").description("Create a new sandbox").option("-p, --provider <provider>", "provider to use").option("--timeout <duration>", "sandbox timeout (e.g. 5m, 1h)").option("--name <name>", "sandbox name").option("--connect", "drop into the REPL after creation").option("--silent", "only output the sandbox ID").action(async (opts) => {
   if (!opts.silent) {
     console.log();
-    p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
+    p4.intro(pc6.cyan(`@computesdk/cli v${VERSION}`));
   }
   await ensureAuth();
   const provider = await resolveProvider(opts.provider);
@@ -1022,7 +1787,7 @@ sandboxCmd.command("create").description("Create a new sandbox").option("-p, --p
       const sandbox = await compute4.sandbox.create(
         buildCreateOptions(opts)
       );
-      spinner4.stop(`Sandbox ready: ${pc5.cyan(sandbox.sandboxId)}`);
+      spinner4.stop(`Sandbox ready: ${pc6.cyan(sandbox.sandboxId)}`);
       const { saveSandbox: saveSandbox2 } = await Promise.resolve().then(() => (init_workspace_cli(), workspace_cli_exports));
       await saveSandbox2({
         id: sandbox.sandboxId,
@@ -1035,7 +1800,7 @@ sandboxCmd.command("create").description("Create a new sandbox").option("-p, --p
         await startREPL(sandbox, provider);
       }
     } catch (error) {
-      spinner4.stop(pc5.red("Failed to create sandbox"));
+      spinner4.stop(pc6.red("Failed to create sandbox"));
       p4.log.error(error.message);
       process.exit(1);
     }
@@ -1064,14 +1829,14 @@ sandboxCmd.command("create").description("Create a new sandbox").option("-p, --p
 });
 sandboxCmd.command("destroy").description("Destroy one or more sandboxes").aliases(["rm", "stop"]).argument("[sandbox_id...]", "sandbox IDs to destroy (optional - will show picker if not provided)").option("-p, --provider <provider>", "provider to use").action(async (sandboxIds, opts) => {
   console.log();
-  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc6.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(pc5.green("Done!"));
+      p4.outro(pc6.green("Done!"));
       return;
     }
     const choices = workspaces.map((ws) => {
@@ -1079,7 +1844,7 @@ sandboxCmd.command("destroy").description("Destroy one or more sandboxes").alias
         (Date.now() - new Date(ws.lastUsed).getTime()) / (1e3 * 60 * 60 * 24)
       );
       const ageStr = age === 0 ? "today" : age === 1 ? "1 day ago" : `${age} days ago`;
-      const status = age > 7 ? pc5.red("stale") : age > 1 ? pc5.yellow("idle") : pc5.green("active");
+      const status = age > 7 ? pc6.red("stale") : age > 1 ? pc6.yellow("idle") : pc6.green("active");
       return {
         value: ws.sandboxId,
         label: `${status} ${ws.sandboxId} (${ws.provider}, last active ${ageStr})`
@@ -1107,7 +1872,7 @@ sandboxCmd.command("destroy").description("Destroy one or more sandboxes").alias
   for (const result of results) {
     if (result.status === "fulfilled") {
       const sandboxId = result.value;
-      console.log(pc5.green(`Destroyed ${sandboxId}`));
+      console.log(pc6.green(`Destroyed ${sandboxId}`));
       const workspaceId = Object.keys(state.workspaces).find(
         (key) => state.workspaces[key].sandboxId === sandboxId
       );
@@ -1115,19 +1880,19 @@ sandboxCmd.command("destroy").description("Destroy one or more sandboxes").alias
         delete state.workspaces[workspaceId];
       }
     } else {
-      console.error(pc5.red(`Failed to destroy: ${result.reason?.message || result.reason}`));
+      console.error(pc6.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(pc5.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc6.cyan(`@computesdk/cli v${VERSION}`));
   await sandboxList();
 });
 sandboxCmd.command("connect").description("Connect to a sandbox (opens REPL; same as compute connect)").aliases(["ssh", "shell"]).argument("[sandbox_id]", "sandbox ID (optional - will show picker if not provided)").option("-p, --provider <provider>", "provider to use").action(async (sandboxId, opts) => {
   console.log();
-  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc6.cyan(`@computesdk/cli v${VERSION}`));
   await ensureAuth();
   const provider = await resolveProvider(opts.provider);
   configureCompute(provider);
@@ -1138,7 +1903,7 @@ sandboxCmd.command("connect").description("Connect to a sandbox (opens REPL; sam
     if (workspaces.length === 0) {
       p4.log.info("No sandboxes found.");
       p4.log.info("Create one with: compute sandbox create");
-      p4.outro(pc5.green("Done!"));
+      p4.outro(pc6.green("Done!"));
       return;
     }
     const choices = workspaces.map((ws) => {
@@ -1146,7 +1911,7 @@ sandboxCmd.command("connect").description("Connect to a sandbox (opens REPL; sam
         (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 ? pc5.red("stale") : age > 1 ? pc5.yellow("idle") : pc5.green("active");
+      const status = age > 7 ? pc6.red("stale") : age > 1 ? pc6.yellow("idle") : pc6.green("active");
       return {
         value: ws.sandboxId,
         label: `${status} ${ws.sandboxId} (${ws.provider}, last active ${ageStr})`
@@ -1166,7 +1931,7 @@ sandboxCmd.command("connect").description("Connect to a sandbox (opens REPL; sam
   spinner4.start("Connecting...");
   const sandbox = await compute4.sandbox.getById(sandboxId);
   if (!sandbox) {
-    spinner4.stop(pc5.red(`Sandbox not found: ${sandboxId}`));
+    spinner4.stop(pc6.red(`Sandbox not found: ${sandboxId}`));
     process.exit(1);
   }
   spinner4.stop("");
@@ -1178,7 +1943,7 @@ sandboxCmd.command("exec").description("Execute a command in a sandbox").argumen
   configureCompute(provider);
   const sandbox = await compute4.sandbox.getById(sandboxId);
   if (!sandbox) {
-    console.error(pc5.red(`Sandbox not found: ${sandboxId}`));
+    console.error(pc6.red(`Sandbox not found: ${sandboxId}`));
     process.exit(1);
   }
   const cmd = buildExecCommand(command, opts);
@@ -1193,7 +1958,7 @@ sandboxCmd.command("exec").description("Execute a command in a sandbox").argumen
 });
 program.command("connect").description("Connect to a sandbox (opens REPL)").aliases(["ssh", "shell"]).argument("[sandbox_id]", "sandbox ID (optional - will show picker if not provided)").option("-p, --provider <provider>", "provider to use").action(async (sandboxId, opts) => {
   console.log();
-  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc6.cyan(`@computesdk/cli v${VERSION}`));
   await ensureAuth();
   const provider = await resolveProvider(opts.provider);
   configureCompute(provider);
@@ -1204,7 +1969,7 @@ program.command("connect").description("Connect to a sandbox (opens REPL)").alia
     if (workspaces.length === 0) {
       p4.log.info("No sandboxes found.");
       p4.log.info("Create one with: compute sandbox create");
-      p4.outro(pc5.green("Done!"));
+      p4.outro(pc6.green("Done!"));
       return;
     }
     const choices = workspaces.map((ws) => {
@@ -1212,7 +1977,7 @@ program.command("connect").description("Connect to a sandbox (opens REPL)").alia
         (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 ? pc5.red("stale") : age > 1 ? pc5.yellow("idle") : pc5.green("active");
+      const status = age > 7 ? pc6.red("stale") : age > 1 ? pc6.yellow("idle") : pc6.green("active");
       return {
         value: ws.sandboxId,
         label: `${status} ${ws.sandboxId} (${ws.provider}, last active ${ageStr})`
@@ -1232,7 +1997,7 @@ program.command("connect").description("Connect to a sandbox (opens REPL)").alia
   spinner4.start("Connecting...");
   const sandbox = await compute4.sandbox.getById(sandboxId);
   if (!sandbox) {
-    spinner4.stop(pc5.red(`Sandbox not found: ${sandboxId}`));
+    spinner4.stop(pc6.red(`Sandbox not found: ${sandboxId}`));
     process.exit(1);
   }
   spinner4.stop("");
@@ -1241,11 +2006,11 @@ program.command("connect").description("Connect to a sandbox (opens REPL)").alia
 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(pc5.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc6.cyan(`@computesdk/cli v${VERSION}`));
   await ensureAuth();
   if (!repo) {
     p4.log.info("Usage: compute workspace create owner/repo --branch main");
-    p4.outro(pc5.green("Done!"));
+    p4.outro(pc6.green("Done!"));
     return;
   }
   const provider = await resolveProvider(options.provider, { interactive: true });
@@ -1258,33 +2023,33 @@ workspaceCmd.command("create").description("Create a new workspace").argument("[
       branch: options.branch,
       provider
     });
-    spinner4.stop(`Workspace ready: ${pc5.cyan(workspace.id)}`);
+    spinner4.stop(`Workspace ready: ${pc6.cyan(workspace.id)}`);
     if (options.attach !== false) {
       console.log();
       await workspaceAttach(workspace.id);
     } else {
-      p4.outro(pc5.green("Workspace created!"));
+      p4.outro(pc6.green("Workspace created!"));
     }
   } catch (error) {
-    spinner4.stop(pc5.red("Failed to create workspace"));
+    spinner4.stop(pc6.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(pc5.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc6.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(pc5.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc6.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(pc5.green("Done!"));
+      p4.outro(pc6.green("Done!"));
       return;
     }
     const choices = workspaceIds.map((key) => {
@@ -1295,7 +2060,7 @@ workspaceCmd.command("destroy").alias("rm").description("Destroy a workspace").a
       const ageStr = age === 0 ? "today" : age === 1 ? "1 day ago" : `${age} days ago`;
       return {
         value: key,
-        label: `${pc5.cyan(key)} (${ws.provider}, last used ${ageStr})`
+        label: `${pc6.cyan(key)} (${ws.provider}, last used ${ageStr})`
       };
     });
     const selected = await p4.multiselect({
@@ -1315,14 +2080,14 @@ workspaceCmd.command("destroy").alias("rm").description("Destroy a workspace").a
 });
 workspaceCmd.command("connect").alias("attach").description("Connect to an existing workspace (with git context)").argument("[id]", "Workspace ID (optional - will show picker if not provided)").action(async (id) => {
   console.log();
-  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc6.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(pc5.green("Done!"));
+      p4.outro(pc6.green("Done!"));
       return;
     }
     const choices = workspaceIds.map((key) => {
@@ -1333,7 +2098,7 @@ workspaceCmd.command("connect").alias("attach").description("Connect to an exist
       const ageStr = age === 0 ? "today" : age === 1 ? "1 day ago" : `${age} days ago`;
       return {
         value: key,
-        label: `${pc5.cyan(key)} (${ws.provider}, last used ${ageStr})`
+        label: `${pc6.cyan(key)} (${ws.provider}, last used ${ageStr})`
       };
     });
     const selected = await p4.select({
@@ -1358,7 +2123,7 @@ program.command("run").description("Create a sandbox, run a command, then option
       buildCreateOptions(opts)
     );
   } catch (error) {
-    console.error(pc5.red(`Failed to create sandbox: ${error.message}`));
+    console.error(pc6.red(`Failed to create sandbox: ${error.message}`));
     process.exit(1);
   }
   try {
@@ -1381,35 +2146,38 @@ program.command("run").description("Create a sandbox, run a command, then option
       } catch {
       }
     }
-    console.error(pc5.red(error.message));
+    console.error(pc6.red(error.message));
     process.exit(1);
   }
 });
 program.command("providers").description("List all providers and their configuration status").action(async () => {
   console.log();
-  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc6.cyan(`@computesdk/cli v${VERSION}`));
   const statuses = getProviderStatus();
   console.log();
   for (const status of statuses) {
-    const icon = status.ready ? pc5.green("\u25CF") : pc5.gray("\u25CB");
-    const name = status.ready ? pc5.white(status.name) : pc5.gray(status.name);
-    const detail = status.ready ? pc5.green("ready") : pc5.gray(`missing: ${status.missing.join(", ")}`);
+    const icon = status.ready ? pc6.green("\u25CF") : pc6.gray("\u25CB");
+    const name = status.ready ? pc6.white(status.name) : pc6.gray(status.name);
+    const detail = status.ready ? pc6.green("ready") : pc6.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(pc5.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc6.cyan(`@computesdk/cli v${VERSION}`));
   await ensureAuth({ forceLogin: true });
-  p4.outro(pc5.green("Authenticated!"));
+  p4.outro(pc6.green("Authenticated!"));
 });
 program.command("logout").description("Clear stored credentials").action(() => {
   console.log();
-  p4.intro(pc5.cyan(`@computesdk/cli v${VERSION}`));
+  p4.intro(pc6.cyan(`@computesdk/cli v${VERSION}`));
   clearStoredCredentials();
   p4.log.success("Logged out. Stored credentials removed.");
-  p4.outro(pc5.green("Done!"));
+  p4.outro(pc6.green("Done!"));
+});
+registerActionsCommands(program);
+program.command("bench").description("Benchmarks platform CLI (run, auth, org, benchmarks, runs, results, artifacts, export, ...)").allowUnknownOption().helpOption(false).action(() => {
 });
 function buildCreateOptions(opts) {
   const options = {};
@@ -1477,8 +2245,16 @@ function parseDuration(input) {
   }
   return total;
 }
-program.parseAsync(process.argv).catch((error) => {
-  console.error(pc5.red(`
+async function main() {
+  if (process.argv[2] === "bench" || process.argv[2] === "benchmark") {
+    const { run: benchRun } = await import("@benchsdk/runner");
+    await benchRun(process.argv.slice(3));
+    return;
+  }
+  await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+  console.error(pc6.red(`
 Error: ${error.message}`));
   process.exit(1);
 });