promigence 0.1.0-beta.12

package/dist/money.js

@@ -0,0 +1,5 @@
+export function usd(n) {
+    if (n === undefined || n === null || !Number.isFinite(n))
+        return "—";
+    return `$${n.toFixed(n < 0.01 && n > 0 ? 4 : 2)}`;
+}

package/dist/orgs.js

@@ -0,0 +1,475 @@
+import { hostname } from "node:os";
+import { PromigenceClient, PromigenceError, credentialsPath, readCredentials } from "./sdk/index.js";
+import { bool, clientOpts, nexts, str } from "./commands.js";
+import { emit, errorEnvelope, errorTextLines, exitWith, okEnvelope, recordNotice, usageError, write } from "./io.js";
+import { accessBody, accessNote, expiryBody, expiryLine, signIn, writeCredentials } from "./login.js";
+import { checkCredentialsPath, loginMintedKey, storedWhere } from "./credfile.js";
+import { sh, shellArg } from "./term.js";
+function client(ctx) {
+    return new PromigenceClient({ ...clientOpts(ctx), onNotice: recordNotice });
+}
+async function personClient(ctx) {
+    const { idToken, nonce, apiUrl } = await signIn(ctx);
+    const base = globalThis.fetch;
+    const fetchWithNonce = (input, init) => {
+        const headers = new Headers(init?.headers);
+        if (nonce)
+            headers.set("promigence-login-nonce", nonce);
+        return base(input, { ...init, headers, redirect: "manual" });
+    };
+    return new PromigenceClient({ apiKey: idToken, apiUrl, onNotice: recordNotice, fetch: fetchWithNonce });
+}
+const enc = encodeURIComponent;
+const orgTail = (ctx) => (str(ctx, "--org") ? ` --org ${shellArg(str(ctx, "--org"))}` : "");
+async function scoped(ctx) {
+    const k = client(ctx);
+    const flag = str(ctx, "--org");
+    let me;
+    try {
+        me = await k.request({ method: "GET", path: "/me" });
+    }
+    catch (e) {
+        if (flag)
+            return { c: await personClient(ctx), org: flag };
+        throw e;
+    }
+    if (!flag || flag === me.org_id || flag === me.org)
+        return { c: k, org: flag ?? me.org_id };
+    return { c: await personClient(ctx), org: flag };
+}
+async function managing(ctx) {
+    let org = str(ctx, "--org");
+    if (!org) {
+        const me = await client(ctx).request({ method: "GET", path: "/me" });
+        org = me.org_id;
+    }
+    return { c: await personClient(ctx), org };
+}
+export async function projectKeyClient(ctx, project) {
+    const { c: person, org } = await managing(ctx);
+    const minting = person.request({
+        method: "POST", path: `/orgs/${enc(org)}/keys`, body: { name: `cli-keys@${hostname()}`.slice(0, 64), project, expires_in_minutes: 15 },
+    });
+    const keyClient = (k) => new PromigenceClient({ ...clientOpts(ctx), apiKey: k.api_key, apiUrl: person.apiUrl, onNotice: recordNotice });
+    const left = (id, why) => `the short-lived key ${id} this command minted in ${project} was not revoked (${why}); revoke it with \`promigence keys revoke ${shellArg(id)} --project ${shellArg(project)}${orgTail(ctx)}\``;
+    let revoking;
+    const revoke = (k) => (revoking ??= (async () => {
+        try {
+            await keyClient(k).request({ method: "DELETE", path: `/keys/${enc(k.key_id)}` });
+            return undefined;
+        }
+        catch (e) {
+            return left(k.key_id, e.message);
+        }
+    })());
+    let interrupted = false;
+    const onSignal = (sig) => {
+        if (interrupted) {
+            void write(process.stderr, `promigence ${ctx.cmd.name}: interrupted again; the short-lived key may still be live: check \`promigence keys list --project ${shellArg(project)}${orgTail(ctx)}\`\n`)
+                .then(() => exitWith(130));
+            return;
+        }
+        interrupted = true;
+        void (async () => {
+            let outcome;
+            try {
+                const k = await minting;
+                outcome = (await revoke(k)) ?? `the short-lived key ${k.key_id} was revoked`;
+            }
+            catch {
+                outcome = "no short-lived key was made";
+            }
+            const check = `promigence keys list --project ${shellArg(project)}${orgTail(ctx)}`;
+            const err = new PromigenceError({ code: "aborted_by_client", message: `interrupted by ${sig}; ${outcome}`, fix: `Nothing to fix; \`${check}\` shows the keys that still work there.`, exitCode: 130 });
+            const next = nexts([check, "the keys that still work there"]);
+            await emit(ctx.mode, errorEnvelope(ctx.cmd.name, err, next), [`promigence ${ctx.cmd.name}: interrupted by ${sig} (exit 130)`, `  ${outcome}`], 130, false);
+        })();
+    };
+    const signals = ["SIGINT", "SIGTERM", "SIGHUP"].map((sig) => [sig, () => onSignal(sig)]);
+    for (const [sig, h] of signals)
+        process.on(sig, h);
+    const settle = async () => {
+        if (interrupted)
+            await new Promise(() => { });
+        for (const [sig, h] of signals)
+            process.off(sig, h);
+    };
+    let k;
+    try {
+        k = await minting;
+    }
+    catch (e) {
+        await settle();
+        throw e;
+    }
+    const done = async () => {
+        const warning = await revoke(k);
+        await settle();
+        return warning;
+    };
+    return { c: keyClient(k), keyId: k.key_id, org, done };
+}
+function arg(ctx, i, what, example) {
+    const v = ctx.args[i];
+    if (!v)
+        throw usageError(`${ctx.cmd.name} needs ${what}`, `Example: ${example}.`);
+    return v;
+}
+function role(ctx, v, fallback) {
+    const r = v ?? fallback;
+    if (r !== "owner" && r !== "member") {
+        throw usageError(`the role must be owner or member, not ${JSON.stringify(r ?? "")}`, `See 'promigence ${ctx.cmd.name} --help'.`);
+    }
+    return r;
+}
+const orgLine = (o) => `  ${o.default ? "*" : " "} ${o.name.padEnd(24)} ${o.org_id}  ${o.role.padEnd(6)}  ${o.members} member${o.members === 1 ? "" : "s"}, ${o.projects} project${o.projects === 1 ? "" : "s"}${o.card_on_file ? "" : "  (no card)"}`;
+const memberLine = (m) => `  ${m.email.padEnd(32)} ${m.user_id}  ${m.role}${m.you ? "  (you)" : ""}`;
+const inviteLine = (i) => `  ${i.invite_id}  ${i.email}  as ${i.role}  to ${i.org_name}  from ${i.invited_by}  ${i.created_at}`;
+const projectLine = (p) => `  ${p.name.padEnd(24)} ${p.project_id}  ${p.keys} key${p.keys === 1 ? "" : "s"}${p.month_spend_usd == null ? "" : `  $${p.month_spend_usd.toFixed(2)} in ${p.month}`}${p.monthly_cap_usd == null ? "" : `  cap $${p.monthly_cap_usd}/month`}${p.default ? "  (default)" : ""}`;
+const auditLine = (e) => `  ${String(e.seq).padStart(6)}  ${e.at}  ${e.action.padEnd(20)} ${e.actor}  ${e.target_type}:${e.target_id}${e.outcome === "ok" ? "" : `  (${e.outcome})`}`;
+const orgList = async (ctx) => {
+    const all = bool(ctx, "--all");
+    const c = all ? await personClient(ctx) : client(ctx);
+    const r = await c.request({ method: "GET", path: "/orgs" });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { ...r, all }, nexts(["promigence org switch <org>", "work in another organization"])), [
+        `promigence org list: ${r.orgs.length} organization${r.orgs.length === 1 ? "" : "s"} (* = default)${all ? "" : " — this key's; --all signs in and lists every one"}`,
+        ...r.orgs.map(orgLine),
+    ], 0, ctx.pointer);
+};
+const orgCreate = async (ctx) => {
+    const name = arg(ctx, 0, "a name", "promigence org create acme");
+    const o = await (await personClient(ctx)).request({ method: "POST", path: "/orgs", body: { name } });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { org: o }, nexts([sh `promigence org switch ${o.name}`, "use it from this machine"])), [
+        `promigence org create: ${o.name} (${o.org_id}), you are its owner`,
+        "  It has no trial credit (the trial is per person): add a card there before its first run.",
+    ], 0, ctx.pointer);
+};
+const orgSwitch = async (ctx) => {
+    const ident = arg(ctx, 0, "an organization", "promigence org switch acme");
+    const stored = readCredentials().api_key;
+    const usingStored = ctx.apiKey === undefined && !process.env["PROMIGENCE_API_KEY"] && stored !== undefined;
+    const minted = loginMintedKey();
+    const mintedHere = usingStored && minted !== undefined && minted.apiKey === stored;
+    const old = client(ctx);
+    let oldKey;
+    if (mintedHere) {
+        try {
+            const me = await old.request({ method: "GET", path: "/me" });
+            oldKey = me.key?.service ? undefined : me.key?.key_id;
+        }
+        catch { }
+    }
+    checkCredentialsPath(credentialsPath());
+    const person = await personClient(ctx);
+    const body = { name: `cli@${hostname()}`.slice(0, 64), default: true };
+    const project = str(ctx, "--project");
+    if (project)
+        body["project"] = project;
+    const k = await person.request({ method: "POST", path: `/orgs/${enc(ident)}/keys`, body });
+    const o = { org_id: k.org_id };
+    const saved = writeCredentials(k.api_key, person.apiUrl, k.key_id);
+    const path = saved.path;
+    const lines = [
+        `promigence org switch: now in ${o.org_id} (your default), project ${k.project_id}`,
+        `  key ${k.key_id} (${k.prefix}…) stored in ${storedWhere(saved)}`,
+        ...(saved.note ? [`  note: ${saved.note}`] : []),
+    ];
+    const warnings = [...saved.warnings];
+    let revoked = null;
+    if (oldKey && !bool(ctx, "--keep-old-key")) {
+        try {
+            await old.request({
+                method: "DELETE", path: `/keys/${enc(oldKey)}?reason=replaced`,
+                headers: { "promigence-replaced-by": k.api_key },
+            });
+            revoked = oldKey;
+            lines.push(`  the previous key ${oldKey} was revoked`);
+        }
+        catch (e) {
+            warnings.push(`the previous key ${oldKey} was not revoked (${e.message}); revoke it with \`${sh `promigence keys revoke ${oldKey}`}\``);
+        }
+    }
+    if ((!usingStored || !mintedHere) && stored !== undefined) {
+        warnings.push(`the key that was stored in ${storedWhere(saved)} was replaced and still works; revoke it if nothing else uses it`);
+    }
+    if (process.env["PROMIGENCE_API_KEY"]) {
+        warnings.push("PROMIGENCE_API_KEY is set in this shell and wins over the stored key: unset it to use the new one");
+    }
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { org: o, key: { ...k, api_key: undefined }, credentials: path, store: saved.store, revoked, warnings }, nexts(["promigence me", "confirm where you are"])), [...lines, ...warnings.map((w) => `  warning: ${w}`)], 0, ctx.pointer);
+};
+const orgMembers = async (ctx) => {
+    const { c, org } = await scoped(ctx);
+    const r = await c.request({ method: "GET", path: `/orgs/${enc(org)}/members` });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, r, nexts(["promigence org invite <email>", "add someone"])), [
+        `promigence org members: ${r.members.length} in ${r.org_id}`,
+        ...r.members.map(memberLine),
+    ], 0, ctx.pointer);
+};
+const orgInvite = async (ctx) => {
+    const email = arg(ctx, 0, "an email address", "promigence org invite dev@example.com --role member");
+    const r0 = role(ctx, str(ctx, "--role"), "member");
+    const { c, org } = await managing(ctx);
+    const i = await c.request({
+        method: "POST", path: `/orgs/${enc(org)}/invites`, body: { email, role: r0 },
+    });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { invite: i }, nexts(["promigence org invites", "pending invites"])), [
+        `promigence org invite: ${i.email} invited to ${i.org_name} as ${i.role} (${i.invite_id})`,
+        "  They accept it signed in with that address, verified: `promigence org invites --mine`, then `promigence org join <id>`.",
+    ], 0, ctx.pointer);
+};
+const orgInvites = async (ctx) => {
+    if (bool(ctx, "--mine"))
+        return inviteList(ctx);
+    const { c, org } = await scoped(ctx);
+    const r = await c.request({ method: "GET", path: `/orgs/${enc(org)}/invites` });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, r, nexts(["promigence org uninvite <invite_id>", "withdraw one"])), [
+        `promigence org invites: ${r.invites.length} pending`,
+        ...r.invites.map(inviteLine),
+    ], 0, ctx.pointer);
+};
+const orgUninvite = async (ctx) => {
+    const id = arg(ctx, 0, "an invite id", "promigence org uninvite inv_3e9f0c2a");
+    const { c, org } = await managing(ctx);
+    const r = await c.request({ method: "DELETE", path: `/orgs/${enc(org)}/invites/${enc(id)}` });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, r, nexts(["promigence org invites", "what is still pending"])), [
+        `promigence org uninvite: ${r.invite_id} revoked`,
+    ], 0, ctx.pointer);
+};
+const orgResend = async (ctx) => {
+    const id = arg(ctx, 0, "an invite id", "promigence org resend inv_3e9f0c2a");
+    const { c, org } = await managing(ctx);
+    const i = await c.request({ method: "POST", path: `/orgs/${enc(org)}/invites/${enc(id)}/resend`, body: {} });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { invite: i }, nexts(["promigence org invites", "pending invites"])), [
+        `promigence org resend: the invite to ${i.email} was sent again (${i.invite_id}); it now expires 14 days from today`,
+    ], 0, ctx.pointer);
+};
+const orgRole = async (ctx) => {
+    const user = arg(ctx, 0, "a member's user id", "promigence org role usr_2b8e11 owner");
+    const r0 = role(ctx, arg(ctx, 1, "a role (owner or member)", "promigence org role usr_2b8e11 owner"));
+    const { c, org } = await managing(ctx);
+    const r = await c.request({
+        method: "PATCH", path: `/orgs/${enc(org)}/members/${enc(user)}`, body: { role: r0 },
+    });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, r, nexts(["promigence org members", "the result"])), [
+        `promigence org role: ${user} is now ${r0}`,
+        ...r.members.map(memberLine),
+    ], 0, ctx.pointer);
+};
+async function removeMember(ctx, org, user, c) {
+    const r = await c.request({
+        method: "DELETE", path: `/orgs/${enc(org)}/members/${enc(user)}`,
+    });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, r, nexts(["promigence org list", "where you still belong"])), [
+        `promigence ${ctx.cmd.name}: ${r.user_id} is no longer a member of ${r.org_id}; ${r.keys_revoked} of their key${r.keys_revoked === 1 ? "" : "s"} revoked`,
+    ], 0, ctx.pointer);
+}
+const orgRemove = async (ctx) => {
+    const user = arg(ctx, 0, "a member's user id", "promigence org remove usr_2b8e11");
+    const { c, org } = await managing(ctx);
+    return removeMember(ctx, org, user, c);
+};
+const orgLeave = async (ctx) => {
+    const k = client(ctx);
+    let me;
+    try {
+        me = await k.request({ method: "GET", path: "/me" });
+    }
+    catch { }
+    const org = ctx.args[0] ?? me?.org_id;
+    if (!org)
+        throw usageError("org leave needs an organization", "Example: promigence org leave acme.");
+    const own = me !== undefined && (org === me.org_id || org === me.org) && Boolean(me.user?.user_id);
+    if (own) {
+        await write(process.stderr, "  note: this is the organization of the key you are using; leaving revokes it. `promigence org switch <org>` first to keep working from here.\n");
+        return removeMember(ctx, org, me.user.user_id, k);
+    }
+    return removeMember(ctx, org, "me", await personClient(ctx));
+};
+function auditNeedsSignIn(ctx) {
+    if (bool(ctx, "--sign-in") || bool(ctx, "--no-browser") || process.env["PROMIGENCE_ID_TOKEN"])
+        return undefined;
+    const again = `promigence org audit${str(ctx, "--org") ? ` --org ${str(ctx, "--org")}` : ""}`;
+    const err = new PromigenceError({
+        code: "forbidden",
+        message: "reading the audit log needs you signed in as yourself, not an API key",
+        fix: `Run \`${again} --sign-in\` to sign in in your browser, or \`${again} --no-browser\` on a machine without one (you paste a code). A script can set PROMIGENCE_ID_TOKEN.`,
+        exitCode: 7,
+    });
+    const next = nexts([`${again} --sign-in`, "sign in in your browser and read the log"]);
+    return emit(ctx.mode, errorEnvelope(ctx.cmd.name, err, next), errorTextLines(ctx.cmd.name, err, 7, next), 7, false);
+}
+const orgAudit = async (ctx) => {
+    const refused = auditNeedsSignIn(ctx);
+    if (refused)
+        return refused;
+    const { c, org } = await managing(ctx);
+    const q = new URLSearchParams();
+    const before = str(ctx, "--before");
+    const limit = str(ctx, "--limit");
+    if (before)
+        q.set("before", before);
+    if (limit)
+        q.set("limit", limit);
+    const qs = q.toString() ? `?${q}` : "";
+    const r = await c.request({ method: "GET", path: `/orgs/${enc(org)}/audit${qs}` });
+    const full = r.entries.length >= Math.min(Number(limit ?? 100), 100);
+    const last = full ? r.entries.at(-1) : undefined;
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, r, nexts(last ? [`promigence org audit --before ${shellArg(last.seq)}${limit ? ` --limit ${shellArg(limit)}` : ""}${orgTail(ctx)}`, "older entries"] : [`promigence org members${orgTail(ctx)}`, "who can act here"])), [
+        `promigence org audit: ${r.entries.length} entr${r.entries.length === 1 ? "y" : "ies"} in ${r.org_id}, newest first`,
+        ...r.entries.map(auditLine),
+    ], 0, ctx.pointer);
+};
+const orgRename = async (ctx) => {
+    const ident = arg(ctx, 0, "an organization", "promigence org rename acme acme-labs");
+    const name = arg(ctx, 1, "the new name", "promigence org rename acme acme-labs");
+    const o = await (await personClient(ctx)).request({ method: "PATCH", path: `/orgs/${enc(ident)}`, body: { name } });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { org: o }, nexts([sh `promigence org list --all`, "your organizations"])), [
+        `promigence org rename: ${o.org_id} is now ${o.name}`,
+        `  Its id is unchanged. Anything that names it by its old name (--org, scripts) must use ${o.name} or ${o.org_id}.`,
+    ], 0, ctx.pointer);
+};
+const orgDelete = async (ctx) => {
+    const ident = arg(ctx, 0, "an organization", "promigence org delete acme --confirm acme");
+    const confirm = str(ctx, "--confirm");
+    if (!confirm) {
+        throw usageError("org delete needs --confirm with the organization's name", `Example: ${sh `promigence org delete ${ident} --confirm <name>`}. Its keys stop working and its members leave it.`);
+    }
+    const c = await personClient(ctx);
+    const r = await c.request({
+        method: "DELETE", path: `/orgs/${enc(ident)}`, body: { confirm },
+    });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, r, nexts(["promigence org list --all", "where you still belong"])), [
+        `promigence org delete: ${r.org_id} deleted; ${r.keys_revoked} key${r.keys_revoked === 1 ? "" : "s"} revoked`,
+        ...(r.members_rehomed ? [`  ${r.members_rehomed} member${r.members_rehomed === 1 ? " had" : "s had"} no other organization and got a personal one`] : []),
+    ], 0, ctx.pointer);
+};
+const inviteList = async (ctx) => {
+    const r = await (await personClient(ctx)).request({ method: "GET", path: "/invites" });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, r, nexts(["promigence org join <invite_id>", "join"])), [
+        `promigence org invites --mine: ${r.invites.length} invite${r.invites.length === 1 ? "" : "s"} for your verified email`,
+        ...r.invites.map(inviteLine),
+    ], 0, ctx.pointer);
+};
+const inviteAccept = async (ctx) => {
+    const id = arg(ctx, 0, "an invite id", "promigence org join inv_3e9f0c2a");
+    if (bool(ctx, "--decline")) {
+        const r = await (await personClient(ctx)).request({ method: "POST", path: `/invites/${enc(id)}/decline`, body: {} });
+        return emit(ctx.mode, okEnvelope(ctx.cmd.name, { declined: r.invite_id }, nexts(["promigence org invites --mine", "what else is waiting"])), [
+            `promigence org join --decline: ${r.invite_id} declined`,
+        ], 0, ctx.pointer);
+    }
+    const o = await (await personClient(ctx)).request({ method: "POST", path: `/invites/${enc(id)}/accept`, body: {} });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { org: o }, nexts([sh `promigence org switch ${o.name}`, "work there from this machine"])), [
+        `promigence org join: you are a${o.role === "owner" ? "n owner" : " member"} of ${o.name} (${o.org_id})`,
+    ], 0, ctx.pointer);
+};
+const projectList = async (ctx) => {
+    const { c, org } = await scoped(ctx);
+    const month = str(ctx, "--month");
+    const q = month ? `?month=${encodeURIComponent(month)}` : "";
+    const r = await c.request({ method: "GET", path: `/orgs/${enc(org)}/projects${q}` });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, r, nexts(["promigence project create <name>", "add one"])), [
+        `promigence project list: ${r.projects.length} in ${r.org_id}`,
+        ...r.projects.map(projectLine),
+    ], 0, ctx.pointer);
+};
+const projectCreate = async (ctx) => {
+    const name = arg(ctx, 0, "a name", "promigence project create evals");
+    const { c, org } = await scoped(ctx);
+    const p = await c.request({ method: "POST", path: `/orgs/${enc(org)}/projects`, body: { name } });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { project: p }, nexts([sh `promigence keys create --project ${p.name}`, "a key for it"])), [
+        `promigence project create: ${p.name} (${p.project_id}) in ${p.org_id}`,
+    ], 0, ctx.pointer);
+};
+const projectRename = async (ctx) => {
+    const from = arg(ctx, 0, "a project", "promigence project rename evals rl");
+    const to = arg(ctx, 1, "the new name", "promigence project rename evals rl");
+    const { c, org } = await scoped(ctx);
+    const p = await c.request({ method: "PATCH", path: `/orgs/${enc(org)}/projects/${enc(from)}`, body: { name: to } });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { project: p }, nexts(["promigence project list", "the result"])), [
+        `promigence project rename: ${p.project_id} is now ${p.name}`,
+    ], 0, ctx.pointer);
+};
+const projectDelete = async (ctx) => {
+    const ident = arg(ctx, 0, "a project", "promigence project delete evals");
+    const { c, org } = await managing(ctx);
+    const r = await c.request({ method: "DELETE", path: `/orgs/${enc(org)}/projects/${enc(ident)}` });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, r, nexts(["promigence project list", "what is left"])), [
+        `promigence project delete: ${r.project_id} deleted`,
+    ], 0, ctx.pointer);
+};
+const projectCap = async (ctx) => {
+    const ident = arg(ctx, 0, "a project", "promigence project cap evals 500");
+    const raw = arg(ctx, 1, "a monthly cap in USD, or off", "promigence project cap evals 500");
+    let cap;
+    if (raw.toLowerCase() === "off")
+        cap = null;
+    else {
+        cap = /^\$?\d+(\.\d+)?$/.test(raw) ? Number(raw.replace(/^\$/, "")) : NaN;
+        if (!Number.isFinite(cap) || cap < 0) {
+            throw usageError(`the cap must be a number of USD or off, not ${JSON.stringify(raw)}`, "Example: promigence project cap evals 500.");
+        }
+    }
+    const { c, org } = await managing(ctx);
+    const p = await c.request({ method: "PATCH", path: `/orgs/${enc(org)}/projects/${enc(ident)}`, body: { monthly_cap_usd: cap } });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { project: p }, nexts([`promigence project list${orgTail(ctx)}`, "every project's cap"])), [
+        p.monthly_cap_usd == null
+            ? `promigence project cap: ${p.name} has no monthly cap`
+            : `promigence project cap: ${p.name} may bill at most $${p.monthly_cap_usd} a month (UTC); a run past it is refused`,
+    ], 0, ctx.pointer);
+};
+const projectMove = async (ctx) => {
+    const ident = arg(ctx, 0, "a project", "promigence project move evals --to acme");
+    const to = str(ctx, "--to");
+    if (!to)
+        throw usageError("project move needs --to <org>", "Example: promigence project move evals --to acme.");
+    const { c, org } = await managing(ctx);
+    const r = await c.request({
+        method: "POST", path: `/orgs/${enc(org)}/projects/${enc(ident)}/move`, body: { to },
+    });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, r, nexts([sh `promigence keys create --org ${r.to_org_id} --project ${ident}`, "a key for it there"])), [
+        `promigence project move: ${r.project_id} is now in ${r.to_org_id}, with ${r.snapshots_moved} snapshot${r.snapshots_moved === 1 ? "" : "s"} and ${r.secrets_moved} secret${r.secrets_moved === 1 ? "" : "s"}`,
+        `  ${r.keys_revoked} key${r.keys_revoked === 1 ? " was" : "s were"} revoked; past runs stay with ${r.from_org_id}.`,
+    ], 0, ctx.pointer);
+};
+export async function keysCreateInOrg(ctx) {
+    const { c, org } = bool(ctx, "--service") || str(ctx, "--project") ? await managing(ctx) : await scoped(ctx);
+    const body = { name: (str(ctx, "--name") ?? `cli@${hostname()}`).slice(0, 64) };
+    const project = str(ctx, "--project");
+    if (project)
+        body["project"] = project;
+    if (bool(ctx, "--service"))
+        body["service"] = true;
+    Object.assign(body, expiryBody(ctx), accessBody(ctx));
+    const k = await c.request({ method: "POST", path: `/orgs/${enc(org)}/keys`, body });
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { key: k }, nexts(["promigence keys list", "confirm it is there"])), [
+        `promigence keys create: ${k.key_id} "${k.name}" in ${k.org_id}, project ${k.project_id}${k.service ? " (service key)" : ""}${accessNote(k.access)}`,
+        `  api_key: ${k.api_key}`,
+        "  This is the only time the secret is shown. Store it now (e.g. in your CI secret store).",
+        ...(k.service ? [] : ["  It is yours: it stops working if you leave the organization. `--service` (owners) makes one that does not."]),
+        expiryLine(k.expires_at),
+    ], 0, ctx.pointer);
+}
+export const ORG_HANDLERS = {
+    "org list": orgList,
+    "org create": orgCreate,
+    "org switch": orgSwitch,
+    "org members": orgMembers,
+    "org invite": orgInvite,
+    "org invites": orgInvites,
+    "org uninvite": orgUninvite,
+    "org role": orgRole,
+    "org remove": orgRemove,
+    "org leave": orgLeave,
+    "org join": inviteAccept,
+    "org audit": orgAudit,
+    "org rename": orgRename,
+    "org resend": orgResend,
+    "org delete": orgDelete,
+    "project list": projectList,
+    "project create": projectCreate,
+    "project rename": projectRename,
+    "project delete": projectDelete,
+    "project cap": projectCap,
+    "project move": projectMove,
+};

