@myapihq/cli 1.2.5 → 1.2.7

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>;

package/dist/commands/payments.js

@@ -0,0 +1,219 @@
+import { payments as sdkPayments } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, printTable, info, printJson } from '../output.js';
+import { formatDate } from '../utils.js';
+import { requireOrg } from '../helpers.js';
+export const EXPOSES = [
+    'POST /payments/orgs/{org_id}/connect',
+    'GET /payments/orgs/{org_id}/connect',
+    'POST /payments/orgs/{org_id}/charges',
+    'GET /payments/orgs/{org_id}/charges',
+    'GET /payments/orgs/{org_id}/charges/{id}',
+    'POST /payments/orgs/{org_id}/charges/{id}/refund',
+    'POST /payments/webhook/{org_id}',
+];
+export const SCHEMA = {
+    'stripe-key': 'string',
+    amount: 'string',
+    description: 'string',
+    email: 'string',
+    every: 'string',
+    'success-url': 'string',
+    'cancel-url': 'string',
+};
+// Dollars → positive cents. The CLI surface is dollars; the API is cents.
+// Pure form returns cents or an error-message string. Charges must be > 0,
+// so $0 is rejected (unlike a spend cap, where $0 is meaningful).
+export function _amountToCents(raw) {
+    const trimmed = raw.trim();
+    const n = Number(trimmed);
+    if (trimmed === '' || !Number.isFinite(n) || n <= 0) {
+        return `"${raw}" is not a valid amount — use a positive number, e.g. 19 or 9.99.`;
+    }
+    return Math.round(n * 100);
+}
+function dollars(cents) {
+    return `$${(cents / 100).toFixed(2)}`;
+}
+function summarizeCharge(c) {
+    return {
+        id: c.id,
+        amount: `${dollars(c.amount_cents)} ${c.currency.toUpperCase()}`,
+        every: c.every || 'one-off',
+        status: c.status,
+        email: c.customer_email || '',
+        created_at: c.created_at ? formatDate(c.created_at) : '',
+    };
+}
+// ── Subcommands ──────────────────────────────────────────────────────────────
+export async function connect(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi payments connect --stripe-key <sk_...> [--org <id>]');
+    const key = flags['stripe-key'];
+    if (!key) {
+        error('Missing --stripe-key.\nUsage: myapi payments connect --stripe-key <sk_...>\n\n→ Your own Stripe secret key (starts with "sk_"). T0 is bring-your-own-Stripe.');
+    }
+    if (!key.startsWith('sk_'))
+        error('--stripe-key must be a Stripe secret key (starts with "sk_").');
+    const res = await sdkPayments.connect(config.api_key, orgId, key);
+    success('Stripe connected.');
+    info(`Tier:              ${res.tier}`);
+    info(`Stripe account:    ${res.stripe_account_id}`);
+    info(`Onboarding:        ${res.onboarding_status}`);
+}
+export async function status(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi payments status [--org <id>]');
+    const res = await sdkPayments.getConnect(config.api_key, orgId);
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    info(`Tier:              ${res.tier}`);
+    info(`Stripe account:    ${res.stripe_account_id}`);
+    info(`Onboarding:        ${res.onboarding_status}`);
+    if (res.application_fee_bps != null) {
+        info(`Platform fee:      ${res.application_fee_bps} bps`);
+    }
+}
+export async function charge(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi payments charge --amount <usd> [--description <text>] [--email <addr>] [--every month|year]');
+    const amountRaw = flags.amount;
+    if (!amountRaw) {
+        error('Missing --amount.\nUsage: myapi payments charge --amount <usd> [--description <text>] [--email <addr>] [--every month|year]\n\n→ --amount is in dollars (e.g. 19 or 9.99).');
+    }
+    const cents = _amountToCents(amountRaw);
+    if (typeof cents === 'string')
+        error(`--amount: ${cents}`);
+    const every = flags.every;
+    if (every && every !== 'month' && every !== 'year') {
+        error(`Invalid --every "${every}". Use "month" or "year" for a subscription, or omit for a one-off payment.`);
+    }
+    const payload = { amount_cents: cents };
+    if (flags.description)
+        payload.description = flags.description;
+    if (flags.email)
+        payload.email = flags.email;
+    if (every)
+        payload.every = every;
+    if (flags['success-url'])
+        payload.success_url = flags['success-url'];
+    if (flags['cancel-url'])
+        payload.cancel_url = flags['cancel-url'];
+    const res = await sdkPayments.createCharge(config.api_key, orgId, payload);
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    success(`Charge created: ${res.payment_id}`);
+    info(`Status:        ${res.status}`);
+    info('');
+    info('Send the customer to this hosted Stripe Checkout URL:');
+    info(`  ${res.checkout_url}`);
+}
+export async function list(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi payments list [--org <id>]');
+    const charges = await sdkPayments.listCharges(config.api_key, orgId);
+    if (flags.json) {
+        printJson(charges);
+        return;
+    }
+    printTable(charges.map(summarizeCharge), {
+        flags,
+        empty: 'No charges yet. Create one with: myapi payments charge --amount <usd>',
+    });
+}
+export async function get(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi payments get <charge_id> [--org <id>]');
+    if (!id)
+        error('Missing charge id.\nUsage: myapi payments get <charge_id>');
+    const c = await sdkPayments.getCharge(config.api_key, orgId, id);
+    if (flags.json) {
+        printJson(c);
+        return;
+    }
+    info(`ID:          ${c.id}`);
+    info(`Amount:      ${dollars(c.amount_cents)} ${c.currency.toUpperCase()}`);
+    info(`Billing:     ${c.every ? `every ${c.every}` : 'one-off'}`);
+    if (c.description)
+        info(`Description: ${c.description}`);
+    if (c.customer_email)
+        info(`Customer:    ${c.customer_email}`);
+    info(`Status:      ${c.status}`);
+    if (c.created_at)
+        info(`Created:     ${formatDate(c.created_at)}`);
+    if (c.succeeded_at)
+        info(`Succeeded:   ${formatDate(c.succeeded_at)}`);
+    if (c.refunded_at)
+        info(`Refunded:    ${formatDate(c.refunded_at)}`);
+}
+export async function refund(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi payments refund <charge_id> [--org <id>]');
+    if (!id)
+        error('Missing charge id.\nUsage: myapi payments refund <charge_id>');
+    const res = await sdkPayments.refundCharge(config.api_key, orgId, id);
+    success(`Charge ${res.id} refunded (status: ${res.status}).`);
+}
+// ── Dispatcher ───────────────────────────────────────────────────────────────
+const SUBCOMMAND_USAGE = {
+    'connect': `myapi payments connect --stripe-key <sk_...> [--org <id>]
+
+Links your own Stripe account (T0 — bring-your-own-Stripe). The key is
+validated live against Stripe, stored encrypted, and never echoed. Connect
+Express (T1) is not yet available.`,
+    'status': 'myapi payments status [--org <id>] [--json]',
+    'charge': `myapi payments charge --amount <usd> [--description <text>] [--email <addr>] [--every month|year] [--success-url <url>] [--cancel-url <url>] [--org <id>]
+
+Opens a Stripe Checkout Session on your connected account and returns a
+hosted checkout URL to send the customer to. --amount is in dollars.
+--every makes it a recurring subscription; omit it for a one-off payment.
+
+Examples:
+  myapi payments charge --amount 19 --description "Pro plan"
+  myapi payments charge --amount 9.99 --every month --email user@example.com`,
+    'list': 'myapi payments list [--org <id>] [--json]',
+    'get': 'myapi payments get <charge_id> [--org <id>] [--json]',
+    'refund': `myapi payments refund <charge_id> [--org <id>]
+
+Issues a full refund. Partial refunds are not supported.`,
+};
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(`Usage: myapi payments <subcommand>
+
+Take payments with Stripe Checkout. Connect your Stripe account, then
+create one-off or recurring charges and refund them.
+
+Subcommands:
+  connect              Link your Stripe account (T0 — bring your own key)
+  status               Show the org's Stripe connection status
+  charge               Create a charge and get a hosted checkout URL
+  list                 List charges in your org
+  get <charge_id>      Inspect a charge
+  refund <charge_id>   Full-refund a charge
+
+All commands accept --org <id> (or set default: myapi config set-org <id>).`);
+        return;
+    }
+    if (flags.help) {
+        const usage = SUBCOMMAND_USAGE[subcommand];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${subcommand}. Run "myapi payments --help" for the list.`);
+        return;
+    }
+    switch (subcommand) {
+        case 'connect': return connect(flags);
+        case 'status': return status(flags);
+        case 'charge': return charge(flags);
+        case 'list': return list(flags);
+        case 'get': return get(args[0], flags);
+        case 'refund': return refund(args[0], flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi payments --help" for available subcommands.`);
+    }
+}

