@myapihq/cli 1.0.84 → 1.1.0-wip.1

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.d.ts

@@ -1,12 +1,4 @@
-export declare function createMailbox(flags: Record<string, string | boolean>): Promise<void>;
-export declare function listMailboxes(flags: Record<string, string | boolean>): Promise<void>;
-export declare function sent(flags: Record<string, string | boolean>): Promise<void>;
-export declare function send(flags: Record<string, string | boolean>): Promise<void>;
-export declare function inbox(address: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function outbox(address: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function listTemplates(flags: Record<string, string | boolean>): Promise<void>;
-export declare function deleteTemplate(id: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function generateTemplate(flags: Record<string, string | boolean>): Promise<void>;
-export declare function listCampaigns(flags: Record<string, string | boolean>): Promise<void>;
-export declare function campaignStats(id: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>): Promise<void>;
+import type { FlagSchema } from '../flags.js';
+import { type Flags } from '../helpers.js';
+export declare const SCHEMA: FlagSchema;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;