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

package/dist/commands/email/message.js

@@ -0,0 +1,115 @@
+import { email as sdkEmail } from '@myapihq/sdk';
+import { requireConfig } from '../../config.js';
+import { success, error, printTable, printJson, info } from '../../output.js';
+async function send(flags) {
+    const config = requireConfig();
+    if (!flags.from || !flags.to || !flags.subject) {
+        error('Missing required arguments.\nUsage: myapi email message send --from <email> --to <email> --subject <str> [--body <str> | --html <str> | --template-id <id> [--template-vars <json>]]');
+    }
+    if (!flags.body && !flags.html && !flags['template-id'])
+        error('Must provide one of --body, --html, or --template-id');
+    if ((flags.body || flags.html) && flags['template-id'])
+        error('Cannot combine --body/--html with --template-id');
+    let templateVars;
+    if (flags['template-vars']) {
+        try {
+            templateVars = JSON.parse(flags['template-vars']);
+        }
+        catch {
+            error('--template-vars must be valid JSON');
+        }
+    }
+    const res = await sdkEmail.sendEmail(config.api_key, {
+        from: flags.from,
+        to: [flags.to],
+        subject: flags.subject,
+        text: flags.body,
+        html: flags.html,
+        template_id: flags['template-id'],
+        template_vars: templateVars,
+    });
+    success(`Email sent! Message ID: ${res.message_id}`);
+}
+async function status(messageId, _flags) {
+    const config = requireConfig();
+    if (!messageId)
+        error('Missing required arguments.\nUsage: myapi email message status <message_id>');
+    const res = await sdkEmail.getEmailStatus(config.api_key, messageId);
+    printJson(res);
+}
+async function sent(flags) {
+    const config = requireConfig();
+    const limit = flags.limit || 50;
+    const offset = flags.offset || 0;
+    const emails = await sdkEmail.getSentEmails(config.api_key, limit, offset);
+    printTable(emails, {
+        flags,
+        empty: 'No sent emails yet.',
+    });
+}
+async function inbox(address, flags) {
+    const config = requireConfig();
+    if (!address)
+        error('Missing required arguments.\nUsage: myapi email message inbox <address>');
+    const messages = await sdkEmail.getInbox(config.api_key, address);
+    printTable(messages, {
+        flags,
+        empty: `No messages in ${address}.`,
+    });
+}
+async function outbox(address, flags) {
+    const config = requireConfig();
+    if (!address)
+        error('Missing required arguments.\nUsage: myapi email message outbox <address>');
+    const messages = await sdkEmail.getOutbox(config.api_key, address);
+    printTable(messages, {
+        flags,
+        empty: `No outbound messages from ${address}.`,
+    });
+}
+async function get(messageId, flags) {
+    const config = requireConfig();
+    if (!messageId || !flags.address)
+        error('Missing required arguments.\nUsage: myapi email message get <message_id> --address <email>');
+    const res = await sdkEmail.getMessage(config.api_key, messageId, flags.address);
+    printJson(res);
+}
+const USAGE = {
+    'send': 'myapi email message send --from <email> --to <email> --subject <str> [--body <str> | --html <str> | --template-id <id> [--template-vars <json>]]',
+    'status': 'myapi email message status <message_id>',
+    'sent': 'myapi email message sent [--limit <n>] [--offset <n>]',
+    'inbox': 'myapi email message inbox <address>',
+    'outbox': 'myapi email message outbox <address>',
+    'get': 'myapi email message get <message_id> --address <email>',
+};
+export async function run(sub, args, flags) {
+    if (!sub || (flags.help && !sub)) {
+        info(`Usage: myapi email message <subcommand>
+
+Subcommands:
+  send                Send an email (transactional or templated)
+  status <id>         Get delivery status of a sent message
+  sent                List sent emails
+  inbox <addr>        Read inbox for a mailbox address
+  outbox <addr>       Read outbox for a mailbox address
+  get <id>            Get a single message (--address <email>)`);
+        return;
+    }
+    if (flags.help) {
+        const usage = USAGE[sub];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${sub}. Run "myapi email message --help" for the list.`);
+        return;
+    }
+    switch (sub) {
+        case 'send': return send(flags);
+        case 'status': return status(args[0], flags);
+        case 'sent': return sent(flags);
+        case 'inbox': return inbox(args[0], flags);
+        case 'outbox': return outbox(args[0], flags);
+        case 'get': return get(args[0], flags);
+        default: error(`Unknown subcommand: ${sub}. Run "myapi email message --help" for the list.`);
+    }
+}

package/dist/commands/email/template.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/template.js

@@ -0,0 +1,106 @@
+import { email as sdkEmail } from '@myapihq/sdk';
+import { requireConfig } from '../../config.js';
+import { success, error, printTable, printJson, info } from '../../output.js';
+import { pollJob } from '../../utils.js';
+import { requireOrg } from '../../helpers.js';
+async function generate(nameArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email template generate <name> --prompt <str> [--org <id>]');
+    const name = nameArg || flags.name;
+    if (!name || !flags.prompt) {
+        error('Missing required arguments.\nUsage: myapi email template generate <name> --prompt <str> [--org <id>]\n   or: myapi email template generate --name <name> --prompt <str> [--org <id>]');
+    }
+    const job = await sdkEmail.generateTemplate(config.api_key, orgId, {
+        prompt: flags.prompt,
+        name,
+    });
+    const status = await pollJob({
+        label: 'Generating template',
+        timeoutMs: 90_000,
+        intervalMs: 3000,
+        check: () => sdkEmail.getTemplateJobStatus(config.api_key, orgId, job.job_id),
+        isDone: s => s.status === 'completed',
+        isFailed: s => s.status === 'failed',
+        failedMessage: 'Template generation failed',
+        timeoutMessage: 'Template generation timed out',
+    });
+    success(`Template generated! ID: ${status.template_id}\nPreview: ${status.result?.preview_url}`);
+}
+async function list(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email template list [--org <id>]');
+    const templates = await sdkEmail.listTemplates(config.api_key, orgId);
+    if (flags.json) {
+        printJson(templates);
+        return;
+    }
+    printTable(templates, {
+        flags,
+        empty: 'No templates yet. Generate one with: myapi email template generate --prompt <p> --name <n>',
+    });
+}
+async function edit(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email template edit <id> --prompt <str> [--org <id>]');
+    if (!id || !flags.prompt)
+        error('Missing required arguments.\nUsage: myapi email template edit <id> --prompt <str> [--org <id>]');
+    const res = await sdkEmail.editTemplate(config.api_key, orgId, id, flags.prompt);
+    success(`Template ${res.template_id} edited\nPreview: ${res.preview_url}`);
+}
+async function sendTest(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email template send-test <template_id> --to <email> [--org <id>]');
+    if (!id || !flags.to)
+        error('Missing required arguments.\nUsage: myapi email template send-test <template_id> --to <email> [--org <id>]');
+    const res = await sdkEmail.sendTestEmail(config.api_key, orgId, id, flags.to);
+    success(`Test sent! Message ID: ${res.message_id}`);
+}
+async function del(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email template delete <id> [--org <id>]');
+    if (!id)
+        error('Missing required arguments.\nUsage: myapi email template delete <id> [--org <id>]');
+    await sdkEmail.deleteTemplate(config.api_key, orgId, id);
+    success(`Deleted template ${id}`);
+}
+const USAGE = {
+    'generate': `myapi email template generate <name> --prompt <str> [--org <id>]
+       myapi email template generate --name <name> --prompt <str> [--org <id>]
+
+Either form works; the positional name is the recommended shape.`,
+    'list': 'myapi email template list [--org <id>] [--json]',
+    'edit': 'myapi email template edit <id> --prompt <str> [--org <id>]',
+    'send-test': 'myapi email template send-test <template_id> --to <email> [--org <id>]',
+    'delete': 'myapi email template delete <id> [--org <id>]',
+};
+export async function run(sub, args, flags) {
+    if (!sub || (flags.help && !sub)) {
+        info(`Usage: myapi email template <subcommand>
+
+Subcommands:
+  generate <name>    Generate AI template (--prompt)
+  list               List templates
+  edit <id>          Edit a template via prompt
+  send-test <id>     Send a test email for a template (--to)
+  delete <id>        Delete a template
+
+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 template --help" for the list.`);
+        return;
+    }
+    switch (sub) {
+        case 'generate': return generate(args[0], flags);
+        case 'list': return list(flags);
+        case 'edit': return edit(args[0], flags);
+        case 'send-test': return sendTest(args[0], flags);
+        case 'delete': return del(args[0], flags);
+        default: error(`Unknown subcommand: ${sub}. Run "myapi email template --help" for the list.`);
+    }
+}

