@arker-ai/sdk 0.6.2 → 0.7.0

package/dist/modal.cjs

@@ -182,6 +182,7 @@ var Arker = class {
   provider;
   apiKey;
   fetchImpl;
+  http2;
   retry;
   constructor(opts = {}) {
     const apiKey = opts.apiKey ?? env("ARKER_API_KEY") ?? env("AUTH_KEY");
@@ -203,6 +204,7 @@ var Arker = class {
     this.region = region ? normalizeRegion(region) : void 0;
     this.provider = effectiveProvider;
     this.fetchImpl = opts.fetch ?? globalThis.fetch;
+    this.http2 = opts.fetch === void 0;
     this.retry = normalizeRetry(opts.retry);
     if (!this.fetchImpl) throw new Error("fetch is required in this runtime");
   }
@@ -263,7 +265,10 @@ var Arker = class {
       egress: src.egress ?? null,
       disk: src.disk ?? true,
       durable: src.durable ?? null,
-      resources
+      resources,
+      // ARK-125: omit to inherit the source's policy; pass a doc to override
+      // (an empty `{ policies: [] }` clears to allow-all, NOT inherit).
+      policies: src.policies ?? null
     };
     const useBurst = sourceOrgId === ARKER_ORG_ID && src.sourceVmName !== void 0 && isBurstRef(src.sourceVmName);
     const baseUrl = useBurst && this.burstBaseUrl ? this.burstBaseUrl : this.baseUrl;
@@ -358,30 +363,29 @@ var Arker = class {
         if (value !== void 0) headers[key] = value;
       }
     }
-    const init = { method, headers };
+    let requestBody;
     if (body !== void 0) {
       headers["content-type"] = "application/json";
-      init.body = JSON.stringify(withoutUndefined(body));
+      requestBody = 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 { status, ok, text } = await sendRequest(url, { method, headers, body: requestBody }, this.fetchImpl, this.http2);
         const payload = parseJson(text);
         const parsedError = extractError(payload);
-        lastStatus = response.status;
+        lastStatus = status;
         lastText = text;
         lastError = parsedError;
-        if (isRetryable(response.status, parsedError) && attempt < this.retry.attempts - 1) {
+        if (isRetryable(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);
+        if (parsedError) throw new ArkerError(parsedError.code, parsedError.message, status);
+        if (!ok) {
+          throw new ArkerError("internal", lastText.slice(0, 300) || `HTTP ${status}`, status);
         }
         return payload;
       } catch (error) {
@@ -593,6 +597,32 @@ var VM = class _VM {
   async delete() {
     return this._client._request("DELETE", vmPath(this.id), void 0, this.baseUrl);
   }
+  // ── ARK-125 egress policy ────────────────────────────────────────
+  /**
+   * Read this VM's outbound egress policy document (ARK-125). Returns an
+   * empty doc (`{}`) when no policy is set.
+   */
+  async getPolicies() {
+    return this._client._request("GET", `${vmPath(this.id)}/policies`, void 0, this.baseUrl);
+  }
+  /**
+   * Replace this VM's outbound egress policy with `doc` — an ordered,
+   * first-match-wins rule list. An empty doc (`{}` or `{ policies: [] }`)
+   * clears the policy to allow-all. Returns the stored policy plus the
+   * domains it escalates to MITM and any degrade warnings.
+   *
+   *     await vm.setPolicies({
+   *       policies: [
+   *         { type: "network.outbound",
+   *           match: { domains: ["github.com"], ports: [443] },
+   *           action: "allow" },
+   *         { type: "network.outbound", action: "deny" },
+   *       ],
+   *     });
+   */
+  async setPolicies(doc) {
+    return this._client._request("PUT", `${vmPath(this.id)}/policies`, doc, 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`, {
@@ -644,6 +674,20 @@ var VM = class _VM {
   async deleteSession(sessionId) {
     return this._client._request("DELETE", `${vmPath(this.id)}/sessions/${pathSegment(sessionId)}`, void 0, this.baseUrl);
   }
+  /**
+   * Update a session via `PATCH /v1/vms/{id}/sessions/{sid}`: resize its PTY
+   * (`cols`/`rows`) and/or set the idle `timeoutSecs`. Works whether or not a
+   * PTY is currently attached — the REST equivalent of {@link PtyConnection.resize}
+   * (which sends an in-band control frame on the live WebSocket).
+   */
+  async updateSession(sessionId, update) {
+    return this._client._request(
+      "PATCH",
+      `${vmPath(this.id)}/sessions/${pathSegment(sessionId)}`,
+      { cols: update.cols, rows: update.rows, timeout_secs: update.timeoutSecs },
+      this.baseUrl
+    );
+  }
   async connectPty(options = {}) {
     const sessionId = options.sessionId ?? sessionIdFrom(await this.createSession());
     const useTicket = options.useTicket ?? !isNodeRuntime();
@@ -1055,6 +1099,84 @@ function base64ToBytes(text) {
 function bufferConstructor() {
   return globalThis.Buffer;
 }
+var http2Module;
+function loadHttp2() {
+  return http2Module ??= (async () => {
+    const proc = globalThis.process;
+    if (!proc?.versions?.node) return null;
+    try {
+      return await import(
+        /* webpackIgnore: true */
+        /* @vite-ignore */
+        "http2"
+      );
+    } catch {
+      return null;
+    }
+  })();
+}
+var HTTP2_REQUEST_TIMEOUT_MS = 12e4;
+var Http2Connection = class {
+  confirmed = false;
+  streams = 0;
+  session;
+  constructor(http2, origin) {
+    this.session = http2.connect(origin);
+    this.session.on("error", () => {
+    });
+  }
+  get closed() {
+    return this.session.closed || this.session.destroyed;
+  }
+  request(method, path, headers, body) {
+    if (this.streams === 0) this.session.ref();
+    this.streams++;
+    return new Promise((resolve, reject) => {
+      const stream = this.session.request({ ...headers, ":method": method, ":path": path });
+      let status = 0;
+      let text = "";
+      stream.setEncoding("utf8");
+      stream.setTimeout(HTTP2_REQUEST_TIMEOUT_MS, () => stream.destroy(new Error("HTTP/2 request timed out")));
+      stream.on("response", (responseHeaders) => {
+        this.confirmed = true;
+        status = Number(responseHeaders[":status"]) || 0;
+      });
+      stream.on("data", (chunk) => {
+        text += chunk;
+      });
+      stream.on("end", () => resolve({ status, ok: status >= 200 && status < 300, text }));
+      stream.on("error", reject);
+      stream.end(body);
+    }).finally(() => {
+      if (--this.streams === 0) this.session.unref();
+    });
+  }
+};
+var http2Connections = /* @__PURE__ */ new Map();
+async function sendRequest(url, init, fetchImpl, http2Enabled) {
+  if (http2Enabled) {
+    const http2 = await loadHttp2();
+    if (http2) {
+      const { origin, pathname, search } = new URL(url);
+      const cached = http2Connections.get(origin);
+      if (cached !== null) {
+        let connection = cached;
+        if (!connection || connection.closed) {
+          connection = new Http2Connection(http2, origin);
+          http2Connections.set(origin, connection);
+        }
+        try {
+          return await connection.request(init.method, `${pathname}${search}`, init.headers, init.body);
+        } catch (error) {
+          if (connection.confirmed) throw error;
+          http2Connections.set(origin, null);
+        }
+      }
+    }
+  }
+  const response = await fetchImpl(url, init);
+  return { status: response.status, ok: response.ok, text: await response.text() };
+}
 
 // src/compat/arker-provider.ts
 var DEFAULT_REGION = "aws-us-east-1";

package/dist/modal.js

@@ -5,8 +5,8 @@ import {
   createCompatSdk,
   guardUnsupported,
   isStringRecord
-} from "./chunk-35IEV6BU.js";
-import "./chunk-7BHPVQNG.js";
+} from "./chunk-YFJEL7PF.js";
+import "./chunk-4NHUAVXK.js";
 
 // src/modal.ts
 import { modal as createModalProvider } from "@computesdk/modal";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arker-ai/sdk",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "TypeScript SDK for the Arker virtual computer platform \u2014 spawn sandboxed VMs, run code, sync files.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -45,7 +45,7 @@
     "demo": "tsx tests/demo.ts",
     "generate:api-types": "openapi-typescript ../contract/openapi.json --default-non-nullable false -o src/generated/api-types.ts",
     "smoke": "tsx tests/conformance/fork-run-sync.ts",
-    "test": "tsx tests/unit.ts && tsx tests/compat.ts && tsx tests/cli.ts",
+    "test": "tsx tests/unit.ts && tsx tests/compat.ts && tsx tests/cli.ts && tsx tests/http2.ts",
     "test:compat": "tsx tests/compat.ts",
     "test:compat-live": "tsx tests/compat-live.ts",
     "test:compat-fallback-live": "tsx tests/compat-fallback-live.ts",