@arker-ai/sdk 0.3.0 → 0.5.1

package/dist/index.cjs

@@ -20,14 +20,31 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ARKER_ORG_ID: () => ARKER_ORG_ID,
   Arker: () => Arker,
   ArkerError: () => ArkerError,
   CHUNK_SIZE: () => CHUNK_SIZE,
-  Computer: () => Computer,
-  Sync: () => Sync
+  VM: () => VM
 });
 module.exports = __toCommonJS(index_exports);
 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;
@@ -38,6 +55,9 @@ var RETRYABLE_CODES = /* @__PURE__ */ new Set(["routing_unavailable", "unavailab
 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 {
@@ -51,39 +71,152 @@ var ArkerError = class extends Error {
   }
 };
 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 region = opts.region ?? (explicitBaseUrl ? void 0 : env(DEFAULT_REGION_ENV));
-    const baseUrl = explicitBaseUrl ?? (region ? regionBaseUrl(region, false) : void 0);
-    const burstBaseUrl = opts.burstBaseUrl ?? env("ARKER_BURST_BASE_URL") ?? (region ? regionBaseUrl(region, true) : void 0);
+    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 Computer(this, vmId, this._baseUrlFor(vmId));
-  }
-  async goldens() {
-    return this._request("GET", "/v1/goldens");
-  }
-  async list() {
-    return this._request("GET", "/v1/vms");
-  }
-  async get(vmId) {
-    return this._request("GET", vmPath(vmId), void 0, this._baseUrlFor(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) {
@@ -153,79 +286,90 @@ var Arker = class {
     return this.baseUrl;
   }
 };
-var Computer = class _Computer {
+var VM = class _VM {
   id;
   baseUrl;
-  sync;
   /** @internal */
   _client;
-  constructor(client, vmId, baseUrl = client._baseUrlFor(vmId)) {
+  // ── 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;
-    this.sync = new Sync(this);
-  }
+    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 response = await this._client._request(
-      "POST",
-      `${vmPath(this.id)}/fork`,
-      request,
-      this.baseUrl
-    );
-    return new _Computer(this._client, stringField(response.vm_id ?? response.id, "fork response.vm_id"), this.baseUrl);
+    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)}/run`,
+      `${vmPath(this.id)}/runs`,
       { ...body, command },
       this.baseUrl,
       headers
     );
     return parseRunResponse(response);
   }
-  async runStatus(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);
-  }
-  async delete() {
-    return this._client._request("DELETE", vmPath(this.id), void 0, this.baseUrl);
-  }
-};
-var Sync = class {
-  /** @internal */
-  _vm;
-  constructor(vm) {
-    this._vm = vm;
+  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 readFile(path) {
-    const response = await this._vm._client._request(
+  async syncRead(path) {
+    const response = await this._client._request(
       "POST",
-      this.path(),
+      `${vmPath(this.id)}/sync`,
       { op: "read", path },
-      this._vm.baseUrl
+      this.baseUrl
     );
     if ("content" in response) return decodeBytes(response.content, response.encoding);
-    const signed = await this._vm._client._fetch(response.presigned_url);
+    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 writeFile(path, data) {
-    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
-    if (bytes.length <= CHUNK_SIZE) {
-      await this.writeInline(path, bytes);
-    } else {
-      await this.writePresigned(path, bytes);
-    }
-  }
-  path() {
-    return `${vmPath(this._vm.id)}/sync`;
-  }
-  async writeInline(path, data) {
+  async syncWriteInline(path, data) {
     const result = await this.sendOneWrite({
       path,
       size: data.length,
@@ -236,30 +380,22 @@ var Sync = class {
     });
     assertWriteComplete(result, "inline write");
   }
-  async writePresigned(path, data) {
-    const request = await this.sendOneWrite({
-      path,
-      size: data.length,
-      presigned: true
-    });
+  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
-    });
+    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._vm._client._retryAttempts();
+    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._vm._client._fetch(url, {
+        const response = await this._client._fetch(url, {
           method: "PUT",
           body: data,
           signal: controller.signal
@@ -277,28 +413,108 @@ var Sync = class {
           throw new ArkerError("network_error", `upload PUT failed: ${message}`, 0);
         }
       }
-      await sleep(this._vm._client._retryDelay(attempt));
+      await sleep(this._client._retryDelay(attempt));
     }
   }
   async sendOneWrite(entry) {
     let lastError;
-    const attempts = this._vm._client._retryAttempts();
+    const attempts = this._client._retryAttempts();
     for (let attempt = 0; attempt < attempts; attempt++) {
-      const response = await this._vm._client._request("POST", this.path(), {
+      const response = await this._client._request("POST", `${vmPath(this.id)}/sync`, {
         op: "write",
         writes: [entry]
-      }, this._vm.baseUrl);
+      }, 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, error) || attempt === attempts - 1) break;
-      await sleep(this._vm._client._retryDelay(attempt));
+      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");
@@ -309,14 +525,26 @@ function normalizeRegion(region) {
   if (!trimmed) throw new Error("region must not be empty");
   return trimmed;
 }
-function regionBaseUrl(region, burst) {
+function computeBaseUrl(provider, region) {
   const normalized = normalizeRegion(region);
-  if (!burst) return `https://${normalized}.arker.ai/api`;
-  return `https://${burstRegionHost(normalized)}.arker.ai/api`;
+  return `https://${provider}-${normalized}.arker.ai/api`;
 }
-function burstRegionHost(region) {
-  if (region.startsWith("aws-")) return `aws-burst-${region.slice("aws-".length)}`;
-  return `${region}-burst`;
+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();
@@ -360,34 +588,24 @@ function parseRunResponse(payload) {
     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");
-    if (body.completed !== true) {
-      throw new ArkerError("internal", "completed run response must have completed=true", 200);
-    }
     return {
       type: "completed",
-      completed: true,
+      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")
+      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",
-      completed: Boolean(body.completed),
       runId: body.run_id,
-      tunnels: Array.isArray(body.tunnels) ? body.tunnels : [],
-      network: isObject(body.network) ? body.network : null
-    };
-  }
-  if (body.pty === true) {
-    return {
-      type: "pty",
-      pty: true,
-      sessionId: stringField(body.session_id, "run response.session_id"),
-      wsUrl: stringField(body.ws_url, "run response.ws_url")
+      state: typeof body.state === "string" ? body.state : "running",
+      tunnels: Array.isArray(body.tunnels) ? body.tunnels : []
     };
   }
   throw new ArkerError("internal", "unrecognized run response shape", 200);
@@ -499,9 +717,9 @@ function bufferConstructor() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ARKER_ORG_ID,
   Arker,
   ArkerError,
   CHUNK_SIZE,
-  Computer,
-  Sync
+  VM
 });