@myapihq/cli 1.3.13 → 2.1.0

package/dist/commands/authproduct.js

@@ -0,0 +1,286 @@
+import { auth as sdkAuth } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, info, printTable, printJson } from '../output.js';
+import { requireOrg } from '../helpers.js';
+// `myapi auth` — the END-USER auth product (my-auth-api): a managed OIDC IdP
+// for the users of apps built on MyAPI. Operator/account auth lives under
+// `myapi account` (see commands/auth.ts + index.ts dispatch). The machine
+// OIDC endpoints (discovery/jwks/authorize/token/userinfo) are consumed by
+// apps + the JS SDK, not the CLI, so only the management surface is here.
+export const SCHEMA = {
+    name: 'string',
+    type: 'string', // spa | web
+    redirect: 'string', // comma-separated redirect URIs
+    theme: 'string', // JSON for the hosted login page
+    connections: 'string', // comma-separated sign-in methods: google,password,magic
+    domain: 'string', // custom auth domain, e.g. auth.acme.com
+};
+export const EXPOSES = [
+    'POST /auth/orgs/{org_id}/tenant',
+    'GET /auth/orgs/{org_id}/tenant',
+    'POST /auth/orgs/{org_id}/clients',
+    'GET /auth/orgs/{org_id}/clients',
+    'GET /auth/orgs/{org_id}/usage',
+    'POST /auth/orgs/{org_id}/domain',
+    'GET /auth/orgs/{org_id}/domain',
+    'DELETE /auth/orgs/{org_id}/domain',
+];
+const SUBCOMMAND_USAGE = {
+    'tenant': `myapi auth tenant [show|create] [--connections <list>] [--theme <json>] [--org <id>] [--json]
+
+Your org's OIDC auth tenant — the identity provider your app's end users sign
+in against. One per org.
+
+  myapi auth tenant              Show the tenant (issuer + hosted login URL)
+  myapi auth tenant create       Create/enable it (idempotent)
+
+  --connections <list>  Sign-in methods on the hosted login page, comma-separated:
+                        google,password,magic (default: google).
+  --theme <json>        Branding JSON for the hosted login page.`,
+    'usage': `myapi auth usage [--org <id>] [--json]
+
+Monthly active users (MAU) for the current period — auth is billed per MAU.`,
+    'domain': `myapi auth domain [show|set|delete] [--domain <host>] [--org <id>] [--json]
+
+Serve auth on your own domain (e.g. auth.acme.com) instead of the default issuer.
+
+  myapi auth domain                         Show the current custom domain + status
+  myapi auth domain set --domain auth.acme.com   Register it (prints the DNS record to create)
+  myapi auth domain delete                  Remove the custom domain
+
+After 'set', create the printed DNS A record; TLS provisions automatically
+(~30 min) and the domain becomes your issuer once active.`,
+    'client': `myapi auth client <list|create> [--org <id>] [--json]
+
+OIDC clients are the apps that authenticate against your tenant.
+
+  myapi auth client list
+  myapi auth client create --name "My App" --type spa --redirect https://app.example.com/callback
+
+  --name <n>          Human label for the app (required)
+  --type spa|web      spa = public (no secret); web = confidential (secret once)
+  --redirect <urls>   Allowed redirect URIs, comma-separated (required).
+                      Absolute https (or http://localhost for dev).`,
+};
+export const HELP = `Usage: myapi auth <subcommand>
+
+Authentication for your app's end users — a managed OIDC identity provider
+(à la Kinde/Auth0). One auth tenant per org; register OIDC clients (apps)
+against it; sign users in via the hosted login page or the JS SDK; verify
+tokens locally against the tenant JWKS.
+
+End users sign in with managed Google, email/password, or magic links — pick
+which via \`tenant create --connections\`. (Operator/account commands moved to
+\`myapi account\`.)
+
+Subcommands:
+  client   Register and list OIDC clients (your apps)
+  domain   Serve auth on your own domain (auth.acme.com)
+  tenant   Show or create your org's OIDC auth tenant (+ sign-in methods)
+  usage    Monthly active users (MAU) for the current period`;
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(HELP);
+        return;
+    }
+    if (flags.help) {
+        const usage = SUBCOMMAND_USAGE[subcommand];
+        info(usage ? `Usage: ${usage}` : `Unknown subcommand "${subcommand}". Run "myapi auth --help".`);
+        return;
+    }
+    switch (subcommand) {
+        case 'tenant': return tenant(args, flags);
+        case 'client': return client(args, flags);
+        case 'usage': return usage(flags);
+        case 'domain': return domain(args, flags);
+        default: error(`Unknown subcommand "${subcommand}". Run "myapi auth --help" for tenant/client/usage/domain.`);
+    }
+}
+async function tenant(args, flags) {
+    const action = args[0] || 'show';
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi auth tenant [show|create] [--org <id>]');
+    if (action === 'show') {
+        try {
+            const t = await sdkAuth.getTenant(config.api_key, orgId);
+            if (flags.json) {
+                printJson(t);
+                return;
+            }
+            info(`Auth tenant: ${t.tenant_id}`);
+            info(`Issuer:    ${t.issuer}`);
+            info(`Login URL: ${t.login_url}`);
+            if (t.connections?.length)
+                info(`Sign-in:   ${t.connections.join(', ')}`);
+        }
+        catch (e) {
+            if (e?.code === 'TENANT_NOT_FOUND' || e?.status === 404) {
+                error('No auth tenant yet for this org.\nCreate it with: myapi auth tenant create');
+            }
+            throw e;
+        }
+        return;
+    }
+    if (action === 'create' || action === 'init') {
+        let theme;
+        if (flags.theme) {
+            try {
+                theme = JSON.parse(flags.theme);
+            }
+            catch {
+                error('--theme must be valid JSON');
+            }
+        }
+        let connections;
+        if (flags.connections) {
+            const allowed = ['google', 'password', 'magic'];
+            connections = flags.connections.split(',').map(s => s.trim()).filter(Boolean);
+            const bad = connections.filter(c => !allowed.includes(c));
+            if (bad.length)
+                error(`--connections may only contain google, password, magic (got: ${bad.join(', ')})`);
+        }
+        const t = await sdkAuth.createTenant(config.api_key, orgId, { theme, connections });
+        if (flags.json) {
+            printJson(t);
+            return;
+        }
+        success(`Auth tenant ready: ${t.tenant_id}`);
+        info(`Issuer:    ${t.issuer}`);
+        info(`Login URL: ${t.login_url}`);
+        if (t.connections?.length)
+            info(`Sign-in:   ${t.connections.join(', ')}`);
+        info('Next: register an app → myapi auth client create --name <n> --type spa --redirect <url>');
+        return;
+    }
+    error(`Unknown action "${action}". Use: myapi auth tenant [show|create]`);
+}
+async function usage(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi auth usage [--org <id>]');
+    const u = await sdkAuth.getUsage(config.api_key, orgId);
+    if (flags.json) {
+        printJson(u);
+        return;
+    }
+    info(`Period:       ${u.period}`);
+    info(`Active users: ${u.active_users} MAU`);
+    info(`Price:        $${(u.price_cents_each / 100).toFixed(2)} per MAU`);
+}
+async function domain(args, flags) {
+    const action = args[0] || 'show';
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi auth domain [show|set|delete] [--org <id>]');
+    const showDomain = (d) => {
+        info(`Domain: ${d.domain}`);
+        info(`Status: ${d.status}`);
+        if (d.status !== 'active') {
+            info('');
+            info(`DNS — create this record:`);
+            info(`  ${d.dns.type}  ${d.dns.name}  →  ${d.dns.value}`);
+            if (d.next)
+                info(`\n${d.next}`);
+        }
+        else {
+            info(`Issuer:    ${d.issuer}`);
+            info(`Login URL: ${d.login_url}`);
+        }
+    };
+    if (action === 'show') {
+        try {
+            const d = await sdkAuth.getDomain(config.api_key, orgId);
+            if (flags.json) {
+                printJson(d);
+                return;
+            }
+            showDomain(d);
+        }
+        catch (e) {
+            if (e?.code === 'NO_DOMAIN' || e?.status === 404) {
+                error('No custom auth domain set.\nSet one with: myapi auth domain set --domain auth.example.com');
+            }
+            throw e;
+        }
+        return;
+    }
+    if (action === 'set' || action === 'register') {
+        const host = flags.domain || args[1] || '';
+        if (!host)
+            error('--domain is required (e.g. --domain auth.example.com)');
+        const d = await sdkAuth.registerDomain(config.api_key, orgId, host);
+        if (flags.json) {
+            printJson(d);
+            return;
+        }
+        success(`Custom auth domain registered: ${d.domain} (${d.status})`);
+        showDomain(d);
+        return;
+    }
+    if (action === 'delete' || action === 'remove') {
+        const host = flags.domain || args[1];
+        let target = host;
+        if (!target) {
+            // No host given — resolve the current one so the user doesn't have to retype it.
+            try {
+                target = (await sdkAuth.getDomain(config.api_key, orgId)).domain;
+            }
+            catch {
+                error('No custom auth domain to delete.');
+            }
+        }
+        await sdkAuth.deleteDomain(config.api_key, orgId, target);
+        success(`Custom auth domain removed: ${target}`);
+        return;
+    }
+    error(`Unknown action "${action}". Use: myapi auth domain [show|set|delete]`);
+}
+async function client(args, flags) {
+    const action = args[0] || 'list';
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi auth client <list|create> [--org <id>]');
+    if (action === 'list') {
+        const res = await sdkAuth.listClients(config.api_key, orgId);
+        if (flags.json) {
+            printJson(res);
+            return;
+        }
+        printTable((res.clients || []).map(c => ({
+            ClientID: c.client_id,
+            Name: c.name || '',
+            Type: c.type,
+            Redirects: (c.redirect_uris || []).join(', '),
+        })), {
+            flags,
+            empty: 'No OIDC clients yet.\nCreate one: myapi auth client create --name <n> --type spa --redirect <url>',
+        });
+        return;
+    }
+    if (action === 'create') {
+        const name = flags.name || '';
+        const type = flags.type;
+        const redirect = flags.redirect || '';
+        if (!name)
+            error('--name is required (e.g. --name "My App")');
+        if (type !== 'spa' && type !== 'web')
+            error("--type must be 'spa' (public) or 'web' (confidential)");
+        if (!redirect)
+            error('--redirect is required (comma-separate multiple URIs)');
+        const redirect_uris = redirect.split(',').map(s => s.trim()).filter(Boolean);
+        const c = await sdkAuth.createClient(config.api_key, orgId, { name, type: type, redirect_uris });
+        if (flags.json) {
+            printJson(c);
+            return;
+        }
+        success(`Client created: ${c.client_id}`);
+        info(`Type:      ${c.type}`);
+        info(`Redirects: ${(c.redirect_uris || []).join(', ')}`);
+        if (c.issuer)
+            info(`Issuer:    ${c.issuer}`);
+        if (c.client_secret) {
+            info('');
+            info('Client secret (shown ONCE — store it now, it cannot be retrieved again):');
+            info(`  ${c.client_secret}`);
+        }
+        return;
+    }
+    error(`Unknown action "${action}". Use: myapi auth client <list|create>`);
+}

