@arker-ai/sdk 0.5.2 → 0.6.3

package/dist/cli.js

@@ -3,14 +3,22 @@ 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 { createRequire } from "module";
 import { homedir } from "os";
 import { join } from "path";
-import * as readline from "readline/promises";
 import { stdin as input, stdout as output } from "process";
+var VERSION = (() => {
+  try {
+    return createRequire(import.meta.url)("../package.json").version;
+  } catch {
+    return "unknown";
+  }
+})();
 function parseArgs(argv) {
   const positional = [];
   const flags = {};
@@ -38,27 +46,30 @@ 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 {};
 }
+var DEFAULT_REGION = "us-west-2";
 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 ?? (baseUrl ? void 0 : DEFAULT_REGION);
   const provider = args.flags.provider ?? process.env.ARKER_PROVIDER;
   if (!apiKey) {
     die("Missing API key. Set ARKER_API_KEY or pass --api-key.");
   }
-  if (!baseUrl && !region) {
-    die("Missing region. Set ARKER_REGION or pass --region (e.g. us-west-2). --provider (aws|aws-burst) defaults to aws.");
-  }
   return new Arker({ apiKey, baseUrl, region, provider, controlBaseUrl });
 }
 function out(value) {
@@ -81,7 +92,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 +138,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 +160,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 +183,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 +208,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 +373,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 +436,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 +448,114 @@ 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);
     });
-  }
-  if (exitCode !== 0) process.exit(exitCode);
-}
-async function runShellLine(computer, sessionId, cmd, timeout) {
-  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 };
-  }
-}
-function classifyShellError(message, vmId) {
-  const msg = message.toLowerCase();
-  if (msg.includes("unauthor") || msg.includes("forbidden") || msg.includes("invalid api key")) {
-    return "fatal";
-  }
-  if ((msg.includes("not_found") || msg.includes("not found")) && msg.includes(vmId.toLowerCase())) {
-    return "fatal";
-  }
-  return "recoverable";
+  });
 }
 function numFlag(args, name) {
   const v = args.flags[name];
@@ -519,10 +569,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);
@@ -531,7 +577,7 @@ async function readAllStdin() {
 function usage() {
   out(
     [
-      "arker \u2014 VM control plane CLI",
+      `arker v${VERSION}`,
       "",
       "Usage:",
       "  arker <command> [args]",
@@ -543,26 +589,46 @@ 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)",
       "",
       "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)",
       "",
       "Flags:",
       "  --api-key <key>            (or env ARKER_API_KEY)",
       "  --region <region>          (or env ARKER_REGION; e.g. us-west-2)",
-      "  --provider <aws|aws-burst> (or env ARKER_PROVIDER; default aws)",
+      "  --provider <aws>           (or env ARKER_PROVIDER; default aws)",
       "  --base-url <url>           override compute URL (env ARKER_BASE_URL)",
       "  --control-base-url <url>   override CF Worker URL (env ARKER_CONTROL_BASE_URL)",
       "  --json                     emit JSON instead of tabular output",
       "",
-      `Arker org id: ${ARKER_ORG_ID}`
+      "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"
     ].join("\n")
   );
   process.exit(2);
@@ -592,6 +658,10 @@ async function main() {
         return await cmdSyncs(args, client);
       case "shell":
         return await cmdShell(args, client);
+      // SSH is descoped/unsupported and hidden from the interface. The
+      // implementation below (cmdSsh / cmdSshKeys) is kept intact; re-add
+      // the `ssh` / `ssh-keys` cases here and their help entries to expose
+      // it once the server-side SSH path is supported.
       // Resources.
       case "vms":
         return await cmdVms(args, client);
@@ -599,8 +669,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 };