promigence 0.1.0-beta.2 → 0.1.0-beta.3

package/dist/account.js

@@ -87,7 +87,7 @@ const status = async (ctx) => {
 };
 const me = async (ctx) => {
     const c = client(ctx);
-    const info = await c.me();
+    const [info, outcomes] = await Promise.all([c.me(), c.outcomes().catch(() => undefined)]);
     const conc = await concurrencyOf(c, info);
     const plan = planName(info);
     const trial = info.trial;
@@ -124,12 +124,42 @@ const me = async (ctx) => {
     ].filter(Boolean);
     if (shape.length)
         lines.push(`  limits: ${shape.join(" · ")}`);
+    if (outcomes && outcomes.sandboxes > 0) {
+        const [head, ...rest] = outcomeLines(outcomes);
+        lines.push(`  ${head}:`, ...rest.map((l) => `  ${l}`));
+    }
     return emit(ctx.mode, okEnvelope(ctx.cmd.name, {
         me: info,
+        ...(outcomes ? { outcomes } : {}),
         ...(plan ? { plan } : {}),
         ...(conc ? { concurrency: { in_use: conc.in_use, limit: conc.limit, source: conc.source, ...(conc.at_least ? { at_least: true } : {}) } } : {}),
     }, next), lines, 0, ctx.pointer);
 };
