@nebulr-group/bridge-cli 0.6.6 → 1.0.0-alpha.0

package/dist/commands/plan.command.js

@@ -1,764 +1,205 @@
-import { readFileSync } from 'node:fs';
-import { getManagementClient, getManagementHttp } from '../config.js';
-import { dryRunPreview } from '../preview.js';
-import { outputSuccess, outputError } from '../output.js';
-import { shapePlan } from '../shape.js';
-import { DecisionNeededError, decisionField } from '../product-decisions.js';
-const QUOTA_POLICIES = ['hard', 'metered'];
-const QUOTA_KINDS = ['counter', 'gauge'];
-const QUOTA_SOURCES = ['membership'];
-/** The kind a quota resolves to — same rule as the server. No metric name is special. */
-export function quotaKindOf(quota) {
-    return quota.kind === 'gauge' ? 'gauge' : 'counter';
-}
-/**
- * TBP-699 — every metric configured on any plan, once each, with its kind and
- * the plans that limit it. Pure; mirrors the MCP `list_plan_quotas` tool.
- */
-export function listMetrics(plans) {
-    const byMetric = new Map();
-    for (const plan of plans) {
-        for (const q of plan.quotas ?? []) {
-            const kind = quotaKindOf(q);
-            const source = kind === 'gauge' && q.source === 'membership' ? 'membership' : undefined;
-            const entry = byMetric.get(q.metric) ?? { metric: q.metric, kind, ...(source ? { source } : {}), plans: [] };
-            if (entry.kind !== kind)
-                entry.kind = 'mixed';
-            else if (entry.source !== source)
-                entry.source = 'mixed';
-            entry.plans.push({ planKey: String(plan.key), kind, ...(source ? { source } : {}), limit: q.limit, policy: q.policy });
-            byMetric.set(q.metric, entry);
-        }
-    }
-    return [...byMetric.values()].sort((a, b) => a.metric.localeCompare(b.metric));
-}
-export function validateQuotaEntry(entry) {
-    const metric = (entry.metric ?? '').trim();
-    if (!metric)
-        throw new Error('--metric is required and must be non-empty.');
-    const limit = entry.limit;
-    if (typeof limit !== 'number' ||
-        !Number.isFinite(limit) ||
-        !Number.isInteger(limit) ||
-        limit < 0) {
-        throw new Error(`--limit must be an integer >= 0, got "${entry.limit}".`);
-    }
-    const policy = entry.policy;
-    if (!QUOTA_POLICIES.includes(policy)) {
-        throw new Error(`--policy must be one of ${QUOTA_POLICIES.join(', ')}, got "${entry.policy}".`);
-    }
-    // TBP-699 — counter vs gauge. Only sent when given, so an omitted kind
-    // leaves the server's default/stored kind in charge.
-    let kind;
-    if (entry.kind !== undefined) {
-        if (!QUOTA_KINDS.includes(entry.kind)) {
-            throw new Error(`--kind must be one of ${QUOTA_KINDS.join(', ')}, got "${entry.kind}".`);
-        }
-        kind = entry.kind;
-    }
-    // TBP-763 — `membership`: Bridge counts the workspace's active members
-    // (seats). Only a hard gauge can have it.
-    let source;
-    if (entry.source === null || entry.source === 'none') {
-        source = null;
-    }
-    else if (entry.source !== undefined) {
-        if (!QUOTA_SOURCES.includes(entry.source)) {
-            throw new Error(`--source must be membership (or none), got "${entry.source}".`);
-        }
-        source = entry.source;
-        if (kind !== 'gauge') {
-            throw new Error(`"${metric}" has --source membership, which only a gauge can have (Bridge answers it with the workspace's active members). Add --kind gauge, or drop --source for a counter the app reports.`);
-        }
-        if (policy === 'metered') {
-            throw new Error(`"${metric}" has --source membership and cannot be metered. Use --policy hard.`);
-        }
-    }
-    if (policy === 'metered' && kind === 'gauge') {
-        throw new Error(`"${metric}" is a gauge and a gauge cannot be metered: metered billing charges for usage that happened during a period, which only a counter records. Use --policy hard, or --kind counter.`);
-    }
-    const withKind = { ...(kind ? { kind } : {}), ...(source !== undefined ? { source } : {}) };
-    // TBP-275 — metered quotas carry a per-unit price; hard quotas must not.
-    if (policy === 'metered') {
-        const amount = entry.priceAmount;
-        if (typeof amount !== 'number' || !Number.isFinite(amount) || amount <= 0) {
-            throw new Error(`--price-amount must be a number > 0 for metered quotas, got "${entry.priceAmount}".`);
-        }
-        const currency = (entry.currency ?? '').trim().toUpperCase();
-        if (!currency) {
-            throw new Error('A currency is required for metered pricing. The plan has no single price currency to derive from — pass --price-currency.');
-        }
-        return { metric, limit, policy, ...withKind, pricing: { amount, currency } };
-    }
-    if (entry.priceAmount !== undefined) {
-        throw new Error('--price-amount is only valid with --policy metered.');
-    }
-    return { metric, limit, policy, ...withKind };
-}
-/** Upsert a quota by metric (replace if present, append otherwise). Pure. */
-export function upsertQuota(quotas, entry) {
-    return [...quotas.filter((q) => q.metric !== entry.metric), entry];
-}
-/** An Error carrying a machine-readable `code` that outputError reports. */
-function codedError(code, message) {
-    return Object.assign(new Error(message), { code });
-}
-/** Same pattern the server enforces. */
-export const FEATURE_KEY_PATTERN = /^[a-z][a-z0-9_]*$/;
-/** Validate one feature key client-side, with a message that says how to fix it. */
-export function validateFeatureKey(key) {
-    const k = (key ?? '').trim();
-    if (!FEATURE_KEY_PATTERN.test(k)) {
-        throw codedError('INVALID_FEATURE', `Feature key "${key}" is not valid: use lower-case letters, digits and underscores, starting with a letter (e.g. "analytics", "priority_support").`);
-    }
-    return k;
-}
-/** One feature entry; the display name defaults to the key. */
-export function buildFeature(key, name) {
-    const k = validateFeatureKey(key);
-    const n = (name ?? '').trim();
-    return { key: k, name: n || k };
-}
-/**
- * Parse `--features`: comma-separated `key` or `key:Display Name` entries,
- * e.g. `analytics,sso:Single sign-on`. A repeated key keeps the last entry.
- */
-export function parseFeaturesOption(raw) {
-    let features = [];
-    for (const part of raw.split(',')) {
-        const entry = part.trim();
-        if (!entry)
-            continue;
-        const i = entry.indexOf(':');
-        const feature = i === -1 ? buildFeature(entry) : buildFeature(entry.slice(0, i), entry.slice(i + 1));
-        features = upsertFeature(features, feature);
-    }
-    return features;
-}
-/** Upsert a feature by key (replace in place if present, append otherwise). Pure. */
-export function upsertFeature(features, entry) {
-    const i = features.findIndex((f) => f.key === entry.key);
-    if (i === -1)
-        return [...features, entry];
-    const next = [...features];
-    next[i] = entry;
-    return next;
-}
-/** Remove a feature by key; throws naming the existing keys when absent. Pure. */
-export function removeFeature(features, key, planKey) {
-    const next = features.filter((f) => f.key !== key);
-    if (next.length === features.length) {
-        throw codedError('FEATURE_NOT_FOUND', `No feature "${key}" on plan "${planKey}". Existing features: ${features.length ? features.map((f) => f.key).join(', ') : '(none)'}.`);
-    }
-    return next;
-}
-/** A plan's features, read defensively (older servers omit the field). */
-export function featuresOf(plan) {
-    const raw = plan?.features;
-    if (!Array.isArray(raw))
-        return [];
-    return raw
-        .filter((f) => !!f && typeof f.key === 'string')
-        .map((f) => ({ key: f.key, name: typeof f.name === 'string' && f.name ? f.name : f.key }));
-}
-/** A plan as printed: always carries `features` (empty when it sells none). */
-function withFeatures(plan) {
-    if (!plan || typeof plan !== 'object')
-        return plan;
-    return { ...plan, features: featuresOf(plan) };
-}
-const VALID_INTERVALS = [
-    'day',
-    'week',
-    'month',
-    'year',
-];
-/**
- * Validate + normalise one price entry from CLI flags. A plan can carry several
- * prices (e.g. monthly + yearly); each is set independently and identified by
- * its currency + interval. `--interval` is always required.
- */
-export function buildPriceEntry(opts) {
-    const amount = opts.amount;
-    if (typeof amount !== 'number' || !Number.isFinite(amount) || amount < 0) {
-        throw new Error(`--amount must be a number >= 0, got "${opts.amount}".`);
-    }
-    const interval = (opts.interval ?? '');
-    if (!VALID_INTERVALS.includes(interval)) {
-        throw new Error(`--interval is required and must be one of ${VALID_INTERVALS.join(', ')}, got "${opts.interval}".`);
-    }
-    const currency = (opts.currency ?? 'USD').trim().toUpperCase();
-    if (!currency)
-        throw new Error('--currency must be non-empty.');
-    return { amount, currency, recurrenceInterval: interval };
-}
-/**
- * TBP-617 — build the price list for `plan create`.
- *
- * The server rejects an explicitly empty `prices` array (a plan with no prices
- * can never be assigned to a workspace), so `plan create` must never send one.
- * Mirrors the MCP `create_plan` tool, which takes one flat price up front as
- * `amount` / `interval` / `currency`; further prices go through `plan price set`.
- *
- * Fails client-side when no price flags were passed, so the user gets the flags
- * that fix it instead of a `BAD_USER_INPUT` from the API.
- */
-export function buildCreatePlanPrices(opts) {
-    if (opts.amount === undefined && opts.interval === undefined) {
-        throw new Error('A plan needs at least one price. Pass --amount and --interval ' +
-            `(one of ${VALID_INTERVALS.join(', ')}), e.g. --amount 29 --interval month. ` +
-            'Use --amount 0 for a free or contact-sales tier; --currency defaults to USD.');
-    }
-    return [buildPriceEntry(opts)];
-}
-/**
- * TBP-617 — remove one price by currency + interval.
- *
- * Throws when the price is absent, and when it is the plan's LAST price: the
- * server rejects an empty price list with a 400 the user cannot act on, so say
- * why here. Mirrors the MCP `remove_plan_price` `LAST_PRICE` guard. Pure.
- */
-export function removePrice(prices, entry, planKey) {
-    const currency = entry.currency.trim().toUpperCase();
-    const next = prices.filter((p) => !(p.currency === currency && p.recurrenceInterval === entry.interval));
-    if (next.length === prices.length) {
-        throw new Error(`No ${currency} ${entry.interval} price on plan "${planKey}".`);
-    }
-    if (next.length === 0) {
-        throw new Error(`Cannot remove the only price on plan "${planKey}": a plan needs at least one price. ` +
-            `Add the replacement first with \`bridge plan price set ${planKey} --amount <n> --interval <interval>\`, ` +
-            'or set this price to --amount 0 for a free tier.');
-    }
-    return next;
-}
-/** Upsert a price by (currency + interval): replace if present, append otherwise. Pure. */
-export function upsertPrice(prices, entry) {
-    return [
-        ...prices.filter((p) => !(p.currency === entry.currency &&
-            p.recurrenceInterval === entry.recurrenceInterval)),
-        entry,
-    ];
-}
-// ── Product decisions (TBP-713) ──────────────────────────────────────────────
-// Mirrors bridge-api's create_plan / set_plan_price / apply_plan: a price,
-// interval, currency or trial the developer has not decided stops the command
-// before anything is written, naming the same fields as the MCP tool.
-/** The distinct currencies of a plan's prices, upper-cased. */
-function planCurrencies(prices) {
-    return [...new Set(prices.map((p) => p.currency?.trim().toUpperCase()).filter((c) => !!c))];
-}
-/**
- * The currency for a price given without one: the plan's one currency when it
- * has exactly one; USD for a free (0) price when it has none; otherwise
- * undefined — the developer decides. Same rule as the MCP tools. Pure.
- */
-export function resolvePriceCurrency(given, amount, others) {
-    if (given !== undefined)
-        return given.trim().toUpperCase();
-    const known = planCurrencies(others);
-    if (known.length === 1)
-        return known[0];
-    return amount === 0 && known.length === 0 ? 'USD' : undefined;
-}
-/** The decisions `plan create` is missing, in the MCP tool's order. Pure. */
-export function createPlanDecisions(opts) {
-    const missing = [];
-    const trial = opts.trial ?? (opts.trialDays !== undefined ? true : undefined);
-    const paidOrUnknown = opts.amount === undefined || opts.amount > 0;
-    if (opts.amount === undefined)
-        missing.push(decisionField('create_plan', 'amount', '--amount <n>'));
-    if (opts.interval === undefined)
-        missing.push(decisionField('create_plan', 'interval', '--interval <interval>'));
-    if (paidOrUnknown && opts.currency === undefined)
-        missing.push(decisionField('create_plan', 'currency', '--currency <code>'));
-    if (paidOrUnknown && trial === undefined)
-        missing.push(decisionField('create_plan', 'trial', '--trial | --no-trial'));
-    if (trial === true && opts.trialDays === undefined)
-        missing.push(decisionField('create_plan', 'trialDays', '--trial-days <n>'));
-    return missing;
-}
-/** Fetch a plan + its quotas/prices (read defensively — list() may omit them). */
-async function getPlan(key) {
-    const plans = (await getManagementClient().plans.list());
-    const plan = plans.find((p) => p.key === key);
-    if (!plan)
-        throw new Error(`Plan not found: ${key}`);
-    const quotas = (plan.quotas ?? []);
-    const prices = (plan.prices ?? []);
-    return { plan, quotas, prices, features: featuresOf(plan) };
-}
-export function registerPlanCommands(program) {
-    const plan = program.command('plan').description('Manage subscription plans');
-    plan.command('list')
-        .description('List all subscription plans')
-        .action(async () => {
-        try {
-            outputSuccess((await getManagementClient().plans.list()).map((p) => withFeatures(shapePlan(p))));
-        }
-        catch (err) {
-            outputError(err);
-        }
-    });
-    plan.command('get')
-        .description('Get a plan by key (includes usage quotas and included features)')
-        .argument('<key>', 'Plan key')
-        .action(async (key) => {
-        try {
-            const { plan: found, quotas, features } = await getPlan(key);
-            outputSuccess(shapePlan({ ...found, quotas, features }));
-        }
-        catch (err) {
-            outputError(err);
-        }
-    });
-    plan.command('create')
-        .description('Create a new plan with its first price (add more with `plan price set`)')
-        .requiredOption('--key <key>', 'Plan key')
-        .requiredOption('--name <name>', 'Plan name')
-        .option('--amount <amount>', 'First price amount (>= 0). Use 0 for a free or contact-sales tier', parseFloat)
-        .option('--interval <interval>', `Billing interval for the first price: ${VALID_INTERVALS.join(' | ')}`)
-        .option('--currency <currency>', 'Currency for the first price (ISO code). Required when --amount is above 0')
-        .option('--description <desc>', 'Description')
-        .option('--trial', 'The plan has a free trial (with --trial-days)')
-        .option('--no-trial', 'The plan has no free trial. One of --trial / --no-trial is required when --amount is above 0')
-        .option('--trial-days <days>', 'Trial period in days', parseInt)
-        .option('--features <list>', 'On/off features the plan includes, comma-separated `key` or `key:Display Name`, e.g. "analytics,sso:Single sign-on". ' +
-        'Each is `bridge:billing.entitlement.<key>` in flag rules')
-        .action(async (opts) => {
-        try {
-            // TBP-755 — validate before anything else so a bad key never half-creates a plan.
-            const features = opts.features !== undefined ? parseFeaturesOption(String(opts.features)) : undefined;
-            // TBP-713 — price, interval, currency and trial are the developer's
-            // decisions: stop and name them instead of defaulting.
-            const missing = createPlanDecisions(opts);
-            if (missing.length) {
-                throw new DecisionNeededError('bridge plan create', missing, opts.amount === undefined ? 'currency and trial are not needed if the price is 0.' : undefined);
-            }
-            // TBP-617 — the server rejects an explicitly empty price list, so build
-            // (and validate) the first price here rather than sending `prices: []`.
-            const prices = buildCreatePlanPrices({
-                amount: opts.amount,
-                interval: opts.interval,
-                currency: opts.currency,
-            });
-            const trial = opts.trial ?? (opts.trialDays !== undefined ? true : false);
-            outputSuccess(shapePlan(await getManagementClient().plans.create({
-                key: opts.key,
-                name: opts.name,
-                description: opts.description,
-                trial,
-                trialDays: opts.trialDays,
-                prices,
-                ...(features && features.length ? { features } : {}),
-            })));
-        }
-        catch (err) {
-            outputError(err);
-        }
-    });
-    plan.command('update')
-        .description('Update a plan')
-        .requiredOption('--key <key>', 'Plan key')
-        .option('--name <name>', 'Plan name')
-        .option('--description <desc>', 'Description')
-        .action(async (opts) => {
-        try {
-            const { key, ...data } = opts;
-            const cleaned = Object.fromEntries(Object.entries(data).filter(([, v]) => v !== undefined));
-            outputSuccess(shapePlan(await getManagementClient().plans.update(key, cleaned)));
-        }
-        catch (err) {
-            outputError(err);
-        }
-    });
-    // TBP-806 — only a plan no workspace is on is deleted. One that workspaces
-    // are on is refused (409 PLAN_IN_USE) with what to do instead: archive it,
-    // or move (`tenant set-plan`) or delete those workspaces first.
-    plan.command('delete')
-        .description('Delete a plan no workspace is on (refused, with the choices, when workspaces are on it)')
-        .requiredOption('--key <key>', 'Plan key')
-        .option('--dry-run', 'Show whether the delete would go through, and which workspaces are on the plan, and change nothing')
-        .action(async (opts) => {
-        try {
-            const path = `/v1/account/payments/plan/${encodeURIComponent(opts.key)}`;
-            if (opts.dryRun) {
-                outputSuccess(await dryRunPreview(path));
-                return;
-            }
-            outputSuccess(await getManagementHttp().delete(path));
-        }
-        catch (err) {
-            outputError(err);
-        }
-    });
-    plan.command('archive')
-        .description('Archive a plan: workspaces on it keep it, nobody new can choose it (--undo brings it back)')
-        .requiredOption('--key <key>', 'Plan key')
-        .option('--undo', 'Bring an archived plan back')
-        .action(async (opts) => {
-        try {
-            outputSuccess(await getManagementHttp().post(`/v1/account/payments/plan/${encodeURIComponent(opts.key)}/archive`, { archived: !opts.undo }));
-        }
-        catch (err) {
-            outputError(err);
-        }
-    });
-    plan.command('apply')
-        .description('Set up or reshape one plan in a single write: name, trial, prices and quotas together (creates it when the key is new)')
-        .requiredOption('--spec <json>', 'The plan as JSON, or @file.json: { key, name?, description?, trial?, trialDays?, ' +
-        'prices?: [{ amount, interval, currency? }], quotas?: [{ metric, limit, policy, kind?, source?, priceAmount?, priceCurrency? }], ' +
-        'features?: [{ key, name? }], removePrices?: [{ interval, currency? }], removeQuotas?: [metric], removeFeatures?: [key] }. ' +
-        'Same shape as the MCP apply_plan tool. Prices, quotas and features are upserted; anything not mentioned is kept')
-        .action(async (opts) => {
-        try {
-            const spec = parsePlanSpec(opts.spec);
-            const plans = (await getManagementClient().plans.list());
-            const write = planApplyWrite(spec, plans);
-            const result = write.created
-                ? await getManagementClient().plans.create(write.body)
-                : await getManagementClient().plans.update(spec.key, write.body);
-            outputSuccess({ created: write.created, plan: shapePlan(result) });
-        }
-        catch (err) {
-            outputError(err);
-        }
-    });
-    registerPriceCommands(plan);
-    registerQuotaCommands(plan);
-    registerFeatureCommands(plan);
-}
-/** An error with a machine-readable code, reported by outputError. */
-export class PlanApplyError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.name = 'PlanApplyError';
-    }
-}
-/** Read `--spec` as inline JSON or `@path`. */
-export function parsePlanSpec(raw) {
-    const text = raw.startsWith('@') ? readFileSync(raw.slice(1), 'utf8') : raw;
-    let spec;
-    try {
-        spec = JSON.parse(text);
-    }
-    catch (err) {
-        throw new PlanApplyError('INVALID_SPEC', `--spec is not valid JSON: ${err.message}`);
-    }
-    if (!spec || typeof spec !== 'object' || typeof spec.key !== 'string' || !spec.key) {
-        throw new PlanApplyError('INVALID_SPEC', '--spec needs a "key", e.g. {"key":"pro","name":"Pro","prices":[{"amount":29,"interval":"month"}]}.');
-    }
-    return spec;
-}
-/** The one write `plan apply` makes: a create body or an update body. Pure. */
-export function planApplyWrite(spec, plans) {
-    const key = spec.key;
-    const current = plans.find((p) => p.key === key);
-    const isNew = !current;
-    const before = isNew ? [] : [...((current.prices ?? []))];
-    let prices = [...before];
-    const planCurrency = planCurrencies(before).length === 1 ? planCurrencies(before)[0] : 'USD';
-    for (const r of spec.removePrices ?? []) {
-        const currency = (r.currency ?? planCurrency).trim().toUpperCase();
-        const slot = (p) => p.currency === currency && p.recurrenceInterval === r.interval;
-        if (!prices.some(slot)) {
-            throw new PlanApplyError('PRICE_NOT_FOUND', `No ${currency} ${r.interval} price on plan "${key}". Nothing was changed.`);
-        }
-        prices = prices.filter((p) => !slot(p));
-    }
-    // TBP-713 — the product decisions, gathered and reported all at once before
-    // anything is written; same fields, same order as the MCP apply_plan tool.
-    const missing = [];
-    const inputs = spec.prices ?? [];
-    const settled = [...before, ...inputs.filter((p) => p.currency !== undefined)];
-    inputs.forEach((p, i) => {
-        const currency = resolvePriceCurrency(p.currency, p.amount, settled);
-        if (!currency) {
-            missing.push(decisionField('apply_plan', 'prices.currency', `"prices[${i}].currency"`, `prices[${i}].currency`));
-            return;
-        }
-        prices = upsertPrice(prices, buildPriceEntry({ amount: p.amount, interval: p.interval, currency }));
-    });
-    if (prices.length === 0 && !isNew && missing.length === 0) {
-        throw new PlanApplyError('LAST_PRICE', `This would remove every price from plan "${key}": a plan needs at least one price. Nothing was changed.`);
-    }
-    if (isNew && spec.name === undefined)
-        missing.push(decisionField('apply_plan', 'name', '"name"'));
-    if (isNew && inputs.length === 0) {
-        missing.push(decisionField('apply_plan', 'prices.amount', '"prices[0].amount"', 'prices[0].amount'), decisionField('apply_plan', 'prices.interval', '"prices[0].interval"', 'prices[0].interval'), decisionField('apply_plan', 'prices.currency', '"prices[0].currency"', 'prices[0].currency'));
-    }
-    const trial = spec.trial ?? (spec.trialDays !== undefined ? true : undefined);
-    const paid = inputs.length === 0 || inputs.some((p) => p.amount > 0);
-    if (isNew && paid && trial === undefined)
-        missing.push(decisionField('apply_plan', 'trial', '"trial"'));
-    const currentTrialDays = current?.trialDays;
-    if (trial === true && spec.trialDays === undefined && !currentTrialDays) {
-        missing.push(decisionField('apply_plan', 'trialDays', '"trialDays"'));
-    }
-    if (missing.length) {
-        throw new DecisionNeededError('bridge plan apply', missing, isNew ? `Plan "${key}" does not exist yet, so this call would create it.` : undefined);
-    }
-    let quotas = isNew ? [] : [...((current.quotas ?? []))];
-    for (const metric of spec.removeQuotas ?? []) {
-        if (!quotas.some((q) => q.metric === metric)) {
-            throw new PlanApplyError('QUOTA_NOT_FOUND', `No quota for metric "${metric}" on plan "${key}". Nothing was changed.`);
-        }
-        quotas = quotas.filter((q) => q.metric !== metric);
-    }
-    const currencies = [...new Set(prices.map((p) => p.currency.toUpperCase()))];
-    for (const q of spec.quotas ?? []) {
-        const existing = quotas.find((e) => e.metric === String(q.metric ?? '').trim());
-        const kind = q.kind ?? existing?.kind;
-        let entry;
-        try {
-            entry = validateQuotaEntry({
-                metric: q.metric,
-                limit: q.limit,
-                policy: q.policy,
-                kind,
-                source: q.source !== undefined ? q.source : kind === 'gauge' ? existing?.source : undefined,
-                priceAmount: q.priceAmount,
-                currency: q.priceCurrency ?? (currencies.length === 1 ? currencies[0] : undefined),
-            });
-        }
-        catch (err) {
-            throw new PlanApplyError('INVALID_QUOTA', err.message);
-        }
-        quotas = upsertQuota(quotas, entry);
-    }
-    // TBP-755 — features: current, minus removals, with upserts by key.
-    let features = isNew ? [] : featuresOf(current);
-    for (const fk of spec.removeFeatures ?? []) {
-        if (!features.some((f) => f.key === fk)) {
-            throw new PlanApplyError('FEATURE_NOT_FOUND', `No feature "${fk}" on plan "${key}". Nothing was changed.`);
-        }
-        features = features.filter((f) => f.key !== fk);
-    }
-    for (const f of spec.features ?? []) {
-        let entry;
-        try {
-            entry = buildFeature(String(f?.key ?? ''), f?.name);
-        }
-        catch (err) {
-            throw new PlanApplyError('INVALID_FEATURE', err.message);
-        }
-        features = upsertFeature(features, entry);
-    }
-    const featuresTouched = spec.features !== undefined || spec.removeFeatures !== undefined;
+import { readFile } from 'node:fs/promises';
+import { InvalidArgumentError } from 'commander';
+import { plans } from '../api/billing.js';
+import { CliError } from '../core/errors.js';
+import { attachUsage, parseCurrencyInterval, parseFeature, parseLimit, parsePrice, parseUsagePrice } from '../money.js';
+import { action, collect } from './context.js';
+const PRICE_HELP = 'A price, "<amount> <CURRENCY>/<interval>" such as "19.99 EUR/month"; repeat for several';
+const USAGE_HELP = 'A per-unit usage price, "<metric> <amount per unit> <CURRENCY>/<interval> [included <n>]" such as "api.calls 0.002 EUR/month included 10000"; repeat for several';
+function trialDays(value) {
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < 1 || n > 730)
+        throw new InvalidArgumentError('A whole number of days from 1 to 730.');
+    return n;
+}
+/** The plan fields the options give. Prices, features and limits are whole lists: given, they replace the plan's. */
+function planFields(opts) {
     const fields = {};
-    for (const f of ['name', 'description', 'trialDays']) {
-        if (spec[f] !== undefined)
-            fields[f] = spec[f];
-    }
-    if (trial !== undefined)
-        fields.trial = trial;
-    if (isNew) {
-        return {
-            created: true,
-            body: {
-                key,
-                trial: false,
-                ...fields,
-                prices,
-                ...(quotas.length ? { quotas } : {}),
-                ...(features.length ? { features } : {}),
-            },
-        };
-    }
-    return {
-        created: false,
-        body: {
-            ...fields,
-            ...(spec.prices !== undefined || spec.removePrices !== undefined ? { prices } : {}),
-            ...(spec.quotas !== undefined || spec.removeQuotas !== undefined ? { quotas } : {}),
-            ...(featuresTouched ? { features } : {}),
-        },
-    };
-}
-// ── plan price (recurring prices) ────────────────────────────────────────────
-function registerPriceCommands(plan) {
-    const price = plan
-        .command('price')
-        .description("Manage a plan's recurring prices (one per currency + interval)");
-    price.command('set')
-        .description('Add or update a price on a plan (idempotent by currency + interval)')
-        .argument('<key>', 'Plan key')
-        .requiredOption('--amount <amount>', 'Price amount (>= 0)', parseFloat)
-        .requiredOption('--interval <interval>', `Billing interval: ${VALID_INTERVALS.join(' | ')}`)
-        .option('--currency <currency>', "Currency (ISO code). Omit only to reuse the plan's one existing price currency")
-        .action(async (key, opts) => {
-        try {
-            const { prices } = await getPlan(key);
-            // TBP-713 — never price in a currency the developer did not choose.
-            const currency = resolvePriceCurrency(opts.currency, opts.amount, prices);
-            if (!currency) {
-                throw new DecisionNeededError('bridge plan price set', [decisionField('set_plan_price', 'currency', '--currency <code>')], `Plan "${key}" has prices in ${planCurrencies(prices).join(', ') || 'no currency yet'}, so there is none to reuse.`);
-            }
-            const entry = buildPriceEntry({
-                amount: opts.amount,
-                interval: opts.interval,
-                currency,
+    if (opts.name !== undefined)
+        fields.name = opts.name;
+    if (opts.description !== undefined)
+        fields.description = opts.description;
+    if (opts.price !== undefined)
+        fields.prices = attachUsage(opts.price.map(parsePrice), (opts.usagePrice ?? []).map(parseUsagePrice));
+    else if (opts.usagePrice !== undefined)
+        throw new CliError('invalid', 'A usage price goes on a price: give the plan\'s prices with --price too, or use `bridge plan usage-price set`.');
+    if (opts.feature !== undefined)
+        fields.features = opts.feature.map(parseFeature);
+    if (opts.limit !== undefined)
+        fields.limits = opts.limit.map(parseLimit);
+    if (opts.trial === false)
+        fields.trial = null;
+    else if (opts.trialDays !== undefined)
+        fields.trial = { days: opts.trialDays, cardRequired: opts.cardRequired ?? false };
+    else if (opts.cardRequired !== undefined)
+        throw new CliError('invalid', '--card-required goes with --trial-days.');
+    return fields;
+}
+const withDocumentOptions = (cmd) => cmd
+    .option('--description <text>', 'What the plan is for')
+    .option('--price <price>', PRICE_HELP, collect)
+    .option('--usage-price <usage>', USAGE_HELP, collect)
+    .option('--feature <feature>', 'A feature the plan includes, "<key>" or "<key>=<name>"; repeat for several', collect)
+    .option('--limit <limit>', 'A limit, "<metric>=<n>" or "<metric>=unlimited"; repeat for several', collect)
+    .option('--trial-days <days>', 'A free trial of this many days', trialDays)
+    .option('--card-required', 'The trial asks for a card up front');
+/** Reads the plan, changes it, writes the changed fields back. */
+async function change(c, appId, key, fn) {
+    const plan = await plans.get(c, appId, key);
+    return plans.update(c, appId, key, fn(plan));
+}
+const priceId = (price) => `${price.currency}/${price.interval ?? 'once'}`;
+export function registerPlanCommands(program, deps) {
+    const plan = program.command('plan').description('Plans: their prices, trials, usage prices, features and limits');
+    plan
+        .command('list')
+        .description('The app\'s plans')
+        .option('--archived', 'Include archived plans')
+        .action(action(deps, async (ctx, opts) => {
+        const { c, appId } = await ctx.forApp();
+        ctx.io.result(await plans.list(c, appId, opts.archived === true));
+    }));
+    plan
+        .command('get <key>')
+        .description('One plan')
+        .action(action(deps, async (ctx, key) => {
+        const { c, appId } = await ctx.forApp();
+        ctx.io.result(await plans.get(c, appId, key));
+    }));
+    withDocumentOptions(plan.command('create <key>').description('Create a plan').requiredOption('--name <name>', 'The plan\'s name')).action(action(deps, async (ctx, key, opts) => {
+        const fields = planFields(opts);
+        const { c, appId } = await ctx.forApp();
+        ctx.io.result(await plans.create(c, appId, { ...fields, key, name: opts.name }));
+    }));
+    withDocumentOptions(plan
+        .command('update <key>')
+        .description('Change a plan. Lists given (--price, --feature, --limit) replace the plan\'s; the sub-commands change one entry')
+        .option('--name <name>', 'The plan\'s name')
+        .option('--no-trial', 'Remove the trial')).action(action(deps, async (ctx, key, opts) => {
+        const fields = planFields(opts);
+        if (Object.keys(fields).length === 0)
+            throw new CliError('invalid', 'Nothing to change.');
+        const { c, appId } = await ctx.forApp();
+        ctx.io.result(await plans.update(c, appId, key, fields));
+    }));
+    plan
+        .command('apply <file>')
+        .description('Create or replace a plan from a JSON file: { "key", "name", "prices", "features", "limits", "trial" }')
+        .action(action(deps, async (ctx, file) => {
+        let document;
+        try {
+            document = JSON.parse(await readFile(file, 'utf8'));
+        }
+        catch (error) {
+            throw new CliError('invalid', `Could not read ${file} as JSON: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (typeof document.key !== 'string' || document.key === '')
+            throw new CliError('invalid', `${file} names no plan "key".`);
+        const { key, ...rest } = document;
+        const { c, appId } = await ctx.forApp();
+        ctx.io.result(await plans.replace(c, appId, key, rest));
+    }));
+    plan
+        .command('archive <key>')
+        .description('Stop offering a plan: workspaces on it keep it, nobody new can choose it')
+        .option('--undo', 'Offer it again')
+        .action(action(deps, async (ctx, key, opts) => {
+        const { c, appId } = await ctx.forApp();
+        ctx.io.result(await plans.archive(c, appId, key, opts.undo !== true));
+    }));
+    plan
+        .command('delete <key>')
+        .description('Delete a plan no workspace is on')
+        .option('--dry-run', 'Only say whether it can be deleted')
+        .action(action(deps, async (ctx, key, opts) => {
+        const { c, appId } = await ctx.forApp();
+        const preview = await plans.deletionPreview(c, appId, key);
+        if (opts.dryRun)
+            return ctx.io.result(preview);
+        if (!preview.deletable) {
+            throw new CliError('conflict', `${String(preview.holders)} workspace(s) are on ${key}, so it cannot be deleted.`, {
+                hint: `Archive it instead: \`bridge plan archive ${key}\`.`,
             });
-            const next = upsertPrice(prices, entry);
-            outputSuccess(shapePlan(await getManagementClient().plans.update(key, { prices: next })));
-        }
-        catch (err) {
-            outputError(err);
-        }
-    });
-    price.command('rm')
-        .description('Remove a price from a plan by interval (+ currency)')
-        .argument('<key>', 'Plan key')
-        .requiredOption('--interval <interval>', `Billing interval: ${VALID_INTERVALS.join(' | ')}`)
-        .option('--currency <currency>', 'Currency (default USD)', 'USD')
-        .action(async (key, opts) => {
-        try {
-            const { prices } = await getPlan(key);
-            // TBP-617 — removing the last price empties the list, which the server
-            // rejects with a 400; removePrice says why before we get there.
-            const next = removePrice(prices, {
-                currency: String(opts.currency ?? 'USD'),
-                interval: opts.interval,
-            }, key);
-            outputSuccess(shapePlan(await getManagementClient().plans.update(key, { prices: next })));
-        }
-        catch (err) {
-            outputError(err);
-        }
-    });
-}
-// ── plan quota (usage caps) ──────────────────────────────────────────────────
-function registerQuotaCommands(plan) {
-    const quota = plan
-        .command('quota')
-        .description('Manage a plan\'s usage quotas (hard | metered caps, counter | gauge kinds)');
-    quota.command('list')
-        .description('List the usage quotas on a plan, or with no key every metric across all plans with its kind')
-        .argument('[key]', 'Plan key (omit to list every metric name and kind across all plans)')
-        .action(async (key) => {
-        try {
-            if (key === undefined) {
-                const plans = (await getManagementClient().plans.list());
-                outputSuccess(listMetrics(plans));
-                return;
-            }
-            const { quotas } = await getPlan(key);
-            outputSuccess((shapePlan({ quotas }).quotas ?? []).map((q) => ({ ...q, kind: quotaKindOf(q) })));
-        }
-        catch (err) {
-            outputError(err);
-        }
-    });
-    quota.command('set')
-        .description('Add or update a usage quota on a plan')
-        .argument('<key>', 'Plan key')
-        .requiredOption('--metric <metric>', 'Metric key (e.g. num.clicks)')
-        .requiredOption('--limit <n>', 'Limit (integer >= 0). 0 = pure per-unit metered (billed from unit 1)', parseInt)
-        .requiredOption('--policy <policy>', `Cap policy: ${QUOTA_POLICIES.join(' | ')}`)
-        .option('--kind <kind>', `${QUOTA_KINDS.join(' | ')}. counter (default) = summed per billing period; gauge = absolute value your app sets, never reset. ` +
-        "If deleting it frees room, it's a gauge and your app counts it; if it happened, it's a counter and Bridge counts it. " +
-        'Omit to keep an existing quota\'s kind')
-        .option('--source <source>', "membership = Bridge counts the workspace's active members, pending invites included (needs --kind gauge, --policy hard). " +
-        'Seats: name the limit (e.g. seats), --kind gauge --source membership; enforce it where invites happen ' +
-        '(the team page seat-limit setting, or @RequireQuota / bridge.requireQuota on your own invite handler), never with a flag or an entitlement. ' +
-        'Omit to keep an existing gauge\'s source; none removes it')
-        .option('--price-amount <n>', 'Per-unit price for metered quotas (required with --policy metered)', parseFloat)
-        .option('--price-currency <currency>', 'Currency for the metered price (defaults to the plan\'s price currency when unambiguous)')
-        .action(async (key, opts) => {
-        try {
-            const { quotas, prices } = await getPlan(key);
-            // Derive the metered currency from the plan's prices when not given and
-            // unambiguous; the backend enforces currency == a plan price currency.
-            const planCurrencies = [
-                ...new Set(prices.map((p) => p.currency?.toUpperCase()).filter(Boolean)),
-            ];
-            const currency = opts.priceCurrency?.toUpperCase() ??
-                (planCurrencies.length === 1 ? planCurrencies[0] : undefined);
-            // TBP-699 — an omitted --kind keeps the existing quota's kind.
-            const existing = quotas.find((q) => q.metric === String(opts.metric ?? '').trim());
-            const kind = opts.kind ?? existing?.kind;
-            // TBP-763 — an omitted --source keeps an existing gauge's source.
-            const entry = validateQuotaEntry({
-                metric: opts.metric,
-                limit: opts.limit,
-                policy: opts.policy,
-                kind,
-                source: opts.source ?? (kind === 'gauge' ? existing?.source : undefined),
-                priceAmount: opts.priceAmount,
-                currency,
-            });
-            const next = upsertQuota(quotas, entry);
-            outputSuccess(shapePlan(await getManagementClient().plans.update(key, { quotas: next })));
-        }
-        catch (err) {
-            outputError(err);
-        }
-    });
-    quota.command('rm')
-        .description('Remove a usage quota from a plan')
-        .argument('<key>', 'Plan key')
-        .requiredOption('--metric <metric>', 'Metric key to remove')
-        .action(async (key, opts) => {
-        try {
-            const { quotas } = await getPlan(key);
-            const next = quotas.filter((q) => q.metric !== opts.metric);
-            if (next.length === quotas.length) {
-                throw new Error(`No quota for metric "${opts.metric}" on plan "${key}".`);
-            }
-            outputSuccess(shapePlan(await getManagementClient().plans.update(key, { quotas: next })));
-        }
-        catch (err) {
-            outputError(err);
-        }
-    });
-}
-// ── plan feature (included on/off features, TBP-755) ─────────────────────────
-function registerFeatureCommands(plan) {
-    const feature = plan
-        .command('feature')
-        .description('Manage the on/off features a plan includes. Each is `bridge:billing.entitlement.<key>` in flag rules: ' +
-        'gate a feature with the rule `bridge:billing.entitlement.<key> eq true`');
-    feature.command('list')
-        .description('List the features a plan includes')
-        .argument('<planKey>', 'Plan key')
-        .action(async (planKey) => {
-        try {
-            outputSuccess((await getPlan(planKey)).features);
-        }
-        catch (err) {
-            outputError(err);
-        }
-    });
-    feature.command('add')
-        .description('Add a feature to a plan, or rename one it already includes (idempotent by key)')
-        .argument('<planKey>', 'Plan key')
-        .argument('<featureKey>', 'Feature key: lower-case letters, digits and underscores, e.g. analytics')
-        .option('--name <name>', 'Display name shown on the pricing table and upgrade dialog (default: the key)')
-        .action(async (planKey, featureKey, opts) => {
-        try {
-            const entry = buildFeature(featureKey, opts.name);
-            const { features } = await getPlan(planKey);
-            const next = upsertFeature(features, entry);
-            outputSuccess(withFeatures(shapePlan(await getManagementClient().plans.update(planKey, { features: next }))));
-        }
-        catch (err) {
-            outputError(err);
-        }
-    });
-    feature.command('remove')
-        .description('Remove a feature from a plan')
-        .argument('<planKey>', 'Plan key')
-        .argument('<featureKey>', 'Feature key to remove')
-        .action(async (planKey, featureKey) => {
-        try {
-            const { features } = await getPlan(planKey);
-            const next = removeFeature(features, featureKey, planKey);
-            outputSuccess(withFeatures(shapePlan(await getManagementClient().plans.update(planKey, { features: next }))));
-        }
-        catch (err) {
-            outputError(err);
         }
-    });
+        ctx.io.result(await plans.remove(c, appId, key));
+    }));
+    const price = plan.command('price').description('One price of a plan, by currency and interval');
+    price
+        .command('set <plan> <price>')
+        .description('Add a price, or change the one in its currency and interval ("19.99 EUR/month")')
+        .action(action(deps, async (ctx, key, text) => {
+        const given = parsePrice(text);
+        const { c, appId } = await ctx.forApp();
+        ctx.io.result(await change(c, appId, key, (p) => {
+            const kept = (p.prices ?? []).find((each) => priceId(each) === priceId(given));
+            const next = { ...given, ...(kept?.usage === undefined ? {} : { usage: kept.usage }) };
+            return { prices: [...(p.prices ?? []).filter((each) => priceId(each) !== priceId(given)), next] };
+        }));
+    }));
+    price
+        .command('remove <plan> <currency-interval>')
+        .description('Remove the price in a currency and interval ("EUR/month")')
+        .action(action(deps, async (ctx, key, text) => {
+        const target = priceId(parseCurrencyInterval(text));
+        const { c, appId } = await ctx.forApp();
+        ctx.io.result(await change(c, appId, key, (p) => {
+            if (!(p.prices ?? []).some((each) => priceId(each) === target))
+                throw new CliError('not-found', `${key} has no ${text} price.`);
+            return { prices: (p.prices ?? []).filter((each) => priceId(each) !== target) };
+        }));
+    }));
+    const usage = plan.command('usage-price').description('Per-unit usage prices on a plan\'s prices');
+    usage
+        .command('set <plan> <usage>')
+        .description('Add or change a usage price ("api.calls 0.002 EUR/month included 10000")')
+        .action(action(deps, async (ctx, key, text) => {
+        const given = parseUsagePrice(text);
+        const { c, appId } = await ctx.forApp();
+        ctx.io.result(await change(c, appId, key, (p) => ({ prices: attachUsage(p.prices ?? [], [given]) })));
+    }));
+    usage
+        .command('remove <plan> <metric>')
+        .description('Remove the usage price on a metric from every price of the plan')
+        .action(action(deps, async (ctx, key, metric) => {
+        const { c, appId } = await ctx.forApp();
+        ctx.io.result(await change(c, appId, key, (p) => ({
+            prices: (p.prices ?? []).map(({ usage: list, ...rest }) => {
+                const left = (list ?? []).filter((each) => each.metric !== metric);
+                return left.length === 0 ? rest : { ...rest, usage: left };
+            }),
+        })));
+    }));
+    const feature = plan.command('feature').description('The features a plan includes');
+    feature
+        .command('add <plan> <feature>')
+        .description('Include a feature ("<key>" or "<key>=<name>"), or rename one the plan has')
+        .action(action(deps, async (ctx, key, text) => {
+        const given = parseFeature(text);
+        const { c, appId } = await ctx.forApp();
+        ctx.io.result(await change(c, appId, key, (p) => ({ features: [...(p.features ?? []).filter((each) => each.key !== given.key), given] })));
+    }));
+    feature
+        .command('remove <plan> <feature>')
+        .description('Stop including a feature')
+        .action(action(deps, async (ctx, key, featureKey) => {
+        const { c, appId } = await ctx.forApp();
+        ctx.io.result(await change(c, appId, key, (p) => ({ features: (p.features ?? []).filter((each) => each.key !== featureKey) })));
+    }));
+    const limit = plan.command('limit').description('How much of a metric a plan allows');
+    limit
+        .command('set <plan> <limit>')
+        .description('Set a limit ("api.calls=10000" or "seats=unlimited")')
+        .action(action(deps, async (ctx, key, text) => {
+        const given = parseLimit(text);
+        const { c, appId } = await ctx.forApp();
+        ctx.io.result(await change(c, appId, key, (p) => ({ limits: [...(p.limits ?? []).filter((each) => each.metric !== given.metric), given] })));
+    }));
+    limit
+        .command('remove <plan> <metric>')
+        .description('Remove a limit')
+        .action(action(deps, async (ctx, key, metric) => {
+        const { c, appId } = await ctx.forApp();
+        ctx.io.result(await change(c, appId, key, (p) => ({ limits: (p.limits ?? []).filter((each) => each.metric !== metric) })));
+    }));
 }
 //# sourceMappingURL=plan.command.js.map