package/dist/commands/pixel.js

@@ -75,7 +75,13 @@ export async function visits(flags) {
         printJson(res);
         return;
     }
-    printTable(res.visits);
+    // `type` is constant ('visit') across this list — omitted from the table.
+    printTable(res.visits.map(v => ({
+        pixel_id: v.pixel_id,
+        from_url: v.from_url,
+        to_url: v.to_url,
+        ts: v.ts,
+    })));
     info(`Total: ${res.total} | Showing: ${res.limit} | Offset: ${res.offset}`);
 }
 // Engagement events (open / click / page_visit / sent) — filterable by
@@ -106,7 +112,14 @@ export async function events(flags) {
         printJson(res);
         return;
     }
-    printTable(res.events);
+    // `type` is constant ('event') across this list — omitted from the table.
+    printTable(res.events.map(e => ({
+        pixel_id: e.pixel_id,
+        event_type: e.event_type,
+        url: e.url ?? '',
+        campaign_id: e.campaign_id ?? '',
+        ts: e.ts,
+    })));
     info(`Total: ${res.total} | Showing: ${res.limit} | Offset: ${res.offset}`);
 }
 // Geographic distribution sample of the org's pixel audience.

package/dist/commands/update.d.ts

@@ -1,7 +1,7 @@
 import type { Flags } from '../helpers.js';
 import type { Exposes } from '../exposes.js';
 export declare const EXPOSES: Exposes;
+export declare function cachedLatestVersion(): string | null;
 export declare function checkForUpdate(currentVersion: string): Promise<void>;
 export declare function update(flags?: Flags): Promise<void>;
-export declare function latestVersion(): Promise<string | null>;
 export declare function isNewer(latest: string, current: string): boolean;