@promigence/sdk 0.1.0-beta.12 → 0.1.0-beta.14

package/dist/cjs/keyed.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Is `method path` a create that takes an `Idempotency-Key`? `path` is relative to `/v1` and may
+ * carry a query string. The list is the API reference's (generated from the operations that
+ * document the header), so a create the API keys is never sent unkeyed by this client.
+ */
+export declare function isKeyedCreate(method: string, path: string): boolean;

package/dist/cjs/keyed.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__keyedInternals = void 0;
+exports.isKeyedCreate = isKeyedCreate;
+const keyed_gen_js_1 = require("./keyed.gen.js");
+const KEYED_PATTERNS = keyed_gen_js_1.KEYED_CREATES.map(([m, p]) => [m, p.split("/").filter(Boolean)]);
+const KEYED_METHODS = new Set(keyed_gen_js_1.KEYED_CREATES.map(([m]) => m));
+let keyedLastMethod = "";
+let keyedLastPath = "";
+let keyedLastAnswer = false;
+let keyedReads = 0;
+function isKeyedCreate(method, path) {
+    if (!KEYED_METHODS.has(method))
+        return false;
+    if (path === keyedLastPath && method === keyedLastMethod)
+        return keyedLastAnswer;
+    const answer = keyedCreateOf(method, path);
+    keyedLastMethod = method;
+    keyedLastPath = path;
+    keyedLastAnswer = answer;
+    return answer;
+}
+function keyedCreateOf(method, path) {
+    keyedReads++;
+    let end = path.indexOf("?");
+    if (end < 0)
+        end = path.length;
+    for (let p = 0; p < KEYED_PATTERNS.length; p++) {
+        const entry = KEYED_PATTERNS[p];
+        if (entry[0] === method && segmentsMatch(path, end, entry[1]))
+            return true;
+    }
+    return false;
+}
+function segmentsMatch(path, end, pat) {
+    let i = 0;
+    let k = 0;
+    for (;;) {
+        while (i < end && path.charCodeAt(i) === 0x2f)
+            i++;
+        if (i >= end)
+            return k === pat.length;
+        if (k >= pat.length)
+            return false;
+        let j = i;
+        while (j < end && path.charCodeAt(j) !== 0x2f)
+            j++;
+        const s = pat[k];
+        if (s.charCodeAt(0) !== 0x7b && (j - i !== s.length || !path.startsWith(s, i)))
+            return false;
+        k++;
+        i = j;
+    }
+}
+exports.__keyedInternals = {
+    reads() {
+        return keyedReads;
+    },
+};

package/dist/cjs/proxy.js

@@ -65,12 +65,23 @@ function noProxy(host, port, env = process.env) {
     }
     return false;
 }
