@arker-ai/sdk 0.2.1 → 0.5.1

package/dist/cli.cjs

@@ -0,0 +1,1316 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var readline = __toESM(require("readline/promises"), 1);
+var import_node_process = require("process");
+
+// src/index.ts
+var CHUNK_SIZE = 4 * 1024 * 1024;
+var ARKER_ORG_ID = "ArkerHQ";
+var GOLDEN_NAMES = /* @__PURE__ */ new Set([
+  "arkuntu",
+  "ubuntu",
+  "ubuntu-small",
+  "ubuntu-nodisk",
+  "ubuntu-nonet-nodisk",
+  "ubuntu-full",
+  "ubuntu-full-32",
+  "ubuntu-py-repl",
+  "ubuntu-js-repl",
+  "ubuntu-docker",
+  "ubuntu-chromium",
+  "ubuntu-servo",
+  "ubuntu-servo-js-repl",
+  "ubuntu-chromium-js-repl"
+]);
+var DEFAULT_RETRY_ATTEMPTS = 4;
+var DEFAULT_RETRY_BASE_DELAY_MS = 200;
+var DEFAULT_RETRY_MAX_DELAY_MS = 2e3;
+var DEFAULT_RETRY_JITTER_MS = 50;
+var PRESIGNED_PUT_TIMEOUT_MS = 6e5;
+var RETRYABLE_HTTP = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+var RETRYABLE_CODES = /* @__PURE__ */ new Set(["routing_unavailable", "unavailable", "temporarily_unavailable"]);
+var TRANSIENT_HINTS = ["503", "Service Unavailable", "throttle", "SlowDown", "ThrottlingException"];
+var ULID_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var DEFAULT_REGION_ENV = "ARKER_REGION";
+var DEFAULT_PROVIDER_ENV = "ARKER_PROVIDER";
+var DEFAULT_PROVIDER = "aws";
+var DEFAULT_CONTROL_BASE_URL = "https://arker.ai/api";
+var BURST_SOURCE_REFS = /* @__PURE__ */ new Set(["arkuntu"]);
+var BURST_VM_ID = /^[0-9A-HJKMNP-TV-Z]{26}_[A-Za-z0-9]+$/;
+var ArkerError = class extends Error {
+  code;
+  status;
+  constructor(code, message, status) {
+    super(`${code}: ${message}`);
+    this.name = "ArkerError";
+    this.code = code;
+    this.status = status;
+  }
+};
+var Arker = class {
+  /** Compute base URL for `provider` + `region` — used for fork/run/
+   * per-VM ops. SDK calls go straight to this host, skipping the CF
+   * Worker control plane. */
+  baseUrl;
+  /** Compute base URL for the burst provider in this region. */
+  burstBaseUrl;
+  /** CF Worker control-plane URL — used for cross-cutting admin calls
+   * like list-VMs and filesystems. */
+  controlBaseUrl;
+  region;
+  provider;
+  apiKey;
+  fetchImpl;
+  retry;
+  constructor(opts = {}) {
+    const apiKey = opts.apiKey ?? env("ARKER_API_KEY") ?? env("AUTH_KEY");
+    const explicitBaseUrl = opts.baseUrl ?? env("ARKER_BASE_URL");
+    const rawRegion = opts.region ?? (explicitBaseUrl ? void 0 : env(DEFAULT_REGION_ENV));
+    const rawProvider = opts.provider ?? env(DEFAULT_PROVIDER_ENV) ?? DEFAULT_PROVIDER;
+    const provider = parseProvider(rawProvider);
+    const { region, providerFromRegion } = splitRegion(rawRegion);
+    const effectiveProvider = providerFromRegion ?? provider;
+    const baseUrl = explicitBaseUrl ?? (region ? computeBaseUrl(effectiveProvider, region) : void 0);
+    const burstBaseUrl = opts.burstBaseUrl ?? env("ARKER_BURST_BASE_URL") ?? (region ? computeBaseUrl("aws-burst", region) : void 0);
+    const controlBaseUrl = opts.controlBaseUrl ?? env("ARKER_CONTROL_BASE_URL") ?? DEFAULT_CONTROL_BASE_URL;
+    if (!apiKey) throw new Error("apiKey is required; pass apiKey or set ARKER_API_KEY");
+    if (!baseUrl) throw new Error("region or baseUrl is required; pass region, baseUrl, ARKER_REGION, or ARKER_BASE_URL");
+    this.apiKey = apiKey;
+    this.baseUrl = normalizeBaseUrl(baseUrl);
+    this.burstBaseUrl = burstBaseUrl ? normalizeBaseUrl(burstBaseUrl) : void 0;
+    this.controlBaseUrl = normalizeBaseUrl(controlBaseUrl);
+    this.region = region ? normalizeRegion(region) : void 0;
+    this.provider = effectiveProvider;
+    this.fetchImpl = opts.fetch ?? globalThis.fetch;
+    this.retry = normalizeRetry(opts.retry);
+    if (!this.fetchImpl) throw new Error("fetch is required in this runtime");
+  }
+  /**
+   * Address an existing VM. Doesn't make any network calls; returns a
+   * lightweight handle.
+   */
+  vm(vmId) {
+    return new VM(this, vmId, this._baseUrlFor(vmId));
+  }
+  /**
+   * Create a new VM by forking from a source.
+   *
+   *     fork("ubuntu-full")                       // public golden by name
+   *     fork("base")                              // a VM by name in your org
+   *     fork(vm)                                  // an existing VM (uses its id)
+   *     fork({ sourceVmId: "vm_abc..." })
+   *     fork({ sourceVmName: "base", sourceOrgId: "org_..." })
+   *
+   * The source can be a name string, a `VM` handle, or a `ForkSource`
+   * object. `sourceOrgId` defaults to the Arker org when `sourceVmName`
+   * is a known public golden, otherwise to your own org; an explicit
+   * value always wins, and it's irrelevant when forking by id. Forking a
+   * VM in another org requires that VM to be `public: true`. The new VM's
+   * name (in your org) is passed as `name`. When the source is a name or
+   * `VM`, extra fork options go in the second `opts` argument.
+   */
+  async fork(source, opts = {}) {
+    const src = typeof source === "string" ? { sourceVmName: source, ...opts } : source instanceof VM ? { sourceVmId: source.id, ...opts } : source;
+    if (!src.sourceVmId && !src.sourceVmName) {
+      throw new ArkerError(
+        "bad_request",
+        "fork requires a source (a name, a VM, sourceVmName, or sourceVmId)",
+        400
+      );
+    }
+    if (src.sourceVmId && src.sourceVmName) {
+      throw new ArkerError(
+        "bad_request",
+        "fork: pass only one of sourceVmId or sourceVmName",
+        400
+      );
+    }
+    const sourceOrgId = src.sourceOrgId ?? (src.sourceVmName !== void 0 && GOLDEN_NAMES.has(src.sourceVmName) ? ARKER_ORG_ID : void 0);
+    const body = {
+      source_vm_id: src.sourceVmId ?? null,
+      source_vm_name: src.sourceVmName ?? null,
+      source_org_id: sourceOrgId ?? null,
+      name: src.name ?? null,
+      public: src.public ?? null,
+      network: src.network ?? null,
+      disk: src.disk ?? true,
+      vcpu_count: src.vcpu_count ?? null,
+      memory_mib: src.memory_mib ?? null,
+      max_memory_mib: src.max_memory_mib ?? null,
+      disk_mib: src.disk_mib ?? null,
+      durable: src.durable ?? null
+    };
+    const useBurst = sourceOrgId === ARKER_ORG_ID && src.sourceVmName !== void 0 && isBurstRef(src.sourceVmName);
+    const baseUrl = useBurst && this.burstBaseUrl ? this.burstBaseUrl : this.baseUrl;
+    const vm = await this._request("POST", "/v1/fork", body, baseUrl);
+    const vmId = vm.vm_id ?? vm.id ?? "";
+    return new VM(this, vmId, baseUrl, vm);
+  }
+  /**
+   * List VMs visible to the authenticated caller. **Admin call** —
+   * goes through the control plane (`controlBaseUrl`) so it can
+   * aggregate across providers and regions. Pass `?provider=` /
+   * `?region=` to narrow.
+   */
+  async listVms(opts = {}) {
+    const resp = await this._request("GET", buildQuery("/v1/vms", {
+      cursor: opts.cursor,
+      limit: opts.limit,
+      region: opts.region,
+      provider: opts.provider,
+      state: opts.state,
+      source_org_id: opts.sourceOrgId,
+      started_after: opts.startedAfter,
+      started_before: opts.startedBefore
+    }), void 0, this.controlBaseUrl);
+    const vms = (resp.vms ?? []).map((v) => {
+      const id = v.vm_id ?? v.id ?? "";
+      return new VM(this, id, this._baseUrlFor(id), v);
+    });
+    return { vms, nextCursor: resp.next_cursor ?? null };
+  }
+  /** Compute call — goes direct to the backend hosting this VM (no
+   * control-plane hop). Returns a fully-populated VM handle. */
+  async getVm(vmId) {
+    const data = await this._request("GET", vmPath(vmId), void 0, this._baseUrlFor(vmId));
+    return new VM(this, vmId, this._baseUrlFor(vmId), data);
+  }
+  // ── Filesystems (region-scoped, served by arkerd directly) ──────────
+  // Route to the regional endpoint (baseUrl), not the control plane: the
+  // control-plane path (arker.ai → api_proxy_bash) does not route
+  // /v1/filesystems, while the regional NLB → arkerd serves the full CRUD.
+  async listFilesystems(opts = {}) {
+    return this._request("GET", buildQuery("/v1/filesystems", {
+      cursor: opts.cursor,
+      limit: opts.limit,
+      name_prefix: opts.namePrefix
+    }), void 0, this.baseUrl);
+  }
+  async createFilesystem(request) {
+    return this._request("POST", "/v1/filesystems", { name: request.name }, this.baseUrl);
+  }
+  async getFilesystem(filesystemId) {
+    return this._request("GET", `/v1/filesystems/${pathSegment(filesystemId)}`, void 0, this.baseUrl);
+  }
+  async deleteFilesystem(filesystemId) {
+    return this._request("DELETE", `/v1/filesystems/${pathSegment(filesystemId)}`, void 0, this.baseUrl);
+  }
+  /** @internal */
+  async _request(method, path, body, baseUrl = this.baseUrl, extraHeaders) {
+    const url = `${baseUrl}${path}`;
+    const headers = {
+      authorization: `Bearer ${this.apiKey}`
+    };
+    if (extraHeaders) {
+      for (const [key, value] of Object.entries(extraHeaders)) {
+        if (value !== void 0) headers[key] = value;
+      }
+    }
+    const init = { method, headers };
+    if (body !== void 0) {
+      headers["content-type"] = "application/json";
+      init.body = JSON.stringify(withoutUndefined(body));
+    }
+    let lastStatus = 0;
+    let lastText = "";
+    let lastError;
+    for (let attempt = 0; attempt < this.retry.attempts; attempt++) {
+      try {
+        const response = await this.fetchImpl(url, init);
+        const text = await response.text();
+        const payload = parseJson(text);
+        const parsedError = extractError(payload);
+        lastStatus = response.status;
+        lastText = text;
+        lastError = parsedError;
+        if (isRetryable(response.status, parsedError) && attempt < this.retry.attempts - 1) {
+          await sleep(retryDelay(this.retry, attempt));
+          continue;
+        }
+        if (parsedError) throw new ArkerError(parsedError.code, parsedError.message, response.status);
+        if (!response.ok) {
+          throw new ArkerError("internal", lastText.slice(0, 300) || `HTTP ${response.status}`, response.status);
+        }
+        return payload;
+      } catch (error) {
+        if (error instanceof ArkerError) throw error;
+        if (attempt < this.retry.attempts - 1) {
+          await sleep(retryDelay(this.retry, attempt));
+          continue;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ArkerError("network_error", message, 0);
+      }
+    }
+    if (lastError) throw new ArkerError(lastError.code, lastError.message, lastStatus);
+    throw new ArkerError("internal", lastText.slice(0, 300) || `HTTP ${lastStatus}`, lastStatus);
+  }
+  /** @internal */
+  async _fetch(input2, init) {
+    return this.fetchImpl(input2, init);
+  }
+  /** @internal */
+  _retryAttempts() {
+    return this.retry.attempts;
+  }
+  /** @internal */
+  _retryDelay(attempt) {
+    return retryDelay(this.retry, attempt);
+  }
+  /** @internal */
+  _baseUrlFor(ref) {
+    if (isBurstRef(ref) && this.burstBaseUrl) return this.burstBaseUrl;
+    return this.baseUrl;
+  }
+};
+var VM = class _VM {
+  id;
+  baseUrl;
+  /** @internal */
+  _client;
+  // ── Data fields ──────────────────────────────────────────────────
+  // Populated from fork/get/list/refresh; `undefined` on a bare handle
+  // from `arker.vm(id)` until you call `refresh()`. Names mirror the
+  // contract (`Vm`).
+  vm_id;
+  name;
+  state;
+  owner_org_id;
+  created_at;
+  public;
+  region;
+  provider;
+  vcpu_count;
+  memory_mib;
+  disk_mib;
+  started_at;
+  root_source_vm_id;
+  root_source_vm_name;
+  worker_id;
+  sessions;
+  tunnels;
+  constructor(client, vmId, baseUrl = client._baseUrlFor(vmId), data) {
+    this._client = client;
+    this.id = vmId;
+    this.baseUrl = baseUrl;
+    if (data) Object.assign(this, data);
+    Object.defineProperty(this, "_client", { enumerable: false });
+  }
+  /** Re-fetch this VM and return a fresh, fully-populated handle. */
+  async refresh() {
+    const data = await this._client._request("GET", vmPath(this.id), void 0, this.baseUrl);
+    return new _VM(this._client, this.id, this.baseUrl, data);
+  }
+  /**
+   * @deprecated Use `Arker.fork({ sourceVmId: this.id, ... })`.
+   * Kept for back-compat with older user code that called `.fork()` on
+   * a VM instance.
+   */
+  async fork(request = {}) {
+    const merged = {
+      ...request,
+      source_vm_id: request.source_vm_id ?? this.id,
+      disk: request.disk ?? true
+    };
+    const vm = await this._client._request("POST", "/v1/fork", merged, this.baseUrl);
+    const vmId = vm.vm_id ?? vm.id ?? "";
+    return new _VM(this._client, vmId, this.baseUrl, vm);
+  }
+  async run(command, options = {}) {
+    const { idempotencyKey, ...body } = options;
+    const headers = idempotencyKey ? { "Idempotency-Key": idempotencyKey } : void 0;
+    const response = await this._client._request(
+      "POST",
+      `${vmPath(this.id)}/runs`,
+      { ...body, command },
+      this.baseUrl,
+      headers
+    );
+    return parseRunResponse(response);
+  }
+  async sync(path, data) {
+    if (data === void 0) return this.syncRead(path);
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    if (bytes.length <= CHUNK_SIZE) await this.syncWriteInline(path, bytes);
+    else await this.syncWritePresigned(path, bytes);
+  }
+  async syncRead(path) {
+    const response = await this._client._request(
+      "POST",
+      `${vmPath(this.id)}/sync`,
+      { op: "read", path },
+      this.baseUrl
+    );
+    if ("content" in response) return decodeBytes(response.content, response.encoding);
+    const signed = await this._client._fetch(response.presigned_url);
+    if (!signed.ok) throw new ArkerError("internal", `signed GET failed: ${signed.status}`, signed.status);
+    return new Uint8Array(await signed.arrayBuffer());
+  }
+  async syncWriteInline(path, data) {
+    const result = await this.sendOneWrite({
+      path,
+      size: data.length,
+      upload_id: ulid(),
+      content: bytesToBase64(data),
+      start: 0,
+      end: data.length
+    });
+    assertWriteComplete(result, "inline write");
+  }
+  async syncWritePresigned(path, data) {
+    const request = await this.sendOneWrite({ path, size: data.length, presigned: true });
+    if (!("presigned_url" in request) || !request.presigned_url || !request.upload_id) {
+      throw new ArkerError("internal", "write response missing presigned upload fields", 200);
+    }
+    await this.putPresigned(request.presigned_url, data);
+    const commit = await this.sendOneWrite({ path, size: data.length, upload_id: request.upload_id });
+    assertWriteComplete(commit, "presigned write commit");
+  }
+  async putPresigned(url, data) {
+    const attempts = this._client._retryAttempts();
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), PRESIGNED_PUT_TIMEOUT_MS);
+      try {
+        const response = await this._client._fetch(url, {
+          method: "PUT",
+          body: data,
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (response.ok) return;
+        if (!RETRYABLE_HTTP.has(response.status) || attempt === attempts - 1) {
+          throw new ArkerError("internal", `upload PUT failed: ${response.status}`, response.status);
+        }
+      } catch (error) {
+        clearTimeout(timeout);
+        if (error instanceof ArkerError) throw error;
+        if (attempt === attempts - 1) {
+          const message = error instanceof Error ? error.message : String(error);
+          throw new ArkerError("network_error", `upload PUT failed: ${message}`, 0);
+        }
+      }
+      await sleep(this._client._retryDelay(attempt));
+    }
+  }
+  async sendOneWrite(entry) {
+    let lastError;
+    const attempts = this._client._retryAttempts();
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      const response = await this._client._request("POST", `${vmPath(this.id)}/sync`, {
+        op: "write",
+        writes: [entry]
+      }, this.baseUrl);
+      const result = response.results[0];
+      if (!result) throw new ArkerError("internal", "write response missing results[0]", 200);
+      const error = result.error ?? void 0;
+      if (!error) return result;
+      lastError = error;
+      if (!isRetryable(200, { code: error.code, message: error.message }) || attempt === attempts - 1) break;
+      await sleep(this._client._retryDelay(attempt));
+    }
+    throw new ArkerError(lastError?.code ?? "internal", lastError?.message ?? "write failed", 200);
+  }
+  async resize(request) {
+    return this._client._request("POST", `${vmPath(this.id)}/resize`, request, this.baseUrl);
+  }
+  async delete() {
+    return this._client._request("DELETE", vmPath(this.id), void 0, this.baseUrl);
+  }
+  // ── Syncs: bindings of a filesystem into this VM at a path ────────
+  async listSyncs(opts = {}) {
+    return this._client._request("GET", buildQuery(`${vmPath(this.id)}/syncs`, {
+      cursor: opts.cursor,
+      limit: opts.limit,
+      filesystem_id: opts.filesystemId
+    }), void 0, this.baseUrl);
+  }
+  async createSync(request) {
+    return this._client._request("POST", `${vmPath(this.id)}/syncs`, {
+      filesystem_id: request.filesystemId,
+      path: request.path
+    }, this.baseUrl);
+  }
+  async deleteSync(syncId) {
+    return this._client._request("DELETE", `${vmPath(this.id)}/syncs/${pathSegment(syncId)}`, void 0, this.baseUrl);
+  }
+  // ── Runs ──────────────────────────────────────────────────────────
+  async listRuns(opts = {}) {
+    return this._client._request("GET", buildQuery(`${vmPath(this.id)}/runs`, {
+      cursor: opts.cursor,
+      limit: opts.limit,
+      state: opts.state,
+      started_after: opts.startedAfter,
+      started_before: opts.startedBefore,
+      completed_after: opts.completedAfter
+    }), void 0, this.baseUrl);
+  }
+  async getRun(runId) {
+    return this._client._request("GET", `${vmPath(this.id)}/runs/${pathSegment(runId)}`, void 0, this.baseUrl);
+  }
+  async cancelRun(runId) {
+    return this._client._request("DELETE", `${vmPath(this.id)}/runs/${pathSegment(runId)}`, void 0, this.baseUrl);
+  }
+  // ── Sessions ──────────────────────────────────────────────────────
+  async listSessions(opts = {}) {
+    return this._client._request("GET", buildQuery(`${vmPath(this.id)}/sessions`, {
+      cursor: opts.cursor,
+      limit: opts.limit,
+      state: opts.state
+    }), void 0, this.baseUrl);
+  }
+  async createSession(request = {}) {
+    return this._client._request("POST", `${vmPath(this.id)}/sessions`, request, this.baseUrl);
+  }
+  async getSession(sessionId) {
+    return this._client._request("GET", `${vmPath(this.id)}/sessions/${pathSegment(sessionId)}`, void 0, this.baseUrl);
+  }
+  async deleteSession(sessionId) {
+    return this._client._request("DELETE", `${vmPath(this.id)}/sessions/${pathSegment(sessionId)}`, void 0, this.baseUrl);
+  }
+  // ── Tunnels: opened as a side effect of fork/run, addressed by port ─
+  async listTunnels(opts = {}) {
+    return this._client._request("GET", buildQuery(`${vmPath(this.id)}/tunnels`, {
+      cursor: opts.cursor,
+      limit: opts.limit,
+      state: opts.state
+    }), void 0, this.baseUrl);
+  }
+  async getTunnel(port) {
+    return this._client._request("GET", `${vmPath(this.id)}/tunnels/${port}`, void 0, this.baseUrl);
+  }
+  async deleteTunnel(port) {
+    return this._client._request("DELETE", `${vmPath(this.id)}/tunnels/${port}`, void 0, this.baseUrl);
+  }
+};
+function buildQuery(path, params) {
+  const usp = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    usp.append(key, String(value));
+  }
+  const qs = usp.toString();
+  return qs ? `${path}?${qs}` : path;
+}
+function normalizeBaseUrl(baseUrl) {
+  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  if (!trimmed) throw new Error("baseUrl must not be empty");
+  return trimmed;
+}
+function normalizeRegion(region) {
+  const trimmed = region.trim().toLowerCase();
+  if (!trimmed) throw new Error("region must not be empty");
+  return trimmed;
+}
+function computeBaseUrl(provider, region) {
+  const normalized = normalizeRegion(region);
+  return `https://${provider}-${normalized}.arker.ai/api`;
+}
+function parseProvider(value) {
+  if (!value) return DEFAULT_PROVIDER;
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed === "aws-burst" || trimmed === "burst") return "aws-burst";
+  return "aws";
+}
+function splitRegion(value) {
+  if (!value) return {};
+  const normalized = value.trim().toLowerCase();
+  if (normalized.startsWith("aws-burst-")) {
+    return { region: normalized.slice("aws-burst-".length), providerFromRegion: "aws-burst" };
+  }
+  if (normalized.startsWith("aws-")) {
+    return { region: normalized.slice("aws-".length), providerFromRegion: "aws" };
+  }
+  return { region: normalized };
+}
+function isBurstRef(ref) {
+  const trimmed = ref.trim();
+  return BURST_SOURCE_REFS.has(trimmed.toLowerCase()) || BURST_VM_ID.test(trimmed);
+}
+function normalizeRetry(retry) {
+  if (retry === false) {
+    return { attempts: 1, baseDelayMs: 0, maxDelayMs: 0, jitterMs: 0 };
+  }
+  return {
+    attempts: Math.max(1, Math.floor(retry?.attempts ?? DEFAULT_RETRY_ATTEMPTS)),
+    baseDelayMs: Math.max(0, retry?.baseDelayMs ?? DEFAULT_RETRY_BASE_DELAY_MS),
+    maxDelayMs: Math.max(0, retry?.maxDelayMs ?? DEFAULT_RETRY_MAX_DELAY_MS),
+    jitterMs: Math.max(0, retry?.jitterMs ?? DEFAULT_RETRY_JITTER_MS)
+  };
+}
+function env(name) {
+  const value = globalThis.process?.env?.[name];
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function vmPath(vmId) {
+  return `/v1/vms/${pathSegment(vmId)}`;
+}
+function pathSegment(value) {
+  return encodeURIComponent(value);
+}
+function withoutUndefined(value) {
+  if (Array.isArray(value)) return value.map(withoutUndefined);
+  if (!value || typeof value !== "object") return value;
+  const output2 = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry !== void 0) output2[key] = withoutUndefined(entry);
+  }
+  return output2;
+}
+function parseRunResponse(payload) {
+  const body = objectPayload(payload, "run response");
+  if (typeof body.stdout === "string") {
+    const stdout = stringValue(body.stdout, "run response.stdout");
+    const stdoutEncoding = stringField(body.stdout_encoding, "run response.stdout_encoding");
+    const stderr = stringValue(body.stderr, "run response.stderr");
+    const stderrEncoding = stringField(body.stderr_encoding, "run response.stderr_encoding");
+    return {
+      type: "completed",
+      runId: typeof body.run_id === "string" ? body.run_id : void 0,
+      state: typeof body.state === "string" ? body.state : "completed",
+      stdout: decodeBytes(stdout, stdoutEncoding),
+      stdoutEncoding,
+      stderr: decodeBytes(stderr, stderrEncoding),
+      stderrEncoding,
+      exitCode: numberField(body.exit_code, "run response.exit_code"),
+      failReason: typeof body.fail_reason === "string" ? body.fail_reason : null
+    };
+  }
+  if (typeof body.run_id === "string") {
+    return {
+      type: "background",
+      runId: body.run_id,
+      state: typeof body.state === "string" ? body.state : "running",
+      tunnels: Array.isArray(body.tunnels) ? body.tunnels : []
+    };
+  }
+  throw new ArkerError("internal", "unrecognized run response shape", 200);
+}
+function parseJson(text) {
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function extractError(payload) {
+  if (!isObject(payload)) return void 0;
+  if (typeof payload.code === "string" && typeof payload.message === "string") {
+    return { code: payload.code, message: payload.message };
+  }
+  if (isObject(payload.error)) {
+    return {
+      code: typeof payload.error.code === "string" ? payload.error.code : "internal",
+      message: typeof payload.error.message === "string" ? payload.error.message : ""
+    };
+  }
+  return void 0;
+}
+function isRetryable(status, error) {
+  if (RETRYABLE_HTTP.has(status)) return true;
+  if (!error) return false;
+  if (RETRYABLE_CODES.has(error.code)) return true;
+  if (error.code !== "internal") return false;
+  return TRANSIENT_HINTS.some((hint) => error.message.includes(hint));
+}
+function retryDelay(retry, attempt) {
+  const base = Math.min(retry.maxDelayMs, retry.baseDelayMs * 2 ** attempt);
+  return base + jitter(retry.jitterMs);
+}
+function jitter(maxMs) {
+  return Math.floor(Math.random() * (maxMs + 1));
+}
+async function sleep(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function objectPayload(value, context) {
+  if (!isObject(value)) throw new ArkerError("internal", `${context} must be an object`, 200);
+  return value;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stringField(value, context) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new ArkerError("internal", `${context} must be a non-empty string`, 200);
+  }
+  return value;
+}
+function stringValue(value, context) {
+  if (typeof value !== "string") throw new ArkerError("internal", `${context} must be a string`, 200);
+  return value;
+}
+function numberField(value, context) {
+  if (typeof value !== "number") throw new ArkerError("internal", `${context} must be a number`, 200);
+  return value;
+}
+function assertWriteComplete(result, context) {
+  if (result.complete && result.written) return;
+  throw new ArkerError("internal", `${context} did not complete`, 200);
+}
+function ulid() {
+  const crypto = globalThis.crypto;
+  if (!crypto?.getRandomValues) throw new Error("crypto.getRandomValues is required in this runtime");
+  const time = BigInt(Date.now()) & (1n << 48n) - 1n;
+  const rand = new Uint8Array(10);
+  crypto.getRandomValues(rand);
+  let raw = time << 80n | rand.reduce((acc, byte) => acc << 8n | BigInt(byte), 0n);
+  const out2 = [];
+  for (let i = 0; i < 26; i++) {
+    out2.push(ULID_ALPHABET[Number(raw & 31n)]);
+    raw >>= 5n;
+  }
+  return out2.reverse().join("");
+}
+function decodeBytes(text, encoding) {
+  if (encoding === "base64") return base64ToBytes(text);
+  return new TextEncoder().encode(text);
+}
+function bytesToBase64(data) {
+  const buffer = bufferConstructor();
+  if (buffer) return buffer.from(data).toString("base64");
+  let binary = "";
+  for (let offset = 0; offset < data.length; offset += 32768) {
+    const chunk = data.subarray(offset, offset + 32768);
+    binary += String.fromCharCode(...chunk);
+  }
+  return btoa(binary);
+}
+function base64ToBytes(text) {
+  const buffer = bufferConstructor();
+  if (buffer) {
+    const decoded = buffer.from(text, "base64");
+    return new Uint8Array(decoded.buffer, decoded.byteOffset, decoded.byteLength);
+  }
+  const binary = atob(text);
+  const out2 = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) out2[i] = binary.charCodeAt(i);
+  return out2;
+}
+function bufferConstructor() {
+  return globalThis.Buffer;
+}
+
+// src/cli.ts
+function parseArgs(argv) {
+  const positional = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const eq = arg.indexOf("=");
+      if (eq !== -1) {
+        flags[arg.slice(2, eq)] = arg.slice(eq + 1);
+      } else {
+        const next = argv[i + 1];
+        if (next !== void 0 && !next.startsWith("--")) {
+          flags[arg.slice(2)] = next;
+          i++;
+        } else {
+          flags[arg.slice(2)] = true;
+        }
+      }
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      flags[arg.slice(1)] = true;
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { positional, flags };
+}
+function readFileConfig() {
+  const path = (0, import_node_path.join)((0, import_node_os.homedir)(), ".arker", "config.json");
+  if (!(0, import_node_fs.existsSync)(path)) return {};
+  try {
+    return JSON.parse((0, import_node_fs.readFileSync)(path, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function clientFromArgs(args) {
+  const file = readFileConfig();
+  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 controlBaseUrl = args.flags["control-base-url"] ?? process.env.ARKER_CONTROL_BASE_URL;
+  const region = args.flags.region ?? process.env.ARKER_REGION ?? 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.");
+  }
+  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) {
+  if (typeof value === "string") {
+    import_node_process.stdout.write(value + "\n");
+  } else {
+    import_node_process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+  }
+}
+function err(msg) {
+  process.stderr.write(`arker: ${msg}
+`);
+}
+function die(msg) {
+  err(msg);
+  process.exit(1);
+}
+function fmtVm(vm) {
+  const provider = vm.provider ?? "?";
+  const region = vm.region ?? "?";
+  const name = vm.name ?? "\u2014";
+  const state = vm.state ?? "?";
+  return `${vm.vm_id ?? vm.id}	${provider}-${region}	${state}	${name}`;
+}
+async function cmdVms(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.listVms({
+        provider: args.flags.provider,
+        region: args.flags.region,
+        state: args.flags.state,
+        cursor: args.flags.cursor,
+        limit: numFlag(args, "limit")
+      });
+      if (args.flags.json) return out({ vms: res.vms, next_cursor: res.nextCursor });
+      for (const vm of res.vms) out(fmtVm(vm));
+      if (res.nextCursor) out(`# next_cursor=${res.nextCursor}`);
+      return;
+    }
+    case "get": {
+      const id = rest[0] ?? die("usage: arker vms get <vm_id>");
+      out(await client.getVm(id));
+      return;
+    }
+    case "rm":
+    case "delete": {
+      const id = rest[0] ?? die("usage: arker vms rm <vm_id>");
+      const r = await client.vm(id).delete();
+      if (r.deleted) out(`deleted ${id}`);
+      else {
+        err("delete failed");
+        process.exitCode = 1;
+      }
+      return;
+    }
+    case "fork": {
+      await cmdFork({ ...args, positional: rest }, client);
+      return;
+    }
+    case "run": {
+      await cmdRun({ ...args, positional: rest }, client);
+      return;
+    }
+    default:
+      die(`unknown vms subcommand: ${sub}`);
+  }
+}
+async function cmdFork(args, client) {
+  const refPositional = args.positional[0];
+  const srcVmIdFlag = args.flags["source-vm-id"];
+  const srcVmNameFlag = args.flags["source-vm-name"];
+  const srcOrgIdFlag = args.flags["source-org-id"];
+  const name = args.flags.name;
+  const publicFlag = boolFlag(args, "public");
+  let sourceVmId = srcVmIdFlag;
+  let sourceVmName = srcVmNameFlag;
+  let sourceOrgId = srcOrgIdFlag;
+  if (!sourceVmId && !sourceVmName && refPositional) {
+    sourceVmName = refPositional;
+  }
+  if (!sourceVmId && !sourceVmName) {
+    die("usage: arker fork <vm_name> | --source-vm-id <id> | --source-vm-name <name> [--source-org-id <org>]");
+  }
+  const computer = await client.fork({
+    sourceVmId,
+    sourceVmName,
+    sourceOrgId,
+    name,
+    public: publicFlag
+  });
+  out({ vm_id: computer.id });
+}
+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 result = await client.vm(vmId).run(command, {
+    background: boolFlag(args, "background"),
+    timeout: numFlag(args, "timeout"),
+    acquire: args.flags.acquire,
+    release: args.flags.release
+  });
+  if (result.type === "completed") {
+    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;
+    return;
+  }
+  out({ run_id: result.runId, tunnels: result.tunnels });
+}
+async function cmdRuns(args, client) {
+  const sub = args.positional[0];
+  const rest = args.positional.slice(1);
+  switch (sub) {
+    case "ls":
+    case "list": {
+      const vm = rest[0] ?? die("usage: arker runs ls <vm_id>");
+      const res = await client.vm(vm).listRuns({
+        state: args.flags.state,
+        cursor: args.flags.cursor,
+        limit: numFlag(args, "limit")
+      });
+      if (args.flags.json) return out(res);
+      for (const r of res.runs) {
+        out(`${r.run_id}	${r.state}	${r.exit_code ?? "-"}	${r.command ?? ""}`);
+      }
+      if (res.next_cursor) out(`# next_cursor=${res.next_cursor}`);
+      return;
+    }
+    case "get": {
+      const [vm, runId] = rest;
+      if (!vm || !runId) die("usage: arker runs get <vm_id> <run_id>");
+      out(await client.vm(vm).getRun(runId));
+      return;
+    }
+    case "rm":
+    case "cancel": {
+      const [vm, runId] = rest;
+      if (!vm || !runId) die("usage: arker runs rm <vm_id> <run_id>");
+      const r = await client.vm(vm).cancelRun(runId);
+      out(r.cancelled ? `cancelled ${runId}` : "cancel failed");
+      return;
+    }
+    default:
+      die(`usage: arker runs <ls|get|rm> ...`);
+  }
+}
+async function cmdSessions(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 sessions ls <vm_id>");
+      const res = await client.vm(vm).listSessions({
+        state: args.flags.state,
+        cursor: args.flags.cursor,
+        limit: numFlag(args, "limit")
+      });
+      if (args.flags.json) return out(res);
+      for (const s of res.sessions) {
+        out(`${s.session_id}	${s.state}	${s.cwd}`);
+      }
+      if (res.next_cursor) out(`# next_cursor=${res.next_cursor}`);
+      return;
+    }
+    case "get": {
+      if (!vm) die("usage: arker sessions get <vm_id> <session_id>");
+      const sid = rest[1] ?? die("missing session_id");
+      out(await client.vm(vm).getSession(sid));
+      return;
+    }
+    case "create": {
+      if (!vm) die("usage: arker sessions create <vm_id>");
+      out(await client.vm(vm).createSession({ cwd: args.flags.cwd }));
+      return;
+    }
+    case "rm":
+    case "delete": {
+      if (!vm) die("usage: arker sessions rm <vm_id> <session_id>");
+      const sid = rest[1] ?? die("missing session_id");
+      const r = await client.vm(vm).deleteSession(sid);
+      out(r.deleted ? `deleted ${sid}` : "delete failed");
+      return;
+    }
+    default:
+      die(`usage: arker sessions <ls|get|create|rm> ...`);
+  }
+}
+async function cmdSyncs(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 syncs ls <vm_id>");
+      const res = await client.vm(vm).listSyncs({
+        cursor: args.flags.cursor,
+        limit: numFlag(args, "limit"),
+        filesystemId: args.flags["filesystem-id"]
+      });
+      if (args.flags.json) return out(res);
+      for (const s of res.syncs) {
+        out(`${s.sync_id}	${s.filesystem_id}	${s.path}`);
+      }
+      if (res.next_cursor) out(`# next_cursor=${res.next_cursor}`);
+      return;
+    }
+    case "create": {
+      if (!vm) die("usage: arker syncs create <vm_id> --filesystem-id <fs> [--path /mnt]");
+      const filesystemId = args.flags["filesystem-id"];
+      if (!filesystemId) die("missing --filesystem-id");
+      out(await client.vm(vm).createSync({
+        filesystemId,
+        path: args.flags.path
+      }));
+      return;
+    }
+    case "rm":
+    case "delete": {
+      if (!vm) die("usage: arker syncs rm <vm_id> <sync_id>");
+      const sid = rest[1] ?? die("missing sync_id");
+      const r = await client.vm(vm).deleteSync(sid);
+      out(r.deleted ? `deleted ${sid}` : "delete failed");
+      return;
+    }
+    default:
+      die(`usage: arker syncs <ls|create|rm> ...  (read/write files with: arker sync)`);
+  }
+}
+async function cmdSync(args, client) {
+  const vm = args.positional[0] ?? die("usage: arker sync <vm_id> <path> [data]   (omit data to read; or pipe stdin to write)");
+  const path = args.positional[1] ?? die("missing path");
+  const inline = args.positional[2];
+  if (inline !== void 0) {
+    await client.vm(vm).sync(path, inline);
+    out(`wrote ${Buffer.byteLength(inline)} bytes to ${path}`);
+    return;
+  }
+  if (!process.stdin.isTTY) {
+    const buf = await readAllStdin();
+    if (buf.length > 0) {
+      await client.vm(vm).sync(path, buf);
+      out(`wrote ${buf.length} bytes to ${path}`);
+      return;
+    }
+  }
+  import_node_process.stdout.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.port}	${t.state}	${t.protocol}	${t.url ?? "-"}`);
+      }
+      if (res.next_cursor) out(`# next_cursor=${res.next_cursor}`);
+      return;
+    }
+    case "get": {
+      if (!vm) die("usage: arker tunnels get <vm_id> <port>");
+      const port = Number(rest[1] ?? die("missing port"));
+      out(await client.vm(vm).getTunnel(port));
+      return;
+    }
+    case "rm":
+    case "delete": {
+      if (!vm) die("usage: arker tunnels rm <vm_id> <port>");
+      const port = Number(rest[1] ?? die("missing port"));
+      const r = await client.vm(vm).deleteTunnel(port);
+      out(r.deleted ? `deleted tunnel ${port}` : "delete failed");
+      return;
+    }
+    default:
+      die(`usage: arker tunnels <ls|get|rm> ...`);
+  }
+}
+async function cmdFilesystems(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.listFilesystems({
+        cursor: args.flags.cursor,
+        limit: numFlag(args, "limit"),
+        namePrefix: args.flags["name-prefix"]
+      });
+      if (args.flags.json) return out(res);
+      for (const f of res.filesystems) {
+        out(`${f.filesystem_id}	${f.name}	${f.size_bytes ?? "-"}`);
+      }
+      if (res.next_cursor) out(`# next_cursor=${res.next_cursor}`);
+      return;
+    }
+    case "create": {
+      const name = args.flags.name ?? rest[0];
+      if (!name) die("usage: arker fs create --name <name>  (or: arker fs create <name>)");
+      out(await client.createFilesystem({ name }));
+      return;
+    }
+    case "get": {
+      const id = rest[0] ?? die("usage: arker fs get <filesystem_id>");
+      out(await client.getFilesystem(id));
+      return;
+    }
+    case "rm":
+    case "delete": {
+      const id = rest[0] ?? die("usage: arker fs rm <filesystem_id>");
+      const r = await client.deleteFilesystem(id);
+      out(r.deleted ? `deleted ${id}` : "delete failed");
+      return;
+    }
+    default:
+      die(`usage: arker fs <ls|create|get|rm> ...`);
+  }
+}
+async function cmdShell(args, client) {
+  let computer;
+  const vmIdArg = args.flags["vm-id"] ?? args.positional[0];
+  if (vmIdArg) {
+    computer = await client.vm(vmIdArg).refresh();
+  } else {
+    const sourceVmName = args.flags["source-vm-name"] ?? "ubuntu-full";
+    computer = await client.fork({
+      sourceVmName,
+      sourceOrgId: ARKER_ORG_ID
+    });
+  }
+  const header = computer;
+  const session = await computer.createSession({
+    cwd: args.flags.cwd
+  });
+  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;
+  import_node_process.stdout.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: import_node_process.stdin, output: import_node_process.stdout, prompt: "> " });
+    rl.on("SIGINT", () => {
+      if (inFlight) {
+        process.stderr.write("^C\n");
+        return;
+      }
+      process.stdout.write("^C\n");
+      rl.write(null, { ctrl: true, name: "u" });
+      rl.prompt();
+    });
+    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}`);
+      }
+      rl.prompt();
+    }
+    rl.close();
+  } finally {
+    await computer.deleteSession(sessionId).catch(() => {
+    });
+  }
+  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];
+  if (typeof v === "string") return Number(v);
+  return void 0;
+}
+function boolFlag(args, name) {
+  const v = args.flags[name];
+  if (v === void 0) return void 0;
+  if (typeof v === "boolean") return v;
+  if (v === "false" || v === "0") return false;
+  return true;
+}
+async function readAllStdin() {
+  const chunks = [];
+  for await (const chunk of import_node_process.stdin) chunks.push(chunk);
+  return new Uint8Array(Buffer.concat(chunks));
+}
+function usage() {
+  out(
+    [
+      "arker \u2014 VM control plane CLI",
+      "",
+      "Usage:",
+      "  arker <command> [args]",
+      "",
+      "Shortcuts:",
+      "  arker ls                                       list VMs",
+      "  arker rm <vm>                                  delete VM",
+      "  arker fork <vm_name>                           fork the public golden (in Arker org)",
+      "  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)",
+      "",
+      "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)",
+      "  --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}`
+    ].join("\n")
+  );
+  process.exit(2);
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0 || argv[0] === "-h" || argv[0] === "--help") usage();
+  const cmd = argv[0];
+  const args = parseArgs(argv.slice(1));
+  const client = clientFromArgs(args);
+  try {
+    switch (cmd) {
+      // Shortcuts.
+      case "ls":
+      case "list":
+        return await cmdVms({ ...args, positional: ["ls", ...args.positional] }, client);
+      case "rm":
+      case "delete":
+        return await cmdVms({ ...args, positional: ["rm", ...args.positional] }, client);
+      case "fork":
+        return await cmdFork(args, client);
+      case "run":
+        return await cmdRun(args, client);
+      case "sync":
+        return await cmdSync(args, client);
+      case "syncs":
+        return await cmdSyncs(args, client);
+      case "shell":
+        return await cmdShell(args, client);
+      // Resources.
+      case "vms":
+        return await cmdVms(args, client);
+      case "runs":
+        return await cmdRuns(args, client);
+      case "sessions":
+        return await cmdSessions(args, client);
+      case "tunnels":
+        return await cmdTunnels(args, client);
+      case "filesystems":
+      case "fs":
+        return await cmdFilesystems(args, client);
+      default:
+        die(`unknown command: ${cmd}. Run 'arker --help'.`);
+    }
+  } catch (e) {
+    if (e instanceof ArkerError) {
+      err(`${e.code}: ${e.message}`);
+      process.exit(1);
+    }
+    throw e;
+  }
+}
+void main();