promigence 0.1.0-beta.12

package/dist/account.js

@@ -0,0 +1,850 @@
+import { bool, client, KEPT_BY_HOLDERS, list, nexts, optimizeForFlag, positional, required, secretListLines, str, } from "./commands.js";
+import { queuedLines } from "./capacity.js";
+import { duration } from "./report.js";
+import { emit, ms, okEnvelope, overMost, parseCount, parseDuration, parseUsd, usageError } from "./io.js";
+import { sh } from "./term.js";
+const usd = (n) => n === undefined ? "—" : `$${n.toFixed(n < 0.01 && n > 0 ? 4 : 2)}`;
+export const PAYMENT_METHOD_NAMES = {
+    apple_pay: "Apple Pay",
+    google_pay: "Google Pay",
+    samsung_pay: "Samsung Pay",
+    link: "Link",
+    cashapp: "Cash App Pay",
+    amazon_pay: "Amazon Pay",
+};
+export function paymentMethodText(card) {
+    const key = card?.brand ?? "";
+    const named = Object.prototype.hasOwnProperty.call(PAYMENT_METHOD_NAMES, key) ? PAYMENT_METHOD_NAMES[key] : undefined;
+    if (named)
+        return card?.last4 ? `${named} •••• ${card.last4}` : named;
+    return `${card?.brand ?? "card"} ••${card?.last4 ?? "??"}`;
+}
+function limitOf(ctx, fallback, most) {
+    const raw = str(ctx, "--limit");
+    if (raw === undefined)
+        return fallback;
+    const n = parseCount(raw, "--limit");
+    return most !== undefined && n > most ? overMost("--limit", raw, most, String(most), true) : n;
+}
+const HOLDING = ["queued", "placing", "ready", "running"];
+export async function concurrencyOf(c, me) {
+    if (!me)
+        return undefined;
+    const limit = me.concurrency?.limit ?? me.limits?.max_concurrency;
+    if (typeof limit !== "number")
+        return undefined;
+    if (typeof me.concurrency?.in_use === "number")
+        return { in_use: me.concurrency.in_use, limit, source: "api" };
+    try {
+        const page = await c.sandboxes.listPage({ limit: 500, state: HOLDING });
+        return { in_use: page.items.length, limit, source: "counted", ...(page.nextCursor ? { at_least: true } : {}) };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function concurrencyText(c) {
+    return `${c.in_use}${c.at_least ? "+" : ""} of ${c.limit} in use (paused sandboxes are not counted)`;
+}
+export function planName(me, b) {
+    if (typeof me?.plan === "string" && me.plan)
+        return me.plan;
+    const onTrial = (me?.trial?.on_trial ?? b?.trial?.on_trial) === true;
+    if (onTrial && (b?.plan === undefined || b.plan === "free"))
+        return "hobby";
+    return b?.plan;
+}
+function span(seconds) {
+    const s = Math.max(0, Math.round(seconds));
+    if (s >= 3600 && s % 3600 === 0)
+        return `${s / 3600}h`;
+    if (s >= 3600)
+        return `${Math.floor(s / 3600)}h${Math.round((s % 3600) / 60)}m`;
+    if (s >= 60)
+        return `${Math.floor(s / 60)}m${s % 60 ? `${s % 60}s` : ""}`;
+    return `${s}s`;
+}
+const status = async (ctx) => {
+    const c = client(ctx);
+    let failure;
+    const keep = (e) => { failure ??= e; return undefined; };
+    const [svc, health] = await Promise.all([
+        c.status().catch(keep),
+        c.health().catch(keep),
+    ]);
+    if (svc === undefined && health === undefined)
+        throw failure;
+    const me = c.authenticated ? await c.me().catch(() => undefined) : undefined;
+    const conc = await concurrencyOf(c, me);
+    const services = svc?.services ?? [];
+    const next = nexts(["promigence me", "your limits, spend and trial credits in full"], ["promigence doctor", "check this client, your key and the API in one pass"]);
+    const env = okEnvelope(ctx.cmd.name, {
+        ok: health?.ok ?? Boolean(svc),
+        ...(health?.version ? { api_version: health.version } : {}),
+        services,
+        ...(svc?.checks === undefined ? {} : { checks: svc.checks }),
+        ...(conc ? { concurrency: conc } : {}),
+        ...(me?.spend === undefined ? {} : { spend: me.spend }),
+    }, next);
+    const lines = [`promigence status: ${health?.ok ?? svc ? "up" : "no answer"}${health?.version ? ` (api ${health.version})` : ""}`];
+    for (const s of services) {
+        lines.push(`  ${s.name}: ${s.state ?? "?"}`);
+    }
+    if (!services.length)
+        lines.push("  (no service reported)");
+    if (conc)
+        lines.push(`  your concurrency: ${concurrencyText(conc)}`);
+    else if (!c.authenticated)
+        lines.push("  your concurrency: sign in to see it (promigence login)");
+    else
+        lines.push("  your concurrency: could not be read with this key (promigence me says why)");
+    return emit(ctx.mode, env, lines, 0, ctx.pointer);
+};
+const me = async (ctx) => {
+    const c = client(ctx);
+    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;
+    const next = nexts(["promigence billing usage", "this month's spend by tier, and the credit that paid it"], ["promigence status", "is the service up, and how much of your limit is in use"]);
+    const org = info.org && info.org !== info.org_id ? `${info.org} (${info.org_id})` : (info.org_id ?? "org");
+    const lines = [`promigence me: ${org}${info.key?.key_id ? ` · key ${info.key.key_id}` : ""}`];
+    if (info.user && typeof info.user === "object" && info.user.email)
+        lines.push(`  signed up as ${info.user.email}`);
+    if (plan)
+        lines.push(`  plan: ${plan}${trial?.on_trial ? " (trial)" : ""}`);
+    if (conc)
+        lines.push(`  concurrency: ${concurrencyText(conc)}`);
+    if (trial?.on_trial) {
+        const left = trial.credits_available ?? trial.credits_remaining;
+        lines.push(`  trial credit: ${usd(left)} left of ${usd(trial.credits_granted)}` +
+            `${trial.credits_reserved ? ` (${usd(trial.credits_reserved)} held for running sandboxes)` : ""}`);
+    }
+    if (typeof info.spend === "number") {
+        const kinds = Object.entries(info.spend_detail?.by_kind ?? {}).filter(([, v]) => v > 0);
+        const kindName = { sandbox: "sandboxes", build: "builds", egress: "data out", storage: "storage" };
+        lines.push(`  spent: ${usd(info.spend)}${kinds.length ? ` (${kinds.map(([k, v]) => `${kindName[k] ?? k} ${usd(v)}`).join(" · ")})` : ""}`);
+    }
+    if (info.spend === undefined && info.trial === undefined) {
+        lines.push("  spend and credit: shown to an owner's key of the default project (or `promigence billing usage --ledger` for this key's project)");
+    }
+    if (info.card_on_file)
+        lines.push("  card: on file");
+    const cap = info.default_spend_cap;
+    lines.push(`  default spend cap: ${typeof cap === "number" && cap > 0 ? usd(cap) : "none; pass --cap USD on each fork or run"}`);
+    const lim = info.limits ?? {};
+    const shape = [
+        typeof lim.max_sandbox_vcpus === "number" ? `sandboxes up to ${lim.max_sandbox_vcpus} vCPU` : "",
+        typeof lim.max_session_s === "number" ? `sessions up to ${span(lim.max_session_s)}` : "",
+    ].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");
+    const cursor = str(ctx, "--cursor");
+    if (cursor !== undefined && !wantLedger)
+        throw usageError("--cursor pages the ledger", "Pass it with --ledger.");
+    const c = client(ctx);
+    const [b, me] = await Promise.all([
+        c.billing.usage().catch((e) => {
+            if (wantLedger && e?.code === "forbidden")
+                return undefined;
+            throw e;
+        }),
+        c.me().catch(() => undefined),
+    ]);
+    const page = wantLedger ? await c.billing.ledgerPage({ limit, ...(cursor === undefined ? {} : { cursor }) }) : undefined;
+    const entries = page?.items ?? [];
+    const moreLedger = page?.nextCursor
+        ? [[sh `promigence billing usage --ledger --limit ${String(limit)} --cursor ${page.nextCursor}`, "the next page of rows"]]
+        : [];
+    if (b === undefined) {
+        const env = okEnvelope(ctx.cmd.name, { org_totals: null, ledger: entries, next_cursor: page?.nextCursor ?? null }, nexts(...moreLedger, ["promigence me", "your limits and concurrency"]));
+        const lines = ["promigence billing usage: the organization's totals are shown to an owner's key of the default project; this key's project's metered rows:"];
+        for (const e of entries) {
+            lines.push(`  ${e.created_at ?? ""} ${e.kind}${e.tier ? ` ${e.tier}` : ""} ${usd(e.amount)}${e.seconds ? ` · ${e.seconds}s` : ""}${e.run_id ? ` · ${e.run_id}` : ""}`);
+        }
+        if (!entries.length)
+            lines.push("  (no metered rows in this period)");
+        if (page?.nextCursor)
+            lines.push(`  more: --cursor ${page.nextCursor}`);
+        return emit(ctx.mode, env, lines, 0, ctx.pointer);
+    }
+    const usage = (b.usage ?? {});
+    const billingOff = b.billing_enabled === false;
+    const next = nexts(...(billingOff
+        ? [["promigence me", "your limits, concurrency and trial credit"]]
+        : b.card_on_file
+            ? [["promigence billing portal", "the card on file and past invoices"]]
+            : [["promigence billing card", "an owner adds a card (nothing is charged now)"]]), ...(moreLedger.length ? moreLedger : [["promigence billing usage --ledger", "this key's project's metered rows"]]));
+    const plan = planName(me, b);
+    const onTrial = (b.trial?.on_trial ?? me?.trial?.on_trial) === true;
+    const env = okEnvelope(ctx.cmd.name, {
+        plan: plan ?? null,
+        billing_plan: b.plan ?? null,
+        period: b.period ?? null,
+        usage,
+        card_on_file: b.card_on_file ?? false,
+        ...(b.card ? { card: b.card } : {}),
+        ...(b.card_note ? { card_note: b.card_note } : {}),
+        ...(b.trial ? { trial: b.trial } : {}),
+        ...(b.suspended ? { suspended: true, suspend_reason: b.suspend_reason ?? null } : {}),
+        upcoming_invoice: b.upcoming_invoice ?? null,
+        ...(b.upcoming_invoice_error ? { upcoming_invoice_error: b.upcoming_invoice_error } : {}),
+        ...(wantLedger ? { ledger: entries, next_cursor: page?.nextCursor ?? null } : {}),
+    }, next);
+    const period = b.period?.start ? `${b.period.start.slice(0, 10)} → ${(b.period.end ?? "").slice(0, 10)}` : "this month";
+    const lines = [`promigence billing usage: ${usd(usage.total)} (${period}, plan ${plan ?? "?"}${onTrial ? ", on the trial" : ""})`];
+    const detail = (row) => `${usd(row.amount)}${row.seconds === undefined ? "" : ` · ${row.seconds}s`}${row.count === undefined ? "" : ` · ${row.count}`}` +
+        `${row.gib === undefined ? "" : ` · ${row.gib} GiB`}${row.entries === undefined ? "" : ` · ${row.entries} entries`}` +
+        `${row.episodes === undefined ? "" : ` · ${row.episodes} episodes`}`;
+    for (const [k, v] of Object.entries(usage)) {
+        if (k === "total" || v === null || typeof v !== "object")
+            continue;
+        const row = v;
+        if (row.amount === undefined) {
+            for (const [name, inner] of Object.entries(row)) {
+                if (inner === null || typeof inner !== "object")
+                    continue;
+                const r = inner;
+                if (!r.amount && !r.seconds && !r.count && !r.entries && !r.episodes)
+                    continue;
+                lines.push(`  ${k} ${name}: ${detail(r)}`);
+            }
+            continue;
+        }
+        if (!row.amount && !row.count && !row.gib)
+            continue;
+        lines.push(`  ${k}: ${detail(row)}`);
+    }
+    if (typeof usage["credits_applied"] === "number" && usage["credits_applied"] > 0) {
+        lines.push(`  paid by trial credits: ${usd(usage["credits_applied"])} · to the card: ${usd(usage["billable"])}`);
+    }
+    const trial = b.trial;
+    if (trial?.credits_remaining !== undefined)
+        lines.push(`  trial credits left: ${usd(trial.credits_remaining)}`);
+    lines.push(`  card: ${b.card_on_file ? paymentMethodText(b.card) : `none on file${billingOff ? " (card payments are not open yet)" : ""}`}`);
+    if (b.card_note)
+        lines.push(`  ${b.card_note}`);
+    if (b.upcoming_invoice?.amount_due !== undefined && b.upcoming_invoice?.amount_due !== null) {
+        lines.push(`  next invoice: ${usd(b.upcoming_invoice.amount_due)}`);
+    }
+    else if (b.upcoming_invoice_error) {
+        lines.push(`  next invoice: not available (${b.upcoming_invoice_error})`);
+    }
+    if (b.suspended)
+        lines.push(`  SUSPENDED: ${b.suspend_reason ?? "see promigence billing card"}`);
+    for (const e of entries) {
+        lines.push(`  ${e.created_at ?? ""} ${e.kind}${e.tier ? ` ${e.tier}` : ""} ${usd(e.amount)}${e.seconds ? ` · ${e.seconds}s` : ""}${e.run_id ? ` · ${e.run_id}` : ""}`);
+    }
+    if (wantLedger && !entries.length)
+        lines.push("  (no metered rows in this period)");
+    if (page?.nextCursor)
+        lines.push(`  more: --cursor ${page.nextCursor}`);
+    return emit(ctx.mode, env, lines, 0, ctx.pointer);
+};
+const billingPortal = async (ctx) => {
+    const res = await client(ctx).billing.portal();
+    const next = nexts(["promigence billing usage", "this month's spend without leaving the terminal"]);
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { url: res.url }, next), ["promigence billing portal: open this page to manage the card and past invoices:", `  ${res.url}`], 0, ctx.pointer);
+};
+const HISTORY_KINDS = ["all", "credits", "payments"];
+const CREDIT_WHAT = {
+    free_credit: "Free credit",
+    card_bonus: "Card bonus",
+    referral: "Referral reward",
+    plan: "Included with your plan",
+    from_promigence: "Credit from Promigence",
+    service_restart: "Credit for a service restart",
+    confirmation_credit: "Credit for the $1 confirmation",
+};
+const CREDIT_ENDED = { used: "used", expired: "expired", taken_back: "taken back" };
+const PAYMENT_WHAT = {
+    invoice_paid: "Invoice paid",
+    payment_failed: "Payment failed",
+    refund: "Refund",
+};
+const PAYMENT_STATUS = {
+    paid: "paid",
+    retrying: "will be retried",
+    failed: "not paid",
+    refunded: "refunded",
+    confirmed: "confirmed",
+};
+const wordFor = (m, k) => k && Object.prototype.hasOwnProperty.call(m, k) ? m[k] : undefined;
+const unpaid = (status) => status === "retrying" || status === "failed";
+export function historyLines(entries) {
+    return entries.map((e) => {
+        const day = (e.at ?? "").slice(0, 10);
+        const c = e.credit;
+        if (c) {
+            const state = wordFor(CREDIT_ENDED, c.status) ??
+                `${usd(c.remaining_usd)} left, ${c.expires_at ? `expires ${c.expires_at.slice(0, 10)}` : "no expiry"}`;
+            return `  ${day}  ${wordFor(CREDIT_WHAT, c.kind) ?? "Credit"}  ${usd(c.granted_usd)}  ${state}`;
+        }
+        const p = e.payment;
+        if (!p)
+            return `  ${day}  (a row this version cannot show: see --json)`;
+        const check = p.kind === "method_check";
+        const what = check
+            ? `$${Number.isInteger(p.amount_usd) ? String(p.amount_usd) : p.amount_usd.toFixed(2)} to confirm ${p.method || "your payment method"}`
+            : (wordFor(PAYMENT_WHAT, p.kind) ?? "Payment");
+        const detail = [p.plan ? `${p.plan} plan` : null, p.invoice_number ? `invoice ${p.invoice_number}` : null]
+            .filter(Boolean)
+            .join(", ");
+        const status = check && p.status === "failed" ? "failed" : (wordFor(PAYMENT_STATUS, p.status) ?? p.status);
+        const url = typeof p.invoice_url === "string" && p.invoice_url.startsWith("https://") ? p.invoice_url : null;
+        const link = url && !check ? ` · ${unpaid(p.status) ? "pay at" : "receipt"} ${url}` : "";
+        return `  ${day}  ${what}${detail ? ` (${detail})` : ""}  ${usd(p.amount_usd)}  ${status}${link}`;
+    });
+}
+const billingHistory = async (ctx) => {
+    const kind = str(ctx, "--kind") ?? "all";
+    if (!HISTORY_KINDS.includes(kind)) {
+        throw usageError(`--kind: '${kind}' is not a kind`, `Pass one of ${HISTORY_KINDS.join(" | ")}.`);
+    }
+    const limit = limitOf(ctx, 50, 100);
+    const cursor = str(ctx, "--cursor");
+    const page = await client(ctx).billing.historyPage({
+        kind: kind,
+        limit,
+        ...(cursor === undefined ? {} : { cursor }),
+    });
+    const entries = page.items;
+    const more = page.nextCursor;
+    const owed = entries.some((e) => e.payment && e.payment.kind !== "method_check" && unpaid(e.payment.status));
+    const next = nexts(...(more
+        ? [[`${sh `promigence billing history --limit ${String(limit)}`}${kind === "all" ? "" : sh ` --kind ${kind}`}${sh ` --cursor ${more}`}`, "the next page"]]
+        : []), ...(owed
+        ? [["promigence billing portal", "pay the open invoice, or update the card on file"]]
+        : [["promigence billing usage", "this month's spend and credit"]]));
+    const empty = { all: "no credits or payments yet", credits: "no credit yet", payments: "no payments yet" };
+    const noun = kind === "all" ? "" : ` ${entries.length === 1 ? kind.slice(0, -1) : kind}`;
+    const lines = [
+        `promigence billing history: ${entries.length}${noun}, newest first`,
+        ...historyLines(entries),
+        ...(entries.length ? [] : [`  (${empty[kind]})`]),
+        ...(more ? [`  more: --cursor ${more}`] : []),
+    ];
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { kind, entries, count: entries.length, next_cursor: more }, next), lines, 0, ctx.pointer);
+};
+const referrals = async (ctx) => {
+    const r = await client(ctx).billing.referrals();
+    const next = r.code
+        ? nexts(["promigence login --ref " + r.code, "what a friend runs to sign up with your code"])
+        : nexts(["promigence billing usage", "this month's spend and credits"]);
+    const lines = [];
+    if (r.program !== "on" || !r.code || !r.offer) {
+        lines.push("promigence referrals: no referral offer is running right now");
+    }
+    else {
+        const o = r.offer;
+        lines.push(`promigence referrals: ${o.headline}`);
+        lines.push(`  your code: ${r.code}  (a friend signs up with: ${sh `promigence login --ref ${r.code}`})`);
+        lines.push(`  they get ${usd(o.give_usd)} of compute credit when they pay their first plan invoice` +
+            `${o.qualifying_plans.length ? ` on ${o.qualifying_plans.join(" / ")}` : ""}; you get ${usd(o.get_usd)} ` +
+            `${o.hold_days > 0 ? `${o.hold_days} day(s) later` : "then"}`);
+        if (o.credit_expiry_days !== null)
+            lines.push(`  credit lasts ${o.credit_expiry_days} day(s) from its grant`);
+        if (o.ends_at)
+            lines.push(`  offer ends ${o.ends_at}`);
+    }
+    const c = r.referrals;
+    lines.push(`  your referrals: ${c.pending} pending · ${c.held} on hold · ${c.rewarded} rewarded` +
+        `${c.under_review ? ` · ${c.under_review} under review` : ""}${c.other ? ` · ${c.other} other` : ""} · earned ${usd(r.earned_usd)}`);
+    if (r.referred_by) {
+        lines.push(`  you were referred: ${r.referred_by.status} (${usd(r.referred_by.reward_usd)} of credit)`);
+    }
+    for (const e of r.expiring_credits) {
+        lines.push(`  credit expiring ${e.expires_at}: ${usd(e.remaining_usd)} left of ${usd(e.granted_usd)}`);
+    }
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { ...r }, next), lines, 0, ctx.pointer);
+};
+const referralsApply = async (ctx) => {
+    const code = positional(ctx, "a referral code", "promigence referrals apply K7QM2XPD");
+    const r = await client(ctx).billing.applyReferral(code);
+    const next = nexts(["promigence referrals", "how the referral stands"]);
+    const lines = r.status === "under_review"
+        ? [`promigence referrals apply: ${r.code} recorded; it is being checked before any credit is granted`]
+        : [
+            `promigence referrals apply: ${r.code} applied`,
+            `  you get ${usd(r.reward_usd)} of compute credit when you pay your first plan invoice` +
+                `${r.qualifying_plans.length ? ` on ${r.qualifying_plans.join(" / ")}` : ""}`,
+        ];
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { ...r }, next), lines, 0, ctx.pointer);
+};
+const snapshotDelete = async (ctx) => {
+    const arg = positional(ctx, "a snapshot", "promigence snapshot delete snap_01");
+    const res = await client(ctx).snapshots.delete(arg);
+    const next = nexts(["promigence snapshot list", "what is left in your catalogue"]);
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { snapshot_id: res.snapshot_id, alias: res.alias ?? null, deleted: true }, next), [
+        `snapshot ${res.snapshot_id}${res.alias ? ` (${res.alias})` : ""}: deleted`,
+        "  the record is gone; finished runs keep their reports",
+    ], 0, ctx.pointer);
+};
+export function buildAliasNote(b) {
+    if (b.snapshot_deleted === true)
+        return " (deleted)";
+    return b.alias ? ` (${b.alias})` : "";
+}
+function stateFlag(ctx, states) {
+    const wanted = str(ctx, "--state");
+    if (wanted !== undefined && !states.includes(wanted)) {
+        throw usageError(`--state: '${wanted}' is not a state`, `Pass one of ${states.join(" | ")}.`);
+    }
+    return wanted;
+}
+const BUILD_STATES = ["queued", "running", "verified", "built", "rejected", "failed"];
+const RUN_STATES = ["running", "completed", "cap_killed", "aborted"];
+const snapshotBuilds = async (ctx) => {
+    const wanted = stateFlag(ctx, BUILD_STATES);
+    const limit = limitOf(ctx, 20, 500);
+    const cursor = str(ctx, "--cursor");
+    const page = await client(ctx).snapshots.buildsPage({ limit: wanted === undefined ? limit : 500, ...(cursor === undefined ? {} : { cursor }) });
+    const matched = wanted === undefined ? page.items : page.items.filter((b) => b.state === wanted);
+    const builds = matched.slice(0, limit);
+    const more = builds.length === matched.length ? page.nextCursor : null;
+    const next = nexts(...(more ? [[`${sh `promigence snapshot builds --limit ${String(limit)}`}${wanted ? sh ` --state ${wanted}` : ""}${sh ` --cursor ${more}`}`, "the next page"]] : []), ...(builds.length ? [[sh `promigence snapshot status ${builds[0].build_id} --log 40`, "the newest build, with the tail of its log"]] : []));
+    const lines = [
+        `promigence snapshot builds: ${builds.length}${wanted ? ` in state ${wanted}` : ""}`,
+        ...builds.map((b) => `  ${b.build_id}  ${b.state}  ${b.snapshot_id ?? "—"}${buildAliasNote(b)}${b.error?.code ? `  ${b.error.code}` : ""}`),
+        ...(builds.length ? [] : ["  (no builds)"]),
+        ...(more ? [`  more: --cursor ${more}`] : []),
+    ];
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { builds, count: builds.length, next_cursor: more }, next), lines, 0, ctx.pointer);
+};
+const snapshotAlias = async (ctx) => {
+    const arg = positional(ctx, "a snapshot", "promigence snapshot alias snap_ab12 opencode");
+    const clear = bool(ctx, "--clear");
+    const name = ctx.args[1];
+    if (!clear && !name) {
+        const rec = await client(ctx).snapshots.get(arg);
+        const alias = rec.alias ?? null;
+        const id = rec.snapshot_id ?? arg;
+        const next = nexts([sh `promigence snapshot alias ${id} NAME`, alias ? "rename it" : "name it"]);
+        return emit(ctx.mode, okEnvelope(ctx.cmd.name, { snapshot_id: id, alias }, next), [`snapshot ${id}: ${alias ? `alias ${alias}` : "no alias"}`], 0, ctx.pointer);
+    }
+    if (clear && name) {
+        throw usageError("--clear takes no name", `Use either ${sh `promigence snapshot alias ${arg} NAME`} or ${sh `promigence snapshot alias ${arg} --clear`}.`);
+    }
+    const res = await client(ctx).snapshots.alias(arg, clear ? null : name);
+    const next = nexts(["promigence snapshot list", "your snapshots and their names"]);
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { snapshot_id: res.snapshot_id, alias: res.alias ?? null }, next), [`snapshot ${res.snapshot_id}: ${clear ? "alias cleared" : `alias ${res.alias}`}`], 0, ctx.pointer);
+};
+const runList = async (ctx) => {
+    const wanted = stateFlag(ctx, RUN_STATES);
+    const limit = limitOf(ctx, 20, 500);
+    const cursor = str(ctx, "--cursor");
+    const page = await client(ctx).runs.listPage({ limit: wanted === undefined ? limit : 500, ...(cursor === undefined ? {} : { cursor }) });
+    const matched = wanted === undefined ? page.items : page.items.filter((r) => r.state === wanted);
+    const runs = matched.slice(0, limit);
+    const more = runs.length === matched.length ? page.nextCursor : null;
+    const next = nexts(...(more ? [[`${sh `promigence run list --limit ${String(limit)}`}${wanted ? sh ` --state ${wanted}` : ""}${sh ` --cursor ${more}`}`, "the next page"]] : []), ...(runs.length ? [[sh `promigence run report ${runs[0].run_id}`, "the newest run's validity report"]] : []));
+    const lines = [
+        `promigence run list: ${runs.length}${wanted ? ` in state ${wanted}` : ""}`,
+        ...runs.map((r) => `  ${r.run_id}  ${r.state}  ${r.count ?? "?"}×  ${r.snapshot_id || r.snapshot || "—"}  ${r.started_at ?? ""}`),
+        ...(runs.length ? [] : ["  (no runs)"]),
+        ...(more ? [`  more: --cursor ${more}`] : []),
+    ];
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { runs, count: runs.length, next_cursor: more }, next), lines, 0, ctx.pointer);
+};
+function labelsOf(ctx) {
+    const out = {};
+    for (const raw of list(ctx, "--label")) {
+        const at = raw.indexOf("=");
+        if (at <= 0) {
+            throw usageError(`--label ${JSON.stringify(raw)} is not KEY=VALUE`, "Write it as --label session=abc, and repeat the flag for a second label.");
+        }
+        const k = raw.slice(0, at);
+        if (k in out) {
+            throw usageError(`--label names ${JSON.stringify(k)} twice`, "A sandbox holds one value per key, so the second could only ever match nothing.");
+        }
+        if (raw.includes(",")) {
+            throw usageError(`--label ${JSON.stringify(raw)} contains a comma`, "A label value cannot hold a comma; that is the separator on the wire.");
+        }
+        out[k] = raw.slice(at + 1);
+    }
+    return out;
+}
+const HELD_STATES = ["queued", "placing", "ready", "running", "paused"];
+export function pauseReasonText(reason) {
+    if (reason === "spend_cap")
+        return "spend cap reached";
+    if (reason === "credits_exhausted")
+        return "out of credits";
+    return undefined;
+}
+const sandboxList = async (ctx) => {
+    const labels = labelsOf(ctx);
+    const states = list(ctx, "--state").flatMap((s) => s.split(",")).map((s) => s.trim()).filter(Boolean);
+    const cursor = str(ctx, "--cursor");
+    const page = await client(ctx).sandboxes.listPage({
+        limit: limitOf(ctx, 50),
+        ...(Object.keys(labels).length ? { labels } : {}),
+        ...(states.length ? { state: states } : {}),
+        ...(cursor === undefined ? {} : { cursor }),
+    });
+    const sandboxes = page.items;
+    let held;
+    if (!states.length && cursor === undefined && page.nextCursor) {
+        const live = await client(ctx).sandboxes.listPage({
+            limit: 200,
+            ...(Object.keys(labels).length ? { labels } : {}),
+            state: [...HELD_STATES],
+        }).catch(() => undefined);
+        if (live) {
+            const onPage = new Set(sandboxes.map((s) => s.sandbox_id));
+            const count = live.items.filter((s) => !onPage.has(s.sandbox_id)).length;
+            if (count > 0)
+                held = { count, atLeast: live.nextCursor !== null };
+        }
+    }
+    const heldCmd = sh `promigence sandbox list --state ${HELD_STATES.join(",")}`;
+    const firstLive = sandboxes.find((s) => s.state !== "ended");
+    const next = nexts(...(held ? [[heldCmd, "the sandboxes still held (live or paused) that this page does not show"]] : []), ...(sandboxes.length ? [[sh `promigence sandbox info ${sandboxes[0].sandbox_id}`, "one sandbox: its run, its state and the execs it has run"]] : []), ...(page.nextCursor
+        ? [[sh `promigence sandbox list --cursor ${page.nextCursor}`, "the next page"]]
+        : []), ...(firstLive ? [["promigence sandbox kill SID", "end one: put its id from this list in place of SID"]] : []));
+    const shown = Object.entries(labels).map(([k, v]) => `${k}=${v}`).join(" ");
+    const lines = [
+        `promigence sandbox list: ${sandboxes.length}${states.length ? ` in state ${states.join(",")}` : ""}${shown ? ` with ${shown}` : ""}`,
+        ...sandboxes.map((s) => {
+            const why = pauseReasonText(s.pause_reason);
+            return `  ${s.sandbox_id}  ${s.state}${why ? ` (${why})` : ""}${s.outcome ? ` (${s.outcome})` : ""}  ${s.run_id ?? ""}`;
+        }),
+        ...(sandboxes.length ? [] : ["  (no sandboxes)"]),
+        ...(page.nextCursor ? [`  more: --cursor ${page.nextCursor}`] : []),
+        ...(held ? [`  ${held.atLeast ? "at least " : ""}${held.count} live or paused not on this page: ${heldCmd}`] : []),
+    ];
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, {
+        sandboxes, count: sandboxes.length, labels, state: states,
+        limit: page.limit, next_cursor: page.nextCursor,
+        ...(held ? { held_not_shown: held.count, ...(held.atLeast ? { held_not_shown_at_least: true } : {}) } : {}),
+    }, next), lines, 0, ctx.pointer);
+};
+const imageResolve = async (ctx) => {
+    const ref = positional(ctx, "an image reference", "promigence image resolve python:3.12");
+    const secret = str(ctx, "--registry-secret");
+    const r = await client(ctx).images.resolve(ref, ...(secret ? [{ registrySecret: secret }] : []));
+    const lines = [
+        r.already_pinned
+            ? `${ref} is already pinned`
+            : `${ref}  ->  ${r.image}`,
+        `  digest      ${r.digest}`,
+        ...(r.platform_digest ? [`  ${r.platform} ${r.platform_digest}`] : []),
+        ...(r.platforms.length ? [`  platforms   ${r.platforms.join(", ")}`] : []),
+    ];
+    const next = nexts([
+        sh `promigence snapshot create --image ${r.image} --tier small`,
+        "build a snapshot from the pinned image",
+    ]);
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, r, next), lines, 0, ctx.pointer);
+};
+function runFacts(run) {
+    if (!run)
+        return {};
+    const q = (run["quote"] ?? {});
+    return {
+        ...(typeof run["tier"] === "string" ? { tier: run["tier"] } : {}),
+        ...(typeof q.vcpus === "number" ? { vcpus: q.vcpus } : {}),
+        ...(typeof q.mem_gib === "number" ? { memGib: q.mem_gib } : {}),
+        ...(typeof q.per_second_usd === "number" ? { perSecond: q.per_second_usd } : {}),
+    };
+}
+export function sandboxFactLines(s, facts, nowMs = Date.now()) {
+    const out = [];
+    if (facts.tier) {
+        const shape = facts.vcpus !== undefined && facts.memGib !== undefined ? ` (${facts.vcpus} vCPU, ${facts.memGib} GiB)` : "";
+        out.push(`  tier ${facts.tier}${shape}`);
+    }
+    const handoff = typeof s["t_handoff"] === "string" ? Date.parse(s["t_handoff"]) : NaN;
+    const end = typeof s["t_end"] === "string" ? Date.parse(s["t_end"]) : NaN;
+    const timing = [];
+    if (Number.isFinite(handoff)) {
+        timing.push(Number.isFinite(end)
+            ? `ran ${span((end - handoff) / 1000)}`
+            : `started ${span((nowMs - handoff) / 1000)} ago`);
+    }
+    const timeout = typeof s["timeout_ms"] === "number" ? s["timeout_ms"] : undefined;
+    const elapsed = typeof s["elapsed_ms"] === "number" ? s["elapsed_ms"] : undefined;
+    if (timeout !== undefined && elapsed !== undefined && s["state"] !== "ended") {
+        timing.push(`${span((timeout - elapsed) / 1000)} left of ${span(timeout / 1000)} (paused time does not count)`);
+    }
+    else if (timeout !== undefined && s["state"] !== "ended") {
+        timing.push(`timeout ${span(timeout / 1000)}`);
+    }
+    if (timing.length)
+        out.push(`  ${timing.join(" · ")}`);
+    if (elapsed !== undefined && facts.perSecond !== undefined) {
+        const secs = Math.ceil(elapsed / 1000);
+        const rate = `$${facts.perSecond.toFixed(9).replace(/0+$/, "").replace(/\.$/, "")}`;
+        out.push(`  cost so far: about ${usd(secs * facts.perSecond)} (${secs} s at ${rate}/s)`);
+    }
+    return out;
+}
+export function supportStopLines(s) {
+    if (s.outcome !== "stopped_by_support")
+        return [];
+    const message = s.failure?.message;
+    return [`  ${typeof message === "string" && message.trim() ? message : "Stopped by Promigence support"}`];
+}
+const sandboxInfo = async (ctx) => {
+    const sid = positional(ctx, "a sandbox id", "promigence sandbox info sbx_01");
+    const c = client(ctx);
+    const s = await c.sandboxes.get(sid);
+    const run = s.run_id ? await c.runs.get(s.run_id).catch(() => undefined) : undefined;
+    const facts = runFacts(run);
+    const execs = (s.execs ?? []);
+    const ended = s.state === "ended";
+    const why = pauseReasonText(s.pause_reason);
+    const limitNext = s.pause_reason === "spend_cap"
+        ? [[sh `promigence sandbox resume ${sid} --cap USD`, "raise its run's cap and go on (paused time is not billed)"]]
+        : s.pause_reason === "credits_exhausted"
+            ? [["promigence billing card", "add a card, then resume it"], [sh `promigence sandbox resume ${sid}`, "go on once credits are added"]]
+            : [];
+    const next = nexts(...limitNext, ...(execs.length ? [[sh `promigence exec output ${execs[execs.length - 1].exec_id} --sandbox ${sid}`, "what its last command printed"]] : []), ...(ended
+        ? (s.run_id ? [[sh `promigence run report ${s.run_id} --sandbox ${sid}`, "how it ended, in its run's report"]] : [])
+        : why ? [] : [[sh `promigence exec --sandbox ${sid} -- CMD`, "run something in it"]]));
+    const lines = [
+        `sandbox ${sid}: ${s.state}${why ? ` (${why})` : ""}${s.outcome ? ` (${s.outcome})` : ""}${s.run_id ? ` · run ${s.run_id}` : ""}`,
+        ...supportStopLines(s),
+        ...(why ? ["  its files and state are kept, and paused time is not billed"] : []),
+        ...queuedLines([s]),
+        ...(s.snapshot_id ? [`  snapshot ${s.snapshot_id}`] : []),
+        ...sandboxFactLines(s, facts),
+        ...(ended && typeof s["cost_usd"] === "number"
+            ? [`  billed ${s["billable_seconds"] ?? 0} s · $${s["cost_usd"]}`]
+            : []),
+        ...(Number(s.auto_pause_s ?? 0) > 0 ? [`  pauses itself after ${s.auto_pause_s} s idle`] : []),
+        ...execs.map((e) => `  ${e.exec_id}  exit ${e.exit_code ?? "—"}  ${(e.argv ?? []).join(" ")}`),
+        ...(execs.length ? [] : ["  (no execs recorded)"]),
+    ];
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, {
+        sandbox: s,
+        ...(facts.tier ? { tier: facts.tier } : {}),
+        ...(facts.perSecond !== undefined && typeof s.elapsed_ms === "number"
+            ? { cost_so_far_usd: Math.round(Math.ceil(s.elapsed_ms / 1000) * facts.perSecond * 1e6) / 1e6 }
+            : {}),
+        ...(ended && typeof s["cost_usd"] === "number"
+            ? { cost_usd: s["cost_usd"], billable_seconds: s["billable_seconds"] }
+            : {}),
+    }, next), lines, 0, ctx.pointer);
+};
+const sandboxPause = async (ctx) => {
+    const sid = positional(ctx, "a sandbox id", "promigence sandbox pause sbx_01");
+    const res = await client(ctx).sandboxes.pause(sid);
+    const next = nexts([sh `promigence sandbox resume ${sid}`, "bring it back and restart the clock"]);
+    const bytes = res.bytes;
+    const took = res.took_ms;
+    const killed = Number(res["background_execs_killed"] ?? 0);
+    const lines = [
+        `sandbox ${sid}: paused${res.already_paused ? " (already was)" : ""}`,
+        "  it holds no capacity and bills no seconds while parked",
+        ...(took === undefined ? [] : [`  took ${ms(took)}`]),
+        ...(bytes?.allocated === undefined ? [] : [`  parked image: ${Math.round(bytes.allocated / 1048576)} MiB`]),
+        ...(killed > 0 ? [`  ended ${killed} background process${killed === 1 ? "" : "es"} (started with exec --background)`] : []),
+        ...(res.warnings ?? []).map((w) => `  warning: ${w}`),
+    ];
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { ...res, sandbox_id: sid, state: "paused" }, next), lines, 0, ctx.pointer);
+};
+const sandboxResume = async (ctx) => {
+    const sid = positional(ctx, "a sandbox id", "promigence sandbox resume sbx_01");
+    const optimizeFor = optimizeForFlag(ctx);
+    const cap = str(ctx, "--cap");
+    const res = await client(ctx).sandboxes.resume(sid, {
+        ...(optimizeFor === undefined ? {} : { optimizeFor }),
+        ...(cap === undefined ? {} : { spendCap: parseUsd(cap, "--cap") }),
+    });
+    const next = nexts([sh `promigence exec --sandbox ${sid} -- CMD`, "run something in it"]);
+    const took = res.took_ms;
+    const lines = [
+        `sandbox ${sid}: ${res.state ?? "ready"}`,
+        ...(took === undefined ? [] : [`  took ${ms(took)}`]),
+    ];
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { ...res, sandbox_id: sid }, next), lines, 0, ctx.pointer);
+};
+const sandboxSnapshot = async (ctx) => {
+    const sid = positional(ctx, "a sandbox id", "promigence sandbox snapshot sbx_01");
+    const alias = str(ctx, "--alias");
+    const force = bool(ctx, "--force");
+    const moveAlias = bool(ctx, "--move-alias");
+    if (moveAlias && !alias) {
+        throw usageError("--move-alias needs --alias", `Name the alias to take: ${sh `promigence sandbox snapshot ${sid} --alias NAME --move-alias`}.`);
+    }
+    const res = await client(ctx).sandboxes.snapshot(sid, {
+        ...(alias ? { alias } : {}),
+        ...(force ? { force: true } : {}),
+        ...(moveAlias ? { moveAlias: true } : {}),
+    });
+    const next = nexts([`${sh `promigence run --snapshot ${res.snapshot_id} --count 1 --cap 1`} -- CMD`, "run something on the copy"]);
+    const bytes = res.bytes;
+    const took = res.took_ms;
+    const killed = Number(res.background_execs_killed ?? 0);
+    const lines = [
+        `snapshot ${res.snapshot_id}${res.alias ? ` (${res.alias})` : ""}`,
+        `  sandbox ${sid} is still running`,
+        ...(alias && !res.alias ? [`  alias ${alias} was taken by another snapshot meanwhile; this one is unnamed (\`${sh `promigence snapshot alias ${res.snapshot_id}`} NAME\`)`] : []),
+        ...(bytes?.allocated === undefined ? [] : [`  image: ${Math.round(bytes.allocated / 1048576)} MiB`]),
+        ...(took === undefined ? [] : [`  took ${ms(took)}`]),
+        ...(killed ? [`  ended ${killed} background process${killed === 1 ? "" : "es"} to take it`] : []),
+        ...(res.warnings ?? []).map((w) => `  warning: ${w}`),
+    ];
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { ...res, sandbox_id: sid }, next), lines, 0, ctx.pointer);
+};
+const sandboxExtend = async (ctx) => {
+    const sid = positional(ctx, "a sandbox id", "promigence sandbox extend sbx_01 --timeout 30m");
+    const timeoutMs = parseDuration(required(ctx, "--timeout", "Pass --timeout DUR — the sandbox's new total timeout, e.g. --timeout 30m."), "--timeout");
+    const res = await client(ctx).sandboxes.patch(sid, { timeoutMs });
+    const cost = res.cost;
+    const next = nexts([sh `promigence sandbox info ${sid}`, "the sandbox as it stands now"]);
+    const lines = [
+        `sandbox ${sid}: timeout now ${duration(timeoutMs)} (${res.committed_seconds ?? "?"} s committed)`,
+        ...(cost?.added === undefined ? [] : [`  this extension commits ${usd(cost.added)}; ${usd(cost.remaining)} left under the cap`]),
+    ];
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { ...res, sandbox_id: sid, timeout_ms: timeoutMs }, next), lines, 0, ctx.pointer);
+};
+const sandboxAutopause = async (ctx) => {
+    const sid = positional(ctx, "a sandbox id", "promigence sandbox autopause sbx_01 --after 15m");
+    const after = str(ctx, "--after");
+    const off = bool(ctx, "--off");
+    if (after !== undefined && off) {
+        throw usageError("--after and --off ask for opposite things", "Pass one: --after DUR sets the idle window, --off removes it, neither reads it.");
+    }
+    const modeFlag = str(ctx, "--mode");
+    if (modeFlag !== undefined && modeFlag !== "requests" && modeFlag !== "activity") {
+        throw usageError(`--mode must be requests or activity, got ${JSON.stringify(modeFlag)}`, "Pass --mode activity for an agent that runs inside the sandbox, --mode requests for the default.");
+    }
+    const mode = modeFlag;
+    if (mode !== undefined && off) {
+        throw usageError("--mode and --off ask for opposite things", "--off removes the idle rule; --mode says what idle means under one.");
+    }
+    const rule = (s, m) => s > 0
+        ? `pauses itself after ${s} s idle${m === "activity" ? " (activity: no CPU, no bytes, no open connection)" : ""}`
+        : "never pauses itself on idle";
+    const next = nexts([sh `promigence sandbox info ${sid}`, "the sandbox as it stands now"]);
+    if (after === undefined && !off && mode === undefined) {
+        const s = await client(ctx).sandboxes.get(sid);
+        const secs = Number(s.auto_pause_s ?? 0);
+        const m = String(s.auto_pause_mode ?? "requests");
+        return emit(ctx.mode, okEnvelope(ctx.cmd.name, { sandbox_id: sid, auto_pause_s: secs, auto_pause_mode: m }, next), [`sandbox ${sid}: ${rule(secs, m)}`], 0, ctx.pointer);
+    }
+    const autoPauseS = after === undefined && !off ? undefined : off ? 0 : Math.round(parseDuration(after, "--after") / 1000);
+    const res = await client(ctx).sandboxes.patch(sid, {
+        ...(autoPauseS !== undefined ? { autoPauseS } : {}),
+        ...(mode !== undefined ? { autoPauseMode: mode } : {}),
+    });
+    const secs = Number(res.auto_pause_s ?? autoPauseS ?? 0);
+    const m = String(res.auto_pause_mode ?? mode ?? "requests");
+    const pausedNow = secs === 0
+        ? await client(ctx).sandboxes.get(sid).then((x) => x.state === "paused").catch(() => false)
+        : false;
+    const lines = [
+        `sandbox ${sid}: ${rule(secs, m)}`,
+        ...(secs > 0 ? [
+            "  a command still running counts as busy, so a long build is safe",
+            "  a finished background command keeps it awake for a short while after it ends (60 s by default), until its output is read (`promigence exec output X_ID --sandbox SID`) or it is forgotten (`promigence exec kill X_ID --sandbox SID --forget`)",
+        ] : []),
+        ...(pausedNow ? [`  it is paused now and stays paused until \`${sh `promigence sandbox resume ${sid}`}\`: with the rule off, a request no longer wakes it`] : []),
+    ];
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { ...res, sandbox_id: sid, auto_pause_s: secs, auto_pause_mode: m, ...(pausedNow ? { paused: true } : {}) }, pausedNow ? nexts([sh `promigence sandbox resume ${sid}`, "bring it back: with the rule off, a request no longer wakes it"]) : next), lines, 0, ctx.pointer);
+};
+const sandboxProbe = async (ctx) => {
+    const sid = positional(ctx, "a sandbox id", "promigence sandbox probe sbx_01");
+    const paths = list(ctx, "--path");
+    const res = await client(ctx).sandboxes.probe(sid, ...(paths.length ? [{ paths }] : []));
+    const ok = res.ok !== false;
+    const env = { ...okEnvelope(ctx.cmd.name, { ...res, sandbox_id: sid }, nexts([sh `promigence sandbox info ${sid}`, "the sandbox, its run and the commands it ran"])), ok };
+    const lines = [
+        `sandbox ${sid}: ${ok ? "matches the verified environment" : "DIFFERS from the verified environment"}`,
+        ...(res.first_bad_path ? [`  first difference at ${res.first_bad_path}`] : []),
+        ...(res.ms === undefined ? [] : [`  checked in ${ms(res.ms)}`]),
+    ];
+    return emit(ctx.mode, env, lines, ok ? 0 : 3, ctx.pointer);
+};
+const filesRm = async (ctx) => {
+    const path = positional(ctx, "a path", "promigence files rm /work/out.log --sandbox sbx_01");
+    if (!path.startsWith("/")) {
+        throw usageError(`'${path}' is not an absolute path`, "Paths inside a sandbox are absolute: promigence files rm /work/out.log --sandbox <sid>.");
+    }
+    const sid = required(ctx, "--sandbox", "Pass --sandbox sbx_<id> — the sandbox the path is in.");
+    const recursive = bool(ctx, "--recursive");
+    const res = await client(ctx).sandboxes.files.delete(sid, path, { recursive });
+    const next = nexts([sh `promigence files ls --sandbox ${sid}`, "what is left"]);
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { sandbox_id: sid, path, deleted: res.deleted, existed: res.existed, recursive }, next), [`${sid}:${path}: ${res.deleted ? "deleted" : "not deleted"}${res.existed === false ? " (it was not there)" : ""}`], 0, ctx.pointer);
+};
+const secretsList = async (ctx) => {
+    const { secrets } = await client(ctx).secrets.list();
+    const next = nexts(["promigence run --snapshot H --count N --cap USD --secret NAME -- CMD", "give one to every sandbox of a run"], ["promigence secrets set NAME --from-env VAR", "store or rotate one"]);
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { secrets, count: secrets.length }, next), [
+        `promigence secrets: ${secrets.length} stored`,
+        ...secrets.flatMap(secretListLines),
+        ...(secrets.length ? [] : ["  (none)"]),
+    ], 0, false);
+};
+const secretsDelete = async (ctx) => {
+    const name = positional(ctx, "a secret name", "promigence secrets delete OPENAI_API_KEY");
+    const res = await client(ctx).secrets.delete(name);
+    const next = nexts(["promigence secrets list", "what this org still has stored"]);
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { name: res.name, deleted: res.deleted, note: KEPT_BY_HOLDERS }, next), [`${sh `promigence secrets delete ${name}`}: removed`, KEPT_BY_HOLDERS], 0, false);
+};
+export const ACCOUNT_HANDLERS = {
+    me,
+    status,
+    "billing usage": billingUsage,
+    "billing portal": billingPortal,
+    "billing history": billingHistory,
+    referrals,
+    "referrals apply": referralsApply,
+    "snapshot delete": snapshotDelete,
+    "snapshot builds": snapshotBuilds,
+    "snapshot alias": snapshotAlias,
+    "run list": runList,
+    "image resolve": imageResolve,
+    "sandbox list": sandboxList,
+    "sandbox info": sandboxInfo,
+    "sandbox pause": sandboxPause,
+    "sandbox resume": sandboxResume,
+    "sandbox snapshot": sandboxSnapshot,
+    "sandbox extend": sandboxExtend,
+    "sandbox autopause": sandboxAutopause,
+    "sandbox probe": sandboxProbe,
+    "files rm": filesRm,
+    "secrets list": secretsList,
+    "secrets delete": secretsDelete,
+};