@arker-ai/sdk 0.6.3 → 0.7.0

package/dist/index.d.ts

@@ -66,6 +66,62 @@ interface components {
             durable?: boolean | null;
             /** @description Resource shape for the new VM. */
             resources?: components["schemas"]["VmResources"] | null;
+            /** @description ARK-125 outbound policy for the new VM. Omit (null) to inherit the source VM's policy, re-encrypted under the child's own key. Present (even an empty doc) replaces it: an empty doc clears to allow-all rather than inheriting. Distinct from `egress` (legacy NetworkPolicy) and `network` (inbound). */
+            policies?: components["schemas"]["PolicyDoc"] | null;
+        };
+        /** @description A VM's egress policy document (ARK-125): an ordered, first-match-wins rule list. Empty `policies` means no policy (allow-all). The engine default when no rule matches is DENY (fail-closed); an explicit catch-all `{ "type": "network.outbound", "action": "allow" }` rule expresses default-allow. */
+        PolicyDoc: {
+            policies?: components["schemas"]["PolicyEntry"][];
+        };
+        /** @description One policy rule. `match` AND's its present fields (absent ⇒ catch-all). */
+        PolicyEntry: {
+            /**
+             * @description Event family. Only network.outbound is supported; an unknown value is rejected with 400.
+             * @enum {string}
+             */
+            type: "network.outbound";
+            match?: components["schemas"]["PolicyMatch"];
+            action: components["schemas"]["PolicyAction"];
+        };
+        /** @description Match criteria: present fields AND'd; list items OR'd. `ips` and `domains` are mutually exclusive. L4 fields = ports/ips/domains; L7 fields = methods/paths/headers/body_contains. A rule with any L7 field needs the MITM proxy (not built yet); until it ships an L7 rule degrades to its domain/L4 projection — allow → domain-allow, deny/rewrite → fail-closed deny. */
+        PolicyMatch: {
+            /** @description Single ports and/or inclusive [start, end] ranges, e.g. [80, 443, [1000, 2000]]. Empty/absent = any port. */
+            ports?: (number | number[])[];
+            /** @description IPs or CIDRs. */
+            ips?: string[];
+            /** @description Label-boundary suffix match: `github.com` matches `api.github.com`, not `evilgithub.com`. */
+            domains?: string[];
+            methods?: string[];
+            /** @description Full-segment path prefixes. */
+            paths?: string[];
+            /** @description Header name → any-of values (names AND'd, a name's values OR'd). */
+            headers?: {
+                [key: string]: string[];
+            };
+            body_contains?: string[];
+        };
+        /** @description allow / deny, or a rewrite object. `rewrite` needs the MITM data-path; until it ships a rewrite rule is inert (treated as deny). */
+        PolicyAction: ("allow" | "deny") | {
+            rewrite: components["schemas"]["Rewrite"];
+        };
+        /** @description Mutate-and-forward (the only mutating action). Static for now — request-time interpolation is future work. */
+        Rewrite: {
+            host?: string;
+            path?: string;
+            /** @description Merge-set these request headers (not replace-all). */
+            headers?: {
+                [key: string]: string;
+            };
+            remove_headers?: string[];
+        };
+        /** @description Response to PUT /v1/vms/{id}/policies. */
+        PutPoliciesResponse: {
+            /** @description The stored policy document — read its rules as `policy.policies`. */
+            policy: components["schemas"]["PolicyDoc"];
+            /** @description Domains the policy would escalate to MITM once the data-path ships. */
+            mitm_domains?: string[];
+            /** @description Non-fatal notes (e.g. L7/rewrite rules degraded until the MITM data-path ships). */
+            warnings?: string[];
         };
         Session: {
             session_id: string;
@@ -528,7 +584,7 @@ declare const CHUNK_SIZE: number;
  */
 declare const ARKER_ORG_ID = "ArkerHQ";
 type FetchLike = typeof fetch;
-type HttpMethod = "GET" | "POST" | "PATCH" | "DELETE";
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
 interface RetryOptions {
     attempts?: number;
     baseDelayMs?: number;
@@ -565,6 +621,15 @@ type ResourceKind = ApiSchema<"ResourceKind">;
 type ErrorCode = ApiSchema<"ErrorCode">;
 type NetworkPolicy = ApiSchema<"NetworkPolicy">;
 type NetworkPolicyInput = ApiSchema<"NetworkPolicyInput">;
+type PolicyDoc = ApiSchema<"PolicyDoc">;
+type PolicyEntry = ApiSchema<"PolicyEntry">;
+type PolicyMatch = ApiSchema<"PolicyMatch">;
+type PolicyAction = ApiSchema<"PolicyAction">;
+type Rewrite = ApiSchema<"Rewrite">;
+type PutPoliciesResponse = ApiSchema<"PutPoliciesResponse">;
+/** A `ports` element: a single port (`80`) or an inclusive `[start, end]`
+ * range (`[1000, 2000]`). A `ports` list may mix the two. */
+type PortSpec = NonNullable<PolicyMatch["ports"]>[number];
 type ForkRequest = ApiSchema<"ForkRequest">;
 type ForkOptions = ForkRequest;
 type VmResources = ApiSchema<"VmResources">;
@@ -759,6 +824,7 @@ declare class Arker {
     readonly provider: "aws" | "aws-burst";
     private readonly apiKey;
     private readonly fetchImpl;
+    private readonly http2;
     private readonly retry;
     constructor(opts?: ArkerOptions);
     /**
@@ -897,6 +963,27 @@ declare class VM {
      */
     resize(request: PatchVmRequest | (VmResources & Pick<PatchVmRequest, "network">)): Promise<Vm>;
     delete(): Promise<DeleteVmResponse>;
+    /**
+     * Read this VM's outbound egress policy document (ARK-125). Returns an
+     * empty doc (`{}`) when no policy is set.
+     */
+    getPolicies(): Promise<PolicyDoc>;
+    /**
+     * 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" },
+     *       ],
+     *     });
+     */
+    setPolicies(doc: PolicyDoc): Promise<PutPoliciesResponse>;
     listSyncs(opts?: ListOpts & {
         filesystemId?: string;
     }): Promise<ListSyncsResponse>;
@@ -919,7 +1006,21 @@ declare class VM {
     createSession(request?: CreateSessionRequest): Promise<Session>;
     getSession(sessionId: string): Promise<Session>;
     deleteSession(sessionId: string): Promise<DeleteSessionResponse>;
+    /**
+     * 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).
+     */
+    updateSession(sessionId: string, update: {
+        cols?: number;
+        rows?: number;
+        timeoutSecs?: number;
+    }): Promise<{
+        ok: boolean;
+        session_id: string;
+    }>;
     connectPty(options?: PtyConnectOptions): Promise<PtyConnection>;
 }
 
-export { ARKER_ORG_ID, Arker, ArkerError, type ArkerOptions, type BackgroundRunResponse, type BackgroundRunResult, CHUNK_SIZE, type CancelRunResponse, type CompletedRunResponse, type CompletedRunResult, type CreateSessionRequest, type DeleteFilesystemResponse, type DeleteSessionResponse, type DeleteSyncResponse, type DeleteVmResponse, type ErrorCode, type ErrorResponse, type Filesystem, type FilesystemCreateRequest, type ForkOptions, type ForkRequest, type ForkSource, type InboundPortRequest, type ListFilesystemsResponse, type ListOpts, type ListOrgRunsOptions, type ListOrgRunsResponse, type ListRunsResponse, type ListSessionsResponse, type ListSyncsResponse, type ListVmsResponse, type NetworkInput, type NetworkPolicy, type NetworkPolicyInput, type NetworkRequest, type NetworkStatus, type OrgRunListRow, type PatchVmRequest, type PtyCloseEvent, type PtyConnectOptions, type PtyConnection, type PtyInput, type PtyWebSocketFactory, type ResourceKind, type RetryOptions, type Run, type RunInboundPortRequest, type RunListRow, type RunNetworkRequest, type RunNetworkStatus, type RunOptions, type RunRequest, type RunResponse, type RunResult, type RunState, type RunStatusResponse, type RunSummary, type Session, type SessionInfo, type SessionState, type Sync, type SyncByteRange, type SyncChunkWriteResult, type SyncCommitWriteResult, type SyncCreateRequest, type SyncPresignedWriteRequestResult, type SyncReadInlineResponse, type SyncReadPresignedResponse, type SyncReadRequest, type SyncReadResponse, type SyncWriteRequest, type SyncWriteResponse, type SyncWriteResult, VM, type Vm, type VmNetwork, type VmResources, type VmState };
+export { ARKER_ORG_ID, Arker, ArkerError, type ArkerOptions, type BackgroundRunResponse, type BackgroundRunResult, CHUNK_SIZE, type CancelRunResponse, type CompletedRunResponse, type CompletedRunResult, type CreateSessionRequest, type DeleteFilesystemResponse, type DeleteSessionResponse, type DeleteSyncResponse, type DeleteVmResponse, type ErrorCode, type ErrorResponse, type Filesystem, type FilesystemCreateRequest, type ForkOptions, type ForkRequest, type ForkSource, type InboundPortRequest, type ListFilesystemsResponse, type ListOpts, type ListOrgRunsOptions, type ListOrgRunsResponse, type ListRunsResponse, type ListSessionsResponse, type ListSyncsResponse, type ListVmsResponse, type NetworkInput, type NetworkPolicy, type NetworkPolicyInput, type NetworkRequest, type NetworkStatus, type OrgRunListRow, type PatchVmRequest, type PolicyAction, type PolicyDoc, type PolicyEntry, type PolicyMatch, type PortSpec, type PtyCloseEvent, type PtyConnectOptions, type PtyConnection, type PtyInput, type PtyWebSocketFactory, type PutPoliciesResponse, type ResourceKind, type RetryOptions, type Rewrite, type Run, type RunInboundPortRequest, type RunListRow, type RunNetworkRequest, type RunNetworkStatus, type RunOptions, type RunRequest, type RunResponse, type RunResult, type RunState, type RunStatusResponse, type RunSummary, type Session, type SessionInfo, type SessionState, type Sync, type SyncByteRange, type SyncChunkWriteResult, type SyncCommitWriteResult, type SyncCreateRequest, type SyncPresignedWriteRequestResult, type SyncReadInlineResponse, type SyncReadPresignedResponse, type SyncReadRequest, type SyncReadResponse, type SyncWriteRequest, type SyncWriteResponse, type SyncWriteResult, VM, type Vm, type VmNetwork, type VmResources, type VmState };

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   ArkerError,
   CHUNK_SIZE,
   VM
-} from "./chunk-7BHPVQNG.js";
+} from "./chunk-4NHUAVXK.js";
 export {
   ARKER_ORG_ID,
   Arker,

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.3",
+  "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",