@myapihq/cli 1.0.84 → 1.1.0-wip.1

package/dist/flags.test.js

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest';
+import { parseFlags } from './flags.js';
+const SCHEMA = {
+    org: 'string',
+    name: 'string',
+    years: 'number',
+    'no-enable': 'boolean',
+};
+describe('parseFlags', () => {
+    it('treats unknown flags as boolean by default (forward-compatible)', () => {
+        const { args, flags } = parseFlags(['funnel', 'get', '--json', 'abc-123'], SCHEMA);
+        expect(flags.json).toBe(true);
+        expect(args).toEqual(['funnel', 'get', 'abc-123']);
+    });
+    it('treats global booleans (--yes, --help, --verbose) as boolean', () => {
+        const { flags } = parseFlags(['--yes', '--help', '--verbose'], SCHEMA);
+        expect(flags.yes).toBe(true);
+        expect(flags.help).toBe(true);
+        expect(flags.verbose).toBe(true);
+    });
+    it('consumes the next token for declared string flags', () => {
+        const { args, flags } = parseFlags(['org', 'create', '--name', 'Acme Inc', '--yes'], SCHEMA);
+        expect(flags.name).toBe('Acme Inc');
+        expect(flags.yes).toBe(true);
+        expect(args).toEqual(['org', 'create']);
+    });
+    it('supports --key=value for any flag', () => {
+        const { flags } = parseFlags(['--org=abc-123', '--json'], SCHEMA);
+        expect(flags.org).toBe('abc-123');
+        expect(flags.json).toBe(true);
+    });
+    it('declared string flag with no next token becomes boolean true', () => {
+        const { flags } = parseFlags(['--name'], SCHEMA);
+        expect(flags.name).toBe(true);
+    });
+    it('declared string flag followed by another flag does not consume it', () => {
+        const { flags } = parseFlags(['--org', '--json'], SCHEMA);
+        expect(flags.org).toBe(true);
+        expect(flags.json).toBe(true);
+    });
+    it('-h maps to help', () => {
+        const { flags } = parseFlags(['-h'], SCHEMA);
+        expect(flags.help).toBe(true);
+    });
+    it('-v maps to version', () => {
+        const { flags } = parseFlags(['-v'], SCHEMA);
+        expect(flags.version).toBe(true);
+    });
+    it('collects positional args correctly', () => {
+        const { args, flags } = parseFlags(['domain', 'register', 'example.com', '--org', 'uuid-here'], SCHEMA);
+        expect(args).toEqual(['domain', 'register', 'example.com']);
+        expect(flags.org).toBe('uuid-here');
+    });
+    it('parses declared number flags as numbers', () => {
+        const { flags } = parseFlags(['--years', '3'], SCHEMA);
+        expect(flags.years).toBe(3);
+        expect(typeof flags.years).toBe('number');
+    });
+    it('declared boolean flag does not consume next token', () => {
+        const { args, flags } = parseFlags(['--no-enable', 'abc'], SCHEMA);
+        expect(flags['no-enable']).toBe(true);
+        expect(args).toEqual(['abc']);
+    });
+    it('-- terminator: everything after is positional', () => {
+        const { args, flags } = parseFlags(['--name', 'X', '--', '--not-a-flag', 'y'], SCHEMA);
+        expect(flags.name).toBe('X');
+        expect(args).toEqual(['--not-a-flag', 'y']);
+    });
+    it('unknown --key=value preserved as a string (not silently lost)', () => {
+        const { flags } = parseFlags(['--mystery=42'], SCHEMA);
+        expect(flags.mystery).toBe('42');
+    });
+});

package/dist/helpers.d.ts

@@ -0,0 +1,6 @@
+import type { Config } from './config.js';
+export type Flags = Record<string, string | boolean | number>;
+export declare function requireOrg(flags: Flags, config: Config, usage: string): string;
+export declare function requireDomain(arg: string | undefined, flags: Flags, config: Config, usage: string): string;
+export declare function requireArg(value: string | undefined, name: string, usage: string): string;
+export declare function requireFlag(flags: Flags, name: string, usage: string): string;

package/dist/helpers.js

