@arker-ai/sdk 0.5.2 → 0.6.2

package/dist/cli.js

@@ -3,13 +3,13 @@ import {
   ARKER_ORG_ID,
   Arker,
   ArkerError
-} from "./chunk-YGZOUXII.js";
+} from "./chunk-7BHPVQNG.js";
 
 // src/cli.ts
 import { readFileSync, existsSync } from "fs";
+import { spawnSync } from "child_process";
 import { homedir } from "os";
 import { join } from "path";
-import * as readline from "readline/promises";
 import { stdin as input, stdout as output } from "process";
 function parseArgs(argv) {
   const positional = [];
@@ -38,20 +38,25 @@ function parseArgs(argv) {
   return { positional, flags };
 }
 function readFileConfig() {
-  const path = join(homedir(), ".arker", "config.json");
-  if (!existsSync(path)) return {};
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return {};
+  for (const name of ["config.json", "config"]) {
+    const path = join(homedir(), ".arker", name);
+    if (!existsSync(path)) continue;
+    try {
+      return JSON.parse(readFileSync(path, "utf8"));
+    } catch {
+      return {};
+    }
   }
+  return {};
 }
 function clientFromArgs(args) {
   const file = readFileConfig();
+  const explicitBaseUrl = args.flags["base-url"] ?? process.env.ARKER_BASE_URL;
+  const explicitRegion = args.flags.region ?? process.env.ARKER_REGION;
   const apiKey = args.flags["api-key"] ?? process.env.ARKER_API_KEY ?? file.apiKey;
-  const baseUrl = args.flags["base-url"] ?? process.env.ARKER_BASE_URL ?? file.baseUrl;
+  const baseUrl = explicitBaseUrl ?? (explicitRegion ? void 0 : file.baseUrl);
   const controlBaseUrl = args.flags["control-base-url"] ?? process.env.ARKER_CONTROL_BASE_URL;
-  const region = args.flags.region ?? process.env.ARKER_REGION ?? file.region;
+  const region = explicitRegion ?? file.region;
   const provider = args.flags.provider ?? process.env.ARKER_PROVIDER;
   if (!apiKey) {
     die("Missing API key. Set ARKER_API_KEY or pass --api-key.");
@@ -81,7 +86,8 @@ function fmtVm(vm) {
   const region = vm.region ?? "?";
   const name = vm.name ?? "\u2014";
   const state = vm.state ?? "?";
-  return `${vm.vm_id ?? vm.id}	${provider}-${region}	${state}	${name}`;
+  const id = vm.vm_id ?? vm.id;
+  return `${id}	${provider}-${region}	${state}	${name}`;
 }
 async function cmdVms(args, client) {
   const sub = args.positional[0];
@@ -126,6 +132,10 @@ async function cmdVms(args, client) {
       await cmdRun({ ...args, positional: rest }, client);
       return;
     }
+    case "resize": {
+      await cmdResize({ ...args, positional: rest }, client);
+      return;
+    }
     default:
       die(`unknown vms subcommand: ${sub}`);
   }
@@ -144,14 +154,22 @@ async function cmdFork(args, client) {
     sourceVmName = refPositional;
   }
   if (!sourceVmId && !sourceVmName) {
-    die("usage: arker fork <vm_name> | --source-vm-id <id> | --source-vm-name <name> [--source-org-id <org>]");
+    die("usage: arker fork <vm_name> | --source-vm-id <id> | --source-vm-name <name> [--source-org-id <org>]\n       [--vcpu N] [--memory-mib N] [--disk-mib N] [--no-disk]");
   }
+  const vcpu = numFlag(args, "vcpu");
+  const memoryMib = numFlag(args, "memory-mib");
+  const diskMib = numFlag(args, "disk-mib");
+  const hasResources = vcpu !== void 0 || memoryMib !== void 0 || diskMib !== void 0;
+  const resources = hasResources ? { vcpu: vcpu ?? null, memory_mib: memoryMib ?? null, disk_mib: diskMib ?? null } : void 0;
+  const disk = boolFlag(args, "no-disk") ? false : void 0;
   const computer = await client.fork({
     sourceVmId,
     sourceVmName,
     sourceOrgId,
     name,
-    public: publicFlag
+    public: publicFlag,
+    ...resources ? { resources } : {},
+    ...disk !== void 0 ? { disk } : {}
   });
   out({ vm_id: computer.id });
 }
@@ -159,13 +177,24 @@ async function cmdRun(args, client) {
   const vmId = args.positional[0] ?? die("usage: arker run <vm_id> <command...>");
   const command = args.positional.slice(1).join(" ");
   if (!command) die("missing command to run");
+  const sessionIdx = numFlag(args, "session-idx");
   const result = await client.vm(vmId).run(command, {
     background: boolFlag(args, "background"),
     timeout: numFlag(args, "timeout"),
     acquire: args.flags.acquire,
-    release: args.flags.release
+    release: args.flags.release,
+    session_id: args.flags["session-id"],
+    ...sessionIdx !== void 0 ? { session_idx: sessionIdx } : {}
   });
+  if (args.flags.json) {
+    out(runResultForJson(result));
+    if (result.type === "completed") process.exitCode = result.exitCode === 0 ? 0 : result.exitCode;
+    return;
+  }
   if (result.type === "completed") {
+    if (result.memoryPartial) {
+      err(`Memory target partially applied: requested ${formatMib(result.memoryRequestedMib)}, achieved ${formatMib(result.memoryAchievedMib)}.`);
+    }
     process.stdout.write(new TextDecoder().decode(result.stdout));
     if (result.stderr.length) process.stderr.write(new TextDecoder().decode(result.stderr));
     process.exitCode = result.exitCode === 0 ? 0 : result.exitCode;
@@ -173,6 +202,30 @@ async function cmdRun(args, client) {
   }
   out({ run_id: result.runId, state: result.state });
 }
+function formatMib(value) {
+  return typeof value === "number" ? `${value} MiB` : "unknown";
+}
+function runResultForJson(result) {
+  switch (result.type) {
+    case "completed":
+      return {
+        type: result.type,
+        runId: result.runId,
+        state: result.state,
+        stdout: new TextDecoder().decode(result.stdout),
+        stdoutEncoding: result.stdoutEncoding,
+        stderr: new TextDecoder().decode(result.stderr),
+        stderrEncoding: result.stderrEncoding,
+        exitCode: result.exitCode,
+        failReason: result.failReason,
+        memoryRequestedMib: result.memoryRequestedMib,
+        memoryAchievedMib: result.memoryAchievedMib,
+        memoryPartial: result.memoryPartial
+      };
+    case "background":
+      return result;
+  }
+}
 async function cmdRuns(args, client) {
   const sub = args.positional[0];
   const rest = args.positional.slice(1);
@@ -314,51 +367,24 @@ async function cmdSync(args, client) {
   }
   output.write(await client.vm(vm).sync(path));
 }
-async function cmdTunnels(args, client) {
-  const sub = args.positional[0];
-  const rest = args.positional.slice(1);
-  const vm = rest[0];
-  switch (sub) {
-    case "ls":
-    case "list": {
-      if (!vm) die("usage: arker tunnels ls <vm_id>");
-      const res = await client.vm(vm).listTunnels({
-        state: args.flags.state,
-        cursor: args.flags.cursor,
-        limit: numFlag(args, "limit")
-      });
-      if (args.flags.json) return out(res);
-      for (const t of res.tunnels) {
-        out(`${t.tunnel_key ?? "-"}	${t.port}	${t.state}	${t.protocol}	${t.url ?? "-"}`);
-      }
-      if (res.next_cursor) out(`# next_cursor=${res.next_cursor}`);
-      return;
-    }
-    case "create": {
-      if (!vm) die("usage: arker tunnels create <vm_id> [--ports 80,8080] [--auth-mode open|authenticated]");
-      const tunnel = await client.vm(vm).createTunnel({
-        ports: parsePorts(args.flags.ports),
-        auth_mode: args.flags["auth-mode"]
-      });
-      return out(tunnel);
-    }
-    case "get": {
-      if (!vm) die("usage: arker tunnels get <vm_id> <key>");
-      const key = rest[1] ?? die("missing key");
-      out(await client.vm(vm).getTunnel(key));
-      return;
-    }
-    case "rm":
-    case "delete": {
-      if (!vm) die("usage: arker tunnels rm <vm_id> <key>");
-      const key = rest[1] ?? die("missing key");
-      const r = await client.vm(vm).deleteTunnel(key);
-      out(r.deleted ? `deleted tunnel ${key}` : "delete failed");
-      return;
-    }
-    default:
-      die(`usage: arker tunnels <ls|create|get|rm> ...`);
+async function cmdResize(args, client) {
+  const vm = args.positional[0];
+  if (!vm) die("usage: arker resize <vm_id> [--memory-mib N] [--vcpu N] [--disk-mib N]");
+  const memoryMib = numFlag(args, "memory-mib");
+  const vcpu = numFlag(args, "vcpu");
+  const diskMib = numFlag(args, "disk-mib");
+  if (memoryMib === void 0 && vcpu === void 0 && diskMib === void 0) {
+    die("resize: pass at least one of --memory-mib, --vcpu, --disk-mib");
   }
+  const updated = await client.vm(vm).resize({
+    resources: {
+      vcpu: vcpu ?? null,
+      memory_mib: memoryMib ?? null,
+      disk_mib: diskMib ?? null
+    }
+  });
+  if (args.flags.json) return out(updated);
+  out(fmtVm(updated));
 }
 async function cmdFilesystems(args, client) {
   const sub = args.positional[0];
@@ -404,6 +430,10 @@ async function cmdFilesystems(args, client) {
 async function cmdShell(args, client) {
   let computer;
   const vmIdArg = args.flags["vm-id"] ?? args.positional[0];
+  const explicitSessionId = args.flags["session-id"];
+  if (!vmIdArg && explicitSessionId) {
+    die("usage: arker shell <vm_id> --session-id <session_id>");
+  }
   if (vmIdArg) {
     computer = await client.vm(vmIdArg).refresh();
   } else {
@@ -412,100 +442,242 @@ async function cmdShell(args, client) {
       sourceVmName,
       sourceOrgId: ARKER_ORG_ID
     });
+    err(`forked ${computer.id}`);
+  }
+  let sessionId = explicitSessionId;
+  if (!sessionId) {
+    const session = await computer.createSession({
+      cwd: args.flags.cwd
+    });
+    sessionId = session.session_id ?? session.id;
+    if (!sessionId) die("createSession response missing session_id");
   }
-  const header = computer;
-  const session = await computer.createSession({
-    cwd: args.flags.cwd
+  const persist = args.flags["no-persist"] === true ? false : boolFlag(args, "persist");
+  const colsFlag = numFlag(args, "cols");
+  const rowsFlag = numFlag(args, "rows");
+  const cols = colsFlag ?? output.columns ?? 80;
+  const rows = rowsFlag ?? output.rows ?? 24;
+  const cancelTtlSecs = numFlag(args, "cancel-ttl");
+  const pty = await computer.connectPty({
+    sessionId,
+    cols,
+    rows,
+    command: args.flags.command,
+    persist,
+    cancelTtlSecs
   });
-  const sessionId = session.session_id;
-  const timeout = numFlag(args, "timeout");
-  const preload = args.positional.slice(vmIdArg ? 1 : 0).join(" ").trim();
-  const exitAfter = args.flags.exit === true;
-  output.write(JSON.stringify(header, null, 2) + "\n");
-  let inFlight = false;
-  let exitCode = 0;
-  try {
-    if (preload && preload !== "exit") {
-      const step = await runShellLine(computer, sessionId, preload, timeout);
-      if (step.kind === "fatal") {
-        err(`shell ended: ${step.message}`);
-        return;
-      }
-      if (step.kind === "recoverable") {
-        err(`error: ${step.message}`);
-        exitCode = 1;
-      } else {
-        exitCode = step.exitCode;
-      }
-    }
-    if (exitAfter || preload === "exit") {
-      process.exit(exitCode);
-    }
-    const rl = readline.createInterface({ input, output, prompt: "> " });
-    rl.on("SIGINT", () => {
-      if (inFlight) {
-        process.stderr.write("^C\n");
-        return;
+  err(`connected ${computer.id} session ${sessionId}`);
+  const exitCode = await bridgePty(pty, {
+    fallbackCols: cols,
+    fallbackRows: rows,
+    autoResize: colsFlag === void 0 && rowsFlag === void 0 && Boolean(output.isTTY)
+  });
+  if (exitCode !== 0) process.exit(exitCode);
+}
+function bridgePty(pty, options) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let rawEnabled = false;
+    const wasRaw = Boolean(input.isTTY && input.isRaw);
+    const restoreTerminal = () => {
+      if (rawEnabled && input.isTTY && typeof input.setRawMode === "function") {
+        input.setRawMode(wasRaw);
       }
-      process.stdout.write("^C\n");
-      rl.write(null, { ctrl: true, name: "u" });
-      rl.prompt();
+      rawEnabled = false;
+    };
+    const finish = (code) => {
+      if (settled) return;
+      settled = true;
+      restoreTerminal();
+      input.off("data", onInput);
+      input.off("end", onInputEnd);
+      process.off("SIGWINCH", onResize);
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+      process.off("SIGHUP", onSighup);
+      process.off("exit", restoreTerminal);
+      offData();
+      offClose();
+      offError();
+      resolve(code);
+    };
+    const onInput = (chunk) => {
+      pty.send(chunk);
+    };
+    const onInputEnd = () => {
+      pty.close();
+    };
+    const onResize = () => {
+      pty.resize(output.columns ?? options.fallbackCols, output.rows ?? options.fallbackRows);
+    };
+    const onSigint = () => {
+      pty.send(new Uint8Array([3]));
+    };
+    const onSigterm = () => {
+      pty.close();
+      finish(143);
+    };
+    const onSighup = () => {
+      pty.close();
+      finish(129);
+    };
+    const offData = pty.onData((data) => {
+      output.write(data);
     });
-    rl.prompt();
-    for await (const line of rl) {
-      const cmd = line.trim();
-      if (!cmd) {
-        rl.prompt();
-        continue;
-      }
-      if (cmd === "exit" || cmd === "quit") break;
-      inFlight = true;
-      const step = await runShellLine(computer, sessionId, cmd, timeout);
-      inFlight = false;
-      if (step.kind === "fatal") {
-        err(`shell ended: ${step.message}`);
-        exitCode = 1;
-        break;
-      }
-      if (step.kind === "recoverable") {
-        err(`error: ${step.message}`);
+    const offClose = pty.onClose(() => finish(0));
+    const offError = pty.onError((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      err(`pty error: ${message}`);
+    });
+    process.once("exit", restoreTerminal);
+    pty.ready.then(() => {
+      if (settled) return;
+      if (input.isTTY && typeof input.setRawMode === "function") {
+        input.setRawMode(true);
+        rawEnabled = true;
       }
-      rl.prompt();
-    }
-    rl.close();
-  } finally {
-    await computer.deleteSession(sessionId).catch(() => {
+      input.resume();
+      input.on("data", onInput);
+      input.on("end", onInputEnd);
+      if (options.autoResize) process.on("SIGWINCH", onResize);
+      process.on("SIGINT", onSigint);
+      process.on("SIGTERM", onSigterm);
+      process.on("SIGHUP", onSighup);
+      if (options.autoResize) onResize();
+    }).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      err(`pty failed to open: ${message}`);
+      finish(1);
     });
+  });
+}
+var SSH_PORT_DEFAULT = 22;
+function defaultIdentityBase() {
+  return join(homedir(), ".ssh", "id_ed25519");
+}
+function resolveLocalSshKey(args) {
+  const explicit = args.flags.identity;
+  const privateKeyPath = explicit ? explicit.replace(/\.pub$/, "") : defaultIdentityBase();
+  const publicKeyPath = `${privateKeyPath}.pub`;
+  if (!existsSync(publicKeyPath)) {
+    if (!boolFlag(args, "generate")) {
+      die(
+        `no SSH public key at ${publicKeyPath}. Pass --identity <path>, or --generate to create an ed25519 key pair.`
+      );
+    }
+    err(`generating ed25519 key pair at ${privateKeyPath}`);
+    const gen = spawnSync(
+      "ssh-keygen",
+      ["-t", "ed25519", "-N", "", "-f", privateKeyPath, "-C", "arker-cli"],
+      { stdio: "inherit" }
+    );
+    if (gen.status !== 0) die("ssh-keygen failed to generate a key pair");
   }
-  if (exitCode !== 0) process.exit(exitCode);
+  const publicKey = readFileSync(publicKeyPath, "utf8").trim();
+  if (!publicKey) die(`SSH public key at ${publicKeyPath} is empty`);
+  return { publicKey, privateKeyPath, publicKeyPath };
+}
+async function registerAccountSshKey(client, publicKey, label) {
+  return client._request(
+    "POST",
+    "/v1/account/ssh-keys",
+    { public_key: publicKey, label: label ?? null },
+    client.baseUrl
+  );
 }
-async function runShellLine(computer, sessionId, cmd, timeout) {
+function resolveSshHost(args, client) {
+  const explicit = args.flags.host ?? process.env.ARKER_SSH_HOST;
+  if (explicit) return explicit;
+  if (client.region) return `aws-${client.region}.arker.ai`;
   try {
-    const result = await computer.run(cmd, { session_id: sessionId, timeout });
-    if (result.type === "completed") {
-      if (result.stdout.length) process.stdout.write(new TextDecoder().decode(result.stdout));
-      if (result.stderr.length) process.stderr.write(new TextDecoder().decode(result.stderr));
-      const tail = result.stderr.length > 0 ? result.stderr[result.stderr.length - 1] : result.stdout.length > 0 ? result.stdout[result.stdout.length - 1] : void 0;
-      if (tail !== void 0 && tail !== 10) process.stdout.write("\n");
-      return { kind: "ok", exitCode: result.exitCode };
-    }
-    out({ run_id: result.runId });
-    return { kind: "ok", exitCode: 0 };
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    const kind = classifyShellError(message, computer.id);
-    return { kind, message };
+    return new URL(client.baseUrl).hostname;
+  } catch {
+    die("could not determine SSH host; pass --host <hostname>");
   }
 }
-function classifyShellError(message, vmId) {
-  const msg = message.toLowerCase();
-  if (msg.includes("unauthor") || msg.includes("forbidden") || msg.includes("invalid api key")) {
-    return "fatal";
+async function cmdSsh(args, client) {
+  const vmId = args.flags["vm-id"] ?? args.positional[0];
+  if (!vmId) {
+    die(
+      "usage: arker ssh <vm_id> [--identity <path>] [--generate] [--host <h>] [--port <n>] [--connect|-c] [--skip-register]"
+    );
   }
-  if ((msg.includes("not_found") || msg.includes("not found")) && msg.includes(vmId.toLowerCase())) {
-    return "fatal";
+  const { publicKey, privateKeyPath } = resolveLocalSshKey(args);
+  if (!boolFlag(args, "skip-register")) {
+    const label = args.flags.label ?? `arker-cli ${homedir().split("/").pop() ?? ""}`.trim();
+    try {
+      const key = await registerAccountSshKey(client, publicKey, label);
+      err(`registered SSH key ${key.fingerprint}${key.label ? ` (${key.label})` : ""}`);
+    } catch (e) {
+      if (e instanceof ArkerError && e.status === 409) {
+        die(`this SSH key is already registered to a different account: ${e.message}`);
+      }
+      if (e instanceof ArkerError && e.status === 403) {
+        die(
+          "your API key lacks the developer role required to register SSH keys. Register the key in the console, then re-run with --skip-register."
+        );
+      }
+      throw e;
+    }
+  }
+  const host = resolveSshHost(args, client);
+  const port = numFlag(args, "port") ?? SSH_PORT_DEFAULT;
+  const sshArgs = [
+    "-i",
+    privateKeyPath,
+    ...port !== 22 ? ["-p", String(port)] : [],
+    `${vmId}@${host}`
+  ];
+  const command = `ssh ${sshArgs.join(" ")}`;
+  if (boolFlag(args, "connect") || boolFlag(args, "c")) {
+    err(`connecting: ${command}`);
+    const r = spawnSync("ssh", sshArgs, { stdio: "inherit" });
+    process.exit(r.status ?? 1);
+  }
+  out(command);
+}
+async function cmdSshKeys(args, client) {
+  const sub = args.positional[0];
+  const rest = args.positional.slice(1);
+  switch (sub) {
+    case void 0:
+    case "ls":
+    case "list": {
+      const res = await client._request(
+        "GET",
+        "/v1/account/ssh-keys",
+        void 0,
+        client.baseUrl
+      );
+      if (args.flags.json) return out(res);
+      for (const k of res.keys) {
+        out(`${k.id}	${k.fingerprint}	${k.label ?? "\u2014"}`);
+      }
+      return;
+    }
+    case "add": {
+      const { publicKey } = resolveLocalSshKey(args);
+      const label = args.flags.label;
+      const key = await registerAccountSshKey(client, publicKey, label);
+      if (args.flags.json) return out(key);
+      out(`${key.id}	${key.fingerprint}	${key.label ?? "\u2014"}`);
+      return;
+    }
+    case "rm":
+    case "delete": {
+      const id = rest[0] ?? die("usage: arker ssh-keys rm <key_id>");
+      const r = await client._request(
+        "DELETE",
+        `/v1/account/ssh-keys/${encodeURIComponent(id)}`,
+        void 0,
+        client.baseUrl
+      );
+      out(r.deleted ? `deleted ${id}` : "delete failed");
+      return;
+    }
+    default:
+      die("usage: arker ssh-keys <ls|add|rm> ...");
   }
-  return "recoverable";
 }
 function numFlag(args, name) {
   const v = args.flags[name];
@@ -519,10 +691,6 @@ function boolFlag(args, name) {
   if (v === "false" || v === "0") return false;
   return true;
 }
-function parsePorts(value) {
-  if (typeof value !== "string" || value.trim() === "") return void 0;
-  return value.split(",").map((part) => Number(part.trim())).filter((port) => Number.isFinite(port));
-}
 async function readAllStdin() {
   const chunks = [];
   for await (const chunk of input) chunks.push(chunk);
@@ -543,16 +711,21 @@ function usage() {
       "  arker fork --source-vm-id <id>                 fork by global id",
       "  arker fork --source-vm-name <n> --source-org-id <org>",
       "                                                 fork by name in another org",
-      "  arker run <vm> <command>                       run a command",
-      "  arker shell [vm_id]                            interactive shell (forks arkuntu if no vm)",
+      "  arker fork <vm> [--vcpu N] [--memory-mib N] [--disk-mib N] [--no-disk]",
+      "                                                 fork with resource/network overrides",
+      "  arker run <vm> <command> [--session-id <id>] [--session-idx N]   run a command",
+      "  arker resize <vm> [--memory-mib N] [--vcpu N] [--disk-mib N]   resize a VM (PATCH)",
+      "  arker shell [vm_id]                            native PTY shell (forks ubuntu-full if no vm)",
+      "  arker ssh <vm_id>                              register your SSH key + print the ssh command",
+      "  arker ssh <vm_id> --connect                    register + drop straight into the ssh session",
       "",
       "Resources:",
       "  arker vms         <ls|get|rm|fork|run> ...",
       "  arker runs        <ls|get|rm> <vm_id> ...",
       "  arker sessions    <ls|get|create|rm> <vm_id> ...",
       "  arker syncs       <ls|create|rm> <vm_id> ...",
-      "  arker tunnels     <ls|get|rm> <vm_id> ...",
       "  arker filesystems <ls|create|get|rm> ...   (alias: fs)",
+      "  arker ssh-keys    <ls|add|rm> ...           manage account SSH keys",
       "",
       "Flags:",
       "  --api-key <key>            (or env ARKER_API_KEY)",
@@ -562,6 +735,35 @@ function usage() {
       "  --control-base-url <url>   override CF Worker URL (env ARKER_CONTROL_BASE_URL)",
       "  --json                     emit JSON instead of tabular output",
       "",
+      "Fork flags:",
+      "  --vcpu <n>                 vCPU count for the new VM (capped by source max_vcpus)",
+      "  --memory-mib <n>           memory (MiB) for the new VM",
+      "  --disk-mib <n>             disk size (MiB) for the new VM",
+      "  --no-disk                  fork a memory-backed (nodisk) VM",
+      "",
+      "Run flags:",
+      "  --session-id <ulid>        run in a specific existing session",
+      "  --session-idx <n>          run in the session at this index (default 0)",
+      "  --background               return a run id instead of blocking",
+      "  --timeout <secs>           per-run timeout",
+      "  --acquire <list>           warm resources before the run (cpu,memory,disk)",
+      "  --release <list>           release resources after the run (cpu,memory,disk)",
+      "",
+      "Shell flags:",
+      "  --session-id <id>          reconnect to an existing PTY session",
+      "  --command <path>           shell executable path (default: /bin/bash)",
+      "  --cols <n> --rows <n>      initial terminal size",
+      "  --no-persist               close the remote PTY process on disconnect",
+      "",
+      "SSH flags:",
+      "  --identity <path>          local key (private or .pub); default ~/.ssh/id_ed25519",
+      "  --generate                 create an ed25519 key pair if none exists",
+      "  --host <hostname>          SSH host (or env ARKER_SSH_HOST; default aws-<region>.arker.ai)",
+      "  --port <n>                 SSH port (default 22)",
+      "  --connect, -c              exec ssh instead of just printing the command",
+      "  --skip-register            don't register the key (assume already registered)",
+      "  --label <text>             label for the registered key",
+      "",
       `Arker org id: ${ARKER_ORG_ID}`
     ].join("\n")
   );
@@ -592,6 +794,11 @@ async function main() {
         return await cmdSyncs(args, client);
       case "shell":
         return await cmdShell(args, client);
+      case "ssh":
+        return await cmdSsh(args, client);
+      case "ssh-keys":
+      case "ssh_keys":
+        return await cmdSshKeys(args, client);
       // Resources.
       case "vms":
         return await cmdVms(args, client);
@@ -599,8 +806,8 @@ async function main() {
         return await cmdRuns(args, client);
       case "sessions":
         return await cmdSessions(args, client);
-      case "tunnels":
-        return await cmdTunnels(args, client);
+      case "resize":
+        return await cmdResize(args, client);
       case "filesystems":
       case "fs":
         return await cmdFilesystems(args, client);

package/dist/common-C5zJ-LkS.d.cts

@@ -0,0 +1,9 @@
+import { SandboxInterface } from 'computesdk';
+
+type UniversalSandbox = SandboxInterface;
+interface CreateOptions {
+    timeout?: number;
+    timeoutMs?: number;
+}
+
+export type { CreateOptions as C, UniversalSandbox as U };

package/dist/common-C5zJ-LkS.d.ts

@@ -0,0 +1,9 @@
+import { SandboxInterface } from 'computesdk';
+
+type UniversalSandbox = SandboxInterface;
+interface CreateOptions {
+    timeout?: number;
+    timeoutMs?: number;
+}
+
+export type { CreateOptions as C, UniversalSandbox as U };