@myapihq/cli 1.2.4 → 1.2.6

package/dist/commands/funnel.js

@@ -1,3 +1,5 @@
+import { readdir, readFile, stat } from 'fs/promises';
+import { join, relative, sep } from 'path';
 import { funnel as sdkFunnel, hq } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson } from '../output.js';
@@ -10,14 +12,25 @@ export const EXPOSES = [
     'DELETE /funnel/orgs/{org_id}/funnels/{funnel_id}',
     'POST /funnel/orgs/{org_id}/funnels/{funnel_id}/push-page',
     'POST /funnel/orgs/{org_id}/funnels/{funnel_id}/verify',
+    'POST /funnel/orgs/{org_id}/funnels/{funnel_id}/files',
     'GET /funnel/orgs/{org_id}/funnels/{funnel_id}/pages',
     'GET /hq/orgs/{org_id}',
 ];
 export const SCHEMA = {
-    org: 'string',
     funnel: 'string',
     slug: 'string',
+    env: 'string',
+    'api-fn': 'string',
 };
+// Backend (2026-05-15): POST /funnels accepts an optional `name` (defaults
+// to the org's preview_subdomain for back-compat). Mirror the backend's
+// validation client-side so typos fail before the network call.
+const FUNNEL_NAME_RE = /^[a-z0-9][a-z0-9-]{0,49}$/;
+function validateFunnelName(name) {
+    if (!FUNNEL_NAME_RE.test(name)) {
+        error(`Invalid --name "${name}". Lowercase letters, digits, hyphens; 1-50 chars; starts with a letter or digit.`);
+    }
+}
 export async function list(flags) {
     const config = requireConfig();
     const orgId = requireOrg(flags, config, 'myapi funnel list [--org <id>]');
@@ -39,9 +52,14 @@ export async function list(flags) {
 }
 export async function create(flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi funnel create [--org <id>]');
-    const result = await sdkFunnel.createFunnel(config.api_key, orgId);
+    const orgId = requireOrg(flags, config, 'myapi funnel create [--name <name>] [--org <id>]');
+    const name = flags.name;
+    if (name)
+        validateFunnelName(name);
+    const result = await sdkFunnel.createFunnel(config.api_key, orgId, name ? { name } : undefined);
     success(`Funnel created! ID: ${result.funnel.id}`);
+    if (result.funnel.name)
+        info(`Name:    ${result.funnel.name}`);
     if (result.domain_url)
         info(`Live: ${result.domain_url}`);
     else if (result.subdomain_url)
@@ -180,13 +198,89 @@ export async function verify(slug, flags) {
     const v = await sdkFunnel.verifyFunnel(config.api_key, orgId, funnelId, { slug: finalSlug });
     printJson(v);
 }
+// Recursively collect every file under `dir`, returning site-relative
+// paths (POSIX separators) paired with their contents.
+async function collectFiles(dir, root) {
+    const out = [];
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+        const abs = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...await collectFiles(abs, root));
+        }
+        else if (entry.isFile()) {
+            out.push({ path: relative(root, abs).split(sep).join('/'), content: await readFile(abs) });
+        }
+    }
+    return out;
+}
+// publish uploads a whole directory as the funnel's site (my-funnel-api v2).
+// Resolves the funnel the same way push/verify do.
+export async function publish(dir, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi funnel publish <dir> [--funnel <id>] [--env dev|prod] [--org <id>]');
+    if (!dir)
+        error('Missing directory.\nUsage: myapi funnel publish <dir> [--funnel <id>] [--env dev|prod]');
+    let dirStat;
+    try {
+        dirStat = await stat(dir);
+    }
+    catch {
+        error(`Directory not found: ${dir}`);
+    }
+    if (!dirStat.isDirectory())
+        error(`Not a directory: ${dir}. Pass the site's root folder.`);
+    const env = flags.env;
+    if (env && env !== 'dev' && env !== 'prod')
+        error(`Invalid --env "${env}". Use "dev" or "prod" (default prod).`);
+    let funnelId = flags.funnel || config.default_funnel;
+    if (!funnelId) {
+        const existing = await sdkFunnel.listFunnels(config.api_key, orgId);
+        if (existing.length === 0)
+            error('No funnel found for this org. Create one with: myapi funnel create');
+        if (existing.length > 1) {
+            error(`Multiple funnels exist for this org and no default is set.\nPick one with --funnel <id>, or set a default:\n  myapi config set-funnel <id>\n\nFunnels:\n${existing.map(f => `  ${f.id}`).join('\n')}`);
+        }
+        funnelId = existing[0].id;
+    }
+    const files = await collectFiles(dir, dir);
+    if (files.length === 0)
+        error(`No files found under ${dir}.`);
+    const result = await sdkFunnel.publishFiles(config.api_key, orgId, funnelId, files, {
+        env: env,
+        apiFunctionId: flags['api-fn'],
+    });
+    if (flags.json) {
+        printJson(result);
+        return;
+    }
+    success(`Published ${result.file_count} file(s) to the ${result.channel} channel`);
+    info(`Size:   ${(result.size_bytes / 1024).toFixed(1)} KB`);
+    info(`SPA:    ${result.spa_mode ? 'on' : 'off'}`);
+    info(`Live:   ${result.published_url}`);
+}
 // ── Dispatcher ───────────────────────────────────────────────────────────────
 const SUBCOMMAND_USAGE = {
     'list': 'myapi funnel list [--org <id>] [--json]',
-    'create': 'myapi funnel create [--org <id>]',
+    'create': 'myapi funnel create [--name <name>] [--org <id>]',
     'get': 'myapi funnel get <id> [--org <id>] [--json]',
     'delete': 'myapi funnel delete <id> [--org <id>]',
     'pages': 'myapi funnel pages [funnel_id] [--funnel <id>] [--org <id>] [--json]',
+    'publish': `myapi funnel publish <dir> [--funnel <id>] [--env dev|prod] [--api-fn <id>] [--org <id>]
+
+Uploads a whole local directory as the funnel's site. Each file's path
+within <dir> becomes its path on the site (e.g. dir/about/index.html →
+/about/index.html). 25MB total cap.
+
+  --env dev|prod    Target channel (default prod). dev publishes to
+                    <name>-dev.makeautonomous.com for preview.
+  --api-fn <id>     Bind /api/* on the site to a deployed function.
+
+SPA fallback is auto-enabled when the publish has a root index.html.
+
+Examples:
+  myapi funnel publish ./dist
+  myapi funnel publish ./dist --env dev
+  myapi funnel publish ./site --api-fn <function_id>`,
     'push': `myapi funnel push [slug] [--funnel <id>] [--slug <path>] [--org <id>] < page.html
 
 Reads HTML from stdin and publishes to <slug> on your funnel. Funnel is resolved
@@ -219,9 +313,10 @@ export async function run(subcommand, args, flags) {
 
 Subcommands:
   list       List funnels
-  create     Create a funnel
+  create     Create a funnel (optional --name; backend defaults to org's preview_subdomain)
   get <id>   Get funnel details
   delete     Delete a funnel
+  publish    Publish a whole local directory as the site (dev or prod)
   push       Push a raw HTML page from stdin to a slug
   pages      List the pages currently published to a funnel
   verify     Verify a published page is reachable
@@ -242,6 +337,7 @@ All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         case 'create': return create(flags);
         case 'get': return get(args[0], flags);
         case 'delete': return del(args[0], flags);
+        case 'publish': return publish(args[0], flags);
         case 'push': return push(args[0], flags);
         case 'verify': return verify(args[0], flags);
         case 'pages': return pages(args[0], flags);

package/dist/commands/keys-validation.test.d.ts

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

package/dist/commands/keys-validation.test.js

@@ -0,0 +1,87 @@
+// Unit tests for the keys-command pure validators: `--grant` parsing and
+// dollar→cents conversion. Both mirror server-side rules so a bad value
+// fails before the network call.
+import { describe, it, expect } from 'vitest';
+import { _parseGrants, _dollarsToCents } from './keys.js';
+import { hq } from '@myapihq/sdk';
+describe('_parseGrants', () => {
+    describe('accepts', () => {
+        it('a bare slot — write is implied', () => {
+            expect(_parseGrants('email')).toEqual({ email: 'write' });
+        });
+        it('an explicit slot:access pair', () => {
+            expect(_parseGrants('crm:read')).toEqual({ crm: 'read' });
+        });
+        it('multiple comma-separated entries, mixed forms', () => {
+            expect(_parseGrants('email:write,crm:read,database')).toEqual({
+                email: 'write', crm: 'read', database: 'write',
+            });
+        });
+        it('the "*" wildcard slot', () => {
+            expect(_parseGrants('*:read')).toEqual({ '*': 'read' });
+            expect(_parseGrants('*')).toEqual({ '*': 'write' });
+        });
+        it('every grantable slot from the SDK vocabulary', () => {
+            for (const slot of hq.GRANTABLE_SLOTS) {
+                expect(_parseGrants(slot)).toEqual({ [slot]: 'write' });
+            }
+        });
+        it('tolerates surrounding whitespace', () => {
+            expect(_parseGrants(' email : write , crm '.replace(/ /g, ''))).toEqual({
+                email: 'write', crm: 'write',
+            });
+            expect(_parseGrants('email, crm')).toEqual({ email: 'write', crm: 'write' });
+        });
+    });
+    describe('rejects (returns an error string)', () => {
+        it('an unknown slot', () => {
+            const r = _parseGrants('rabbitmq:write');
+            expect(typeof r).toBe('string');
+            expect(r).toMatch(/Unknown slot "rabbitmq"/);
+        });
+        it('a management slot — hq is not grantable', () => {
+            expect(typeof _parseGrants('hq:write')).toBe('string');
+            expect(_parseGrants('hq:write')).toMatch(/Unknown slot "hq"/);
+        });
+        it('an invalid access level', () => {
+            const r = _parseGrants('email:admin');
+            expect(typeof r).toBe('string');
+            expect(r).toMatch(/Invalid access "admin"/);
+        });
+        it('an empty string', () => {
+            expect(typeof _parseGrants('')).toBe('string');
+            expect(_parseGrants('')).toMatch(/--grant was empty/);
+        });
+        it('a string of only commas/whitespace', () => {
+            expect(typeof _parseGrants(' , , ')).toBe('string');
+        });
+        it('reports the FIRST bad entry when several are present', () => {
+            // crm is valid, bogus is not — error names bogus.
+            expect(_parseGrants('crm:read,bogus:write')).toMatch(/Unknown slot "bogus"/);
+        });
+    });
+});
+describe('_dollarsToCents', () => {
+    describe('accepts', () => {
+        it.each([
+            ['50', 5000],
+            ['9.99', 999],
+            ['0', 0],
+            ['0.5', 50],
+            ['100', 10000],
+            ['0.01', 1],
+        ])('%s → %d cents', (input, cents) => {
+            expect(_dollarsToCents(input)).toBe(cents);
+        });
+        it('rounds sub-cent input', () => {
+            expect(_dollarsToCents('9.999')).toBe(1000); // 999.9 → 1000
+        });
+    });
+    describe('rejects (returns an error string)', () => {
+        it.each(['-5', 'abc', '', 'free', '$50', '10usd'])('rejects %s', (input) => {
+            const r = _dollarsToCents(input);
+            expect(typeof r).toBe('string');
+            expect(r).toMatch(/not a valid dollar amount/);
+        });
+    });
+});

package/dist/commands/keys.d.ts

@@ -1,10 +1,14 @@
+import { hq } from '@myapihq/sdk';
 import type { FlagSchema } from '../flags.js';
 import type { Flags } from '../helpers.js';
 import type { Exposes } from '../exposes.js';
 export declare const SCHEMA: FlagSchema;
 export declare const EXPOSES: Exposes;
-export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;
-export declare function runApiKeys(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;
+export declare function _parseGrants(raw: string): hq.Grants | string;
+export declare function _dollarsToCents(raw: string): number | string;
 export declare function createNew(flags: Flags): Promise<void>;
 export declare function list(flags: Flags): Promise<void>;
 export declare function revoke(id: string, _flags: Flags): Promise<void>;
+export declare function revokeAll(flags: Flags): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;
+export declare function runApiKeys(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/keys.js

@@ -1,47 +1,215 @@
 import { hq } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson } from '../output.js';
-import { formatDate } from '../utils.js';
-import { ask } from '../prompt.js';
+import { ask, confirm, isNonInteractive } from '../prompt.js';
 import { requireArg } from '../helpers.js';
 export const SCHEMA = {
     name: 'string',
+    // Capability IAM (design-iam-capability-keys-2026-05-15).
+    grant: 'string', // slot:access list, e.g. "email:write,crm:read"
+    org: 'string', // lock the key to one org id
+    'spend-cap': 'string', // per-key spend ceiling, in dollars
+    kind: 'string', // revoke-all filter: function|manual|account
 };
 export const EXPOSES = [
     'POST /hq/account/create/key',
     'GET /hq/account/keys',
+    'POST /hq/account/keys/revoke-all',
     'DELETE /hq/account/delete/key/{key_id}',
 ];
-const KEYS_HEADER = `Usage: myapi keys <subcommand>
+// "*" is a valid grant target (wildcard slot) but not a named slot.
+const VALID_GRANT_TARGETS = new Set([...hq.GRANTABLE_SLOTS, '*']);
+const KEY_KINDS = ['function', 'manual', 'account'];
+// Parses a `--grant` string into a Grants map. Accepts comma-separated
+// `slot` (write implied) or `slot:access` entries. Validates every slot
+// against the closed vocabulary so a typo fails before the network call.
+//
+// `_parseGrants` is the pure form — returns the Grants map on success or an
+// error-message string on failure (suitable for unit tests). `parseGrants`
+// is the thin wrapper that calls `error()` (which exits) on failure.
+export function _parseGrants(raw) {
+    const grants = {};
+    for (const part of raw.split(',').map(s => s.trim()).filter(Boolean)) {
+        const [slot, accessRaw] = part.includes(':') ? part.split(':', 2) : [part, 'write'];
+        if (!VALID_GRANT_TARGETS.has(slot)) {
+            return `Unknown slot "${slot}" in --grant. Valid slots: ${[...hq.GRANTABLE_SLOTS].join(', ')} (or "*").`;
+        }
+        if (accessRaw !== 'read' && accessRaw !== 'write') {
+            return `Invalid access "${accessRaw}" for "${slot}" in --grant. Use read or write.`;
+        }
+        grants[slot] = accessRaw;
+    }
+    if (Object.keys(grants).length === 0) {
+        return '--grant was empty. Example: --grant email:write,crm:read  (or --grant email for write)';
+    }
+    return grants;
+}
+function parseGrants(raw) {
+    const r = _parseGrants(raw);
+    if (typeof r === 'string')
+        error(r);
+    return r;
+}
+// Dollars → cents. The CLI surface is dollars (matches `billing topup`);
+// the API is cents. Pure form returns cents or an error-message string.
+export function _dollarsToCents(raw) {
+    // Number('') and Number('   ') are both 0 — reject empty input explicitly
+    // so a missing value never silently becomes a $0 cap.
+    const trimmed = raw.trim();
+    const n = Number(trimmed);
+    if (trimmed === '' || !Number.isFinite(n) || n < 0) {
+        return `"${raw}" is not a valid dollar amount — use a non-negative number, e.g. 50 or 9.99.`;
+    }
+    return Math.round(n * 100);
+}
+function dollarsToCents(raw, flagName) {
+    const r = _dollarsToCents(raw);
+    if (typeof r === 'string')
+        error(`${flagName}: ${r}`);
+    return r;
+}
+function grantsSummary(g) {
+    const entries = Object.entries(g);
+    if (entries.length === 0)
+        return 'none';
+    // write is the common case — show bare slot; annotate only read.
+    return entries.map(([s, a]) => (a === 'write' ? s : `${s}:${a}`)).join(',');
+}
+// Plain-English one-liner — the "what can this key do" the IAM model promises
+// you can answer by reading the key.
+function describeKey(k) {
+    const parts = [k.org_id ? `org ${k.org_id}` : 'all orgs', grantsSummary(k.grants)];
+    if (k.spend_cap_cents != null) {
+        parts.push(`cap $${(k.spend_cap_cents / 100).toFixed(2)}/${k.spend_cap_period}`);
+    }
+    return parts.join(' · ');
+}
+// ── Subcommands ──────────────────────────────────────────────────────────────
+export async function createNew(flags) {
+    const config = requireConfig();
+    let name = flags.name || '';
+    if (!name)
+        name = await ask('Enter a name for the new key: ');
+    if (!name.trim())
+        error('Key name cannot be empty. Use --name <name>');
+    const opts = {};
+    if (typeof flags.grant === 'string')
+        opts.grants = parseGrants(flags.grant);
+    if (typeof flags.org === 'string')
+        opts.orgId = flags.org;
+    if (typeof flags['spend-cap'] === 'string')
+        opts.spendCapCents = dollarsToCents(flags['spend-cap'], '--spend-cap');
+    const key = await hq.createApiKey(config.api_key, name.trim(), opts);
+    if (flags.json) {
+        printJson(key);
+        return;
+    }
+    success('New API key created!');
+    info(`Name:   ${key.name}`);
+    info(`Key:    ${key.api_key}`);
+    info(`Scope:  ${describeKey(key)}`);
+    info('');
+    info("Copy the key now — you won't be able to see it again.");
+}
+export async function list(flags) {
+    const config = requireConfig();
+    const keysList = await hq.listApiKeys(config.api_key);
+    if (flags.json) {
+        printJson(keysList);
+        return;
+    }
+    const rows = keysList.map(k => ({
+        Name: k.name || 'Unnamed',
+        ID: k.id,
+        Kind: k.kind,
+        Scope: k.org_id ? 'org' : 'account',
+        Grants: grantsSummary(k.grants),
+        // "spent / cap" for the current period; "—" when uncapped.
+        Cap: k.spend_cap_cents != null
+            ? `$${((k.current_period_spend_cents ?? 0) / 100).toFixed(2)} / $${(k.spend_cap_cents / 100).toFixed(2)} (${k.spend_cap_period})`
+            : '—',
+    }));
+    printTable(rows, {
+        flags,
+        empty: 'No API keys yet. Create one with: myapi keys create',
+    });
+}
+export async function revoke(id, _flags) {
+    requireArg(id, 'id', 'myapi keys revoke <id>');
+    const config = requireConfig();
+    await hq.revokeApiKey(config.api_key, id);
+    success(`Key ${id} revoked successfully.`);
+}
+export async function revokeAll(flags) {
+    const config = requireConfig();
+    const kind = flags.kind;
+    if (kind && !KEY_KINDS.includes(kind)) {
+        error(`Invalid --kind "${kind}". Use one of: ${KEY_KINDS.join(', ')}.`);
+    }
+    const scope = kind
+        ? `all "${kind}" keys`
+        : 'EVERY active key in the account — including the key this CLI is using';
+    if (!flags.yes && !flags.y) {
+        if (isNonInteractive()) {
+            error(`revoke-all is destructive and needs confirmation. Re-run with --yes:\n  myapi keys revoke-all${kind ? ` --kind ${kind}` : ''} --yes`);
+        }
+        const ok = await confirm(`Revoke ${scope}? This cannot be undone. (y/N) `, false);
+        if (!ok) {
+            info('Aborted.');
+            return;
+        }
+    }
+    const res = await hq.revokeAllKeys(config.api_key, kind);
+    success(`Revoked ${res.revoked} key(s).`);
+    if (!kind) {
+        info('Your current key was revoked too — re-authenticate with: myapi auth setup');
+    }
+}
+// ── Dispatcher ───────────────────────────────────────────────────────────────
+function header(prefix) {
+    return `Usage: myapi ${prefix} <subcommand>
 
-Manage programmatic API keys for your account.
+Manage programmatic API keys. A key carries its authority inline — org scope,
+slot grants, and an optional spend cap. A minted key is always a subset of the
+key that minted it (no privilege escalation).
 
 Subcommands:
-  list             List all API keys with IDs and creation dates
-  create           Create a new API key (the key value is shown once)
-  revoke <id>      Permanently revoke an API key by ID
+  list                 List keys with kind, scope, grants, and spend cap
+  create               Mint a new key (value shown once)
+  revoke <id>          Revoke one key by ID
+  revoke-all           Kill switch — revoke every key (or --kind function|manual|account)
 
-Alias for: myapi auth api-keys`;
-const API_KEYS_HEADER = `Usage: myapi auth api-keys <subcommand>
+create flags:
+  --name <name>        Key name (prompted if omitted)
+  --grant <list>       Slot grants, e.g. --grant email:write,crm:read
+                       (bare slot = write; "*" = all slots). Omit for unrestricted.
+  --org <org_id>       Lock the key to one org. Omit for account-wide.
+  --spend-cap <usd>    Per-key spend ceiling in dollars, e.g. --spend-cap 50
 
-Manage programmatic API keys for your account.
-
-Subcommands:
-  list             List all API keys with IDs and creation dates
-  create           Create a new API key (the key value is shown once)
-  revoke <id>      Permanently revoke an API key by ID
-
-Alias: myapi keys <subcommand>`;
+${prefix === 'keys' ? 'Alias for: myapi auth api-keys' : 'Alias: myapi keys <subcommand>'}`;
+}
 function subcommandUsage(prefix) {
     return {
         'list': `myapi ${prefix} list [--json]`,
-        'create': `myapi ${prefix} create [--name <name>]\n\nCreates a new API key. If --name is omitted you will be prompted.`,
-        'revoke': `myapi ${prefix} revoke <id>\n\nPermanently revokes an API key by ID. The key stops working immediately and the action cannot be undone.`,
+        'create': `myapi ${prefix} create [--name <name>] [--grant <list>] [--org <org_id>] [--spend-cap <usd>]
+
+Mints a key whose authority is a subset of the calling key's. Examples:
+  myapi ${prefix} create --name ci --grant funnel:write,storage:read
+  myapi ${prefix} create --name billing-fn --org <org_id> --grant email --spend-cap 25
+  myapi ${prefix} create --name readonly --grant '*:read'
+
+Omitting --grant mints an unrestricted key. --grant slots: ${[...hq.GRANTABLE_SLOTS].join(', ')}.`,
+        'revoke': `myapi ${prefix} revoke <id>\n\nRevokes one key by ID. Takes effect immediately; cannot be undone.`,
+        'revoke-all': `myapi ${prefix} revoke-all [--kind function|manual|account] [--yes]
+
+Kill switch. With no --kind, revokes EVERY active key in the account — including
+the key this CLI is authenticated with (recovery: myapi auth setup). --kind
+narrows it to one provenance class. Destructive — confirms unless --yes.`,
     };
 }
 async function dispatch(prefix, subcommand, args, flags) {
     if (!subcommand || (flags.help && !subcommand)) {
-        info(prefix === 'keys' ? KEYS_HEADER : API_KEYS_HEADER);
+        info(header(prefix));
         return;
     }
     if (flags.help) {
@@ -56,6 +224,7 @@ async function dispatch(prefix, subcommand, args, flags) {
         case 'create': return createNew(flags);
         case 'list': return list(flags);
         case 'revoke': return revoke(args[0], flags);
+        case 'revoke-all': return revokeAll(flags);
         default: error(`Unknown subcommand: ${subcommand}. Run "myapi ${prefix} --help" for available subcommands.`);
     }
 }
@@ -65,38 +234,3 @@ export async function run(subcommand, args, flags) {
 export async function runApiKeys(subcommand, args, flags) {
     return dispatch('auth api-keys', subcommand, args, flags);
 }
-export async function createNew(flags) {
-    const config = requireConfig();
-    let name = flags.name || '';
-    if (!name)
-        name = await ask('Enter a name for the new key: ');
-    if (!name.trim())
-        error('Key name cannot be empty. Use --name <name>');
-    const keyInfo = await hq.createApiKey(config.api_key, name.trim());
-    success(`New API key created!\n\nName: ${keyInfo.prefix}...\nKey:  ${keyInfo.api_key}\n\nMake sure to copy your new API key now. You won't be able to see it again!`);
-}
-export async function list(flags) {
-    const config = requireConfig();
-    const keysList = await hq.listApiKeys(config.api_key);
-    if (flags.json) {
-        printJson(keysList);
-        return;
-    }
-    const formattedKeys = keysList.map(k => ({
-        Name: k.name || 'Unnamed',
-        Prefix: k.prefix,
-        ID: k.id,
-        'Created At': formatDate(k.created_at),
-        'Last Used': k.last_used_at ? formatDate(k.last_used_at) : 'Never',
-    }));
-    printTable(formattedKeys, {
-        flags,
-        empty: 'No API keys yet. Create one with: myapi keys create',
-    });
-}
-export async function revoke(id, _flags) {
-    requireArg(id, 'id', 'myapi keys revoke <id>');
-    const config = requireConfig();
-    await hq.revokeApiKey(config.api_key, id);
-    success(`Key ${id} revoked successfully.`);
-}

package/dist/commands/payments-validation.test.d.ts

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

package/dist/commands/payments-validation.test.js

@@ -0,0 +1,31 @@
+// Unit tests for payments.ts CLI's pure dollar-amount validator. A charge
+// must be strictly positive — $0 and negatives are rejected (unlike a spend
+// cap, where $0 is a meaningful "block everything" value).
+import { describe, it, expect } from 'vitest';
+import { _amountToCents } from './payments.js';
+describe('_amountToCents — pure helper', () => {
+    describe('valid amounts', () => {
+        it.each([
+            ['19', 1900],
+            ['9.99', 999],
+            ['0.01', 1],
+            ['  25  ', 2500], // surrounding whitespace tolerated
+            ['100', 10000],
+            ['0.999', 100], // rounds to nearest cent
+        ])('converts %s → %d cents', (raw, cents) => {
+            expect(_amountToCents(raw)).toBe(cents);
+        });
+    });
+    describe('rejections', () => {
+        it.each([
+            ['empty string', ''],
+            ['whitespace only', '   '],
+            ['zero', '0'],
+            ['negative', '-5'],
+            ['non-numeric', 'abc'],
+            ['NaN-ish', 'one dollar'],
+        ])('rejects %s', (_label, raw) => {
+            expect(_amountToCents(raw)).toMatch(/not a valid amount/);
+        });
+    });
+});

package/dist/commands/payments.d.ts

@@ -0,0 +1,13 @@
+import type { FlagSchema } from '../flags.js';
+import { type Flags } from '../helpers.js';
+import type { Exposes } from '../exposes.js';
+export declare const EXPOSES: Exposes;
+export declare const SCHEMA: FlagSchema;
+export declare function _amountToCents(raw: string): number | string;
+export declare function connect(flags: Flags): Promise<void>;
+export declare function status(flags: Flags): Promise<void>;
+export declare function charge(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 refund(id: string, flags: Flags): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;