package/dist/commands/billing-auto-recharge.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/billing-auto-recharge.test.js

@@ -0,0 +1,103 @@
+// Tests for the auto-recharge client surface: the SDK `withFundsRetry`
+// poll-and-retry helper + the CLI's `autoRechargeSummary` render helper.
+import { describe, it, expect, vi } from 'vitest';
+import { MyApiError, withFundsRetry, isInsufficientFunds, isSpendCapExceeded, autoRechargeState } from '@myapihq/sdk';
+import { autoRechargeSummary } from './billing.js';
+// Build a 402 the way client.ts does — body is the unwrapped `error` object.
+function funds(state, retryAfter) {
+    const body = { code: 'INSUFFICIENT_FUNDS', auto_recharge: state };
+    if (retryAfter != null)
+        body.retry_after_seconds = retryAfter;
+    return new MyApiError('INSUFFICIENT_FUNDS', 402, 'insufficient balance', body);
+}
+const noopSleep = () => Promise.resolve();
+describe('withFundsRetry', () => {
+    it('returns the value when the call succeeds first try (no retry)', async () => {
+        const call = vi.fn().mockResolvedValue('ok');
+        await expect(withFundsRetry(call, { sleep: noopSleep })).resolves.toBe('ok');
+        expect(call).toHaveBeenCalledTimes(1);
+    });
+    it('retries on an in-flight refill, then succeeds', async () => {
+        const call = vi.fn()
+            .mockRejectedValueOnce(funds('in_flight', 0))
+            .mockResolvedValueOnce('ok');
+        const sleep = vi.fn(noopSleep);
+        await expect(withFundsRetry(call, { sleep })).resolves.toBe('ok');
+        expect(call).toHaveBeenCalledTimes(2);
+        expect(sleep).toHaveBeenCalledTimes(1);
+    });
+    it('honors the server retry_after_seconds for the sleep duration', async () => {
+        const call = vi.fn()
+            .mockRejectedValueOnce(funds('in_flight', 7))
+            .mockResolvedValueOnce('ok');
+        const sleep = vi.fn(noopSleep);
+        await withFundsRetry(call, { sleep });
+        expect(sleep).toHaveBeenCalledWith(7000);
+    });
+    it('gives up after maxRetries and rethrows the last error', async () => {
+        const call = vi.fn().mockRejectedValue(funds('in_flight', 0));
+        await expect(withFundsRetry(call, { maxRetries: 2, sleep: noopSleep }))
+            .rejects.toMatchObject({ code: 'INSUFFICIENT_FUNDS' });
+        expect(call).toHaveBeenCalledTimes(3); // initial + 2 retries
+    });
+    it('does NOT retry a capped refill — rethrows immediately (needs a human)', async () => {
+        const call = vi.fn().mockRejectedValue(funds('capped'));
+        await expect(withFundsRetry(call, { sleep: noopSleep })).rejects.toMatchObject({ code: 'INSUFFICIENT_FUNDS' });
+        expect(call).toHaveBeenCalledTimes(1);
+    });
+    it('does NOT retry no_pm / failed / disabled states', async () => {
+        for (const state of ['no_pm', 'failed', 'disabled']) {
+            const call = vi.fn().mockRejectedValue(funds(state));
+            await expect(withFundsRetry(call, { sleep: noopSleep })).rejects.toBeInstanceOf(MyApiError);
+            expect(call).toHaveBeenCalledTimes(1);
+        }
+    });
+    it('does NOT retry a SPEND_CAP_EXCEEDED hard ceiling', async () => {
+        const err = new MyApiError('SPEND_CAP_EXCEEDED', 402, 'cap', { code: 'SPEND_CAP_EXCEEDED', cap_cents: 5000 });
+        const call = vi.fn().mockRejectedValue(err);
+        await expect(withFundsRetry(call, { sleep: noopSleep })).rejects.toBe(err);
+        expect(call).toHaveBeenCalledTimes(1);
+    });
+    it('rethrows non-funds errors untouched', async () => {
+        const err = new Error('network down');
+        const call = vi.fn().mockRejectedValue(err);
+        await expect(withFundsRetry(call, { sleep: noopSleep })).rejects.toBe(err);
+        expect(call).toHaveBeenCalledTimes(1);
+    });
+});
+describe('funds predicates', () => {
+    it('isInsufficientFunds matches both new and legacy codes', () => {
+        expect(isInsufficientFunds(funds('disabled'))).toBe(true);
+        expect(isInsufficientFunds(new MyApiError('INSUFFICIENT_BALANCE', 402, 'x', {}))).toBe(true);
+        expect(isInsufficientFunds(new MyApiError('SPEND_CAP_EXCEEDED', 402, 'x', {}))).toBe(false);
+        expect(isInsufficientFunds(new Error('x'))).toBe(false);
+    });
+    it('isSpendCapExceeded + autoRechargeState read the right fields', () => {
+        expect(isSpendCapExceeded(new MyApiError('SPEND_CAP_EXCEEDED', 402, 'x', {}))).toBe(true);
+        expect(autoRechargeState(funds('in_flight'))).toBe('in_flight');
+        expect(autoRechargeState(new Error('x'))).toBeUndefined();
+    });
+});
+describe('autoRechargeSummary', () => {
+    const base = {
+        enabled: true, threshold_cents: 500, amount_cents: 2000, monthly_cap_cents: 10000,
+        month_to_date_recharged_cents: 4000, has_payment_method: true,
+        last_recharge_status: 'succeeded', last_recharge_attempt_at: null,
+    };
+    it('returns null when disabled', () => {
+        expect(autoRechargeSummary({ ...base, enabled: false })).toBeNull();
+    });
+    it('summarizes an enabled config with dollar amounts', () => {
+        const s = autoRechargeSummary(base);
+        expect(s).toContain('$5.00');
+        expect(s).toContain('$20.00');
+        expect(s).toContain('$40.00'); // month-to-date
+        expect(s).toContain('$100.00'); // cap
+    });
+    it('flags a failed/capped status but not a healthy/pending one', () => {
+        expect(autoRechargeSummary({ ...base, last_recharge_status: 'failed' })).toContain('⚠ failed');
+        expect(autoRechargeSummary({ ...base, last_recharge_status: 'capped' })).toContain('⚠ capped');
+        expect(autoRechargeSummary({ ...base, last_recharge_status: 'pending' })).not.toContain('⚠');
+        expect(autoRechargeSummary(base)).not.toContain('⚠');
+    });
+});