package/dist/commands/email/warmup.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/warmup.js

@@ -0,0 +1,43 @@
+import { email as sdkEmail } from '@myapihq/sdk';
+import { requireConfig } from '../../config.js';
+import { success, error, printJson, info } from '../../output.js';
+export async function run(sub, args, flags) {
+    if (!sub || (flags.help && !sub)) {
+        info('Usage: myapi email warmup <start|pause|resume|stop|stats> --address <email>');
+        return;
+    }
+    if (flags.help) {
+        info(`Usage: myapi email warmup ${sub} --address <email>`);
+        return;
+    }
+    const config = requireConfig();
+    const address = flags.address || args[0];
+    if (!address)
+        error('Missing required argument: --address <email>');
+    switch (sub) {
+        case 'start': {
+            const res = await sdkEmail.startWarmup(config.api_key, address);
+            success(`Warmup started: ${address} (${res.warmup_status})`);
+            return;
+        }
+        case 'pause':
+            await sdkEmail.pauseWarmup(config.api_key, address);
+            success(`Warmup paused: ${address}`);
+            return;
+        case 'resume':
+            await sdkEmail.resumeWarmup(config.api_key, address);
+            success(`Warmup resumed: ${address}`);
+            return;
+        case 'stop':
+            await sdkEmail.stopWarmup(config.api_key, address);
+            success(`Warmup stopped: ${address}`);
+            return;
+        case 'stats': {
+            const res = await sdkEmail.getWarmupStats(config.api_key, address);
+            printJson(res);
+            return;
+        }
+        default:
+            error(`Unknown warmup subcommand: ${sub}. Use start|pause|resume|stop|stats`);
+    }
+}