+let proxyLastInputs;
+let proxyLast;
 function proxyFor(url, env = process.env) {
     const https = envOf(env, "HTTPS_PROXY");
     const http = envOf(env, "HTTP_PROXY");
     const all = envOf(env, "ALL_PROXY");
     if (https === undefined && http === undefined && all === undefined)
         return undefined;
+    const inputs = `${url}\n${https ?? "\0"}\n${http ?? "\0"}\n${all ?? "\0"}\n${envOf(env, "NO_PROXY") ?? "\0"}`;
+    if (inputs === proxyLastInputs)
+        return proxyLast;
+    const found = proxyForOf(url, env, https, http, all);
+    proxyLastInputs = inputs;
+    proxyLast = found;
+    return found;
+}
+function proxyForOf(url, env, https, http, all) {
     let u;
     try {
         u = new URL(url);

package/dist/cjs/sandbox.d.ts

@@ -396,7 +396,9 @@ export declare class Sandbox {
     }>;
     /**
      * `forkHandles`, plus what `create` needs to end a run it was interrupted starting: the key the
-     * create is sent under, a signal for it and its waits, and the start options as sent.
+     * create is sent under, a signal for it and its waits, and the start options as sent (`onStart`
+     * is handed the very options sent, the signal included); `client` and `count` stand in for the
+     * options' own.
      */
     private static forkHandlesWith;
     /** Attach to a running sandbox (`GET /sandboxes/:id`). */

package/dist/cjs/sandbox.js

@@ -178,16 +178,19 @@ function onSigint() {
         return;
     void Promise.allSettled(cleanups.map((f) => f())).finally(() => { process.kill(process.pid, "SIGINT"); });
 }
+function createAborted() {
+    return new core_js_1.TimeoutError("Sandbox.create was aborted by the caller's signal; anything it had started was ended", "Nothing to fix: the caller aborted it.");
+}
 function holdSigint(cleanup) {
     if (typeof process === "undefined" || typeof process.listenerCount !== "function")
-        return () => { };
-    if (process.listenerCount("SIGINT") - (sigintHeld ? 1 : 0) > 0)
-        return () => { };
-    creatingNow.add(cleanup);
+        return undefined;
     if (!sigintHeld) {
+        if (process.listenerCount("SIGINT") > 0)
+            return undefined;
         process.once("SIGINT", onSigint);
         sigintHeld = true;
     }
+    creatingNow.add(cleanup);
     return () => {
         creatingNow.delete(cleanup);
         if (creatingNow.size === 0 && sigintHeld) {
@@ -465,7 +468,7 @@ class Sandbox {
             ...(opts.apiKey === undefined ? {} : { apiKey: opts.apiKey }),
             ...(opts.apiUrl === undefined ? {} : { apiUrl: opts.apiUrl }),
         });
-        const aborted = () => new core_js_1.TimeoutError("Sandbox.create was aborted by the caller's signal; anything it had started was ended", "Nothing to fix: the caller aborted it.");
+        const aborted = createAborted;
         if (opts.signal?.aborted)
             throw aborted();
         if (opts.image !== undefined) {
@@ -486,24 +489,31 @@ class Sandbox {
         else if (snapshotIdOrAlias === undefined || snapshotIdOrAlias === "base") {
             snapshotIdOrAlias = exports.DEFAULT_SNAPSHOT;
         }
-        const stop = new AbortController();
         const key = (0, client_js_1.newIdempotencyKey)();
         let sent;
         let runId;
         let ending;
         const end = () => (ending ??= endInterruptedCreate(client, runId, sent));
-        const release = holdSigint(() => { stop.abort(); return end(); });
-        const onAbort = () => { stop.abort(); };
-        opts.signal?.addEventListener("abort", onAbort, { once: true });
+        let stop;
+        const release = holdSigint(() => { stop?.abort(); return end(); });
+        const callerSignal = opts.signal;
+        const onAbort = callerSignal === undefined ? undefined : () => { stop?.abort(); };
+        if (release !== undefined || callerSignal !== undefined)
+            stop = new AbortController();
+        if (onAbort !== undefined)
+            callerSignal.addEventListener("abort", onAbort, { once: true });
         try {
             let handles;
             try {
-                ({ runId, handles } = await Sandbox.forkHandlesWith(snapshotIdOrAlias, { ...opts, count: 1, client }, {
-                    idempotencyKey: key, signal: stop.signal, onStart: (s) => { sent = s; },
-                }));
+                const extra = {
+                    idempotencyKey: key, onStart: (s) => { sent = s; }, client, count: 1,
+                };
+                if (stop !== undefined)
+                    extra.signal = stop.signal;
+                ({ runId, handles } = await Sandbox.forkHandlesWith(snapshotIdOrAlias, opts, extra));
             }
             catch (e) {
-                if (stop.signal.aborted) {
+                if (stop?.signal.aborted) {
                     await end();
                     throw aborted();
                 }
@@ -516,7 +526,7 @@ class Sandbox {
                 return await first;
             }
             catch (e) {
-                if (stop.signal.aborted) {
+                if (stop?.signal.aborted) {
                     await end();
                     throw aborted();
                 }
@@ -528,8 +538,9 @@ class Sandbox {
             }
         }
         finally {
-            release();
-            opts.signal?.removeEventListener("abort", onAbort);
+            release?.();
+            if (onAbort !== undefined)
+                callerSignal.removeEventListener("abort", onAbort);
         }
     }
     static async fork(snapshotIdOrAlias, opts = {}) {
@@ -540,11 +551,11 @@ class Sandbox {
         return Sandbox.forkHandlesWith(snapshotIdOrAlias, opts, {});
     }
     static async forkHandlesWith(snapshotIdOrAlias, opts, extra) {
-        const client = opts.client ?? new client_js_1.PromigenceClient({
+        const client = extra.client ?? opts.client ?? new client_js_1.PromigenceClient({
             ...(opts.apiKey === undefined ? {} : { apiKey: opts.apiKey }),
             ...(opts.apiUrl === undefined ? {} : { apiUrl: opts.apiUrl }),
         });
-        const count = opts.count ?? 1;
+        const count = extra.count ?? opts.count ?? 1;
         const spendCap = spendCapFromEnv(opts.spendCap);
         const start = { snapshot: snapshotIdOrAlias, count };
         if (spendCap !== undefined)
@@ -565,8 +576,10 @@ class Sandbox {
             start.optimizeFor = opts.optimizeFor;
         if (extra.idempotencyKey !== undefined)
             start.idempotencyKey = extra.idempotencyKey;
-        extra.onStart?.({ ...start });
-        const run = await client.runs.start(extra.signal === undefined ? start : { ...start, signal: extra.signal });
+        if (extra.signal !== undefined)
+            start.signal = extra.signal;
+        extra.onStart?.(start);
+        const run = await client.runs.start(start);
         const envs = opts.envs;
         const mk = (ref) => {
             const init = { sandboxId: ref.sandbox_id, runId: run.run_id, snapshot: snapshotIdOrAlias, client };

package/dist/cjs/trace.d.ts

@@ -31,3 +31,5 @@ export declare function mark(s: TraceStamp | undefined, phase: string): void;
 export declare function traceEvent(name: string): void;
 /** A process event that happened at `t` (`performance.now()` terms), recorded now: one another thread reported. */
 export declare function traceEventAt(name: string, t: number): void;
+/** `fn` runs once at exit, before the trace is written (tracing on only). */
+export declare function onTraceFlush(fn: () => void): void;

package/dist/cjs/trace.js

@@ -6,6 +6,7 @@ exports.traceBegin = traceBegin;
 exports.mark = mark;
 exports.traceEvent = traceEvent;
 exports.traceEventAt = traceEventAt;
+exports.onTraceFlush = onTraceFlush;
 const node_fs_1 = require("node:fs");
 const core_js_1 = require("./core.js");
 exports.TRACE_ON = (() => {
@@ -68,7 +69,23 @@ function modulePath() {
     const m = /\((.*):\d+:\d+\)\s*$/.exec(frame) ?? /at (.*):\d+:\d+\s*$/.exec(frame);
     return m?.[1] ?? "";
 }
+const beforeFlush = [];
+function onTraceFlush(fn) {
+    if (!exports.TRACE_ON)
+        return;
+    beforeFlush.push(fn);
+    if (!hooked) {
+        hooked = true;
+        process.once("exit", flush);
+    }
+}
 function flush() {
+    for (const fn of beforeFlush.splice(0)) {
+        try {
+            fn();
+        }
+        catch { }
+    }
     const head = {
         trace: "promigence-sdk",
         version: core_js_1.VERSION,

package/dist/cjs/transport-worker.js

@@ -36,6 +36,11 @@ function start(init) {
         }
         catch { }
     };
+    const ev = (n) => {
+        if (init.trace === true)
+            post({ t: "ev", n, hr: hrNow() });
+    };
+    ev("boot");
     const live = () => sessions.filter((e) => !e.retired && !e.session.closed && !e.session.destroyed);
     const end = (reason) => {
         if (closed)
@@ -96,14 +101,14 @@ function start(init) {
     catch {
         context = undefined;
     }
-    const connect = (address) => new Promise((resolve) => {
+    const connect = (address, k) => new Promise((resolve) => {
         let done = false;
         const finish = (e) => { if (!done) {
             done = true;
             clearTimeout(timer);
             resolve(e);
         } };
-        const timer = setTimeout(() => { try {
+        const timer = setTimeout(() => { ev(`timeout${k}`); try {
             socket.destroy();
         }
         catch { } finish(null); }, init.connectTimeoutMs);
@@ -115,8 +120,11 @@ function start(init) {
             checkServerIdentity: ca_guard_js_1.guardCertChain,
             ...(context === undefined ? {} : { secureContext: context }),
         });
-        socket.once("error", () => finish(null));
+        if (init.trace === true)
+            socket.once("connect", () => { ev(`tcp${k}`); });
+        socket.once("error", (e) => { ev(`fail${k} ${e?.code ?? "error"}`); finish(null); });
         socket.once("secureConnect", () => {
+            ev(`tls${k}`);
             if (socket.alpnProtocol !== "h2") {
                 socket.destroy();
                 finish(null);
@@ -169,14 +177,66 @@ function start(init) {
             resolve(v4);
             return;
         }
-        try {
-            const r = new dns.Resolver({ timeout: init.lookupTimeoutMs, tries: 1 });
-            if (Array.isArray(init.servers) && init.servers.length > 0)
-                r.setServers(init.servers);
-            r.resolve4(name, (err, addrs) => resolve(!err && Array.isArray(addrs) ? addrs : []));
-        }
-        catch {
-            resolve([]);
+        const at = init.lookupAtMs.length > 0 ? init.lookupAtMs : [0];
+        const resolvers = [];
+        const timers = [];
+        let done = false;
+        let asked = 0;
+        let failed = 0;
+        const finish = (addrs) => {
+            if (done)
+                return;
+            done = true;
+            for (const t of timers)
+                clearTimeout(t);
+            for (const r of resolvers) {
+                try {
+                    r.cancel();
+                }
+                catch { }
+            }
+            resolve(addrs);
+        };
+        const gaveUp = () => {
+            if (++failed < asked)
+                return;
+            if (asked < at.length)
+                ask();
+            else
+                finish([]);
+        };
+        const ask = () => {
+            if (done || asked >= at.length)
+                return;
+            const k = asked++;
+            try {
+                const r = new dns.Resolver({ timeout: init.lookupTimeoutMs, tries: init.lookupTries });
+                const list = Array.isArray(init.servers) && init.servers.length > 0 ? init.servers : r.getServers();
+                if (list.length > 0)
+                    r.setServers(list.map((_, i) => list[(i + k) % list.length]));
+                resolvers.push(r);
+                ev(`lookup${k + 1}`);
+                r.resolve4(name, (err, addrs) => {
+                    if (done)
+                        return;
+                    if (!err && Array.isArray(addrs) && addrs.length > 0) {
+                        ev(`addrs${k + 1} ${addrs.length}`);
+                        finish(addrs);
+                        return;
+                    }
+                    ev(`nolookup${k + 1} ${err?.code ?? "empty"}`);
+                    gaveUp();
+                });
+            }
+            catch {
+                gaveUp();
+            }
+        };
+        for (const ms of at) {
+            if (ms <= 0)
+                ask();
+            else
+                timers.push(setTimeout(ask, ms));
         }
     });
     const limitOf = (e) => {
@@ -198,7 +258,7 @@ function start(init) {
         }
         const n = Math.max(1, init.sessions);
         pendingConnects = n;
-        const tries = Array.from({ length: n }, (_, i) => connect(addrs[i % addrs.length]).then((e) => {
+        const tries = Array.from({ length: n }, (_, i) => connect(addrs[i % addrs.length], i).then((e) => {
             pendingConnects--;
             if (closed) {
                 if (e)
@@ -336,7 +396,7 @@ function start(init) {
             return;
         }
         entry.active++;
-        post({ t: "ack", id: req.id });
+        Atomics.store(init.acks, req.mark, req.id);
         const sent = init.trace !== true ? 0 : granted > 0 ? granted : hrNow();
         let head = 0;
         let status = 0;
@@ -445,11 +505,20 @@ function start(init) {
         else
             armIdle(init.idleMs);
     };
+    let wedged = false;
     port.on("message", (m) => {
-        if (closed)
+        if (closed || wedged)
+            return;
+        if (m?.t === "wedge-for-test") {
+            wedged = true;
             return;
+        }
         if (m?.t === "req")
             void run(m);
+        else if (m?.t === "reqs") {
+            for (const r of m.list)
+                void run(r);
+        }
         else if (m?.t === "drain")
             drain("asked");
         else if (m?.t === "cancel" && typeof m.id === "number") {

package/dist/client.d.ts

@@ -5,6 +5,7 @@ import { type Bundle } from "./bundle.js";
 import { type PtyExit, type PtySession } from "./pty.js";
 import { type SshTunnel } from "./ssh.js";
 import type * as M from "./models.gen.js";
+import { isKeyedCreate } from "./keyed.js";
 import { type ConnectRequest, type ConnectTicket, type GithubConnect, type GithubDisconnected, type GithubRepos, type GithubStatus, type GithubUntracked } from "./github.js";
 import { type GitlabConnect, type GitlabDisconnected, type GitlabRepos, type GitlabStatus, type GitlabUntracked } from "./gitlab.js";
 export type FetchLike = typeof globalThis.fetch;
@@ -1882,12 +1883,7 @@ export declare function errorFor(code: string, message: string, fix: string, ext
     category?: string;
     retryable?: boolean;
 }): PromigenceError;
-/**
- * Is `method path` a create that takes an `Idempotency-Key`? `path` is relative to `/v1` and may
- * carry a query string. The list is the API reference's (generated from the operations that
- * document the header), so a create the API keys is never sent unkeyed by this client.
- */
-export declare function isKeyedCreate(method: string, path: string): boolean;
+export { isKeyedCreate };
 /** A sandbox id as a request names it: a non-empty string, or refused before anything is sent. */
 export declare function checkSandboxId(sandboxId: unknown, call: string): asserts sandboxId is string;
 /** A spend cap in USD: a finite number, 0 or more. A negative one used to be sent and echoed back as "$-1.00". */
@@ -2006,6 +2002,7 @@ export declare class PromigenceClient {
     private readExtras;
     private guardDispatcher;
     private dispatcherFor;
+    private againKeyed;
     request<T>(opts: RequestOpts): Promise<T>;
     /**
      * A request whose body — in either direction — is **bytes, not JSON** (`files get|put`).
@@ -2066,6 +2063,7 @@ export declare class PromigenceClient {
             signal?: AbortSignal;
         }) => Promise<M.TemplateDetail>;
     };
+    private group_templates;
     me(opts?: {
         signal?: AbortSignal;
     }): Promise<MeResponse>;
@@ -2114,6 +2112,7 @@ export declare class PromigenceClient {
         /** `POST /referrals/apply` — apply a referral code (an owner's key, before the first paid invoice). */
         applyReferral: (code: string) => Promise<ReferralApplied>;
     };
+    private group_billing;
     /**
      * This key's API keys. With an API key the list is the key's own project's; `all` includes
      * revoked ones.
@@ -2137,6 +2136,7 @@ export declare class PromigenceClient {
          */
         revoke: (keyId: string) => Promise<KeyRecord>;
     };
+    private group_keys;
     /** The organization this key belongs to, its projects, members and pending invites. */
     readonly orgs: {
         /** `GET /orgs` — with an API key, the key's own organization. */
@@ -2175,10 +2175,12 @@ export declare class PromigenceClient {
             rename: (org: string, project: string, name: string) => Promise<ProjectRecord>;
         };
     };
+    private group_orgs;
     readonly credits: {
         /** `GET /credits/offer` — claimable (how much, until when), claimed, being checked, or none. */
         offer: () => Promise<CreditOffer>;
     };
+    private group_credits;
     /**
      * The GitHub connection: install the platform's GitHub App once, then build snapshots from the
      * repositories it can read (`snapshots.create({ repo: "github:owner/name", ref })`).
@@ -2206,6 +2208,7 @@ export declare class PromigenceClient {
         /** `DELETE /integrations/github/tracks/:id` — the snapshot stays; pushes stop rebuilding it. */
         untrack: (trackId: string) => Promise<GithubUntracked>;
     };
+    private group_github;
     /**
      * The GitLab connection: authorize the platform's GitLab application once (read-only), have an
      * owner confirm it, then build snapshots from the projects it can read
@@ -2235,6 +2238,7 @@ export declare class PromigenceClient {
         /** `DELETE /integrations/gitlab/tracks/:id` — the snapshot stays; new commits stop rebuilding it. */
         untrack: (trackId: string) => Promise<GitlabUntracked>;
     };
+    private group_gitlab;
     readonly runs: {
         /** `POST /runs` — returns immediately; sandboxes start `queued`. */
         start: (opts: RunStartOpts) => Promise<RunStartResponse>;
@@ -2328,6 +2332,7 @@ export declare class PromigenceClient {
          */
         waitDone: (runId: string, opts?: WaitOpts) => Promise<WaitRunResult>;
     };
+    private group_runs;
     /**
      * The loop behind `waitReady` / `waitDone`.
      *
@@ -2805,6 +2810,7 @@ export declare class PromigenceClient {
             };
         }) => Promise<ExecOutput>;
     };
+    private group_sandboxes;
     /** Bound helpers for one sandbox (kept from the 0.0.0 shape). */
     sandbox(id: string): {
         id: string;
@@ -2874,6 +2880,7 @@ export declare class PromigenceClient {
             deleted: boolean;
         }>;
     };
+    private group_secrets;
     /**
      * Container images, as far as we need to know about them: what digest does this tag name?
      */
@@ -2901,6 +2908,7 @@ export declare class PromigenceClient {
             registrySecret?: string;
         }) => Promise<ResolvedImage>;
     };
+    private group_images;
     readonly captures: {
         /**
          * `DELETE /captures/:snapshot_id` — destroy a preserved failure now, before it expires.
@@ -2916,6 +2924,7 @@ export declare class PromigenceClient {
             deleted_at: string;
         }>;
     };
+    private group_captures;
     readonly snapshots: {
         /**
          * `POST /snapshots` — 202 with a `build_id`, or 200 with the existing snapshot when an
@@ -3011,5 +3020,6 @@ export declare class PromigenceClient {
             record?: SnapshotRecord;
         }>;
     };
+    private group_snapshots;
 }
 export declare function toCommandResult(r: ExecResponse): CommandResult;