package/dist/commands/billing.d.ts

@@ -1,3 +1,4 @@
+import { hq } from '@myapihq/sdk';
 import type { FlagSchema } from '../flags.js';
 import type { Flags } from '../helpers.js';
 import type { Exposes } from '../exposes.js';
@@ -9,4 +10,6 @@ export declare function history(flags: Flags): Promise<void>;
 export declare function usage(flags: Flags): Promise<void>;
 export declare function topup(amountStr: string, flags: Flags): Promise<void>;
 export declare function setup(_flags: Flags): Promise<void>;
+export declare function autoRechargeSummary(cfg: hq.AutoRechargeConfig): string | null;
+export declare function autoRecharge(action: string | undefined, flags: Flags): Promise<void>;
 export declare function spendCap(arg: string | undefined, flags: Flags): Promise<void>;

package/dist/commands/billing.js

@@ -5,6 +5,9 @@ import { confirm, isNonInteractive } from '../prompt.js';
 import { formatDate } from '../utils.js';
 export const SCHEMA = {
     period: 'string', // spend-cap window: month | day
+    threshold: 'string', // auto-recharge: refill when balance drops below ($)
+    amount: 'string', // auto-recharge: how much to refill each time ($)
+    'monthly-cap': 'string', // auto-recharge: max auto-recharged per month ($)
 };
 export const EXPOSES = [
     'GET /hq/billing/balance',
@@ -14,8 +17,26 @@ export const EXPOSES = [
     'POST /hq/billing/topup',
     'GET /hq/account/me',
     'PATCH /hq/account/spend-cap',
+    'GET /hq/billing/auto-recharge',
+    'PUT /hq/billing/auto-recharge',
+    'DELETE /hq/billing/auto-recharge',
 ];
 const SUBCOMMAND_USAGE = {
+    'auto-recharge': `myapi billing auto-recharge [show | set | disable]
+
+Keep the prepaid wallet funded without a human in the loop: when the balance
+drops below the threshold, MyAPI charges your saved card to refill it, bounded
+by a monthly cap. Off by default; enabling needs a payment method on file.
+
+  myapi billing auto-recharge                 Show current config + status
+  myapi billing auto-recharge set \\
+      --threshold 5 --amount 20 --monthly-cap 100
+                                              Refill to keep ≥$5, $20 at a time,
+                                              up to $100/month
+  myapi billing auto-recharge disable         Turn off (settings are kept)
+
+Amounts are whole dollars. The refill amount must be ≥ $5 and ≥ the threshold;
+the monthly cap must be ≥ the refill amount.`,
     'balance': 'myapi billing balance [--json]',
     'history': 'myapi billing history [--json]',
     'usage': `myapi billing usage [--period month|30d] [--json]
@@ -48,6 +69,7 @@ export async function run(subcommand, args, flags) {
         info(`Usage: myapi billing <subcommand>
 
 Subcommands:
+  auto-recharge  Keep the wallet funded automatically (show/set/disable)
   balance    Check balance, credits, and payment method status
   history    View recent transactions and top-ups
   setup      Open a checkout link to add or update payment method
@@ -71,6 +93,7 @@ Subcommands:
         case 'topup': return topup(args[0], flags);
         case 'setup': return setup(flags);
         case 'spend-cap': return spendCap(args[0], flags);
+        case 'auto-recharge': return autoRecharge(args[0], flags);
         default: error(`Unknown subcommand: ${subcommand}. Run "myapi billing --help" for available subcommands.`);
     }
 }