@@ -0,0 +1,31 @@
+import { error } from './output.js';
+// error() returns `never`, so after `if (!x) error(...)` TS narrows x to a
+// non-falsy value and the casts disappear.
+export function requireOrg(flags, config, usage) {
+    const orgId = (typeof flags.org === 'string' ? flags.org : '') || config.default_org;
+    if (!orgId) {
+        error(`Missing required arguments.\nUsage: ${usage}\n(Or set default: myapi config set-org <id>)`);
+    }
+    return orgId;
+}
+export function requireDomain(arg, flags, config, usage) {
+    const fromFlag = typeof flags.domain === 'string' ? flags.domain : '';
+    const fromConfig = typeof config.default_domain === 'string' ? config.default_domain : '';
+    const domain = arg || fromFlag || fromConfig;
+    if (!domain) {
+        error(`Missing required arguments.\nUsage: ${usage}\n(Or set default: myapi config set-domain <domain>)`);
+    }
+    return domain;
+}
+export function requireArg(value, name, usage) {
+    if (!value)
+        error(`Missing required argument: ${name}.\nUsage: ${usage}`);
+    return value;
+}
+export function requireFlag(flags, name, usage) {
+    const v = flags[name];
+    if (v === undefined || v === true || v === false || v === '') {
+        error(`Missing required flag: --${name}.\nUsage: ${usage}`);
+    }
+    return String(v);
+}

package/dist/index.js

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
-// manually maintained — do not regenerate from scripts/generate-indexes.js
-import { parseArgs } from './utils.js';
 import { error, info, success } from './output.js';
 import { loadConfig } from './config.js';
 import { MyApiError } from '@myapihq/sdk';
 import * as fs from 'fs';
+import { parseFlags } from './flags.js';
 const pkgPath = new URL('../package.json', import.meta.url);
 const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
 import * as keysCmd from './commands/keys.js';
@@ -14,8 +13,29 @@ import * as setupCmd from './commands/setup.js';
 import * as updateCmd from './commands/update.js';
 import * as domainCmd from './commands/domain.js';
 import * as funnelCmd from './commands/funnel.js';
+import * as webhookCmd from './commands/webhook.js';
+import * as workflowCmd from './commands/workflow.js';
+import * as emailCmd from './commands/email/index.js';
 import * as authCmd from './commands/auth.js';
 import * as configCmd from './commands/config.js';