+export function outcomeLines(o) {
+    const usd = (n) => `$${n.toFixed(2)}`;
+    const lines = [`this month (since ${o.since.slice(0, 10)})`];
+    if (o.sandboxes <= 0) {
+        lines.push("  nothing ran yet this month");
+        return lines;
+    }
+    lines.push(`  runs                ${o.runs.toLocaleString("en-US")}`);
+    const ready = o.ready_ms_p50 ?? null;
+    lines.push(`  sandboxes           ${o.sandboxes.toLocaleString("en-US")}${ready === null ? "" : `, ready in ${ms(ready)} (median)`}`);
+    if (o.failures_ours > 0)
+        lines.push(`  failures of ours    ${o.failures_ours}, not billed${o.failures_ours_usd > 0 ? ` (${usd(o.failures_ours_usd)} given back)` : ""}`);
+    const speedup = o.batch_speedup ?? null;
+    const saved = o.batch_saved_s ?? null;
+    if (speedup !== null && saved !== null) {
+        lines.push(`  many at once        ${o.batch_runs} runs, ${speedup.toFixed(1)}x faster than one after another, ${duration(saved * 1000)} not spent waiting`);
+    }
+    if (o.kept_failures > 0)
+        lines.push(`  kept failures       ${o.kept_failures} you can still reopen`);
+    const hours = o.paused_hours ?? null;
+    const paidNot = o.paused_usd ?? null;
+    if (hours !== null)
+        lines.push(`  paused, not billed  ${hours.toFixed(1)} h${paidNot === null ? "" : ` (${usd(paidNot)} you did not pay)`}`);
+    return lines;
+}
 const billingUsage = async (ctx) => {
     const limit = limitOf(ctx, 20, 1000);
     const wantLedger = bool(ctx, "--ledger");

package/dist/bin.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { GLOBAL_FLAGS, LISTED_COMMANDS, REQUEST_TIMEOUT_DEFAULT, SCHEMA, VERSION, findCommand, nearestFlag, notReleasedEnvelope, notReleasedLines, renderCommandHelp, renderHelp, unknownFlags, } from "./surface.js";
-import { HANDLERS, client } from "./commands.js";
+import { HANDLERS, client, serverLocation } from "./commands.js";
+import { maybeFarNotice } from "./timing.js";
 import { refineError } from "./errfix.js";
 import { EXTRA_HANDLERS } from "./handlers.js";
 import { BUNDLE_HANDLERS } from "./bundle.js";
@@ -17,7 +18,7 @@ import { RUNNERS_HANDLERS } from "./runners.js";
 import { PRICING_HANDLERS } from "./pricing.js";
 import { GITHUB_HANDLERS } from "./github.js";
 import { GITLAB_HANDLERS } from "./gitlab.js";
-import { emit, errorEnvelope, errorTextLines, parseDuration, toPromigenceError, usageError as usageFailure, USAGE_DOCS, write, } from "./io.js";
+import { emit, errorEnvelope, errorTextLines, parseDuration, setBeforeExit, toPromigenceError, usageError as usageFailure, USAGE_DOCS, write, } from "./io.js";
 import { setCaller } from "./sdk/caller.js";
 import { sh } from "./term.js";
 import { parse, positionalsBeforeTail, takesTail } from "./argv.js";
@@ -286,6 +287,7 @@ async function main(argv) {
     if (ctx.apiKey !== undefined && cmd.name !== "auth login" && cmd.name !== "doctor") {
         process.stderr.write("promigence: warning: --api-key puts the key on the command line, where `ps` and shell history can read it; prefer PROMIGENCE_API_KEY or `promigence auth login --from-env VAR`.\n");
     }
+    setBeforeExit(() => maybeFarNotice({ json: ctx.mode === "json", location: () => serverLocation(ctx) }));
     try {
         checkFlags(cmd, p, argv);
         ctx.requestTimeoutMs = requestTimeoutMs(p);

package/dist/commands.d.ts

@@ -24,6 +24,7 @@ export declare function clientOpts(ctx: Ctx): {
     cliErrors: true;
 };
 export declare function client(ctx: Ctx): PromigenceClient;
+export declare function serverLocation(ctx: Ctx): Promise<string | undefined>;
 export declare const nexts: (...items: Array<[string, string]>) => NextHint[];
 export declare const KEPT_BY_HOLDERS = "sandboxes that were already given its value keep it until they end; it stays masked in their output";
 export declare function waitBound(ctx: Ctx): number;
@@ -52,6 +53,7 @@ export declare function snapshotSource(s: {
     commit?: string;
     verification?: Record<string, unknown>;
 }): string;
+export declare function readyLine(ourMs: number | undefined, totalMs: number): string;
 export declare function sandboxIdLines(sandboxes: ReadonlyArray<Pick<SandboxRef, "sandbox_id" | "state">>, cap?: number): string[];
 type EnvError = {
     code: string;
@@ -67,6 +69,7 @@ export interface ExecOutcome {
     error?: EnvError;
 }
 export declare function execOutcome(res: ExecResponse, sandboxId: string, timeoutMs?: number, words?: "cli" | "mcp"): ExecOutcome;
+export declare function execTimingLine(exitCode: number | null | undefined, wallMs: unknown, totalMs: number, isTTY?: boolean, env?: NodeJS.ProcessEnv): string;
 export declare function endNotice(res: ExecResponse, timeoutMs?: number): string;
 export declare const MAX_OUTPUT_BYTES_PIPED: number;
 export declare function truncationNotice(kept: "first" | "last", maxOutputBytes: number | undefined): string;

package/dist/commands.js

@@ -4,6 +4,7 @@ import { closeSync, constants as fsConstants, existsSync, fstatSync, lstatSync,
 import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { DEFAULT_API_URL, DEFAULT_SNAPSHOT, ERRORS_DOCS_URL, MAX_OUTPUT_BYTES_DEFAULT, CONTEXT_GIT_RE, PromigenceClient, checkRepoUrl, withoutPin, PromigenceError, SpendCapError, TimeoutError, checkImageRef, contextRelative, credentialsPath, FILE_PUT_CHUNK_BYTES, imageSnapshot, isWaiting, execOutputBytes, packContext, readCredentials, } from "./sdk/index.js";
+import { fmtMs, recordTiming } from "./timing.js";
 import { capacityLine, queuedClause, queuedLines, statusLine } from "./capacity.js";
 import { DevcontainerError, detectOne, load, planJson, planLines, planSetup, resolveGiven, translate, workspaceRootFor, wrapCommand, } from "./devcontainer.js";
 import { detect, ecosystemOfCommands, imageCreateCommand, readConfig } from "./init.js";
@@ -52,7 +53,11 @@ export function clientOpts(ctx) {
     };
 }
 export function client(ctx) {
-    return new PromigenceClient({ ...clientOpts(ctx), onNotice: recordNotice });
+    return new PromigenceClient({ ...clientOpts(ctx), onNotice: recordNotice, onTiming: recordTiming });
+}
+export async function serverLocation(ctx) {
+    const h = await client(ctx).health({ timeoutMs: 3000 }).catch(() => undefined);
+    return typeof h?.location === "string" && h.location !== "" ? h.location : undefined;
 }
 export const nexts = (...items) => items.map(([cmd, why]) => ({ cmd, why }));
 export const KEPT_BY_HOLDERS = "sandboxes that were already given its value keep it until they end; it stays masked in their output";
@@ -1048,13 +1053,16 @@ const fork = async (ctx) => {
         env.error = failure;
     return emit(ctx.mode, env, [
         ...(replayed ? [replayed] : []),
-        `${up} of ${opts.count} sandbox${opts.count === 1 ? "" : "es"} ready in ${waited.waitedMs} ms (run ${runId})`,
+        `${up} of ${opts.count} sandbox${opts.count === 1 ? "" : "es"} ready in ${readyLine(report?.fork?.ready_ms?.p50, waited.waitedMs)} (run ${runId})`,
         ...sandboxIdLines(waited.sandboxes),
         ...(report && bool(ctx, "--verbose") ? [`  ${forkLine(report.fork)}`, `  ${totalsLine(report.totals)}`] : []),
         ...(report && exit !== 0 ? failureLines(report, new Map(), false) : []),
         `  next: ${execNext[0].cmd}`,
     ], exit, ctx.pointer);
 };
+export function readyLine(ourMs, totalMs) {
+    return ourMs === undefined ? `${totalMs} ms` : `${fmtMs(ourMs)} on our side · ${fmtMs(totalMs)} total`;
+}
 export function sandboxIdLines(sandboxes, cap = 10) {
     const lines = sandboxes.slice(0, cap).map((s) => `  ${s.sandbox_id} ${s.state}`);
     if (sandboxes.length > cap)
@@ -1135,6 +1143,91 @@ function wantsStream(ctx) {
         return true;
     return Boolean(process.stdout.isTTY);
 }
+let followKill;
+const FOLLOW_MAX_OUTPUT = 8 * 1024 * 1024;
+const FOLLOW_RECONNECT_MS = 10 * 60_000;
+async function followExec(c, sandboxId, execOpts) {
+    let rec;
+    try {
+        rec = await c.sandboxes.execBackground(sandboxId, {
+            argv: execOpts.argv,
+            ...(execOpts.secrets ? { secrets: execOpts.secrets } : {}),
+            ...(execOpts.timeoutMs === undefined ? {} : { timeoutMs: execOpts.timeoutMs }),
+            maxOutputBytes: execOpts.maxOutputBytes ?? FOLLOW_MAX_OUTPUT,
+            follow: true,
+        });
+    }
+    catch (err) {
+        const e = toPromigenceError(err);
+        if (e.code === "usage" && /follow/.test(e.message))
+            return undefined;
+        throw err;
+    }
+    const eid = rec.exec_id;
+    followKill = () => Promise.race([
+        c.sandboxes.execs.forget(sandboxId, eid).then(() => undefined, () => undefined),
+        new Promise((r) => setTimeout(r, 2000)),
+    ]);
+    const offset = { stdout: 0, stderr: 0 };
+    let last = rec;
+    let lostAt;
+    const say = (s) => write(process.stderr, s);
+    const pump = async (fd) => {
+        for (let backoff = 500;;) {
+            try {
+                const r = await c.sandboxes.execs.read(sandboxId, eid, fd, { offset: offset[fd], waitMs: 25_000, untilOutput: true });
+                if (lostAt !== undefined) {
+                    lostAt = undefined;
+                    await say("promigence: reconnected; the command's output continues from where it was\n");
+                }
+                backoff = 500;
+                if (r.skipped > 0) {
+                    await say(`\npromigence: ${r.skipped} bytes of the command's ${fd} were not kept while this connection was down (the newest 8 MiB are)\n`);
+                }
+                if (r.data.length)
+                    await writeBytes(fd === "stdout" ? process.stdout : process.stderr, r.data);
+                offset[fd] = r.offset + r.skipped + r.data.length;
+                last = r.record;
+                if (r.eof || (r.record.state !== "running" && r.data.length === 0))
+                    return;
+            }
+            catch (err) {
+                const e = toPromigenceError(err);
+                if (e.code !== "unreachable" && e.code !== "timeout")
+                    throw err;
+                if (lostAt === undefined) {
+                    lostAt = Date.now();
+                    await say(`\npromigence: connection lost; the command keeps running in the sandbox. Reconnecting… ` +
+                        `(or later: ${sh `promigence exec output ${eid} --sandbox ${sandboxId} --follow`})\n`);
+                }
+                else if (Date.now() - lostAt > FOLLOW_RECONNECT_MS) {
+                    throw err;
+                }
+                await new Promise((r) => setTimeout(r, backoff));
+                backoff = Math.min(backoff * 2, 5_000);
+            }
+        }
+    };
+    try {
+        await Promise.all([pump("stdout"), pump("stderr")]);
+    }
+    finally {
+        followKill = undefined;
+    }
+    const fin = last.state === "running" || !last.exit ? await c.sandboxes.execs.get(sandboxId, eid, { waitMs: 5_000 }) : last;
+    await c.sandboxes.execs.forget(sandboxId, eid).catch(() => undefined);
+    const x = fin.exit;
+    const signal = typeof x?.signal === "number" ? x.signal : undefined;
+    return {
+        exec_id: eid,
+        exit_code: x?.exit_code ?? null,
+        ...(signal === undefined ? {} : { signal }),
+        ...(x?.oom_killed ? { reason: "out_of_memory" } : signal !== undefined ? { reason: "signal" } : {}),
+        ...(typeof x?.wall_ms === "number" ? { wall_ms: x.wall_ms } : {}),
+        ...(typeof x?.cpu_ms === "number" ? { cpu_ms: x.cpu_ms } : {}),
+        truncated: false,
+    };
+}
 async function streamExec(ctx, c, sandboxId, execOpts) {
     const ndjson = ctx.mode === "json";
     const dec = { stdout: new TextDecoder(), stderr: new TextDecoder() };
@@ -1195,6 +1288,11 @@ async function emitChild(res, exit, notice) {
         await write(process.stderr, notice);
     return exitWith(exit);
 }
+export function execTimingLine(exitCode, wallMs, totalMs, isTTY = Boolean(process.stderr.isTTY), env = process.env) {
+    if (!isTTY || env["PROMIGENCE_QUIET"] === "1" || typeof wallMs !== "number" || !Number.isFinite(wallMs))
+        return "";
+    return `promigence: exit ${exitCode ?? "none"} · ran ${fmtMs(wallMs)} on our side · ${fmtMs(totalMs)} round trip\n`;
+}
 export function endNotice(res, timeoutMs) {
     const sig = typeof res["signal"] === "number" ? ` (signal ${res["signal"]})` : "";
     switch (res.reason) {
@@ -1284,6 +1382,10 @@ const exec = async (ctx) => {
             execOpts.maxOutputBytes = MAX_OUTPUT_BYTES_PIPED;
         }
         const interrupted = (sig) => {
+            const ending = followKill?.() ?? Promise.resolve();
+            void ending.finally(() => interruptedEnvelope(sig));
+        };
+        const interruptedEnvelope = (sig) => {
             const err = new PromigenceError({
                 code: "aborted_by_client",
                 message: `interrupted by ${sig}; the command in the sandbox ends with this connection`,
@@ -1297,9 +1399,14 @@ const exec = async (ctx) => {
         };
         for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"])
             process.once(sig, () => interrupted(sig));
-        const res = streaming
+        const execStarted = performance.now();
+        const followed = streaming && ctx.mode === "text" && process.env["PROMIGENCE_EXEC_FOLLOW"] !== "0"
+            ? await followExec(c, sandboxId, execOpts)
+            : undefined;
+        const res = followed ?? (streaming
             ? await streamExec(ctx, c, sandboxId, execOpts)
-            : asText(await c.sandboxes.exec(sandboxId, { ...execOpts, encoding: "base64" }));
+            : asText(await c.sandboxes.exec(sandboxId, { ...execOpts, encoding: "base64" })));
+        const execTotalMs = performance.now() - execStarted;
         const outcome = execOutcome(res, sandboxId, execOpts.timeoutMs);
         const passthrough = !bool(ctx, "--no-passthrough");
         let exit = passthrough ? (outcome.exitCode ?? 4) : (outcome.exitCode === 0 ? 0 : 4);
@@ -1309,13 +1416,15 @@ const exec = async (ctx) => {
             const notice = (res.truncated ? truncationNotice(streaming ? "first" : "last", execOpts.maxOutputBytes) : "")
                 + endNotice(res, execOpts.timeoutMs);
             const raw = streaming || typeof res.stdout_b64 === "string";
-            const gap = notice && raw && process.stdout.isTTY && !endsWithNewline(res) ? "\n" : "";
+            const timed = execTimingLine(outcome.exitCode, res.wall_ms, execTotalMs);
+            const all = notice + timed;
+            const gap = all && raw && process.stdout.isTTY && !endsWithNewline(res) ? "\n" : "";
             if (streaming) {
-                if (notice)
-                    await write(process.stderr, gap + notice);
+                if (all)
+                    await write(process.stderr, gap + all);
                 return exitWith(exit);
             }
-            return emitChild(res, exit, notice ? gap + notice : undefined);
+            return emitChild(res, exit, all ? gap + all : undefined);
         }
         const next = nexts(...(res.truncated
             ? [[`${sh `promigence exec --sandbox ${sandboxId} --max-output 32m --`} ${argv.map(shellArg).join(" ")}`, "re-run with a larger --max-output"]]

package/dist/handlers.js

@@ -12,6 +12,7 @@ import { detect, gitFacts, imageCreateCommand, renderConfig, stripRemoteCredenti
 import { TIERS } from "./generated.js";
 import { GOLDEN_PATH, SCHEMA, VERSION } from "./surface.js";
 import { jsonLine, sh } from "./term.js";
+import { fmtMs, median, where } from "./timing.js";
 const SECTION_NAMES = new Set(["core", "commands", "errors", "cost"]);
 const agentGuide = async (ctx) => {
     const format = str(ctx, "--format") ?? (ctx.explicitMode === "json" ? "json" : "md");
@@ -323,6 +324,46 @@ async function apiChecks(ctx, checks) {
         checks.push(fail("auth_accepted", `${e.code}: ${e.message}`, e.fix, e.cliExit ?? 7));
     }
 }
+const ping = async (ctx) => {
+    const n = Number(process.env["PROMIGENCE_PING_COUNT"] ?? "5");
+    if (!Number.isInteger(n) || n < 1 || n > 50)
+        throw usageError("PROMIGENCE_PING_COUNT takes 1 to 50", "Unset it for the default of five.");
+    const c = client(ctx);
+    const rounds = [];
+    let location;
+    for (let i = 0; i < n; i++) {
+        const h = await c.health({ timeoutMs: 10_000 });
+        if (typeof h.location === "string" && h.location)
+            location = h.location;
+        const tm = c.lastTiming;
+        if (tm)
+            rounds.push({ totalMs: tm.totalMs, ourMs: tm.ourMs });
+    }
+    const totals = rounds.map((r) => r.totalMs);
+    const ours = rounds.map((r) => r.ourMs).filter((x) => x !== null);
+    const nets = rounds.filter((r) => r.ourMs !== null).map((r) => Math.max(0, r.totalMs - r.ourMs));
+    const rt = median(totals);
+    const our = median(ours);
+    const net = median(nets);
+    const r1 = (x) => (x === undefined ? null : Math.round(x * 10) / 10);
+    const fields = {
+        location: location ?? null,
+        round_trips: n,
+        round_trip_ms: { median: r1(rt), min: r1(Math.min(...totals)), max: r1(Math.max(...totals)) },
+        our_side_ms: r1(our),
+        network_ms: r1(net),
+    };
+    const lines = [
+        `promigence ping: ${where(location)}`,
+        `  round trip   ${rt === undefined ? "—" : fmtMs(rt)} (median of ${n}; ${fmtMs(Math.min(...totals))} to ${fmtMs(Math.max(...totals))})`,
+        `  our side     ${our === undefined ? "— (not said by this service)" : fmtMs(our)}`,
+        `  your network ${net === undefined ? "—" : fmtMs(net)}`,
+        ...(net !== undefined && net >= 150
+            ? ["  Times marked 'on our side' are the platform's own; the rest is the distance to our servers."]
+            : []),
+    ];
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, fields, nexts(["promigence doctor", "check the client, your key and the API"])), lines, 0, ctx.pointer);
+};
 const doctor = async (ctx) => {
     const checks = await clientChecks(ctx);
     await apiChecks(ctx, checks);
@@ -466,5 +507,6 @@ export const EXTRA_HANDLERS = {
     init,
     examples,
     doctor,
+    ping,
     "exec output": execOutput,
 };

package/dist/io.d.ts

@@ -6,6 +6,7 @@ export declare function markGuideSeen(): void;
 export declare function isGoneReader(code: string | undefined): boolean;
 export declare function writeBytes(stream: NodeJS.WriteStream, data: Uint8Array): Promise<void>;
 export declare function write(stream: NodeJS.WriteStream, text: string): Promise<void>;
+export declare function setBeforeExit(fn: (() => Promise<unknown>) | undefined): void;
 export declare function exitWith(code: number): Promise<never>;
 export declare function recordNotice(n: AccountNotice): void;
 export declare function noticeLine(n: AccountNotice): string;

package/dist/io.js

@@ -53,7 +53,15 @@ function flush(stream) {
         stream.write("", () => resolve());
     });
 }
+let beforeExit;
+export function setBeforeExit(fn) {
+    beforeExit = fn;
+}
 export async function exitWith(code) {
+    const hook = beforeExit;
+    beforeExit = undefined;
+    if (hook)
+        await hook().catch(() => undefined);
     await flush(process.stdout);
     await flush(process.stderr);
     process.exit(code);
@@ -238,7 +246,7 @@ export function forkLine(fork) {
         return "fork: (no timings yet)";
     const p = (name, v) => v === undefined ? `${name} —` : `${name} p50 ${ms(v.p50)} p95 ${ms(v.p95)}${v.p99 === undefined ? "" : ` p99 ${ms(v.p99)}`}`;
     return [
-        `fork n=${fork.n}`,
+        `fork n=${fork.n} (on our side)`,
         p("queued", fork.queued_ms),
         p("ready", fork.ready_ms),
         p("e2e", fork.e2e_ms),

package/dist/login.js

@@ -809,6 +809,7 @@ async function signInAndStore(ctx, isSignup) {
     }
     const consoleHome = viaConsole ? `${new URL(viaConsole).origin}/home` : undefined;
     const credit = await offerAfterLogin(ctx, anon.apiUrl, session.api_key, consoleHome);
+    const location = await anon.health({ timeoutMs: 3000 }).then((h) => (typeof h.location === "string" && h.location ? h.location : undefined)).catch(() => undefined);
     const next = nexts(["promigence me", "your org, limits and spend"], ["promigence examples", "what you can fork with no build (the built-in base)"]);
     const fields = {
         credentials: path, store: stored.store, mode: stored.store === "file" ? "0600" : null, created: session.created,
@@ -820,6 +821,8 @@ async function signInAndStore(ctx, isSignup) {
     if (session.referral)
         fields["referral"] = session.referral;
     fields["credit_offer"] = credit.field;
+    if (location)
+        fields["location"] = location;
     if (warnings.length)
         fields["warnings"] = warnings;
     const rf = session.referral;
@@ -831,6 +834,7 @@ async function signInAndStore(ctx, isSignup) {
     return emit(ctx.mode, okEnvelope(ctx.cmd.name, fields, next), [
         `promigence login: ${session.created ? "account created" : "signed in"} as ${session.user.email} (${session.user.provider})`,
         `  org: ${session.org.name} (${session.org.org_id})`,
+        ...(location ? [`  Your sandboxes run on our servers on the ${location}.`] : []),
         `  key: ${session.key?.prefix ?? ""}… "${session.key?.name ?? keyName}" stored in ${storedWhere(stored)}`,
         ...(session.key?.expires_at ? [`  key expires: ${session.key.expires_at.slice(0, 10)} (sign in again before then; \`promigence keys list\` shows it)`] : []),
         ...(stored.note ? [`  note: ${stored.note}`] : []),

package/dist/routes.js

@@ -43,6 +43,7 @@ export const ROUTE_COMMANDS = {
     "GET /pricing": "pricing",
     "GET /billing": "billing usage",
     "GET /me/ledger": "billing usage",
+    "GET /me/outcomes": "me",
     "POST /billing/checkout": "billing card",
     "POST /billing/portal": "billing portal",
     "GET /referrals": "referrals",

package/dist/sdk/client.d.ts

@@ -83,6 +83,8 @@ export interface Capacity {
     queued_message?: string;
 }
 export type Outcome = M.Outcome;
+/** `GET /me/outcomes`: what the organization got this month, measured. */
+export type Outcomes = M.Outcomes;
 export interface Percentiles {
     p50: number;
     p95: number;
@@ -631,6 +633,8 @@ export interface HealthResponse {
     build_sha?: string;
     /** Whether the service can start new sandboxes right now. */
     serving?: boolean;
+    /** Where sandboxes run, in plain words (for example "US East Coast"); absent when not said. */
+    location?: string;
     [extra: string]: unknown;
 }
 /** One service's row in `GET /status` (`api`, `sandboxes`): `up`, `degraded` or `down`. */
@@ -1213,6 +1217,10 @@ export interface BackgroundExecRecord {
     stdout_total?: number;
     stderr_total?: number;
     truncated?: boolean;
+    /** Started with `follow`: the newest output is kept, and the handle goes 10 minutes after it ends. */
+    follow?: boolean;
+    /** A range read of a `follow` command: bytes dropped between the asked offset and the first held. */
+    skipped?: number;
     exit?: {
         exit_code: number | null;
         signal: number | null;
@@ -1421,6 +1429,11 @@ export interface PromigenceClientOpts {
      * on `client.notice`.
      */
     onNotice?: (notice: AccountNotice) => void;
+    /**
+     * Called with every answer's timing ([`Timing`]): the round trip this process saw and how long
+     * the answer took on Promigence's side. A CLI uses it to say how far away the caller is.
+     */
+    onTiming?: (timing: Timing) => void;
 }
 /** `GET /sandboxes/:id/network`. */
 export interface SandboxNetwork {
@@ -1857,6 +1870,17 @@ interface RequestOpts {
     /** Extra request headers (e.g. `promigence-replaced-by`). Never the authorization. */
     headers?: Record<string, string>;
 }
+/** One answer's timing ([`PromigenceClient.lastTiming`]). */
+export interface Timing {
+    method: string;
+    path: string;
+    /** The round trip as the client saw it, in ms, until the answer's headers arrived. */
+    totalMs: number;
+    /** How long the answer took on Promigence's side, in ms; `null` when the service did not say. */
+    ourMs: number | null;
+}
+/** The `app` span of a `Server-Timing` header (`app;dur=12.35`), in ms; `null` without one. */
+export declare function serverAppMs(header: string | null | undefined): number | null;
 export declare class PromigenceClient {
     #private;
     readonly apiUrl: string;
@@ -1879,9 +1903,16 @@ export declare class PromigenceClient {
         requests: number;
         retries: number;
     };
+    /**
+     * The most recent answer's timing: `totalMs` is the whole round trip as this process saw it,
+     * until the answer's headers arrived; `ourMs` is how long the answer took on Promigence's side
+     * (`null` when the service did not say). `totalMs − ourMs` is the network between you and us.
+     */
+    lastTiming: Timing | null;
     /** The latest account notice any response carried (`Promigence-Notice`), if one did. */
     notice: AccountNotice | undefined;
     private readonly onNotice;
+    private readonly onTiming;
     private readonly noticesSeen;
     constructor(opts?: PromigenceClientOpts);
     /** Read `Promigence-Notice` off a response (its raw value); tell the caller once per distinct notice. */
@@ -1975,6 +2006,13 @@ export declare class PromigenceClient {
     me(opts?: {
         signal?: AbortSignal;
     }): Promise<MeResponse>;
+    /**
+     * `GET /me/outcomes?period=month` — what this organization (with a project's key: that project) got
+     * this month, measured from its own runs and sandboxes. A figure with nothing behind it is `null`.
+     */
+    outcomes(opts?: {
+        signal?: AbortSignal;
+    }): Promise<Outcomes>;
     readonly billing: {
         /** `GET /billing` — plan, card, period, usage, trial, upcoming invoice. */
         usage: () => Promise<BillingUsage>;
@@ -2245,6 +2283,7 @@ export declare class PromigenceClient {
          */
         execBackground: (sandboxId: string, opts: Omit<ExecOpts, "terminal" | "killOnExit" | "signal"> & {
             stdin?: boolean;
+            follow?: boolean;
         }) => Promise<BackgroundExecRecord>;
         /** Background execs of one sandbox (`GET|POST|DELETE /sandboxes/:id/execs/:exec_id…`). */
         execs: {
@@ -2262,10 +2301,14 @@ export declare class PromigenceClient {
             read: (sandboxId: string, execId: string, stream: "stdout" | "stderr", opts?: {
                 offset?: number;
                 len?: number;
+                waitMs?: number;
+                untilOutput?: boolean;
+                signal?: AbortSignal;
             }) => Promise<{
                 data: Uint8Array;
                 offset: number;
                 eof: boolean;
+                skipped: number;
                 record: BackgroundExecRecord;
             }>;
             /**

package/dist/sdk/client.js

@@ -904,6 +904,16 @@ function waitQuery(waitMs) {
         : "";
 }
 const notReleased = (what) => Promise.reject(new NotReleasedError(what));
+export function serverAppMs(header) {
+    if (!header)
+        return null;
+    for (const part of header.split(",")) {
+        const m = /^\s*app\s*;(?:.*;)?\s*dur=([0-9]+(?:\.[0-9]+)?)/.exec(part);
+        if (m)
+            return Number(m[1]);
+    }
+    return null;
+}
 function headerOf(res, name) {
     return res instanceof H2Response ? res.header(name) : res.headers.get(name);
 }
@@ -920,8 +930,10 @@ export class PromigenceClient {
     cliErrors;
     caller;
     stats = { requests: 0, retries: 0 };
+    lastTiming = null;
     notice;
     onNotice;
+    onTiming;
     noticesSeen = new Set();
     constructor(opts = {}) {
         traceEvent("client:ctor");
@@ -940,6 +952,7 @@ export class PromigenceClient {
         this.caller = resolveCaller(opts.caller);
         this.userAgent = userAgentWithCaller(opts.userAgent ?? `promigence/${VERSION} node/${process.versions.node}`, this.caller);
         this.onNotice = opts.onNotice;
+        this.onTiming = opts.onTiming;
         this.cliErrors = opts.cliErrors === true;
         traceEvent("client:ready");
     }
@@ -1045,6 +1058,7 @@ export class PromigenceClient {
         for (let attempt = 0;; attempt++) {
             let res;
             this.stats.requests++;
+            const sentAt = performance.now();
             try {
                 if (this.h2) {
                     const init = {
@@ -1074,6 +1088,13 @@ export class PromigenceClient {
                     res = await this.fetchImpl(url, init);
                 }
                 mark(tr, "res");
+                this.lastTiming = {
+                    method: opts.method,
+                    path: opts.path,
+                    totalMs: performance.now() - sentAt,
+                    ourMs: serverAppMs(headerOf(res, "server-timing")),
+                };
+                this.onTiming?.(this.lastTiming);
             }
             catch (err) {
                 const e = err;
@@ -1391,6 +1412,9 @@ export class PromigenceClient {
     me(opts = {}) {
         return this.request({ method: "GET", path: "/me", ...(opts.signal ? { signal: opts.signal } : {}) });
     }
+    outcomes(opts = {}) {
+        return this.request({ method: "GET", path: "/me/outcomes?period=month", ...(opts.signal ? { signal: opts.signal } : {}) });
+    }
     billing = {
         usage: () => this.request({ method: "GET", path: "/billing" }),
         ledger: async (limit = 100) => (await this.billing.ledgerPage({ limit })).items,
@@ -1966,6 +1990,8 @@ export class PromigenceClient {
                 body["secrets"] = opts.secrets;
             if (opts.stdin)
                 body["stdin"] = true;
+            if (opts.follow)
+                body["follow"] = true;
             const timeoutMs = commandTimeoutMs(opts.timeoutMs);
             if (timeoutMs !== undefined)
                 body["timeout_ms"] = timeoutMs;
@@ -1998,11 +2024,18 @@ export class PromigenceClient {
                 const q = [`stream=${stream}`, `offset=${Math.max(0, Math.floor(opts.offset ?? 0))}`];
                 if (opts.len !== undefined)
                     q.push(`len=${Math.max(0, Math.floor(opts.len))}`);
+                const wait = opts.waitMs !== undefined && opts.waitMs > 0 ? Math.min(Math.floor(opts.waitMs), WAIT_MS_CAP) : 0;
+                if (wait)
+                    q.push(`wait_ms=${wait}`);
+                if (wait && opts.untilOutput)
+                    q.push("until=output");
                 const r = await this.request({
                     method: "GET",
                     path: `/sandboxes/${encodeURIComponent(sandboxId)}/execs/${encodeURIComponent(execId)}?${q.join("&")}`,
+                    ...(wait ? { timeoutMs: wait + this.requestTimeoutMs } : {}),
+                    ...(opts.signal ? { signal: opts.signal } : {}),
                 });
-                return { data: b64ToBytes(r.data ?? ""), offset: r.offset ?? opts.offset ?? 0, eof: Boolean(r.eof), record: r };
+                return { data: b64ToBytes(r.data ?? ""), offset: r.offset ?? opts.offset ?? 0, eof: Boolean(r.eof), skipped: r.skipped ?? 0, record: r };
             },
             stdin: (sandboxId, execId, opts = {}) => {
                 if (opts.data === undefined && !opts.eof) {

package/dist/sdk/core.d.ts

@@ -1,5 +1,5 @@
 /** Promigence SDK — constants, error hierarchy and shared types. */
-export declare const VERSION = "0.1.0-beta.2";
+export declare const VERSION = "0.1.0-beta.3";
 export declare const DOCS_URL = "https://promigence.ai";
 /** The error reference; each code is an anchor on it (the API's `docs` link has the same form). */
 export declare const ERRORS_DOCS_URL = "https://www.promigence.ai/docs/errors";

package/dist/sdk/core.js

@@ -1,5 +1,5 @@
 import { hintArg } from "./hint.js";
-export const VERSION = "0.1.0-beta.2";
+export const VERSION = "0.1.0-beta.3";
 export const DOCS_URL = "https://promigence.ai";
 export const ERRORS_DOCS_URL = "https://www.promigence.ai/docs/errors";
 export const DEFAULT_API_URL = "https://api.promigence.ai/v1";

package/dist/sdk/models.gen.d.ts

@@ -146,6 +146,11 @@ export interface BackgroundExec {
      * How the command ended; only once `state` is `exited`.
      */
     exit?: BackgroundExecExit | null;
+    /**
+     * Started with `follow`: the newest output is kept, and the handle is freed 10 minutes
+     * after the command ends.
+     */
+    follow?: boolean | null;
     /**
      * Present when the sandbox pauses itself when idle: after this command ends, the idle rule
      * waits up to this many seconds for its result to be read before it pauses the sandbox (a
@@ -166,6 +171,11 @@ export interface BackgroundExec {
     len?: number | null;
     offset?: number | null;
     sandbox_id: string;
+    /**
+     * A `follow` command only: bytes between the `offset` asked for and the first byte still
+     * held, dropped to keep the newest output; `data` then starts at `offset + skipped`.
+     */
+    skipped?: number | null;
     /**
      * Unix nanoseconds.
      */
@@ -1018,6 +1028,14 @@ export interface ExecCreate {
      * Extra environment variables.
      */
     env?: Record<string, string>;
+    /**
+     * With `background`: the command is read as it runs, by a caller that may lose its
+     * connection and come back. The newest `max_output_bytes` of each stream are kept (8 MiB by
+     * default; older bytes are dropped, and a read that asks for them says how many in
+     * `skipped`), and the handle is freed 10 minutes after the command ends, read or not. The
+     * command never stops because a caller went away.
+     */
+    follow?: boolean;
     /**
      * End the sandbox when the command exits (default: the value of `terminal`).
      */
@@ -1904,6 +1922,11 @@ export interface Health {
      * The commit this build came from; empty for a local build.
      */
     build_sha: string;
+    /**
+     * Where sandboxes run, in plain words (for example "US East Coast"). Absent when the service
+     * does not say.
+     */
+    location?: string | null;
     ok: boolean;
     /**
      * Whether new sandboxes can start right now. Answered to a request made with a key; absent
@@ -2325,6 +2348,16 @@ export interface Me {
      */
     key?: KeyRef | null;
     limits: MeLimits;
+    /**
+     * Where sandboxes run, in plain words (for example "US East Coast"), as `GET /v1/health` says
+     * it. Absent when the service does not say.
+     */
+    location?: string | null;
+    /**
+     * The same place as a short code for an icon: `us-east`, `us-west`, `us-midwest`, `eu-west` or
+     * `india`. Only beside `location`; a code you do not know is fine to ignore.
+     */
+    location_code?: string | null;
     /**
      * A notice about a coming change to the trial rules; `null` when there is none.
      */
@@ -2627,6 +2660,67 @@ export interface OtherUsage {
     entries: number;
 }
 export type Outcome = "completed" | "task_failed" | "env_failed" | "snapshot_failed" | "aborted_by_client" | "expired" | "cap_killed" | "not_started" | "superseded" | "grader_failed" | "preempted";
+/**
+ * `GET /v1/me/outcomes?period=month` — what the organization (with a project's key: that project)
+ * got this period, measured from its own runs and sandboxes. A figure with nothing behind it is
+ * `null`; counts are `0`.
+ */
+export interface Outcomes {
+    /**
+     * Finished runs of two or more sandboxes this period.
+     */
+    batch_runs: number;
+    /**
+     * For those runs: seconds not spent waiting, the sum of their sandboxes' own times minus
+     * the runs' wall time; `null` without such a run.
+     */
+    batch_saved_s?: number | null;
+    /**
+     * For those runs: the sum of their sandboxes' own times divided by the runs' wall time
+     * (how many times faster than one after another); `null` without such a run.
+     */
+    batch_speedup?: number | null;
+    /**
+     * Sandboxes that ended on a failure on our side and were not billed for it.
+     */
+    failures_ours: number;
+    /**
+     * What was given back for those failures, in USD (`0` when they ended before any charge).
+     */
+    failures_ours_usd: number;
+    /**
+     * Failed sandboxes kept to reopen that can still be reopened.
+     */
+    kept_failures: number;
+    /**
+     * Hours this period's sandboxes spent paused, which is not billed; `null` if none paused.
+     */
+    paused_hours?: number | null;
+    /**
+     * What those paused hours would have cost running, in USD; `null` if none paused.
+     */
+    paused_usd?: number | null;
+    /**
+     * `month`: the calendar month so far, UTC.
+     */
+    period: string;
+    /**
+     * The median milliseconds until a sandbox was ready to take work; `null` with no sandbox.
+     */
+    ready_ms_p50?: number | null;
+    /**
+     * Runs started this period.
+     */
+    runs: number;
+    /**
+     * Sandboxes started this period.
+     */
+    sandboxes: number;
+    /**
+     * When the period began (RFC 3339, UTC).
+     */
+    since: string;
+}
 /**
  * What a parked sandbox occupies on disk.
  */
@@ -4256,8 +4350,9 @@ export interface SandboxView {
      */
     billable_seconds?: number | null;
     /**
-     * Once it has ended, what it cost in USD at its run's rates (the run report's `cost`).
-     * Present on `GET /v1/sandboxes/{id}` for an ended sandbox; absent from list rows.
+     * What it has cost in USD at its run's rates: once it has ended, the run report's `cost`; while
+     * it is live, the seconds billed so far (running time only). Present on `GET /v1/sandboxes/{id}`
+     * once it has started; absent from list rows.
      */
     cost_usd?: number | null;
     /**

package/dist/surface.d.ts

@@ -6,7 +6,7 @@ export declare const DESCRIPTION = "Promigence \u2014 verified, reproducible, fo
 export declare const GOLDEN_PATH = "promigence run --snapshot promigence/base --count 2 --cap 1 --json -- python3 -c 'print(6*7)'";
 export declare const WAIT_TIMEOUT_DEFAULT = "100s";
 export declare const REQUEST_TIMEOUT_DEFAULT = "30s";
-export declare const LIVE_COMMANDS: readonly ["login", "signup", "logout", "auth login", "keys list", "keys create", "keys revoke", "org list", "org create", "org switch", "org members", "org invite", "org invites", "org uninvite", "org resend", "org role", "org remove", "org leave", "org join", "org audit", "org rename", "org delete", "project list", "project create", "project rename", "project delete", "project cap", "project move", "me", "billing card", "doctor", "init", "examples", "templates", "templates show", "agent-guide", "mcp", "snapshot create", "snapshot status", "snapshot list", "snapshot inspect", "snapshot verify", "snapshot export", "fork", "exec", "exec output", "exec ps", "exec kill", "files put", "files get", "files ls", "run", "run quote", "run report", "run status", "run cancel", "run kill", "run replay", "run open", "run captures", "sandbox kill", "sandbox shell", "sandbox ssh", "sandbox network", "port expose", "port list", "port revoke", "secrets set", "bench burst", "status", "billing usage", "billing portal", "snapshot delete", "snapshot builds", "snapshot alias", "run list", "sandbox list", "sandbox info", "sandbox pause", "sandbox resume", "sandbox extend", "sandbox probe", "files rm", "secrets list", "secrets delete", "image resolve", "sandbox snapshot", "files search", "files mkdir", "files mv", "files cp", "files chmod", "exec stdin", "sandbox autopause", "agent start", "referrals", "referrals apply", "credits", "credits claim", "runners github", "runners gitlab", "pricing", "github connect", "github status", "github disconnect", "github untrack", "repos", "gitlab connect", "gitlab status", "gitlab disconnect", "gitlab untrack"];
+export declare const LIVE_COMMANDS: readonly ["login", "signup", "logout", "auth login", "keys list", "keys create", "keys revoke", "org list", "org create", "org switch", "org members", "org invite", "org invites", "org uninvite", "org resend", "org role", "org remove", "org leave", "org join", "org audit", "org rename", "org delete", "project list", "project create", "project rename", "project delete", "project cap", "project move", "me", "billing card", "doctor", "ping", "init", "examples", "templates", "templates show", "agent-guide", "mcp", "snapshot create", "snapshot status", "snapshot list", "snapshot inspect", "snapshot verify", "snapshot export", "fork", "exec", "exec output", "exec ps", "exec kill", "files put", "files get", "files ls", "run", "run quote", "run report", "run status", "run cancel", "run kill", "run replay", "run open", "run captures", "sandbox kill", "sandbox shell", "sandbox ssh", "sandbox network", "port expose", "port list", "port revoke", "secrets set", "bench burst", "status", "billing usage", "billing portal", "snapshot delete", "snapshot builds", "snapshot alias", "run list", "sandbox list", "sandbox info", "sandbox pause", "sandbox resume", "sandbox extend", "sandbox probe", "files rm", "secrets list", "secrets delete", "image resolve", "sandbox snapshot", "files search", "files mkdir", "files mv", "files cp", "files chmod", "exec stdin", "sandbox autopause", "agent start", "referrals", "referrals apply", "credits", "credits claim", "runners github", "runners gitlab", "pricing", "github connect", "github status", "github disconnect", "github untrack", "repos", "gitlab connect", "gitlab status", "gitlab disconnect", "gitlab untrack"];
 export declare const GUIDE_COMMON_ERRORS: readonly ["auth", "not_found", "not_verified", "cap_exceeded", "timeout", "nonzero_exit"];
 export type Group = "Setup" | "Snapshots" | "Runs" | "Sandboxes" | "Ops";
 export type CommandStatus = "planned" | "released";

package/dist/surface.js

@@ -10,7 +10,7 @@ export const LIVE_COMMANDS = [
     "login", "signup", "logout", "auth login", "keys list", "keys create", "keys revoke",
     "org list", "org create", "org switch", "org members", "org invite", "org invites", "org uninvite", "org resend", "org role", "org remove", "org leave", "org join", "org audit", "org rename", "org delete",
     "project list", "project create", "project rename", "project delete", "project cap", "project move",
-    "me", "billing card", "doctor", "init", "examples", "templates", "templates show", "agent-guide", "mcp",
+    "me", "billing card", "doctor", "ping", "init", "examples", "templates", "templates show", "agent-guide", "mcp",
     "snapshot create", "snapshot status", "snapshot list", "snapshot inspect", "snapshot verify",
     "snapshot export",
     "fork", "exec", "exec output", "exec ps", "exec kill", "files put", "files get", "files ls",
@@ -322,6 +322,13 @@ export const COMMANDS = [
         flags: [json],
         next: ["promigence examples"],
     },
+    {
+        name: "ping", group: "Setup", status: "released",
+        helpRow: { key: "doctor", summary: "" },
+        summary: "your distance to our servers",
+        flags: [json],
+        next: ["promigence doctor"],
+    },
     {
         name: "init", group: "Setup", status: "released",
         summary: "write promigence.toml",

package/dist/timing.js

@@ -0,0 +1,71 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const seen = [];
+export function recordTiming(t) {
+    seen.push(t);
+}
+export function timings() {
+    return seen.filter((t) => t.ourMs !== null);
+}
+export function networkMs(list = timings()) {
+    let best;
+    for (const t of list) {
+        if (t.ourMs === null)
+            continue;
+        const n = Math.max(0, t.totalMs - t.ourMs);
+        if (best === undefined || n < best)
+            best = n;
+    }
+    return best;
+}
+export function ourSideLine(ourMs, totalMs) {
+    const ours = `${fmtMs(ourMs)} on our side`;
+    return totalMs === undefined ? ours : `${ours} · ${fmtMs(totalMs)} round trip`;
+}
+export function fmtMs(ms) {
+    return ms >= 10 ? `${Math.round(ms)} ms` : `${Math.round(ms * 10) / 10} ms`;
+}
+export function where(location) {
+    return location ? `our servers on the ${location}` : "our servers";
+}
+export const FAR_MS = 150;
+export function farMarker(env = process.env) {
+    const base = env["XDG_CONFIG_HOME"] ? join(env["XDG_CONFIG_HOME"], "promigence") : join(homedir(), ".config", "promigence");
+    return join(base, "far-notice-shown");
+}
+export function farNoticeText(ms, location) {
+    return `promigence: You're about ${Math.round(ms)} ms from ${where(location)}. ` +
+        "Times marked 'on our side' are the platform's own; the rest is your network. " +
+        "(Shown once. `promigence ping` measures it again.)\n";
+}
+export async function maybeFarNotice(opts) {
+    const env = opts.env ?? process.env;
+    if (opts.json || env["PROMIGENCE_QUIET"] === "1")
+        return undefined;
+    if (!(opts.isTTY ?? process.stderr.isTTY))
+        return undefined;
+    const ms = networkMs(opts.list ?? timings());
+    if (ms === undefined || ms < FAR_MS)
+        return undefined;
+    const marker = farMarker(env);
+    if (existsSync(marker))
+        return undefined;
+    const loc = await opts.location().catch(() => undefined);
+    const text = farNoticeText(ms, loc);
+    (opts.write ?? ((s) => process.stderr.write(s)))(text);
+    try {
+        mkdirSync(join(marker, ".."), { recursive: true, mode: 0o700 });
+        writeFileSync(marker, `${new Date().toISOString()} ${Math.round(ms)}\n`, { mode: 0o600 });
+    }
+    catch {
+    }
+    return text;
+}
+export function median(xs) {
+    if (!xs.length)
+        return undefined;
+    const s = [...xs].sort((a, b) => a - b);
+    const m = s.length >> 1;
+    return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}

package/llms.txt

@@ -1,4 +1,4 @@
-# Promigence — promigence@0.1.0-beta.2
+# Promigence — promigence@0.1.0-beta.3
 
 > Verified, reproducible, forkable execution environments for agents. The CLI is the
 > `promigence` command (package `promigence`, which is also the TypeScript SDK).
@@ -36,6 +36,7 @@
 - `promigence me` — plan, concurrency in use, trial credit, spend, limits
 - `promigence billing card` — add a card: prints a checkout URL (trial credits kept)
 - `promigence doctor` — check client, auth and API
+- `promigence ping` — your distance to our servers
 - `promigence init` — write promigence.toml
 - `promigence examples` — what forks with no build (no auth)
 - `promigence templates` — the templates: ready-made starting points to fork (no auth)
@@ -125,7 +126,7 @@
 
 ---
 
-# Promigence — agent guide (promigence@0.1.0-beta.2)
+# Promigence — agent guide (promigence@0.1.0-beta.3)
 
 Promigence is an **environment runtime**: verified, reproducible, forkable execution
 environments, billed per second (vCPU + memory). The model is one line:
@@ -195,4 +196,4 @@ Highest-precedence code wins: 2 > 5 > 6 > 7/8/9/10 > 11 > 3 > 12 > 4 > 1 > 0.
 · `promigence <command> --help` · https://promigence.ai
 Same surface as MCP tools: `promigence mcp` (stdio; `claude mcp add promigence -- promigence mcp`).
 
-Live in v0.1.0-beta.2: login · signup · logout · auth login · keys list/create/revoke · org list/create/switch/members/invite/invites/uninvite/resend/role/remove/leave/join/audit/rename/delete · project list/create/rename/delete/cap/move · me · billing card/usage/portal · doctor · init · examples · templates +show · agent-guide · mcp · snapshot create/status/list/inspect/verify/export/delete/builds/alias · image resolve · github connect/status/disconnect/untrack · repos · gitlab connect/status/disconnect/untrack · run +quote/report/status/cancel/kill/replay/open/captures/list · fork · exec +output/ps/stdin/kill · files put/get/ls/search/mkdir/mv/cp/chmod/rm · agent start · sandbox kill/network/shell/ssh/list/pause/resume/snapshot/info/extend/autopause/probe · port expose/list/revoke · secrets set/list/delete · bench burst · runners github/gitlab · status · referrals +apply · pricing · credits +claim
+Live in v0.1.0-beta.3: login · signup · logout · auth login · keys list/create/revoke · org list/create/switch/members/invite/invites/uninvite/resend/role/remove/leave/join/audit/rename/delete · project list/create/rename/delete/cap/move · me · billing card/usage/portal · doctor · ping · init · examples · templates +show · agent-guide · mcp · snapshot create/status/list/inspect/verify/export/delete/builds/alias · image resolve · github connect/status/disconnect/untrack · repos · gitlab connect/status/disconnect/untrack · run +quote/report/status/cancel/kill/replay/open/captures/list · fork · exec +output/ps/stdin/kill · files put/get/ls/search/mkdir/mv/cp/chmod/rm · agent start · sandbox kill/network/shell/ssh/list/pause/resume/snapshot/info/extend/autopause/probe · port expose/list/revoke · secrets set/list/delete · bench burst · runners github/gitlab · status · referrals +apply · pricing · credits +claim

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promigence",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.0-beta.3",
   "description": "The fastest sandboxes for AI agents and code. Snapshot an environment once, fork it as often as you need, run commands in every copy, and get a report that tells environment failures from task failures. Billed per second, with a quote before a run and a hard spend cap. One package: the promigence command and the TypeScript SDK.",
   "license": "Apache-2.0",
   "homepage": "https://www.promigence.ai",