package/dist/pricing.d.ts

@@ -0,0 +1,52 @@
+import { PromigenceClient, type PricingView } from "./sdk/index.js";
+import { type Ctx, type Handler } from "./commands.js";
+export declare const COMPILED_NOTE = "list prices at build time; could not reach the API";
+export declare const PUBLISHED_NOTE = "published list prices; your organization's own need a key (promigence login)";
+export interface PriceTier {
+    name: string;
+    vcpus: number;
+    mem_gib: number;
+    disk_gib: number;
+    per_second_usd: number;
+    per_hour_usd: number;
+    preemptible_per_second_usd?: number;
+    available?: boolean;
+}
+export interface Prices {
+    source: "api" | "compiled" | "published";
+    note?: string;
+    reason?: string;
+    view?: PricingView;
+    vcpu_second_usd: number;
+    gib_second_usd: number;
+    preemptible_vcpu_second_usd: number;
+    preemptible_gib_second_usd: number;
+    build_usd: number;
+    build_max_s: number;
+    granularity_seconds: number;
+    tiers: PriceTier[];
+}
+export declare function publishedPrices(): Prices;
+export declare const DEFAULT_BUILD_TIER = "small";
+export declare function compiledPrices(note?: string, reason?: string): Prices;
+export declare function pricesFrom(view: PricingView): Prices;
+export declare function livePricing(c: PromigenceClient, opts?: {
+    newAccount?: boolean;
+    strict?: boolean;
+}): Promise<Prices>;
+export interface BuildPrice {
+    most_usd: number;
+    per_second_usd: number;
+    max_s: number;
+}
+export declare function buildPriceIn(p: Prices, tier?: string): BuildPrice;
+export declare function buildPrice(c: PromigenceClient, tier?: string): Promise<BuildPrice>;
+export declare function buildLimit(s: number): string;
+export declare function buildPriceWords(p: BuildPrice, tier?: string): string;
+export declare function quickClient(ctx: Ctx): PromigenceClient;
+export declare function rate(n: number): string;
+export declare function pricingLines(p: Prices, opts?: {
+    cardsOff?: boolean;
+}): string[];
+export declare function pricingJson(p: Prices): Record<string, unknown>;
+export declare const PRICING_HANDLERS: Readonly<Record<string, Handler>>;