+// Each command file declares the value flags it understands. We union them
+// into a single schema for the upfront parse, so adding a new value flag in
+// one command means editing one file (its SCHEMA), not a global allowlist.
+const COMBINED_SCHEMA = {
+    ...authCmd.SCHEMA,
+    ...billingCmd.SCHEMA,
+    ...configCmd.SCHEMA,
+    ...domainCmd.SCHEMA,
+    ...emailCmd.SCHEMA,
+    ...funnelCmd.SCHEMA,
+    ...keysCmd.SCHEMA,
+    ...orgCmd.SCHEMA,
+    ...webhookCmd.SCHEMA,
+    ...workflowCmd.SCHEMA,
+    // Top-level flags
+    version: 'boolean',
+    V: 'boolean',
+};
 const ERROR_MESSAGES = {
     DOMAIN_NOT_FOUND: 'Domain not found.',
     INVALID_DOMAIN: 'Invalid domain name.',
@@ -43,7 +63,7 @@ function friendlyError(code) {
     return ERROR_MESSAGES[code] || code;
 }
 async function main() {
-    const { args, flags } = parseArgs(process.argv.slice(2));
+    const { args, flags } = parseFlags(process.argv.slice(2), COMBINED_SCHEMA);
     if (flags.version || flags.v || flags.V) {
         const latest = await updateCmd.latestVersion();
         const updateNote = latest && updateCmd.isNewer(latest, pkg.version)
@@ -71,89 +91,16 @@ async function main() {
     try {
         switch (command) {
             case 'auth':
-                if (!subcommand || (flags.help && !subcommand)) {
-                    info('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');
-                    break;
-                }
-                if (subcommand === 'setup')
-                    await setupCmd.setup(flags);
-                else if (subcommand === 'import-key')
-                    await setupCmd.importKey(restArgs[0], flags);
-                else if (subcommand === 'whoami')
-                    await authCmd.whoami(flags);
-                else if (subcommand === 'link')
-                    await authCmd.link(flags, restArgs[0]);
-                else if (subcommand === 'switch')
-                    await authCmd.switchCmd(flags, restArgs[0]);
-                else if (subcommand === 'install-skills') {
-                    if (flags.help) {
-                        info('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.');
-                        break;
-                    }
-                    await setupCmd.installSkills();
-                    success('› Skills installed.');
-                }
-                else if (subcommand === 'config')
-                    await configCmd.run(restArgs[0], restArgs.slice(1), flags);
-                else if (subcommand === 'api-keys') {
-                    if (flags.help && !restArgs[0]) {
-                        info('Usage: myapi auth api-keys <subcommand>\n\nManage programmatic API keys for your account. API keys are used to authenticate\nrequests to the MyAPI SDK and REST API.\n\nSubcommands:\n  list             List all API keys with their IDs and creation dates\n  create           Create a new API key (the key value is shown once)\n  revoke <id>      Permanently revoke an API key by ID\n\nExamples:\n  myapi auth api-keys list\n  myapi auth api-keys create\n  myapi auth api-keys revoke hq_live_xxxxxxxxxxxxxxxxxxxx');
-                        break;
-                    }
-                    if (!restArgs[0]) {
-                        info('Run: myapi auth api-keys --help');
-                        break;
-                    }
-                    if (restArgs[0] === 'create')
-                        await keysCmd.createNew(flags);
-                    else if (restArgs[0] === 'list')
-                        await keysCmd.list(flags);
-                    else if (restArgs[0] === 'revoke')
-                        await keysCmd.revoke(restArgs[1], flags);
-                }
-                else
-                    info('Unknown subcommand. Run: myapi auth --help');
+                await dispatchAuth(subcommand, restArgs, flags);
                 break;
             case 'update':
                 await updateCmd.update(flags);
                 break;
             case 'org':
-                if (!subcommand || (flags.help && !subcommand)) {
-                    info('Usage: myapi org <subcommand>\n\nSubcommands:\n  list        List organizations\n  create      Create an organization · myapi org create "Name" --yes\n  get         Get details of an organization\n  delete      Delete an organization\n  sync-brand  Sync brand info (name, logo, description) from an existing website into an org');
-                    break;
-                }
-                if (subcommand === 'list')
-                    await orgCmd.list(flags);
-                else if (subcommand === 'create')
-                    await orgCmd.create(restArgs, flags);
-                else if (subcommand === 'get')
-                    await orgCmd.get(restArgs[0], flags);
-                else if (subcommand === 'delete')
-                    await orgCmd.del(restArgs[0], flags);
-                else if (subcommand === 'sync-brand')
-                    await orgCmd.importOrg(restArgs, flags);
-                else if (subcommand === 'import') {
-                    process.stderr.write('› Note: "org import" is deprecated — use "org sync-brand" instead.\n');
-                    await orgCmd.importOrg(restArgs, flags);
-                }
-                else
-                    printHelp();
+                await orgCmd.run(subcommand, restArgs, flags);
                 break;
             case 'billing':
-                if (!subcommand || (flags.help && !subcommand)) {
-                    info('Usage: myapi billing <subcommand>\n\nSubcommands:\n  balance    Check balance\n  history    View billing history\n  topup      Top up your balance\n  setup      Setup a payment method');
-                    break;
-                }
-                if (subcommand === 'balance')
-                    await billingCmd.balance(flags);
-                else if (subcommand === 'history')
-                    await billingCmd.history(flags);
-                else if (subcommand === 'topup')
-                    await billingCmd.topup(restArgs[0], flags);
-                else if (subcommand === 'setup')
-                    await billingCmd.setup(flags);
-                else
-                    printHelp();
+                await billingCmd.run(subcommand, restArgs, flags);
                 break;
             case 'domain':
                 await domainCmd.run(subcommand, restArgs, flags);
@@ -161,6 +108,15 @@ async function main() {
             case 'funnel':
                 await funnelCmd.run(subcommand, restArgs, flags);
                 break;
+            case 'webhook':
+                await webhookCmd.run(subcommand, restArgs, flags);
+                break;
+            case 'workflow':
+                await workflowCmd.run(subcommand, restArgs, flags);
+                break;
+            case 'email':
+                await emailCmd.run(subcommand, restArgs, flags);
+                break;
             // Convenience aliases
             case 'setup':
                 await setupCmd.setup(flags);
@@ -169,45 +125,21 @@ async function main() {
                 await authCmd.whoami(flags);
                 break;
             case 'keys':
-                if (!subcommand || (flags.help && !subcommand)) {
-                    info('Usage: myapi keys <subcommand>\n\nManage programmatic API keys for your account. API keys are used to authenticate\nrequests to the MyAPI SDK and REST API.\n\nSubcommands:\n  list             List all API keys with their IDs and creation dates\n  create           Create a new API key (the key value is shown once)\n  revoke <id>      Permanently revoke an API key by ID\n\nExamples:\n  myapi keys list\n  myapi keys create\n  myapi keys revoke hq_live_xxxxxxxxxxxxxxxxxxxx\n\nAlias for: myapi auth api-keys');
-                    break;
-                }
-                if (subcommand === 'create')
-                    await keysCmd.createNew(flags);
-                else if (subcommand === 'list')
-                    await keysCmd.list(flags);
-                else if (subcommand === 'revoke')
-                    await keysCmd.revoke(restArgs[0], flags);
+                await keysCmd.run(subcommand, restArgs, flags);
                 break;
             case 'config':
                 await configCmd.run(subcommand, restArgs, { ...flags, _via: 'config' });
                 break;
             case 'install-skills':
                 if (flags.help) {
-                    info('Usage: myapi install-skills\n\nAlias for: myapi auth install-skills');
+                    info(authCmd.INSTALL_SKILLS_HELP);
                     break;
                 }
                 await setupCmd.installSkills();
                 success('› Skills installed.');
                 break;
             case 'help':
-                if (subcommand === 'funnel')
-                    await funnelCmd.run(undefined, [], { help: true });
-                else if (subcommand === 'domain')
-                    await domainCmd.run(undefined, [], { help: true });
-                else if (subcommand === 'auth')
-                    info('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  switch [index]  Switch active account by index or email\n  config          Manage CLI defaults (org, funnel, domain)\n  install-skills  Install or update the MyAPI skills pack for AI agents\n  api-keys        Manage API keys · list / create / revoke');
-                else if (subcommand === 'org')
-                    info('Usage: myapi org <subcommand>\n\nSubcommands:\n  list        List organizations\n  create      Create an organization · myapi org create "Name" --yes\n  get         Get details of an organization\n  delete      Delete an organization\n  sync-brand  Sync brand info from an existing website into an org');
-                else if (subcommand === 'billing')
-                    info('Usage: myapi billing <subcommand>\n\nSubcommands:\n  balance    Check balance\n  history    View billing history\n  topup      Top up your balance\n  setup      Setup a payment method');
-                else if (subcommand === 'keys')
-                    info('Usage: myapi keys <subcommand>\n\nSubcommands:\n  list             List all API keys\n  create           Create a new API key\n  revoke <id>      Revoke an API key\n\nAlias for: myapi auth api-keys');
-                else if (subcommand)
-                    info(`Run: myapi ${subcommand} --help`);
-                else
-                    printHelp();
+                await dispatchHelp(subcommand);
                 break;
             default:
                 error(`Unknown command: ${command}. Run "myapi" for available commands.`);
@@ -223,16 +155,70 @@ async function main() {
                 else if (err.code === 'NO_PAYMENT_METHOD')
                     error('No payment method on file. Run: myapi billing setup');
                 else
-                    error(`Insufficient balance. Run: myapi billing topup <amount>`);
+                    error('Insufficient balance. Run: myapi billing topup <amount>');
             }
             else
                 error(friendlyError(err.code) || err.message);
         }
         else {
-            error(err.message || (typeof err === 'object' ? JSON.stringify(err) : String(err)));
+            // Don't JSON.stringify Error instances — that returns "{}" because
+            // Error's enumerable surface is empty. Prefer .message; fall back to
+            // String() which Errors stringify reasonably ("Error: ...").
+            error(err?.message ?? String(err));
         }
     }
 }
+async function dispatchAuth(subcommand, restArgs, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(authCmd.HELP);
+        return;
+    }
+    switch (subcommand) {
+        case 'setup': return setupCmd.setup(flags);
+        case 'import-key': return setupCmd.importKey(restArgs[0], flags);
+        case 'whoami': return authCmd.whoami(flags);
+        case 'link': return authCmd.link(flags, restArgs[0]);
+        case 'switch': return authCmd.switchCmd(flags, restArgs[0]);
+        case 'install-skills':
+            if (flags.help) {
+                info(authCmd.INSTALL_SKILLS_HELP);
+                return;
+            }
+            await setupCmd.installSkills();
+            success('› Skills installed.');
+            return;
+        case 'config': return configCmd.run(restArgs[0], restArgs.slice(1), flags);
+        case 'api-keys':
+        case 'keys': return keysCmd.runApiKeys(restArgs[0], restArgs.slice(1), flags);
+        default: info('Unknown subcommand. Run: myapi auth --help');
+    }
+}
+const HELP_TARGETS = {
+    funnel: f => funnelCmd.run(undefined, [], f),
+    domain: f => domainCmd.run(undefined, [], f),
+    webhook: f => webhookCmd.run(undefined, [], f),
+    workflow: f => workflowCmd.run(undefined, [], f),
+    email: f => emailCmd.run(undefined, [], f),
+    org: f => orgCmd.run(undefined, [], f),
+    billing: f => billingCmd.run(undefined, [], f),
+    keys: f => keysCmd.run(undefined, [], f),
+    config: f => configCmd.run(undefined, [], f),
+};
+async function dispatchHelp(target) {
+    if (!target) {
+        printHelp();
+        return;
+    }
+    if (target === 'auth') {
+        info(authCmd.HELP);
+        return;
+    }
+    const handler = HELP_TARGETS[target];
+    if (handler)
+        await handler({ help: true });
+    else
+        info(`Run: myapi ${target} --help`);
+}
 function printHelp() {
     const config = loadConfig();
     const quickStart = config?.api_key
@@ -252,6 +238,9 @@ Commands:
   update       Update CLI and skills to the latest version
   domain       Manage domain configurations
   funnel       Manage websites (publish pages, custom domains, funnels)
+  webhook      Manage inbound webhook endpoints and inspect deliveries
+  email        Manage mailboxes, send/read email, templates, and campaigns
+  workflow     Run actions (send email, post to Slack) when a webhook fires
 
 Aliases:
   whoami          → myapi auth whoami
@@ -264,4 +253,4 @@ Run "myapi <command> --help" for subcommand help.
 
 ${quickStart}`);
 }
-main().catch(err => { error(err.message || (typeof err === 'object' ? JSON.stringify(err) : String(err))); });
+main().catch(err => { error(err?.message ?? String(err)); });

package/dist/output.d.ts

@@ -1,6 +1,17 @@
+export type TableFlags = {
+    json?: boolean | string | number;
+} & Record<string, unknown>;
 export declare function success(message: string): void;
 export declare function error(message: string): never;
 export declare function info(message: string): void;
 export declare function banner(message: string): void;
 export declare function printJson(data: unknown): void;
-export declare function printTable(rows: Record<string, unknown>[]): void;
+export declare function spinnerFrame(i: number): string;
+export declare function clearLine(): void;
+export interface PrintTableOptions {
+    /** Pass `flags` so `--json` (any truthy form) routes to JSON output. */
+    flags?: TableFlags;
+    /** Hint shown when the table is empty (instead of "No data found."). */
+    empty?: string;
+}
+export declare function printTable<T extends object>(rows: T[], opts?: PrintTableOptions): void;

package/dist/output.js

@@ -15,19 +15,29 @@ export function banner(message) {
 export function printJson(data) {
     console.log(JSON.stringify(data, null, 2));
 }
-export function printTable(rows) {
-    if (process.argv.includes('--json')) {
+// Spinner / line-clear primitives. Used by polling helpers (utils.pollJob)
+// and any handler that wants its own progress UI.
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+export function spinnerFrame(i) {
+    return SPINNER_FRAMES[i % SPINNER_FRAMES.length];
+}
+export function clearLine() {
+    process.stdout.write('\r\x1b[K');
+}
+// Generic so callers don't need `as unknown as Record<string, unknown>[]`.
+// Field names come from the first row; if SDK renames a field, the projector
+// (passed in by the caller) is where it'll fail at compile time.
+export function printTable(rows, opts = {}) {
+    if (opts.flags && opts.flags.json) {
         printJson(rows);
         return;
     }
     if (rows.length === 0) {
-        console.log("No data found.");
+        console.log(opts.empty ?? 'No data found.');
         return;
     }
     const columns = Object.keys(rows[0]);
-    const colWidths = columns.map(col => {
-        return Math.max(col.length, ...rows.map(row => String(row[col] ?? '').length));
-    });
+    const colWidths = columns.map(col => Math.max(col.length, ...rows.map(row => String(row[col] ?? '').length)));
     const printRow = (row) => {
         console.log(row.map((cell, i) => cell.padEnd(colWidths[i] + 2)).join(''));
     };

package/dist/prompt.d.ts

@@ -0,0 +1,24 @@
+import * as readline from 'readline';
+/**
+ * Ask a free-form question on stdin. Returns the trimmed answer.
+ *
+ * Handles the readline lifecycle so callers don't open/close interfaces
+ * inline. Replaces five copies of the same boilerplate across commands.
+ */
+export declare function ask(question: string): Promise<string>;
+/**
+ * Yes/No confirm. `defaultYes` controls how Enter (no input) is interpreted.
+ *
+ * - `confirm('› Continue? (Y/n) ', true)` — Enter means yes.
+ * - `confirm('› Delete? (y/N) ', false)` — Enter means no.
+ *
+ * Accepted yes inputs: 'y', 'yes' (case-insensitive). Anything else is no
+ * when `defaultYes=false`; when `defaultYes=true`, only an explicit 'n' /
+ * 'no' counts as no, matching the existing Y/n convention in the CLI.
+ */
+export declare function confirm(question: string, defaultYes: boolean): Promise<boolean>;
+/**
+ * Lower-level escape hatch: get a readline.Interface, do something with it,
+ * close it on the way out (even if your callback throws).
+ */
+export declare function withReadline<T>(fn: (rl: readline.Interface) => Promise<T>): Promise<T>;

package/dist/prompt.js

@@ -0,0 +1,41 @@
+import * as readline from 'readline';
+/**
+ * Ask a free-form question on stdin. Returns the trimmed answer.
+ *
+ * Handles the readline lifecycle so callers don't open/close interfaces
+ * inline. Replaces five copies of the same boilerplate across commands.
+ */
+export async function ask(question) {
+    return withReadline(rl => new Promise(resolve => {
+        rl.question(question, ans => resolve(ans.trim()));
+    }));
+}
+/**
+ * Yes/No confirm. `defaultYes` controls how Enter (no input) is interpreted.
+ *
+ * - `confirm('› Continue? (Y/n) ', true)` — Enter means yes.
+ * - `confirm('› Delete? (y/N) ', false)` — Enter means no.
+ *
+ * Accepted yes inputs: 'y', 'yes' (case-insensitive). Anything else is no
+ * when `defaultYes=false`; when `defaultYes=true`, only an explicit 'n' /
+ * 'no' counts as no, matching the existing Y/n convention in the CLI.
+ */
+export async function confirm(question, defaultYes) {
+    const ans = (await ask(question)).toLowerCase();
+    if (defaultYes)
+        return ans !== 'n' && ans !== 'no';
+    return ans === 'y' || ans === 'yes';
+}
+/**
+ * Lower-level escape hatch: get a readline.Interface, do something with it,
+ * close it on the way out (even if your callback throws).
+ */
+export async function withReadline(fn) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return await fn(rl);
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/skills/my-email-api/README.md

@@ -0,0 +1,45 @@
+---
+# my-email-api
+
+Send transactional email and run drip campaigns from mailboxes on your own registered domains. Includes AI template generation, warmup, and inbox/outbox reading.
+
+## What it does
+
+- Create mailboxes on your registered domains
+- Send transactional emails (one-shot or templated)
+- Read inbox, outbox, sent history, and per-message status
+- Generate HTML email templates with AI from a prompt
+- Run paced drip campaigns against uploaded contact lists
+- Manage IP/domain warmup for sender reputation
+
+## Quickstart
+
+```bash
+# Create a mailbox + activate sending
+myapi email mailbox create hello@yourdomain.com
+myapi email mailbox activate-sending --address hello@yourdomain.com
+
+# Send
+myapi email message send \
+  --from hello@yourdomain.com \
+  --to recipient@example.com \
+  --subject "Hi" \
+  --body "Test"
+```
+
+## Authentication
+
+```bash
+export MYAPI_KEY=mak_...
+```
+
+Requires:
+- An `api_key` from **myapihq**
+- A registered domain via **mydomainapi**, assigned to your org
+- Default `org_id` (for templates/campaigns) — set with `myapi auth config set-org <id>`
+
+## Documentation
+
+Full command reference and flow diagrams: see `SKILL.md`.
+
+Run `myapi email --help` for inline reference.