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

package/dist/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/keyed.js

@@ -0,0 +1,55 @@
+import { KEYED_CREATES } from "./keyed.gen.js";
+const KEYED_PATTERNS = KEYED_CREATES.map(([m, p]) => [m, p.split("/").filter(Boolean)]);
+const KEYED_METHODS = new Set(KEYED_CREATES.map(([m]) => m));
+let keyedLastMethod = "";
+let keyedLastPath = "";
+let keyedLastAnswer = false;
+let keyedReads = 0;
+export 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;
+    }
+}
+export const __keyedInternals = {
+    reads() {
+        return keyedReads;
+    },
+};

package/dist/proxy.js

@@ -57,12 +57,23 @@ export function noProxy(host, port, env = process.env) {
     }
     return false;
 }
+let proxyLastInputs;
+let proxyLast;
 export 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/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/sandbox.js

@@ -168,16 +168,19 @@ function onSigint() {
         return;
     void Promise.allSettled(cleanups.map((f) => f())).finally(() => { process.kill(process.pid, "SIGINT"); });
 }
+function createAborted() {
+    return new 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) {
@@ -455,7 +458,7 @@ export class Sandbox {
             ...(opts.apiKey === undefined ? {} : { apiKey: opts.apiKey }),
             ...(opts.apiUrl === undefined ? {} : { apiUrl: opts.apiUrl }),
         });
-        const aborted = () => new 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) {
@@ -476,24 +479,31 @@ export class Sandbox {
         else if (snapshotIdOrAlias === undefined || snapshotIdOrAlias === "base") {
             snapshotIdOrAlias = DEFAULT_SNAPSHOT;
         }
-        const stop = new AbortController();
         const key = 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();
                 }
@@ -506,7 +516,7 @@ export class Sandbox {
                 return await first;
             }
             catch (e) {
-                if (stop.signal.aborted) {
+                if (stop?.signal.aborted) {
                     await end();
                     throw aborted();
                 }
@@ -518,8 +528,9 @@ export class Sandbox {
             }
         }
         finally {
-            release();
-            opts.signal?.removeEventListener("abort", onAbort);
+            release?.();
+            if (onAbort !== undefined)
+                callerSignal.removeEventListener("abort", onAbort);
         }
     }
     static async fork(snapshotIdOrAlias, opts = {}) {
@@ -530,11 +541,11 @@ export class Sandbox {
         return Sandbox.forkHandlesWith(snapshotIdOrAlias, opts, {});
     }
     static async forkHandlesWith(snapshotIdOrAlias, opts, extra) {
-        const client = opts.client ?? new PromigenceClient({
+        const client = extra.client ?? opts.client ?? new 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)
@@ -555,8 +566,10 @@ export 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/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/trace.js

@@ -60,7 +60,23 @@ function modulePath() {
     const m = /\((.*):\d+:\d+\)\s*$/.exec(frame) ?? /at (.*):\d+:\d+\s*$/.exec(frame);
     return m?.[1] ?? "";
 }
+const beforeFlush = [];
+export function onTraceFlush(fn) {
+    if (!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: VERSION,

package/dist/transport-worker.js

@@ -34,6 +34,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)
@@ -94,14 +99,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);
@@ -113,8 +118,11 @@ function start(init) {
             checkServerIdentity: 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);
@@ -167,14 +175,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) => {
@@ -196,7 +256,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)
@@ -334,7 +394,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;
@@ -443,11 +503,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promigence/sdk",
-  "version": "0.1.0-beta.12",
+  "version": "0.1.0-beta.14",
   "description": "The fastest sandboxes for AI agents and code. The Promigence TypeScript SDK: snapshot an environment once, fork it as often as you need, run commands in every copy. A simple Sandbox class and the full PromigenceClient, with zero runtime dependencies.",
   "license": "Apache-2.0",
   "homepage": "https://www.promigence.ai",