package/dist/commands/email.js

@@ -1,7 +1,7 @@
 import { email as sdkEmail } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, printJson, info } from '../output.js';
-import { sleep } from '../utils.js';
+import { pollJob } from '../utils.js';
 import { requireOrg } from '../helpers.js';
 export const SCHEMA = {
     org: 'string',
@@ -25,12 +25,25 @@ export const SCHEMA = {
     'per-day': 'number',
 };
 // ─── Mailbox ─────────────────────────────────────────────────────────────────
-async function mailboxCreate(flags) {
+async function mailboxCreate(addressArg, flags) {
     const config = requireConfig();
-    const domain = flags.domain || config.default_domain;
-    const username = flags.username;
-    if (!domain || !username) {
-        error('Missing required arguments.\nUsage: myapi email mailbox create --domain <domain> --username <user> [--display-name <name>]\n(Or set default: myapi config set-domain <domain>)');
+    // 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.
@@ -39,7 +52,7 @@ async function mailboxCreate(flags) {
 async function mailboxList(flags) {
     const config = requireConfig();
     if (!flags.domain && flags.filter !== 'unassigned') {
-        error('Must provide either --domain <domain> or --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,
@@ -59,17 +72,26 @@ async function mailboxActivateSending(flags) {
     success(`Sending activated: ${address} (status: ${res.status})`);
 }
 const MAILBOX_USAGE = {
-    'create': 'myapi email mailbox create --domain <domain> --username <user> [--display-name <name>]',
-    'list': 'myapi email mailbox list (--domain <domain> | --filter unassigned)',
+    '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>',
 };
-async function mailboxRun(sub, flags) {
+async function mailboxRun(sub, args, flags) {
     if (!sub || (flags.help && !sub)) {
         info(`Usage: myapi email mailbox <subcommand>
 
 Subcommands:
-  create             Create a mailbox on a domain
-  list               List mailboxes (--domain or --filter unassigned)
+  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;
     }
@@ -82,7 +104,7 @@ Subcommands:
         return;
     }
     switch (sub) {
-        case 'create': return mailboxCreate(flags);
+        case 'create': return mailboxCreate(args[0], flags);
         case 'list': return mailboxList(flags);
         case 'activate-sending': return mailboxActivateSending(flags);
         default: error(`Unknown subcommand: ${sub}. Run "myapi email mailbox --help" for the list.`);
@@ -243,37 +265,28 @@ async function warmupRun(sub, args, flags) {
     }
 }
 // ─── Templates ───────────────────────────────────────────────────────────────
-async function templateGenerate(flags) {
+async function templateGenerate(nameArg, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi email template generate --prompt <str> --name <str> [--org <id>]');
-    if (!flags.prompt || !flags.name) {
-        error('Missing required arguments.\nUsage: myapi email template generate --prompt <str> --name <str> [--org <id>]');
+    const orgId = requireOrg(flags, config, 'myapi email template generate <name> --prompt <str> [--org <id>]');
+    const name = nameArg || flags.name;
+    if (!name || !flags.prompt) {
+        error('Missing required arguments.\nUsage: myapi email template generate <name> --prompt <str> [--org <id>]\n   or: myapi email template generate --name <name> --prompt <str> [--org <id>]');
     }
     const job = await sdkEmail.generateTemplate(config.api_key, orgId, {
         prompt: flags.prompt,
-        name: flags.name,
+        name,
     });
-    process.stdout.write('Generating template ');
-    const chars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    let i = 0;
-    let elapsed = 0;
-    while (elapsed < 90000) {
-        const status = await sdkEmail.getTemplateJobStatus(config.api_key, orgId, job.job_id);
-        if (status.status === 'completed') {
-            process.stdout.write('\r\x1b[K');
-            success(`Template generated! ID: ${status.template_id}\nPreview: ${status.result?.preview_url}`);
-            return;
-        }
-        if (status.status === 'failed') {
-            process.stdout.write('\r\x1b[K');
-            error('Template generation failed');
-        }
-        process.stdout.write(`\rGenerating template ${chars[i++ % chars.length]}`);
-        await sleep(3000);
-        elapsed += 3000;
-    }
-    process.stdout.write('\r\x1b[K');
-    error('Template generation timed out');
+    const status = await pollJob({
+        label: 'Generating template',
+        timeoutMs: 90_000,
+        intervalMs: 3000,
+        check: () => sdkEmail.getTemplateJobStatus(config.api_key, orgId, job.job_id),
+        isDone: s => s.status === 'completed',
+        isFailed: s => s.status === 'failed',
+        failedMessage: 'Template generation failed',
+        timeoutMessage: 'Template generation timed out',
+    });
+    success(`Template generated! ID: ${status.template_id}\nPreview: ${status.result?.preview_url}`);
 }
 async function templateList(flags) {
     const config = requireConfig();
@@ -313,7 +326,10 @@ async function templateDelete(id, flags) {
     success(`Deleted template ${id}`);
 }
 const TEMPLATE_USAGE = {
-    'generate': 'myapi email template generate --prompt <str> --name <str> [--org <id>]',
+    'generate': `myapi email template generate <name> --prompt <str> [--org <id>]
+       myapi email template generate --name <name> --prompt <str> [--org <id>]
+
+Either form works; the positional name is the recommended shape.`,
     'list': 'myapi email template list [--org <id>] [--json]',
     'edit': 'myapi email template edit <id> --prompt <str> [--org <id>]',
     'send-test': 'myapi email template send-test <template_id> --to <email> [--org <id>]',
@@ -324,7 +340,7 @@ async function templateRun(sub, args, flags) {
         info(`Usage: myapi email template <subcommand>
 
 Subcommands:
-  generate           Generate AI template (--prompt --name)
+  generate <name>    Generate AI template (--prompt)
   list               List templates
   edit <id>          Edit a template via prompt
   send-test <id>     Send a test email for a template (--to)
@@ -342,7 +358,7 @@ All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         return;
     }
     switch (sub) {
-        case 'generate': return templateGenerate(flags);
+        case 'generate': return templateGenerate(args[0], flags);
         case 'list': return templateList(flags);
         case 'edit': return templateEdit(args[0], flags);
         case 'send-test': return templateSendTest(args[0], flags);
@@ -351,15 +367,16 @@ All commands accept --org <id> (or set default: myapi config set-org <id>).`);
     }
 }
 // ─── Campaigns ───────────────────────────────────────────────────────────────
-async function campaignCreate(flags) {
+async function campaignCreate(nameArg, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi email campaign create --name <str> --template-id <id> --from <email> [--per-day <n>] [--org <id>]');
-    if (!flags.name || !flags['template-id'] || !flags.from) {
-        error('Missing required arguments.\nUsage: myapi email campaign create --name <str> --template-id <id> --from <email> [--per-day <n>] [--org <id>]');
+    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: flags.name,
+        name,
         template_id: flags['template-id'],
         from_address: flags.from,
         per_day_limit: perDayLimit,
@@ -446,7 +463,10 @@ async function campaignStats(id, flags) {
     printJson(stats);
 }
 const CAMPAIGN_USAGE = {
-    'create': 'myapi email campaign create --name <str> --template-id <id> --from <email> [--per-day <n>] [--org <id>]',
+    '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>]',
@@ -461,7 +481,7 @@ async function campaignRun(sub, args, flags) {
         info(`Usage: myapi email campaign <subcommand>
 
 Subcommands:
-  create              Create a campaign (--name --template-id --from)
+  create <name>       Create a campaign (--template-id --from)
   list                List campaigns
   get <id>            Get a single campaign
   update <id>         Patch name / per-day-limit
@@ -483,7 +503,7 @@ All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         return;
     }
     switch (sub) {
-        case 'create': return campaignCreate(flags);
+        case 'create': return campaignCreate(args[0], flags);
         case 'list': return campaignList(flags);
         case 'get': return campaignGet(args[0], flags);
         case 'update': return campaignUpdate(args[0], flags);
@@ -556,7 +576,7 @@ Run "myapi email <namespace> --help" for namespace-specific commands.`);
 }
 async function dispatchNamespace(ns, sub, restArgs, flags) {
     switch (ns) {
-        case 'mailbox': return mailboxRun(sub, flags);
+        case 'mailbox': return mailboxRun(sub, restArgs, flags);
         case 'message': return messageRun(sub, restArgs, flags);
         case 'warmup': return warmupRun(sub, restArgs, flags);
         case 'template': return templateRun(sub, restArgs, flags);

package/dist/commands/funnel.d.ts

@@ -6,5 +6,5 @@ export declare function create(flags: Flags): Promise<void>;
 export declare function get(id: string, flags: Flags): Promise<void>;
 export declare function del(id: string, flags: Flags): Promise<void>;
 export declare function push(slug: string, flags: Flags): Promise<void>;
-export declare function verify(id: string, flags: Flags): Promise<void>;
+export declare function verify(slug: string, flags: Flags): Promise<void>;
 export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/funnel.js

@@ -43,6 +43,10 @@ export async function get(id, flags) {
     if (!id)
         error('Missing required arguments.\nUsage: myapi funnel get <id> [--org <id>]');
     const raw = await sdkFunnel.getFunnel(config.api_key, orgId, id);
+    // Backend response shape varies between two layouts:
+    //   1) { funnel: {...}, subdomain_url, domain_url }    (newer, wrapped)
+    //   2) { id, ..., subdomain_url, domain_url }          (older, flat)
+    // Coalesce both so this works regardless of which shape we get back.
     const funnel = raw.funnel ?? raw;
     const subdomain_url = raw.subdomain_url ?? funnel.subdomain_url;
     const domain_url = raw.domain_url ?? funnel.domain_url;
@@ -114,15 +118,24 @@ export async function push(slug, flags) {
         }
     }
 }
-export async function verify(id, flags) {
+// Verify uses the same shape as push: slug positional (default '/'), funnel
+// resolved from --funnel / default / the org's only funnel.
+export async function verify(slug, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi funnel verify <id> [--slug <slug>] [--org <id>]');
-    if (!id)
-        error('Missing required arguments.\nUsage: myapi funnel verify <id> [--slug <slug>] [--org <id>]');
-    const opts = {};
-    if (flags.slug)
-        opts.slug = flags.slug;
-    const v = await sdkFunnel.verifyFunnel(config.api_key, orgId, id, opts);
+    const orgId = requireOrg(flags, config, 'myapi funnel verify [slug] [--funnel <id>] [--org <id>]');
+    const rawSlug = slug || flags.slug || '/';
+    const finalSlug = rawSlug.startsWith('/') ? rawSlug : `/${rawSlug}`;
+    let funnelId = flags.funnel || config.default_funnel;
+    if (!funnelId) {
+        const existing = await sdkFunnel.listFunnels(config.api_key, orgId);
+        if (existing.length === 0)
+            error('No funnel found for this org. Create one with: myapi funnel create');
+        if (existing.length > 1) {
+            error(`Multiple funnels exist for this org and no default is set.\nPick one with --funnel <id>, or set a default:\n  myapi config set-funnel <id>\n\nFunnels:\n${existing.map(f => `  ${f.id}`).join('\n')}`);
+        }
+        funnelId = existing[0].id;
+    }
+    const v = await sdkFunnel.verifyFunnel(config.api_key, orgId, funnelId, { slug: finalSlug });
     printJson(v);
 }
 // ── Dispatcher ───────────────────────────────────────────────────────────────
@@ -141,7 +154,16 @@ Examples:
   cat about.html | myapi funnel push /about
   myapi funnel push < index.html
   cat p.html | myapi funnel push /pricing --funnel <uuid>`,
-    'verify': 'myapi funnel verify <id> [--slug <slug>] [--org <id>]',
+    'verify': `myapi funnel verify [slug] [--funnel <id>] [--org <id>]
+
+Verifies the page at <slug> on a funnel. Slug defaults to '/'. Funnel is
+resolved from --funnel, the default funnel, or (only if the org has exactly
+one) auto-picked — same shape as "funnel push".
+
+Examples:
+  myapi funnel verify              # verifies '/' on the default funnel
+  myapi funnel verify /pricing
+  myapi funnel verify / --funnel <uuid>`,
 };
 export async function run(subcommand, args, flags) {
     if (!subcommand || (flags.help && !subcommand)) {

package/dist/commands/keys.d.ts

@@ -5,4 +5,4 @@ export declare function run(subcommand: string | undefined, args: string[], flag
 export declare function runApiKeys(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;
 export declare function createNew(flags: Flags): Promise<void>;
 export declare function list(flags: Flags): Promise<void>;
-export declare function revoke(id: string, flags: Flags): Promise<void>;
+export declare function revoke(id: string, _flags: Flags): Promise<void>;

package/dist/commands/keys.js

@@ -2,7 +2,8 @@ import { hq } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson } from '../output.js';
 import { formatDate } from '../utils.js';
-import * as readline from 'readline';
+import { ask } from '../prompt.js';
+import { requireArg } from '../helpers.js';
 export const SCHEMA = {
     name: 'string',
 };
@@ -62,11 +63,8 @@ export async function runApiKeys(subcommand, args, flags) {
 export async function createNew(flags) {
     const config = requireConfig();
     let name = flags.name || '';
-    if (!name) {
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        name = await new Promise(resolve => rl.question('Enter a name for the new key: ', resolve));
-        rl.close();
-    }
+    if (!name)
+        name = await ask('Enter a name for the new key: ');
     if (!name.trim())
         error('Key name cannot be empty. Use --name <name>');
     const keyInfo = await hq.createApiKey(config.api_key, name.trim());
@@ -91,9 +89,8 @@ export async function list(flags) {
         empty: 'No API keys yet. Create one with: myapi keys create',
     });
 }
-export async function revoke(id, flags) {
-    if (!id)
-        error('Missing key ID. Usage: myapi keys revoke <id>');
+export async function revoke(id, _flags) {
+    requireArg(id, 'id', 'myapi keys revoke <id>');
     const config = requireConfig();
     await hq.revokeApiKey(config.api_key, id);
     success(`Key ${id} revoked successfully.`);