@myapihq/cli 1.1.0-wip.0 → 1.1.0-wip.2

package/dist/commands/auth.js

@@ -1,6 +1,6 @@
-import * as readline from 'readline';
 import { loadConfig, saveConfig, addAccount, switchAccount, listAccounts } from '../config.js';
 import { info, success, error, printJson } from '../output.js';
+import { ask, confirm, withReadline } from '../prompt.js';
 import { installSkills } from './setup.js';
 import { hq } from '@myapihq/sdk';
 export const SCHEMA = {
@@ -9,21 +9,75 @@ export const SCHEMA = {
     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));
-}
-function yn(answer, defaultYes = true) {
-    const t = answer.trim().toLowerCase();
-    if (t === '')
-        return defaultYes;
-    return t === 'y' || t === 'yes';
+export const HELP = `Usage: myapi auth <subcommand>
+
+Subcommands:
+  setup           Configure your account
+  import-key      Import an existing API key non-interactively
+  whoami          Show current account · supports --json
+  link [email]    Upgrade anonymous account to registered (or add a second session)
+                  Use myapi auth setup to create a completely new account
+  switch [index]  Switch active account by index or email
+  config          Manage CLI defaults (org, funnel, domain) · supports set-org / set-funnel / set-domain
+  install-skills  Install or update the MyAPI skills pack for AI agents
+  api-keys        Manage API keys · list / create / revoke
+  keys            Alias for api-keys`;
+export const INSTALL_SKILLS_HELP = `Usage: myapi auth install-skills
+
+Installs the MyAPI skills pack for AI coding agents (Claude, Gemini, Cursor).
+
+This command writes skill definition files to:
+  ~/.agents/skills/myapi/
+
+And creates symlinks in the appropriate agent config directories:
+  ~/.claude/  (Claude)
+  ~/.gemini/  (Gemini)
+  ~/.cursor/  (Cursor, if detected)
+
+These files teach agents how to use the MyAPI CLI and API directly.
+Run this command again to update existing skills to the latest version.`;
+const LINK_HELP = `Usage: myapi auth link [email]
+
+Behavior depends on whether the email is new or already registered:
+
+  New email:        Attaches it to your current anonymous account, upgrading it
+                    to a registered account. A one-time code is sent to confirm.
+
+  Existing email:   Does NOT merge accounts. The existing account is added as a
+                    second active session — your anonymous account stays separate.
+                    Switch between sessions with: myapi auth switch
+
+To create a completely new account from scratch, use: myapi auth setup`;
+const WHOAMI_HELP = `Usage: myapi auth whoami [--json]
+
+Displays the active account details: email, account ID, default org,
+default funnel, account type, and current balance.
+
+Flags:
+  --json   Output raw JSON`;
+const SWITCH_HELP = `Usage: myapi auth switch [index|email]
+
+Switches the active account. Run without arguments to see a numbered list
+of accounts and choose interactively.
+
+Pass an index number or email address to switch non-interactively:
+  myapi auth switch 2
+  myapi auth switch you@example.com
+
+Note: index numbers can shift as accounts are added or removed.
+Use email as a stable identifier in scripts.`;
+// Resolve the user's "install skills?" preference: explicit flag wins, else prompt.
+async function resolveSkillsPreference(flags) {
+    if (flags['install-skills'])
+        return true;
+    if (flags['no-skills'])
+        return false;
+    return confirm('› Install the MyAPI skills pack? (Y/n) ', true);
 }
 // myapi auth link — upgrade anonymous session to registered account.
 export async function link(flags = {}, emailArg) {
     if (flags.help) {
-        info('Usage: myapi auth link [email]\n\nBehavior depends on whether the email is new or already registered:\n\n  New email:        Attaches it to your current anonymous account, upgrading it\n                    to a registered account. A one-time code is sent to confirm.\n\n  Existing email:   Does NOT merge accounts. The existing account is added as a\n                    second active session — your anonymous account stays separate.\n                    Switch between sessions with: myapi auth switch\n\nTo create a completely new account from scratch, use: myapi auth setup');
+        info(LINK_HELP);
         return;
     }
     const config = loadConfig();
@@ -31,9 +85,8 @@ export async function link(flags = {}, emailArg) {
         error('Not configured. Run: myapi auth setup');
     if (!config.is_anonymous)
         error('Already registered. Use your existing account.');
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const email = emailArg || (await ask(rl, '› Email? ')).trim();
+    await withReadline(async () => {
+        const email = emailArg || await ask('› Email? ');
         if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email))
             error(`Invalid email address: "${email}".`);
         let upgradeOk = true;
@@ -46,16 +99,14 @@ export async function link(flags = {}, emailArg) {
             upgradeOk = false;
             info(`› That email already has an account — accounts cannot be merged.`);
             info(`› Your anonymous account will be kept and you can switch back to it anytime.`);
-            const ans = (await ask(rl, '› Sign in and add it as a second account? (Y/n) ')).trim();
-            if (!yn(ans))
+            if (!await confirm('› Sign in and add it as a second account? (Y/n) ', true))
                 return;
             await hq.sendCode(email);
         }
         info(`› Sent a code to ${email} · paste it below`);
-        const code = (await ask(rl, '› Code? ')).trim();
+        const code = await ask('› 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());
+        const wantsSkills = await resolveSkillsPreference(flags);
         if (upgradeOk) {
             saveConfig({
                 ...config,
@@ -84,15 +135,12 @@ export async function link(flags = {}, emailArg) {
         }
         if (wantsSkills)
             await installSkills();
-    }
-    finally {
-        rl.close();
-    }
+    });
 }
 // myapi auth whoami — show current session info.
 export async function whoami(flags = {}) {
     if (flags.help) {
-        info('Usage: myapi auth whoami [--json]\n\nDisplays the active account details: email, account ID, default org, default funnel, account type, and current balance.\n\nFlags:\n  --json   Output raw JSON');
+        info(WHOAMI_HELP);
         return;
     }
     const config = loadConfig();
@@ -126,7 +174,7 @@ export async function whoami(flags = {}) {
 // myapi auth switch [index] — switch between saved accounts.
 export async function switchCmd(flags = {}, indexArg) {
     if (flags.help) {
-        info('Usage: myapi auth switch [index|email]\n\nSwitches the active account. Run without arguments to see a numbered list\nof accounts and choose interactively.\n\nPass an index number or email address to switch non-interactively:\n  myapi auth switch 2\n  myapi auth switch you@example.com\n\nNote: index numbers can shift as accounts are added or removed.\nUse email as a stable identifier in scripts.');
+        info(SWITCH_HELP);
         return;
     }
     const accounts = listAccounts();
@@ -145,13 +193,7 @@ export async function switchCmd(flags = {}, indexArg) {
     }
     let idxStr = indexArg ?? '';
     if (!idxStr) {
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        try {
-            idxStr = (await ask(rl, `› Switch to account (1-${accounts.length})? `)).trim();
-        }
-        finally {
-            rl.close();
-        }
+        idxStr = await ask(`› Switch to account (1-${accounts.length})? `);
     }
     // Support email as a stable identifier
     let idx;

package/dist/commands/billing.js

@@ -1,7 +1,7 @@
-import * as readline from 'readline';
 import { hq } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson } from '../output.js';
+import { confirm } from '../prompt.js';
 import { formatDate } from '../utils.js';
 export const SCHEMA = {};
 const SUBCOMMAND_USAGE = {
@@ -82,10 +82,8 @@ export async function topup(amountStr, flags) {
         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 });
-        const ans = await new Promise(resolve => rl.question(`› Charge $${amount} to your saved payment method? (y/N) `, resolve));
-        rl.close();
-        if (ans.trim().toLowerCase() !== 'y' && ans.trim().toLowerCase() !== 'yes') {
+        const ok = await confirm(`› Charge $${amount} to your saved payment method? (y/N) `, false);
+        if (!ok) {
             info('Cancelled.');
             return;
         }

package/dist/commands/domain.js

@@ -57,11 +57,18 @@ export async function list(flags) {
         printJson(domains);
         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 = requireOrg(flags, config, 'myapi domain assign <domain> [--org <id>]');

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} (${res.emails_quota_remaining} emails/day quota)`);
+}
+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>;