@myapihq/cli 1.0.84 → 1.1.0-wip.1

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,57 @@ 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.map(summarizeDomain), {
+        flags,
+        empty: 'No domains found in this organization. Register one with: myapi domain register <name>',
+    });
+}
+// Column projection: rename `org_id` → `assigned_to_org` (clearer header)
+// and replace empty/null with "(unassigned)". Lives next to the SDK type
+// so it'll fail at compile time if a field is removed.
+function summarizeDomain(d) {
+    const { org_id, ...rest } = d;
+    return { ...rest, assigned_to_org: org_id || '(unassigned)' };
 }
 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 +99,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 +119,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/campaign.d.ts

@@ -0,0 +1,2 @@
+import { type Flags } from '../../helpers.js';
+export declare function run(sub: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/email/campaign.js

@@ -0,0 +1,152 @@
+import { email as sdkEmail } from '@myapihq/sdk';
+import { requireConfig } from '../../config.js';
+import { success, error, printTable, printJson, info } from '../../output.js';
+import { requireOrg } from '../../helpers.js';
+async function create(nameArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email campaign create <name> --template-id <id> --from <email> [--per-day <n>] [--org <id>]');
+    const name = nameArg || flags.name;
+    if (!name || !flags['template-id'] || !flags.from) {
+        error('Missing required arguments.\nUsage: myapi email campaign create <name> --template-id <id> --from <email> [--per-day <n>] [--org <id>]\n   or: myapi email campaign create --name <name> --template-id <id> --from <email> [--per-day <n>] [--org <id>]');
+    }
+    const perDayLimit = flags['per-day'];
+    const res = await sdkEmail.createCampaign(config.api_key, orgId, {
+        name,
+        template_id: flags['template-id'],
+        from_address: flags.from,
+        per_day_limit: perDayLimit,
+    });
+    success(`Campaign created! ID: ${res.id}`);
+}
+async function list(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email campaign list [--org <id>]');
+    const campaigns = await sdkEmail.listCampaigns(config.api_key, orgId);
+    printTable(campaigns, {
+        flags,
+        empty: 'No campaigns yet. Create one with: myapi email campaign create',
+    });
+}
+async function get(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email campaign get <id> [--org <id>]');
+    if (!id)
+        error('Missing required arguments.\nUsage: myapi email campaign get <id> [--org <id>]');
+    const c = await sdkEmail.getCampaign(config.api_key, orgId, id);
+    printJson(c);
+}
+async function update(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email campaign update <id> [--name <str>] [--per-day <n>] [--org <id>]');
+    if (!id)
+        error('Missing required arguments.\nUsage: myapi email campaign update <id> [--name <str>] [--per-day <n>] [--org <id>]');
+    const payload = {};
+    if (flags.name)
+        payload.name = flags.name;
+    if (flags['per-day'])
+        payload.per_day_limit = flags['per-day'];
+    if (!payload.name && payload.per_day_limit === undefined) {
+        error('Nothing to update. Pass at least one of --name, --per-day.');
+    }
+    const res = await sdkEmail.updateCampaign(config.api_key, orgId, id, payload);
+    success(`Campaign ${res.id} updated`);
+}
+async function uploadContacts(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email campaign upload-contacts <campaign_id> --emails <a@x,b@y> [--org <id>]');
+    if (!id || !flags.emails) {
+        error('Missing required arguments.\nUsage: myapi email campaign upload-contacts <campaign_id> --emails <a@x,b@y> [--org <id>]');
+    }
+    const emails = flags.emails.split(',').map(s => s.trim()).filter(Boolean);
+    const res = await sdkEmail.uploadContactList(config.api_key, orgId, id, emails);
+    success(`Uploaded ${res.total} contacts (status: ${res.status})`);
+}
+async function start(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email campaign start <id> [--org <id>]');
+    if (!id)
+        error('Missing required arguments.\nUsage: myapi email campaign start <id> [--org <id>]');
+    const status = await sdkEmail.getContactUploadStatus(config.api_key, orgId, id);
+    if (status.upload_status !== 'ready') {
+        error(`Contacts not ready (current status: ${status.upload_status})`);
+    }
+    const res = await sdkEmail.startCampaign(config.api_key, orgId, id);
+    success(`Campaign started (status: ${res.status})`);
+}
+async function pause(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email campaign pause <id> [--org <id>]');
+    if (!id)
+        error('Missing required arguments.\nUsage: myapi email campaign pause <id> [--org <id>]');
+    await sdkEmail.pauseCampaign(config.api_key, orgId, id);
+    success(`Campaign ${id} paused`);
+}
+async function resume(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email campaign resume <id> [--org <id>]');
+    if (!id)
+        error('Missing required arguments.\nUsage: myapi email campaign resume <id> [--org <id>]');
+    await sdkEmail.resumeCampaign(config.api_key, orgId, id);
+    success(`Campaign ${id} resumed`);
+}
+async function stats(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email campaign stats <id> [--org <id>]');
+    if (!id)
+        error('Missing required arguments.\nUsage: myapi email campaign stats <id> [--org <id>]');
+    const res = await sdkEmail.getCampaignStats(config.api_key, orgId, id);
+    printJson(res);
+}
+const USAGE = {
+    'create': `myapi email campaign create <name> --template-id <id> --from <email> [--per-day <n>] [--org <id>]
+       myapi email campaign create --name <name> --template-id <id> --from <email> [--per-day <n>] [--org <id>]
+
+Either form works; the positional name is the recommended shape.`,
+    'list': 'myapi email campaign list [--org <id>]',
+    'get': 'myapi email campaign get <id> [--org <id>]',
+    'update': 'myapi email campaign update <id> [--name <str>] [--per-day <n>] [--org <id>]',
+    'upload-contacts': 'myapi email campaign upload-contacts <campaign_id> --emails <a@x,b@y> [--org <id>]',
+    'start': 'myapi email campaign start <id> [--org <id>]',
+    'pause': 'myapi email campaign pause <id> [--org <id>]',
+    'resume': 'myapi email campaign resume <id> [--org <id>]',
+    'stats': 'myapi email campaign stats <id> [--org <id>]',
+};
+export async function run(sub, args, flags) {
+    if (!sub || (flags.help && !sub)) {
+        info(`Usage: myapi email campaign <subcommand>
+
+Subcommands:
+  create <name>       Create a campaign (--template-id --from)
+  list                List campaigns
+  get <id>            Get a single campaign
+  update <id>         Patch name / per-day-limit
+  upload-contacts <id>  Upload contact list (--emails a@x,b@y)
+  start <id>          Start a campaign
+  pause <id>          Pause a campaign
+  resume <id>         Resume a campaign
+  stats <id>          Get campaign stats
+
+All commands accept --org <id> (or set default: myapi config set-org <id>).`);
+        return;
+    }
+    if (flags.help) {
+        const usage = USAGE[sub];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${sub}. Run "myapi email campaign --help" for the list.`);
+        return;
+    }
+    switch (sub) {
+        case 'create': return create(args[0], flags);
+        case 'list': return list(flags);
+        case 'get': return get(args[0], flags);
+        case 'update': return update(args[0], flags);
+        case 'upload-contacts': return uploadContacts(args[0], flags);
+        case 'start': return start(args[0], flags);
+        case 'pause': return pause(args[0], flags);
+        case 'resume': return resume(args[0], flags);
+        case 'stats': return stats(args[0], flags);
+        default: error(`Unknown subcommand: ${sub}. Run "myapi email campaign --help" for the list.`);
+    }
+}

package/dist/commands/email/index.d.ts

@@ -0,0 +1,4 @@
+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>;

package/dist/commands/email/index.js

@@ -0,0 +1,98 @@
+// Top-level router for `myapi email <namespace> <subcommand>`. Each
+// namespace lives in its own file in this directory; this index just
+// routes to the right one and handles the deprecated flat aliases.
+import { error, info } from '../../output.js';
+import * as mailbox from './mailbox.js';
+import * as message from './message.js';
+import * as warmup from './warmup.js';
+import * as template from './template.js';
+import * as campaign from './campaign.js';
+export const SCHEMA = {
+    org: 'string',
+    domain: 'string',
+    username: 'string',
+    'display-name': 'string',
+    filter: 'string',
+    address: 'string',
+    from: 'string',
+    to: 'string',
+    subject: 'string',
+    body: 'string',
+    html: 'string',
+    'template-id': 'string',
+    'template-vars': 'string',
+    limit: 'number',
+    offset: 'number',
+    prompt: 'string',
+    name: 'string',
+    emails: 'string',
+    'per-day': 'number',
+};
+// Old flat subcommand → [namespace, sub]. Kept so existing scripts/skills
+// don't break. Emits a one-line stderr deprecation note then runs the new
+// path.
+const DEPRECATED_ALIASES = {
+    'create-mailbox': ['mailbox', 'create'],
+    'list-mailboxes': ['mailbox', 'list'],
+    'activate-sending': ['mailbox', 'activate-sending'],
+    'send': ['message', 'send'],
+    'get-status': ['message', 'status'],
+    'sent': ['message', 'sent'],
+    'inbox': ['message', 'inbox'],
+    'outbox': ['message', 'outbox'],
+    'get-message': ['message', 'get'],
+    'generate-template': ['template', 'generate'],
+    'list-templates': ['template', 'list'],
+    'edit-template': ['template', 'edit'],
+    'send-test': ['template', 'send-test'],
+    'delete-template': ['template', 'delete'],
+    'create-campaign': ['campaign', 'create'],
+    'list-campaigns': ['campaign', 'list'],
+    'get-campaign': ['campaign', 'get'],
+    'update-campaign': ['campaign', 'update'],
+    'upload-contacts': ['campaign', 'upload-contacts'],
+    'start-campaign': ['campaign', 'start'],
+    'pause-campaign': ['campaign', 'pause'],
+    'resume-campaign': ['campaign', 'resume'],
+    'campaign-stats': ['campaign', 'stats'],
+};
+async function dispatchNamespace(ns, sub, restArgs, flags) {
+    switch (ns) {
+        case 'mailbox': return mailbox.run(sub, restArgs, flags);
+        case 'message': return message.run(sub, restArgs, flags);
+        case 'warmup': return warmup.run(sub, restArgs, flags);
+        case 'template': return template.run(sub, restArgs, flags);
+        case 'campaign': return campaign.run(sub, restArgs, flags);
+        default: error(`Unknown namespace: ${ns}. Run "myapi email --help" for the list.`);
+    }
+}
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(`Usage: myapi email <namespace> <subcommand>
+
+Namespaces:
+  mailbox    Mailboxes (account-scoped) — create, list, activate-sending
+  message    Send & read mail (account-scoped) — send, status, sent, inbox, outbox, get
+  warmup     Warmup controls (account-scoped) — start, pause, resume, stop, stats
+  template   Email templates (org-scoped) — generate, list, edit, send-test, delete
+  campaign   Email campaigns (org-scoped) — create, list, get, update, upload-contacts, start, pause, resume, stats
+
+Examples:
+  myapi email mailbox create hello@example.com
+  myapi email message send --from a@x --to b@y --subject hi --body "hello"
+  myapi email template generate welcome --prompt "Welcome email"
+  myapi email campaign create "Q2 Launch" --template-id <id> --from a@x
+
+Org-scoped commands accept --org <id> (or set default: myapi config set-org <id>).
+Run "myapi email <namespace> --help" for namespace-specific commands.`);
+        return;
+    }
+    // Deprecated flat command? Forward to the new path with a one-line note.
+    const aliased = DEPRECATED_ALIASES[subcommand];
+    if (aliased) {
+        const [ns, sub] = aliased;
+        process.stderr.write(`› Note: "email ${subcommand}" is deprecated — use "email ${ns} ${sub}" instead.\n`);
+        return dispatchNamespace(ns, sub, args, flags);
+    }
+    return dispatchNamespace(subcommand, args[0], args.slice(1), flags);
+}

package/dist/commands/email/mailbox.d.ts

@@ -0,0 +1,2 @@
+import type { Flags } from '../../helpers.js';
+export declare function run(sub: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/email/mailbox.js

@@ -0,0 +1,88 @@
+import { email as sdkEmail } from '@myapihq/sdk';
+import { requireConfig } from '../../config.js';
+import { success, error, printTable, info } from '../../output.js';
+async function create(addressArg, flags) {
+    const config = requireConfig();
+    // Convention: first required arg is positional. For mailboxes that's the
+    // full address `user@domain`. The flag form (--username + --domain) is
+    // still accepted for back-compat / scripts that built up parts separately.
+    let username = flags.username;
+    let domain = flags.domain || config.default_domain;
+    if (addressArg) {
+        const at = addressArg.indexOf('@');
+        if (at > 0 && at < addressArg.length - 1) {
+            username = addressArg.slice(0, at);
+            domain = addressArg.slice(at + 1);
+        }
+        else {
+            error(`"${addressArg}" is not a valid email address. Expected format: user@domain.com`);
+        }
+    }
+    if (!username || !domain) {
+        error('Missing required arguments.\nUsage: myapi email mailbox create <user@domain> [--display-name <name>]\n   or: myapi email mailbox create --username <u> --domain <d> [--display-name <name>]\n(Or set default: myapi config set-domain <domain>)');
+    }
+    const res = await sdkEmail.createMailbox(config.api_key, domain, username, flags['display-name']);
+    // Backend response sometimes omits address; we know it from the inputs.
+    success(`Mailbox created: ${res.address || `${username}@${domain}`}`);
+}
+async function list(flags) {
+    const config = requireConfig();
+    if (!flags.domain && flags.filter !== 'unassigned') {
+        error('Must provide either --domain <domain> (mailboxes on that domain) or --filter unassigned (mailboxes whose domain is not assigned to any org).');
+    }
+    const mailboxes = await sdkEmail.listMailboxes(config.api_key, {
+        domain: flags.domain,
+        filter: flags.filter === 'unassigned' ? 'unassigned' : undefined,
+    });
+    printTable(mailboxes, {
+        flags,
+        empty: 'No mailboxes found.',
+    });
+}
+async function activateSending(flags) {
+    const config = requireConfig();
+    const address = flags.address;
+    if (!address)
+        error('Missing required arguments.\nUsage: myapi email mailbox activate-sending --address <email>');
+    const res = await sdkEmail.activateSending(config.api_key, address);
+    success(`Sending activated: ${address} (status: ${res.status})`);
+}
+const USAGE = {
+    'create': `myapi email mailbox create <user@domain> [--display-name <name>]
+       myapi email mailbox create --username <u> --domain <d> [--display-name <name>]
+
+Either form works. The positional address is the recommended shape and
+matches the rest of the CLI ("first required arg is positional").`,
+    'list': `myapi email mailbox list (--domain <domain> | --filter unassigned)
+
+  --domain <domain>     List mailboxes on the given domain.
+  --filter unassigned   List mailboxes whose domain is NOT assigned to any
+                        org (orphaned mailboxes — domain was unassigned
+                        without first deleting them).`,
+    'activate-sending': 'myapi email mailbox activate-sending --address <email>',
+};
+export async function run(sub, args, flags) {
+    if (!sub || (flags.help && !sub)) {
+        info(`Usage: myapi email mailbox <subcommand>
+
+Subcommands:
+  create             Create a mailbox (positional <user@domain> or --username/--domain)
+  list               List mailboxes on a domain (--domain) or orphaned ones (--filter unassigned)
+  activate-sending   Activate outbound sending for a mailbox`);
+        return;
+    }
+    if (flags.help) {
+        const usage = USAGE[sub];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${sub}. Run "myapi email mailbox --help" for the list.`);
+        return;
+    }
+    switch (sub) {
+        case 'create': return create(args[0], flags);
+        case 'list': return list(flags);
+        case 'activate-sending': return activateSending(flags);
+        default: error(`Unknown subcommand: ${sub}. Run "myapi email mailbox --help" for the list.`);
+    }
+}

package/dist/commands/email/message.d.ts

@@ -0,0 +1,2 @@
+import type { Flags } from '../../helpers.js';
+export declare function run(sub: string | undefined, args: string[], flags: Flags): Promise<void>;