@myapihq/cli 1.0.82 → 1.1.0-wip.0

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.`);
+    }
 }

package/dist/commands/email.d.ts

@@ -1,12 +1,4 @@
-export declare function createMailbox(flags: Record<string, string | boolean>): Promise<void>;
-export declare function listMailboxes(flags: Record<string, string | boolean>): Promise<void>;
-export declare function sent(flags: Record<string, string | boolean>): Promise<void>;
-export declare function send(flags: Record<string, string | boolean>): Promise<void>;
-export declare function inbox(address: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function outbox(address: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function listTemplates(flags: Record<string, string | boolean>): Promise<void>;
-export declare function deleteTemplate(id: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function generateTemplate(flags: Record<string, string | boolean>): Promise<void>;
-export declare function listCampaigns(flags: Record<string, string | boolean>): Promise<void>;
-export declare function campaignStats(id: 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 run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;