@@ -92,7 +115,7 @@ export async function balance(flags) {
     // Anonymous accounts can't transact — paid surface is gated on a
     // verified email and credits only fund on upgrade. Surface the unblock.
     if (config.is_anonymous) {
-        info('→ Link an email to unlock $5 free credit + paid actions: myapi auth link <email>');
+        info('→ Link an email to unlock $5 free credit + paid actions: myapi account link <email>');
     }
 }
 export async function history(flags) {
@@ -165,6 +188,98 @@ export async function setup(_flags) {
     const result = await hq.setupPayment(config.api_key);
     success(`Open this URL in your browser to set up payment:\n${result.url}`);
 }
+function fmtCents(c) {
+    return c == null ? '—' : `$${(c / 100).toFixed(2)}`;
+}
+// One-line summary of auto-recharge state, reused by `billing auto-recharge`
+// and `status`. Returns null when off (callers decide whether to show "off").
+export function autoRechargeSummary(cfg) {
+    if (!cfg.enabled)
+        return null;
+    let s = `on — refill to ≥ ${fmtCents(cfg.threshold_cents)}, ${fmtCents(cfg.amount_cents)} each (${fmtCents(cfg.month_to_date_recharged_cents)}/${fmtCents(cfg.monthly_cap_cents)} this month)`;
+    if (cfg.last_recharge_status && cfg.last_recharge_status !== 'succeeded' && cfg.last_recharge_status !== 'pending') {
+        s += `  ⚠ ${cfg.last_recharge_status}`;
+    }
+    return s;
+}
+const RECHARGE_STATUS_HINT = {
+    failed: 'last refill was declined — check your card: myapi billing setup',
+    capped: 'monthly cap reached — refills paused until next month, or raise --monthly-cap',
+    no_pm: 'no payment method — add one: myapi billing setup',
+    pending: 'a refill is in progress',
+};
+function renderAutoRecharge(cfg) {
+    if (!cfg.enabled) {
+        info('Auto-recharge: off');
+        info(`  Payment method on file: ${cfg.has_payment_method ? 'yes' : 'no'}`);
+        info('  Enable with: myapi billing auto-recharge set --threshold <$> --amount <$> --monthly-cap <$>');
+        if (!cfg.has_payment_method)
+            info('  (add a payment method first: myapi billing setup)');
+        return;
+    }
+    info('Auto-recharge: on');
+    info(`  Refill to keep balance ≥ ${fmtCents(cfg.threshold_cents)}, adding ${fmtCents(cfg.amount_cents)} each time`);
+    info(`  Monthly cap: ${fmtCents(cfg.month_to_date_recharged_cents)} of ${fmtCents(cfg.monthly_cap_cents)} used this month`);
+    info(`  Payment method on file: ${cfg.has_payment_method ? 'yes' : 'no'}`);
+    if (cfg.last_recharge_status && cfg.last_recharge_status !== 'succeeded') {
+        const hint = RECHARGE_STATUS_HINT[cfg.last_recharge_status];
+        info(`  ⚠ Status: ${cfg.last_recharge_status}${hint ? ` — ${hint}` : ''}`);
+    }
+}
+// Keep the wallet funded without a human. No arg / "show" → display config;
+// "set" → enable/update from --threshold/--amount/--monthly-cap (whole
+// dollars); "disable" → turn off (settings preserved for easy re-enable).
+export async function autoRecharge(action, flags) {
+    const config = requireConfig();
+    const act = action ?? 'show';
+    if (act === 'show') {
+        const cfg = await hq.getAutoRecharge(config.api_key);
+        if (flags.json) {
+            printJson(cfg);
+            return;
+        }
+        renderAutoRecharge(cfg);
+        return;
+    }
+    if (act === 'disable') {
+        await hq.disableAutoRecharge(config.api_key);
+        success('Auto-recharge disabled. Your threshold/amount/cap are kept — re-enable with: myapi billing auto-recharge set');
+        return;
+    }
+    if (act === 'set') {
+        const dollarsToCents = (v, name) => {
+            if (v == null)
+                return undefined;
+            const n = Number(v);
+            if (!Number.isFinite(n) || n < 0) {
+                error(`Invalid --${name} "${v}". Use a whole dollar amount (e.g. --${name} 20).`);
+            }
+            return Math.round(n * 100);
+        };
+        const input = { enabled: true };
+        const threshold = dollarsToCents(flags.threshold, 'threshold');
+        const amount = dollarsToCents(flags.amount, 'amount');
+        const cap = dollarsToCents(flags['monthly-cap'], 'monthly-cap');
+        if (threshold != null)
+            input.threshold_cents = threshold;
+        if (amount != null)
+            input.amount_cents = amount;
+        if (cap != null)
+            input.monthly_cap_cents = cap;
+        // The backend enforces the invariants (≥$5 floor, amount ≥ threshold,
+        // cap ≥ amount, payment method present) and returns a 400 the top-level
+        // handler renders — no need to duplicate that validation here.
+        const cfg = await hq.setAutoRecharge(config.api_key, input);
+        if (flags.json) {
+            printJson(cfg);
+            return;
+        }
+        success('Auto-recharge enabled.');
+        renderAutoRecharge(cfg);
+        return;
+    }
+    error(`Unknown action "${act}". Use: myapi billing auto-recharge [show | set | disable]`);
+}
 // The account-level spend ceiling. No arg → show; "clear" → remove; a
 // dollar amount → set. Distinct from per-key caps (myapi keys create
 // --spend-cap): this is the aggregate backstop across the whole account.

package/dist/commands/config.js

@@ -49,7 +49,7 @@ export async function setFunnel(id, _flags, via = 'auth config') {
     const config = requireConfig();
     const orgId = config.default_org;
     if (!orgId)
-        error('No default organization set. Run: myapi auth config set-org <id>');
+        error('No default organization set. Run: myapi account config set-org <id>');
     info('› Validating…');
     const { funnel } = await sdkFunnel.getFunnel(config.api_key, orgId, id);
     const funnelId = funnel.id;

package/dist/commands/container.d.ts

@@ -11,6 +11,7 @@ export declare function create(flags: Flags): Promise<void>;
 export declare function list(flags: Flags): Promise<void>;
 export declare function get(id: string, flags: Flags): Promise<void>;
 export declare function del(id: string, flags: Flags): Promise<void>;
+export declare function _isTarball(p: string): boolean;
 export declare function deploy(id: string, image: string, flags: Flags): Promise<void>;
 export declare function logs(id: string, flags: Flags): Promise<void>;
 export declare function domain(id: string, domainArg: string | undefined, flags: Flags): Promise<void>;