@myapihq/cli 1.0.84 → 1.1.0-wip.0

package/dist/commands/auth.d.ts

@@ -1,3 +1,8 @@
-export declare function link(flags?: Record<string, string | boolean>, emailArg?: string): Promise<void>;
-export declare function whoami(flags?: Record<string, string | boolean>): Promise<void>;
-export declare function switchCmd(flags?: Record<string, string | boolean>, indexArg?: string): Promise<void>;
+import type { FlagSchema } from '../flags.js';
+import type { Flags } from '../helpers.js';
+export declare const SCHEMA: FlagSchema;
+export declare const HELP = "Usage: myapi auth <subcommand>\n\nSubcommands:\n  setup           Configure your account\n  import-key      Import an existing API key non-interactively\n  whoami          Show current account \u00B7 supports --json\n  link [email]    Upgrade anonymous account to registered (or add a second session)\n                  Use myapi auth setup to create a completely new account\n  switch [index]  Switch active account by index or email\n  config          Manage CLI defaults (org, funnel, domain) \u00B7 supports set-org / set-funnel / set-domain\n  install-skills  Install or update the MyAPI skills pack for AI agents\n  api-keys        Manage API keys \u00B7 list / create / revoke\n  keys            Alias for api-keys";
+export declare const INSTALL_SKILLS_HELP = "Usage: myapi auth install-skills\n\nInstalls the MyAPI skills pack for AI coding agents (Claude, Gemini, Cursor).\n\nThis command writes skill definition files to:\n  ~/.agents/skills/myapi/\n\nAnd creates symlinks in the appropriate agent config directories:\n  ~/.claude/  (Claude)\n  ~/.gemini/  (Gemini)\n  ~/.cursor/  (Cursor, if detected)\n\nThese files teach agents how to use the MyAPI CLI and API directly.\nRun this command again to update existing skills to the latest version.";
+export declare function link(flags?: Flags, emailArg?: string): Promise<void>;
+export declare function whoami(flags?: Flags): Promise<void>;
+export declare function switchCmd(flags?: Flags, indexArg?: string): Promise<void>;

package/dist/commands/auth.js

@@ -3,7 +3,14 @@ import { loadConfig, saveConfig, addAccount, switchAccount, listAccounts } from
 import { info, success, error, printJson } from '../output.js';
 import { installSkills } from './setup.js';
 import { hq } from '@myapihq/sdk';
-const API_BASE = process.env.MYAPI_API_BASE ?? 'https://api.myapihq.com';
+export const SCHEMA = {
+    'install-skills': 'boolean',
+    'no-skills': 'boolean',
+    anonymous: 'boolean',
+    anon: 'boolean',
+};
+export const HELP = 'Usage: myapi auth <subcommand>\n\nSubcommands:\n  setup           Configure your account\n  import-key      Import an existing API key non-interactively\n  whoami          Show current account · supports --json\n  link [email]    Upgrade anonymous account to registered (or add a second session)\n                  Use myapi auth setup to create a completely new account\n  switch [index]  Switch active account by index or email\n  config          Manage CLI defaults (org, funnel, domain) · supports set-org / set-funnel / set-domain\n  install-skills  Install or update the MyAPI skills pack for AI agents\n  api-keys        Manage API keys · list / create / revoke\n  keys            Alias for api-keys';
+export const INSTALL_SKILLS_HELP = 'Usage: myapi auth install-skills\n\nInstalls the MyAPI skills pack for AI coding agents (Claude, Gemini, Cursor).\n\nThis command writes skill definition files to:\n  ~/.agents/skills/myapi/\n\nAnd creates symlinks in the appropriate agent config directories:\n  ~/.claude/  (Claude)\n  ~/.gemini/  (Gemini)\n  ~/.cursor/  (Cursor, if detected)\n\nThese files teach agents how to use the MyAPI CLI and API directly.\nRun this command again to update existing skills to the latest version.';
 function ask(rl, q) {
     return new Promise(resolve => rl.question(q, resolve));
 }
@@ -13,31 +20,6 @@ function yn(answer, defaultYes = true) {
         return defaultYes;
     return t === 'y' || t === 'yes';
 }
-async function post(path, body, apiKey) {
-    const headers = { 'Content-Type': 'application/json' };
-    if (apiKey)
-        headers['Authorization'] = `Bearer ${apiKey}`;
-    const res = await fetch(`${API_BASE}${path}`, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify(body),
-    });
-    const json = await res.json();
-    if (!res.ok)
-        throw new Error(json.error ?? `HTTP ${res.status}`);
-    return json.data ?? json;
-}
-async function patch(path, body, apiKey) {
-    const res = await fetch(`${API_BASE}${path}`, {
-        method: 'PATCH',
-        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
-        body: JSON.stringify(body),
-    });
-    const json = await res.json();
-    if (!res.ok)
-        throw new Error(json.error ?? `HTTP ${res.status}`);
-    return json.data ?? json;
-}
 // myapi auth link — upgrade anonymous session to registered account.
 export async function link(flags = {}, emailArg) {
     if (flags.help) {
@@ -56,7 +38,7 @@ export async function link(flags = {}, emailArg) {
             error(`Invalid email address: "${email}".`);
         let upgradeOk = true;
         try {
-            await patch('/hq/account/upgrade', { email }, config.api_key);
+            await hq.upgradeAccount(config.api_key, email);
         }
         catch (err) {
             if (err.message !== 'EMAIL_TAKEN')
@@ -67,11 +49,11 @@ export async function link(flags = {}, emailArg) {
             const ans = (await ask(rl, '› Sign in and add it as a second account? (Y/n) ')).trim();
             if (!yn(ans))
                 return;
-            await post('/hq/account/send-code', { email });
+            await hq.sendCode(email);
         }
         info(`› Sent a code to ${email} · paste it below`);
         const code = (await ask(rl, '› Code? ')).trim();
-        const data = await post('/hq/account/verify-code', { email, code });
+        const data = await hq.verifyCode(email, code);
         const skillsFromFlag = flags['install-skills'] ? true : flags['no-skills'] ? false : null;
         const wantsSkills = skillsFromFlag !== null ? skillsFromFlag : yn((await ask(rl, '› Install the MyAPI skills pack? (Y/n) ')).trim());
         if (upgradeOk) {

package/dist/commands/billing.d.ts

@@ -1,4 +1,8 @@
-export declare function balance(flags: Record<string, string | boolean>): Promise<void>;
-export declare function history(flags: Record<string, string | boolean>): Promise<void>;
-export declare function topup(amountStr: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function setup(flags: Record<string, string | boolean>): Promise<void>;
+import type { FlagSchema } from '../flags.js';
+import type { Flags } from '../helpers.js';
+export declare const SCHEMA: FlagSchema;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;
+export declare function balance(flags: Flags): Promise<void>;
+export declare function history(flags: Flags): Promise<void>;
+export declare function topup(amountStr: string, flags: Flags): Promise<void>;
+export declare function setup(_flags: Flags): Promise<void>;

package/dist/commands/billing.js

@@ -3,11 +3,46 @@ import { hq } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson } from '../output.js';
 import { formatDate } from '../utils.js';
-export async function balance(flags) {
+export const SCHEMA = {};
+const SUBCOMMAND_USAGE = {
+    'balance': 'myapi billing balance [--json]',
+    'history': 'myapi billing history [--json]',
+    'topup': `myapi billing topup <amount> [--yes]
+
+Amount is in whole dollars (e.g. "10" charges $10).
+Confirmation is required for amounts of $50 or more — pass --yes to skip it.
+
+Example: myapi billing topup 10`,
+    'setup': 'myapi billing setup',
+};
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(`Usage: myapi billing <subcommand>
+
+Subcommands:
+  balance    Check balance, credits, and payment method status
+  history    View recent transactions and top-ups
+  topup      Top up your balance (whole dollars)
+  setup      Open a checkout link to add or update payment method`);
+        return;
+    }
     if (flags.help) {
-        info('Usage: myapi billing balance [--json]\n\nShows your current account balance, credits, and payment method status.\n\nFlags:\n  --json   Output raw JSON');
+        const usage = SUBCOMMAND_USAGE[subcommand];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${subcommand}. Run "myapi billing --help" for the list.`);
         return;
     }
+    switch (subcommand) {
+        case 'balance': return balance(flags);
+        case 'history': return history(flags);
+        case 'topup': return topup(args[0], flags);
+        case 'setup': return setup(flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi billing --help" for available subcommands.`);
+    }
+}
+export async function balance(flags) {
     const config = requireConfig();
     const result = await hq.getBalance(config.api_key);
     if (flags.json) {
@@ -24,37 +59,27 @@ export async function balance(flags) {
     info(`Balance: ${result.balance_display}  |  Credits: ${result.credits_display} (not usable for domains)  |  Payment method: ${pm}`);
 }
 export async function history(flags) {
-    if (flags.help) {
-        info('Usage: myapi billing history [--json]\n\nShows your recent billing transactions and top-ups.\n\nFlags:\n  --json   Output raw JSON');
-        return;
-    }
     const config = requireConfig();
     const items = await hq.getBillingHistory(config.api_key);
     if (flags.json) {
         printJson(items);
         return;
     }
-    if (items.length === 0) {
-        info('No transactions yet.');
-        return;
-    }
     const formattedItems = items.map(item => ({
         Type: item.type || 'unknown',
         Amount: item.amount_display,
         Status: item.status ? item.status.charAt(0).toUpperCase() + item.status.slice(1) : '',
         Date: formatDate(item.created_at),
     }));
-    printTable(formattedItems);
+    printTable(formattedItems, {
+        flags,
+        empty: 'No transactions yet.',
+    });
 }
 export async function topup(amountStr, flags) {
-    if (flags.help) {
-        info('Usage: myapi billing topup <amount>\n\nAmount is in whole dollars (e.g. "10" charges $10).\nConfirmation is required for amounts of $50 or more. Use --yes to skip it.\nExample: myapi billing topup 10\n\nFlags:\n  --yes   Skip confirmation prompt for large amounts');
-        return;
-    }
     const amount = Math.round(parseFloat(amountStr));
     if (!amountStr || isNaN(amount) || amount <= 0) {
-        error("Amount must be a positive whole number of dollars (e.g. myapi billing topup 10)");
-        return;
+        error('Amount must be a positive whole number of dollars (e.g. myapi billing topup 10)');
     }
     if (!flags.yes && !flags.y && amount >= 50) {
         const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -69,11 +94,7 @@ export async function topup(amountStr, flags) {
     const result = await hq.topUp(config.api_key, amount);
     success(`Top up successful! New balance: ${result.new_balance_display}`);
 }
-export async function setup(flags) {
-    if (flags.help) {
-        info('Usage: myapi billing setup\n\nGenerates a secure checkout link to add or update your payment method.');
-        return;
-    }
+export async function setup(_flags) {
     const config = requireConfig();
     const result = await hq.setupPayment(config.api_key);
     success(`Open this URL in your browser to set up payment:\n${result.url}`);

package/dist/commands/config.d.ts

@@ -1,5 +1,8 @@
-export declare function setOrg(id: string, flags: Record<string, string | boolean>, via?: string): Promise<void>;
-export declare function setFunnel(id: string, flags: Record<string, string | boolean>, via?: string): Promise<void>;
-export declare function setDomain(domain: string, flags: Record<string, string | boolean>, via?: string): Promise<void>;
-export declare function view(flags: Record<string, string | boolean>, via?: string): Promise<void>;
-export declare function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>): Promise<void>;
+import type { FlagSchema } from '../flags.js';
+import type { Flags } from '../helpers.js';
+export declare const SCHEMA: FlagSchema;
+export declare function setOrg(id: string, _flags: Flags, via?: string): Promise<void>;
+export declare function setFunnel(id: string, _flags: Flags, via?: string): Promise<void>;
+export declare function setDomain(domain: string, _flags: Flags, via?: string): Promise<void>;
+export declare function view(flags: Flags, _via?: string): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/config.js

@@ -1,10 +1,13 @@
 import { hq, funnel as sdkFunnel } from '@myapihq/sdk';
 import { requireConfig, saveConfig } from '../config.js';
-import { success, error, info } from '../output.js';
+import { success, error, info, printJson } from '../output.js';
+export const SCHEMA = {
+    _via: 'string',
+};
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-export async function setOrg(id, flags, via = 'auth config') {
-    if (!id || flags.help) {
-        info(`Usage: myapi ${via} set-org <id>\n\nSets the default organization for all commands that require --org.\nThe ID is validated against the API before saving.\n\nExample:\n  myapi ${via} set-org xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`);
+export async function setOrg(id, _flags, via = 'auth config') {
+    if (!id) {
+        info(`Usage: myapi ${via} set-org <id>`);
         return;
     }
     if (!UUID_RE.test(id))
@@ -16,9 +19,9 @@ export async function setOrg(id, flags, via = 'auth config') {
     saveConfig(config);
     success(`Default organization set to: ${org.name || org.id}`);
 }
-export async function setFunnel(id, flags, via = 'auth config') {
-    if (!id || flags.help) {
-        info(`Usage: myapi ${via} set-funnel <id>\n\nSets the default funnel. The funnel must belong to your current default org.\nThe ID is validated against the API before saving.\n\nExample:\n  myapi ${via} set-funnel xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`);
+export async function setFunnel(id, _flags, via = 'auth config') {
+    if (!id) {
+        info(`Usage: myapi ${via} set-funnel <id>`);
         return;
     }
     if (!UUID_RE.test(id))
@@ -34,9 +37,9 @@ export async function setFunnel(id, flags, via = 'auth config') {
     saveConfig(config);
     success(`Default funnel set to: ${funnelId}`);
 }
-export async function setDomain(domain, flags, via = 'auth config') {
-    if (!domain || flags.help) {
-        info(`Usage: myapi ${via} set-domain <domain>\n\nSets the default domain used by domain commands when the domain argument is omitted.\n\nExample:\n  myapi ${via} set-domain example.com`);
+export async function setDomain(domain, _flags, via = 'auth config') {
+    if (!domain) {
+        info(`Usage: myapi ${via} set-domain <domain>`);
         return;
     }
     const config = requireConfig();
@@ -44,14 +47,9 @@ export async function setDomain(domain, flags, via = 'auth config') {
     saveConfig(config);
     success(`Default domain set to: ${domain}`);
 }
-export async function view(flags, via = 'auth config') {
-    if (flags.help) {
-        info(`Usage: myapi ${via} view [--json]\n\nShows the currently configured defaults: default org, funnel, and domain.\n\nFlags:\n  --json   Output raw JSON`);
-        return;
-    }
+export async function view(flags, _via = 'auth config') {
     const config = requireConfig();
     if (flags.json) {
-        const { printJson } = await import('../output.js');
         printJson({
             default_org: config.default_org ?? null,
             default_funnel: config.default_funnel ?? null,
@@ -63,20 +61,47 @@ export async function view(flags, via = 'auth config') {
     info(`Default Funnel: ${config.default_funnel || 'Not set'}`);
     info(`Default Domain: ${config.default_domain || 'Not set'}`);
 }
+// ── Dispatcher ───────────────────────────────────────────────────────────────
+function subcommandUsage(via) {
+    return {
+        'view': `myapi ${via} view [--json]`,
+        'set-org': `myapi ${via} set-org <id>\n\nSets the default organization for all commands that require --org.\nThe ID is validated against the API before saving.`,
+        'set-funnel': `myapi ${via} set-funnel <id>\n\nSets the default funnel. Must belong to your current default org.\nThe ID is validated against the API before saving.`,
+        'set-domain': `myapi ${via} set-domain <domain>\n\nSets the default domain used by domain commands when the domain arg is omitted.`,
+    };
+}
 export async function run(subcommand, args, flags) {
     const via = flags._via || 'auth config';
     if (!subcommand || (flags.help && !subcommand)) {
-        info(`Usage: myapi ${via} <subcommand>\n\nManages CLI defaults (org, funnel, domain) so you don't have to pass --org / --domain on every command.\n\nSubcommands:\n  view         Show current defaults\n  set-org      Set default organization (validates access)\n  set-funnel   Set default funnel (must be owned by default org)\n  set-domain   Set default domain\n\nExamples:\n  myapi auth config set-org <id>\n  myapi auth config set-funnel <id>\n  myapi auth config view`);
+        info(`Usage: myapi ${via} <subcommand>
+
+Manages CLI defaults (org, funnel, domain) so you don't have to pass --org / --domain on every command.
+
+Subcommands:
+  view         Show current defaults
+  set-org      Set default organization (validates access)
+  set-funnel   Set default funnel (must be owned by default org)
+  set-domain   Set default domain
+
+Examples:
+  myapi ${via} set-org <id>
+  myapi ${via} set-funnel <id>
+  myapi ${via} view`);
         return;
     }
-    if (subcommand === 'view')
-        await view(flags, via);
-    else if (subcommand === 'set-org')
-        await setOrg(args[0], flags, via);
-    else if (subcommand === 'set-funnel')
-        await setFunnel(args[0], flags, via);
-    else if (subcommand === 'set-domain')
-        await setDomain(args[0], flags, via);
-    else
-        error(`Unknown subcommand: ${subcommand}. Run "myapi config --help" for a list of valid subcommands.`);
+    if (flags.help) {
+        const usage = subcommandUsage(via)[subcommand];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${subcommand}. Run "myapi ${via} --help" for the list.`);
+        return;
+    }
+    switch (subcommand) {
+        case 'view': return view(flags, via);
+        case 'set-org': return setOrg(args[0], flags, via);
+        case 'set-funnel': return setFunnel(args[0], flags, via);
+        case 'set-domain': return setDomain(args[0], flags, via);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi ${via} --help" for a list of valid subcommands.`);
+    }
 }

package/dist/commands/domain.d.ts

@@ -1,9 +1,12 @@
-export declare function check(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function register(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function list(flags: Record<string, string | boolean>): Promise<void>;
-export declare function assign(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function unassign(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function status(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function settings(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function updateSettings(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>): Promise<void>;
+import type { FlagSchema } from '../flags.js';
+import { type Flags } from '../helpers.js';
+export declare const SCHEMA: FlagSchema;
+export declare function check(domainArg: string, flags: Flags): Promise<void>;
+export declare function register(domainArg: string, flags: Flags): Promise<void>;
+export declare function list(flags: Flags): Promise<void>;
+export declare function assign(domainArg: string, flags: Flags): Promise<void>;
+export declare function unassign(domainArg: string, flags: Flags): Promise<void>;
+export declare function status(domainArg: string, flags: Flags): Promise<void>;
+export declare function settings(domainArg: string, flags: Flags): Promise<void>;
+export declare function updateSettings(domainArg: string, flags: Flags): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/domain.js

@@ -2,16 +2,20 @@ import { domain as sdkDomain } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, info, printTable, printJson } from '../output.js';
 import { formatDate } from '../utils.js';
+import { requireOrg, requireDomain } from '../helpers.js';
+export const SCHEMA = {
+    org: 'string',
+    domain: 'string',
+    filter: 'string',
+    years: 'number',
+    security: 'string',
+    'browser-check': 'string',
+    'purge-cache': 'boolean',
+};
 export async function check(domainArg, flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    const domain = domainArg || config.default_domain;
-    if (!orgId || !domain) {
-        const hint = config.default_org
-            ? `(current default org: ${config.default_org})`
-            : '(Set defaults: myapi config set-org <id> / myapi config set-domain <domain>)';
-        error(`Missing required arguments.\nUsage: myapi domain check <domain>${config.default_org ? '' : ' --org <id>'}\n${hint}`);
-    }
+    const orgId = requireOrg(flags, config, 'myapi domain check <domain> [--org <id>]');
+    const domain = requireDomain(domainArg, flags, config, 'myapi domain check <domain> [--org <id>]');
     const res = await sdkDomain.checkDomain(config.api_key, orgId, domain);
     if (flags.json) {
         const out = { domain, available: res.available };
@@ -34,58 +38,50 @@ export async function check(domainArg, flags) {
 }
 export async function register(domainArg, flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    const domain = domainArg;
-    if (!orgId || !domain)
-        error("Missing required arguments.\nUsage: myapi domain register <domain> --org <id> [--years <num>]");
-    const years = parseInt(flags.years) || 1;
-    const res = await sdkDomain.registerDomain(config.api_key, orgId, domain, years);
-    success(`Registered ${domain}!`);
-    info(`Assign it to your org now:\n  myapi domain assign ${domain} --org ${orgId}`);
-    info(`DNS propagation can take a few minutes — track it with: myapi domain status ${domain}`);
-    info(`Your funnel will be live on https://${domain} once propagation completes.`);
+    const orgId = requireOrg(flags, config, 'myapi domain register <domain> [--years <n>] [--org <id>]');
+    if (!domainArg)
+        error('Missing required arguments.\nUsage: myapi domain register <domain> [--years <n>] [--org <id>]');
+    const years = flags.years || 1;
+    await sdkDomain.registerDomain(config.api_key, orgId, domainArg, years);
+    success(`Registered ${domainArg}!`);
+    info(`Assign it to your org now:\n  myapi domain assign ${domainArg} --org ${orgId}`);
+    info(`DNS propagation can take a few minutes — track it with: myapi domain status ${domainArg}`);
+    info(`Your funnel will be live on https://${domainArg} once propagation completes.`);
 }
 export async function list(flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    if (!orgId)
-        error("Missing required arguments.\nUsage: myapi domain list --org <id> [--filter=all|unassigned|org]\n(Set default: myapi auth config set-org <id>)");
+    const orgId = requireOrg(flags, config, 'myapi domain list [--filter=all|unassigned|org] [--org <id>]');
     const filter = flags.filter;
     const domains = await sdkDomain.listDomains(config.api_key, orgId, filter);
     if (flags.json) {
         printJson(domains);
         return;
     }
-    if (domains.length === 0) {
-        info('No domains found in this organization. Register one with: myapi domain register <name>');
-        return;
-    }
-    printTable(domains);
+    printTable(domains, {
+        flags,
+        empty: 'No domains found in this organization. Register one with: myapi domain register <name>',
+    });
 }
 export async function assign(domainArg, flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    const domain = domainArg;
-    if (!orgId || !domain)
-        error("Missing required arguments.\nUsage: myapi domain assign <domain> --org <id>");
-    await sdkDomain.assignDomain(config.api_key, orgId, domain);
-    success(`Assigned ${domain} to org ${orgId}`);
+    const orgId = requireOrg(flags, config, 'myapi domain assign <domain> [--org <id>]');
+    if (!domainArg)
+        error('Missing required arguments.\nUsage: myapi domain assign <domain> [--org <id>]');
+    await sdkDomain.assignDomain(config.api_key, orgId, domainArg);
+    success(`Assigned ${domainArg} to org ${orgId}`);
 }
 export async function unassign(domainArg, flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    const domain = domainArg;
-    if (!orgId || !domain)
-        error("Missing required arguments.\nUsage: myapi domain unassign <domain> --org <id>");
-    await sdkDomain.unassignDomain(config.api_key, orgId, domain);
-    success(`Unassigned ${domain} from org ${orgId}`);
+    const orgId = requireOrg(flags, config, 'myapi domain unassign <domain> [--org <id>]');
+    if (!domainArg)
+        error('Missing required arguments.\nUsage: myapi domain unassign <domain> [--org <id>]');
+    await sdkDomain.unassignDomain(config.api_key, orgId, domainArg);
+    success(`Unassigned ${domainArg} from org ${orgId}`);
 }
 export async function status(domainArg, flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    const domain = domainArg || config.default_domain;
-    if (!orgId || !domain)
-        error("Missing required arguments.\nUsage: myapi domain status <domain> --org <id>\n(Set defaults: myapi auth config set-org <id> / myapi auth config set-domain <domain>)");
+    const orgId = requireOrg(flags, config, 'myapi domain status <domain> [--org <id>]');
+    const domain = requireDomain(domainArg, flags, config, 'myapi domain status <domain> [--org <id>]');
     const res = await sdkDomain.getDomainStatus(config.api_key, orgId, domain);
     if (flags.json) {
         printJson(res);
@@ -96,23 +92,19 @@ export async function status(domainArg, flags) {
     if (res.expires_at)
         info(`Expires: ${formatDate(res.expires_at)}`);
     if (res.status === 'active')
-        info(`Note: if recently activated, the SSL certificate may still be provisioning — allow a few minutes before the site is reachable over HTTPS.`);
+        info('Note: if recently activated, the SSL certificate may still be provisioning — allow a few minutes before the site is reachable over HTTPS.');
 }
 export async function settings(domainArg, flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    const domain = domainArg || config.default_domain;
-    if (!orgId || !domain)
-        error("Missing required arguments.\nUsage: myapi domain settings <domain> --org <id>\n(Set defaults: myapi auth config set-org <id> / myapi auth config set-domain <domain>)");
+    const orgId = requireOrg(flags, config, 'myapi domain settings <domain> [--org <id>]');
+    const domain = requireDomain(domainArg, flags, config, 'myapi domain settings <domain> [--org <id>]');
     const res = await sdkDomain.getDomainSettings(config.api_key, orgId, domain);
     printJson(res);
 }
 export async function updateSettings(domainArg, flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    const domain = domainArg || config.default_domain;
-    if (!orgId || !domain)
-        error("Missing required arguments.\nUsage: myapi domain update-settings <domain> --org <id> [--security=...] [--browser-check=...] [--purge-cache]\n(Set defaults: myapi auth config set-org <id> / myapi auth config set-domain <domain>)");
+    const orgId = requireOrg(flags, config, 'myapi domain update-settings <domain> [--org <id>]');
+    const domain = requireDomain(domainArg, flags, config, 'myapi domain update-settings <domain> [--org <id>]');
     const payload = {};
     if (flags.security)
         payload.security_level = flags.security;
@@ -120,49 +112,88 @@ export async function updateSettings(domainArg, flags) {
         payload.browser_check = flags['browser-check'];
     if (flags['purge-cache'])
         payload.purge_cache = true;
+    if (Object.keys(payload).length === 0) {
+        error('Nothing to update. Pass at least one of --security=<level>, --browser-check=<on|off>, --purge-cache.');
+    }
     const res = await sdkDomain.updateDomainSettings(config.api_key, orgId, domain, payload);
     success(`Updated settings for ${domain}!\n${JSON.stringify(res, null, 2)}`);
 }
+// ── Dispatcher ───────────────────────────────────────────────────────────────
+const SUBCOMMAND_USAGE = {
+    'list': `myapi domain list [--filter=all|unassigned|org] [--org <id>] [--json]
+
+  --filter=all         All domains owned by the account.
+  --filter=unassigned  Domains not yet assigned to any org.
+  --filter=org         (Default) Domains assigned to the specified org.
+
+Note: --filter=all and --filter=unassigned are account-wide; --org is only used
+to authenticate the request.`,
+    'check': 'myapi domain check <domain> [--org <id>] [--json]',
+    'register': `myapi domain register <domain> [--years <num>] [--org <id>]
+
+  --years <num>   Number of years to register for (default: 1)
+
+Prerequisites:
+  - Sufficient balance (myapi billing balance)
+  - Domain available (myapi domain check <domain>)
+
+After registering: myapi domain assign <domain>
+DNS propagation takes a few minutes — track it with: myapi domain status <domain>`,
+    'assign': `myapi domain assign <domain> [--org <id>]
+
+Assigns a registered domain to an org. Once assigned, your funnel is served at
+https://<domain> after DNS propagation completes.
+
+To transfer to a different org: unassign first, then assign to the new org.`,
+    'unassign': 'myapi domain unassign <domain> [--org <id>]',
+    'status': 'myapi domain status <domain> [--org <id>] [--json]',
+    'settings': `myapi domain settings <domain> [--org <id>]
+
+Gets current edge/CDN settings (security level, browser check, cache).
+Use "myapi domain update-settings" to change them.`,
+    'update-settings': `myapi domain update-settings <domain> [--security=<level>] [--browser-check=on|off] [--purge-cache] [--org <id>]
+
+  --security=<level>       essentially_off | low | medium | high | under_attack  (default: medium)
+  --browser-check=<on|off> Browser integrity challenge for suspicious traffic     (default: on)
+  --purge-cache            Immediately clear the CDN cache for this domain
+
+Example:
+  myapi domain update-settings example.com --security=high --purge-cache`,
+};
 export async function run(subcommand, args, flags) {
     if (!subcommand || (flags.help && !subcommand)) {
-        info('Usage: myapi domain <subcommand>\n\nSubcommands:\n  list             List domains\n  check            Check domain availability\n  register         Register a domain\n  assign           Assign domain to an org\n  unassign         Unassign domain from its current org\n  status           Get domain status\n  settings         Get domain settings\n  update-settings  Update edge/CDN settings\n\nTip: Set defaults with "myapi auth config set-org <id>" to skip --org on every command.');
+        info(`Usage: myapi domain <subcommand>
+
+Subcommands:
+  list             List domains
+  check            Check domain availability
+  register         Register a domain
+  assign           Assign domain to an org
+  unassign         Unassign domain from its current org
+  status           Get domain status
+  settings         Get edge/CDN settings
+  update-settings  Update edge/CDN settings
+
+Tip: Set defaults with "myapi config set-org <id>" / "set-domain <domain>" to skip flags on every command.`);
         return;
     }
     if (flags.help) {
-        if (subcommand === 'list')
-            info('Usage: myapi domain list [--org <id>] [--filter=all|unassigned|org] [--json]\n\nLists registered domains. --org (or default org) is used to identify your account.\n\n  --filter=all        All domains owned by the account.\n  --filter=unassigned Domains not yet assigned to any org.\n  --filter=org        (Default) Domains assigned to the specified org.\n  --json              Output raw JSON\n\nNote: --filter=all and --filter=unassigned are account-wide and do not filter by org;\nthe --org flag is only needed to authenticate the request.');
-        else if (subcommand === 'check')
-            info('Usage: myapi domain check <domain> --org <id> [--json]\n\nChecks if a domain name is available for registration.\n\nFlags:\n  --json   Output raw JSON');
-        else if (subcommand === 'register')
-            info('Usage: myapi domain register <domain> --org <id> [--years <num>]\n\nRegisters a new domain name under your account.\n\nFlags:\n  --years <num>   Number of years to register for (default: 1)\n\nPrerequisites:\n  - You must have sufficient balance (myapi billing balance)\n  - The domain must be available (myapi domain check <domain>)\n\nAfter registering, assign the domain to your org:\n  myapi domain assign <domain> --org <id>\n\nDNS propagation takes a few minutes. Track it with:\n  myapi domain status <domain>');
-        else if (subcommand === 'assign')
-            info('Usage: myapi domain assign <domain> --org <id>\n\nAssigns a registered domain to an organization. The domain must already be\nregistered under your account. Once assigned, your funnel will be served at\nhttps://<domain> after DNS propagation completes.\n\nTo transfer a domain to a different org: unassign it first, then assign to the new org.');
-        else if (subcommand === 'unassign')
-            info('Usage: myapi domain unassign <domain> --org <id>\n\nUnassigns a domain from its current organization. The domain remains registered\nunder your account and can be reassigned to a different org at any time.');
-        else if (subcommand === 'status')
-            info('Usage: myapi domain status <domain> --org <id> [--json]\n\nGets the registration status of a domain.\n\nFlags:\n  --json   Output raw JSON');
-        else if (subcommand === 'settings')
-            info('Usage: myapi domain settings <domain> --org <id>\n\nGets the current edge/CDN settings for a domain (security level, browser check, cache).\nUse "myapi domain update-settings" to change them.');
-        else if (subcommand === 'update-settings')
-            info('Usage: myapi domain update-settings <domain> --org <id> [flags]\n\nUpdates edge/CDN settings for a domain.\n\nFlags:\n  --security=<level>       CDN security level. Controls bot/threat filtering.\n                           Values: essentially_off | low | medium | high | under_attack\n                           Default (if unset): medium\n  --browser-check=<on|off> Enable or disable browser integrity challenge for suspicious traffic.\n                           Default: on\n  --purge-cache            Immediately clears the CDN cache for this domain.\n                           Use after deploying changes that are not yet visible.\n\nExample:\n  myapi domain update-settings example.com --org <id> --security=high --purge-cache');
+        const usage = SUBCOMMAND_USAGE[subcommand];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${subcommand}. Run "myapi domain --help" for the list.`);
         return;
     }
-    if (subcommand === 'list')
-        await list(flags);
-    else if (subcommand === 'check')
-        await check(args[0], flags);
-    else if (subcommand === 'register')
-        await register(args[0], flags);
-    else if (subcommand === 'assign')
-        await assign(args[0], flags);
-    else if (subcommand === 'unassign')
-        await unassign(args[0], flags);
-    else if (subcommand === 'status')
-        await status(args[0], flags);
-    else if (subcommand === 'settings')
-        await settings(args[0], flags);
-    else if (subcommand === 'update-settings')
-        await updateSettings(args[0], flags);
-    else
-        error(`Unknown subcommand: ${subcommand}. Run "myapi domain --help" for a list of valid subcommands.`);
+    switch (subcommand) {
+        case 'list': return list(flags);
+        case 'check': return check(args[0], flags);
+        case 'register': return register(args[0], flags);
+        case 'assign': return assign(args[0], flags);
+        case 'unassign': return unassign(args[0], flags);
+        case 'status': return status(args[0], flags);
+        case 'settings': return settings(args[0], flags);
+        case 'update-settings': return updateSettings(args[0], flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi domain --help" for a list of valid subcommands.`);
+    }
 }