@mailmodo/cli 0.0.2 → 0.0.3-beta.pr5.8

package/dist/commands/domain/index.js

@@ -0,0 +1,163 @@
+import { Flags } from '@oclif/core';
+import { input } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { BaseCommand } from '../../lib/base-command.js';
+import { API_ENDPOINTS, DNS_GUIDE_URL } from '../../lib/constants.js';
+import { saveYaml } from '../../lib/yaml-config.js';
+export default class Domain extends BaseCommand {
+    static description = 'Set up and verify your sending domain';
+    static examples = [
+        '<%= config.bin %> domain',
+        '<%= config.bin %> domain --verify',
+        '<%= config.bin %> domain --status',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        status: Flags.boolean({ default: false, description: 'Show domain health status' }),
+        verify: Flags.boolean({ default: false, description: 'Verify DNS records' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Domain);
+        await this.ensureAuth();
+        if (flags.verify) {
+            await this.verifyDomain(flags.json);
+            return;
+        }
+        if (flags.status) {
+            await this.showDomainStatus(flags.json);
+            return;
+        }
+        await this.setupDomain(flags);
+    }
+    /**
+     * Interactive domain setup: collects domain, sender email, and business address,
+     * then calls the API to retrieve the required DNS records.
+     */
+    async setupDomain(flags) {
+        const yamlConfig = await this.ensureYaml();
+        this.log(`\n  ${'─'.repeat(53)}`);
+        this.log(`  ${chalk.bold('DOMAIN SETUP')}`);
+        this.log(`  ${'─'.repeat(53)}\n`);
+        let domain;
+        let senderEmail;
+        let address;
+        if (flags.yes) {
+            domain = yamlConfig.project?.domain || '';
+            senderEmail = yamlConfig.project?.fromEmail || '';
+            address = yamlConfig.project?.address || '';
+            if (!domain) {
+                this.error('Domain is required. Set it in mailmodo.yaml or use interactive mode.');
+            }
+        }
+        else {
+            domain = await input({
+                default: yamlConfig.project?.domain,
+                message: 'What domain will you send from?',
+                validate: (v) => (v?.trim() ? true : 'Domain is required'),
+            });
+            senderEmail = await input({
+                default: yamlConfig.project?.fromEmail,
+                message: 'Sender email address:',
+                validate: (v) => (v?.includes('@') ? true : 'Please enter a valid email'),
+            });
+            address = await input({
+                default: yamlConfig.project?.address,
+                message: 'Business address (required by law):',
+                validate: (v) => (v?.trim() ? true : 'Address is required'),
+            });
+        }
+        const response = await this.apiClient.post(API_ENDPOINTS.DOMAIN, {
+            address,
+            domain,
+            fromEmail: senderEmail,
+        });
+        if (!response.ok) {
+            this.handleApiError(response);
+        }
+        yamlConfig.project.domain = domain;
+        yamlConfig.project.fromEmail = senderEmail;
+        yamlConfig.project.address = address;
+        await saveYaml(yamlConfig);
+        const records = response.data?.dnsRecords || [];
+        if (flags.json) {
+            this.log(JSON.stringify({ dnsRecords: records, domain }, null, 2));
+            return;
+        }
+        this.log(`\n  Add these ${records.length} DNS records to your domain provider:\n`);
+        for (const [i, record] of records.entries()) {
+            this.log(`  ${chalk.bold(`RECORD ${i + 1} — ${this.recordLabel(i)}`)}`);
+            this.log(`  Type:   ${record.type}`);
+            this.log(`  Host:   ${record.host}`);
+            this.log(`  Value:  ${record.value}\n`);
+        }
+        this.log(`  DNS changes take 5–30 minutes to propagate.`);
+        this.log(`  Full guide: ${chalk.cyan(DNS_GUIDE_URL)}\n`);
+        if (!flags.yes) {
+            const action = await input({
+                default: '',
+                message: "Press Enter once you've added the records, or 'skip'.",
+            });
+            if (action.toLowerCase() !== 'skip') {
+                await this.verifyDomain(false);
+            }
+        }
+    }
+    /**
+     * Calls the domain verification API and displays pass/fail for each DNS record.
+     */
+    async verifyDomain(jsonOutput) {
+        if (!jsonOutput) {
+            this.log(`\n  Checking DNS...`);
+        }
+        const response = await this.apiClient.get(API_ENDPOINTS.DOMAIN_VERIFY);
+        if (!response.ok) {
+            this.handleApiError(response);
+        }
+        const { dkim, dmarc, spf } = response.data;
+        if (jsonOutput) {
+            this.log(JSON.stringify({ dkim, dmarc, spf }, null, 2));
+            return;
+        }
+        this.log(`  SPF    ${spf === 'pass' ? chalk.green('✓') : chalk.red('✗  Not found')}`);
+        this.log(`  DKIM   ${dkim === 'pass' ? chalk.green('✓') : chalk.red('✗  Not found')}`);
+        this.log(`  DMARC  ${dmarc === 'pass' ? chalk.green('✓') : chalk.red('✗  Not found')}`);
+        const allPassed = spf === 'pass' && dkim === 'pass' && dmarc === 'pass';
+        if (allPassed) {
+            this.log(`\n  ${chalk.green('✓')} Domain verified.\n`);
+        }
+        else {
+            this.log(`\n  ${chalk.yellow('Some records failed.')}`);
+            if (dkim !== 'pass') {
+                this.log(`\n  DKIM common mistakes:`);
+                this.log(`  - Using TXT instead of CNAME record type`);
+                this.log(`  - Including the full domain in the Host field`);
+                this.log(`  - Cloudflare: proxy must be OFF (grey cloud, not orange)`);
+            }
+            this.log(`\n  Fix the records and run ${chalk.cyan('mailmodo domain --verify')} again.`);
+            this.log(`  Help: ${chalk.cyan(DNS_GUIDE_URL)}\n`);
+        }
+    }
+    /**
+     * Displays domain health metrics including verification status,
+     * bounce rate, and spam complaint rate.
+     */
+    async showDomainStatus(jsonOutput) {
+        const response = await this.apiClient.get(API_ENDPOINTS.DOMAIN_STATUS);
+        if (!response.ok) {
+            this.handleApiError(response);
+        }
+        const { data } = response;
+        if (jsonOutput) {
+            this.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        this.log(`\n  Domain: ${chalk.bold(data.domain || 'not configured')}`);
+        this.log(`  Status: ${data.verified ? chalk.green('✓ verified') : chalk.red('✗ not verified')}`);
+        this.log(`  Bounce rate: ${data.bounceRate ?? 'N/A'}%`);
+        this.log(`  Spam rate:   ${data.spamRate ?? 'N/A'}%\n`);
+    }
+    recordLabel(index) {
+        const labels = ['SPF', 'DKIM', 'DMARC'];
+        return labels[index] || `Record ${index + 1}`;
+    }
+}

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

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class Edit extends BaseCommand {
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        change: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/edit/index.js

@@ -0,0 +1,96 @@
+import { Args, Flags } from '@oclif/core';
+import { confirm, input } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { BaseCommand } from '../../lib/base-command.js';
+import { API_ENDPOINTS } from '../../lib/constants.js';
+import { loadTemplate, saveTemplate, saveYaml } from '../../lib/yaml-config.js';
+export default class Edit extends BaseCommand {
+    static args = {
+        id: Args.string({ description: 'Email ID to edit', required: true }),
+    };
+    static description = 'Edit an email using AI-assisted natural language changes';
+    static examples = [
+        '<%= config.bin %> edit welcome',
+        '<%= config.bin %> edit welcome --change "make subject more urgent" --yes',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        change: Flags.string({ description: 'Natural language description of the change' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Edit);
+        await this.ensureAuth();
+        const yamlConfig = await this.ensureYaml();
+        const emailIndex = yamlConfig.emails.findIndex((e) => e.id === args.id);
+        if (emailIndex === -1) {
+            this.error(`Email '${args.id}' not found in mailmodo.yaml.`);
+        }
+        const email = yamlConfig.emails[emailIndex];
+        const templateHtml = await loadTemplate(`${email.id}.html`);
+        if (!flags.json) {
+            this.log(`\n  Current subject: '${chalk.cyan(email.subject)}'`);
+        }
+        let changeDescription = flags.change;
+        if (!changeDescription) {
+            changeDescription = await input({
+                message: 'What do you want to change?',
+                validate: (value) => (value?.trim() ? true : 'Please describe the change'),
+            });
+        }
+        const response = await this.apiClient.post(API_ENDPOINTS.EDIT, {
+            changeRequest: changeDescription,
+            currentEmail: {
+                condition: email.condition,
+                goal: email.goal,
+                html: templateHtml,
+                id: email.id,
+                previewText: email.previewText,
+                subject: email.subject,
+                trigger: email.trigger,
+            },
+        });
+        if (!response.ok) {
+            this.handleApiError(response);
+        }
+        const updated = response.data;
+        const oldSubject = email.subject;
+        const newSubject = updated.subject || email.subject;
+        if (!flags.json && oldSubject !== newSubject) {
+            this.log(`\n  Suggested subject:`);
+            this.log(`  ${chalk.red(`- ${oldSubject}`)}`);
+            this.log(`  ${chalk.green(`+ ${newSubject}`)}`);
+        }
+        if (!flags.yes) {
+            const accepted = await confirm({ default: true, message: 'Accept changes?' });
+            if (!accepted) {
+                this.log('\n  Changes discarded.\n');
+                return;
+            }
+        }
+        if (updated.subject)
+            email.subject = updated.subject;
+        if (updated.previewText)
+            email.previewText = updated.previewText;
+        const updatedYaml = {
+            ...yamlConfig,
+            emails: [...yamlConfig.emails],
+        };
+        updatedYaml.emails[emailIndex] = email;
+        await saveYaml(updatedYaml);
+        if (updated.html) {
+            await saveTemplate(`${email.id}.html`, updated.html);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({
+                diff: {
+                    subject: oldSubject === newSubject ? undefined : { new: newSubject, old: oldSubject },
+                },
+                email,
+                status: 'updated',
+            }, null, 2));
+            return;
+        }
+        this.log(`\n  Updated ${chalk.green('mailmodo.yaml')}`);
+        this.log(`  Preview the change: ${chalk.cyan(`mailmodo preview ${email.id}`)}\n`);
+    }
+}

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

@@ -0,0 +1,10 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class Emails extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/emails/index.js

@@ -0,0 +1,62 @@
+import { input } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { BaseCommand } from '../../lib/base-command.js';
+export default class Emails extends BaseCommand {
+    static description = 'List and view configured email sequences';
+    static examples = [
+        '<%= config.bin %> emails',
+        '<%= config.bin %> emails --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async run() {
+        const { flags } = await this.parse(Emails);
+        const yamlConfig = await this.ensureYaml();
+        const { emails } = yamlConfig;
+        if (flags.json) {
+            this.log(JSON.stringify({ emails, total: emails.length }, null, 2));
+            return;
+        }
+        this.log(`\n  ${chalk.bold(String(emails.length))} emails configured in mailmodo.yaml:\n`);
+        const maxIdLen = Math.max(...emails.map((e) => e.id.length), 2);
+        const maxTriggerLen = Math.max(...emails.map((e) => e.trigger.length), 7);
+        for (const email of emails) {
+            const id = email.id.padEnd(maxIdLen + 2);
+            const trigger = `trigger: ${email.trigger}`.padEnd(maxTriggerLen + 12);
+            const delay = `delay: ${email.delay}`;
+            const condition = email.condition ? chalk.dim(` [if ${email.condition}]`) : '';
+            this.log(`  ${chalk.cyan(id)} ${trigger} ${delay}${condition}`);
+        }
+        this.log('');
+        if (!flags.yes) {
+            const emailId = await input({
+                default: 'n',
+                message: "View an email? (id or 'n'):",
+            });
+            if (emailId !== 'n') {
+                const email = emails.find((e) => e.id === emailId);
+                if (!email) {
+                    this.log(`\n  Email '${emailId}' not found.\n`);
+                    return;
+                }
+                this.log('');
+                this.log(`  ${chalk.bold('ID:')}       ${email.id}`);
+                this.log(`  ${chalk.bold('Trigger:')}  ${email.trigger}`);
+                this.log(`  ${chalk.bold('Delay:')}    ${email.delay === 0 || email.delay === '0' ? '0 (immediate)' : email.delay}`);
+                this.log(`  ${chalk.bold('Subject:')}  ${email.subject}`);
+                this.log(`  ${chalk.bold('Template:')} ${email.template}`);
+                if (email.style) {
+                    this.log(`  ${chalk.bold('Style:')}    ${email.style}`);
+                }
+                if (email.condition) {
+                    this.log(`  ${chalk.bold('Condition:')} ${email.condition}`);
+                }
+                if (email.goal) {
+                    this.log(`  ${chalk.bold('Goal:')}     ${email.goal}`);
+                }
+                this.log('');
+            }
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class Init extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        url: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/init/index.js

@@ -0,0 +1,124 @@
+import { Flags } from '@oclif/core';
+import { confirm, input } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { BaseCommand } from '../../lib/base-command.js';
+import { API_ENDPOINTS, DEFAULT_BRAND_COLOR } from '../../lib/constants.js';
+import { saveTemplate, saveYaml } from '../../lib/yaml-config.js';
+function isValidUrl(value) {
+    try {
+        return Boolean(new URL(value));
+    }
+    catch {
+        return false;
+    }
+}
+export default class Init extends BaseCommand {
+    static description = 'Analyze your product and generate email sequences';
+    static examples = [
+        '<%= config.bin %> init',
+        '<%= config.bin %> init --url https://myapp.com --yes',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        url: Flags.string({ description: 'Product URL to analyze' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Init);
+        await this.ensureAuth();
+        let productUrl = flags.url;
+        if (!productUrl) {
+            productUrl = await input({
+                message: 'What is your product URL?',
+                validate(value) {
+                    if (!value?.trim())
+                        return 'URL is required';
+                    if (isValidUrl(value))
+                        return true;
+                    return 'Please enter a valid URL (e.g., https://myapp.com)';
+                },
+            });
+        }
+        this.log(`\n  Analyzing your product...`);
+        this.log(`  Scraping: homepage, pricing, features\n`);
+        const analysisResponse = await this.apiClient.post(API_ENDPOINTS.ANALYZE, { url: productUrl });
+        if (!analysisResponse.ok) {
+            this.handleApiError(analysisResponse);
+        }
+        const analysis = analysisResponse.data;
+        if (!flags.json) {
+            this.log(`  Detected:`);
+            this.log(`  - Type:    ${analysis.businessType} — ${analysis.description}`);
+            this.log(`  - Model:   ${analysis.pricingModel}`);
+            this.log(`  - Users:   ${analysis.targetUser}`);
+            if (analysis.events?.length) {
+                this.log(`  - Events:  ${analysis.events.join(', ')}`);
+            }
+            this.log('');
+        }
+        if (!flags.yes) {
+            const ok = await confirm({ default: true, message: 'Does this look right?' });
+            if (!ok) {
+                this.log(`\n  Run ${chalk.cyan('mailmodo init')} again to re-analyze.\n`);
+                return;
+            }
+        }
+        this.log('\n  Generating emails...\n');
+        const generateResponse = await this.apiClient.post(API_ENDPOINTS.GENERATE, { analysis, productUrl });
+        if (!generateResponse.ok) {
+            this.handleApiError(generateResponse);
+        }
+        const generatedEmails = generateResponse.data?.emails || [];
+        const emailConfigs = analysis.recommendedEmails.map((rec, index) => {
+            const generated = generatedEmails[index];
+            return {
+                delay: rec.delay || '0',
+                id: rec.id,
+                trigger: rec.trigger,
+                ...(rec.condition ? { condition: rec.condition } : {}),
+                subject: generated?.subject || `Email for ${rec.id}`,
+                template: `mailmodo/${rec.id}.html`,
+                ...(generated?.previewText ? { previewText: generated.previewText } : {}),
+                goal: rec.goal,
+            };
+        });
+        const yamlConfig = {
+            emails: emailConfigs,
+            project: {
+                brandColor: analysis.brand?.color || DEFAULT_BRAND_COLOR,
+                emailStyle: 'branded',
+                fromEmail: '',
+                fromName: `Team ${analysis.productName}`,
+                logoUrl: analysis.brand?.logoUrl || '',
+                name: analysis.productName,
+                replyTo: '',
+                type: analysis.pricingModel,
+                url: productUrl,
+                webhookUrl: '',
+            },
+        };
+        await saveYaml(yamlConfig);
+        const templateSaves = analysis.recommendedEmails.flatMap((rec, index) => {
+            const generated = generatedEmails[index];
+            const saves = [];
+            if (generated?.html) {
+                saves.push(saveTemplate(`${rec.id}.html`, generated.html));
+            }
+            if (generated?.plainHtml) {
+                saves.push(saveTemplate(`${rec.id}_plain.html`, generated.plainHtml));
+            }
+            return saves;
+        });
+        await Promise.all(templateSaves);
+        if (flags.json) {
+            this.log(JSON.stringify({
+                brandDetected: analysis.brand,
+                emails: emailConfigs,
+                emailsCreated: emailConfigs.length,
+                style: yamlConfig.project.emailStyle,
+            }, null, 2));
+            return;
+        }
+        this.log(`  Created ${chalk.green('mailmodo.yaml')} + ${chalk.green(String(emailConfigs.length))} email templates in ${chalk.green('/mailmodo')}\n`);
+        this.log(`  Run ${chalk.cyan("'mailmodo emails'")} to review.\n`);
+    }
+}

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

@@ -0,0 +1,10 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class Login extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/login/index.js

@@ -0,0 +1,65 @@
+import { input } from '@inquirer/prompts';
+import chalk from 'chalk';
+import open from 'open';
+import { BaseCommand } from '../../lib/base-command.js';
+import { ApiClient } from '../../lib/api-client.js';
+import { saveConfig } from '../../lib/config.js';
+import { API_ENDPOINTS, SIGNUP_URL } from '../../lib/constants.js';
+export default class Login extends BaseCommand {
+    static description = 'Authenticate with Mailmodo using your API key';
+    static examples = [
+        '<%= config.bin %> login',
+        'MAILMODO_API_KEY=mm_live_xxx <%= config.bin %> login',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async run() {
+        const { flags } = await this.parse(Login);
+        let apiKey = process.env.MAILMODO_API_KEY;
+        if (apiKey) {
+            this.log('Detected MAILMODO_API_KEY from environment.');
+        }
+        else {
+            this.log(`\n  Get your free API key at: ${chalk.cyan(SIGNUP_URL)}\n`);
+            try {
+                await open(SIGNUP_URL);
+                this.log('  Opening in browser...\n');
+            }
+            catch {
+                this.log(`  ${chalk.dim('Could not open browser. Visit the URL above manually.')}\n`);
+            }
+            apiKey = await input({
+                message: 'Paste your API key:',
+                validate(value) {
+                    if (!value?.trim())
+                        return 'API key is required';
+                    if (!value.startsWith('mm_'))
+                        return 'Invalid API key format. Keys start with mm_';
+                    return true;
+                },
+            });
+        }
+        const trimmedKey = apiKey.trim();
+        const client = new ApiClient(trimmedKey);
+        const response = await client.get(API_ENDPOINTS.AUTH_VALIDATE);
+        if (!response.ok) {
+            this.handleApiError(response);
+        }
+        const { accountName, email, freeRemaining } = response.data;
+        await saveConfig({
+            accountName,
+            apiKey: trimmedKey,
+            email,
+            freeRemaining,
+        });
+        if (flags.json) {
+            this.log(JSON.stringify({ accountName, email, freeRemaining, status: 'authenticated' }, null, 2));
+            return;
+        }
+        this.log(`\n  Logged in as ${chalk.green(email)}`);
+        this.log(`  Free tier: ${chalk.cyan(String(freeRemaining ?? 1000))} emails remaining`);
+        this.log('  No credit card required.\n');
+        this.log(`  Next: Run ${chalk.cyan("'mailmodo init'")} to generate your email sequences.\n`);
+    }
+}

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

@@ -0,0 +1,20 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class Logs extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        email: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        failed: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /**
+     * Returns the appropriate chalk color function based on the delivery status.
+     * Green for sent/opened/clicked, red for bounced/failed, yellow for skipped.
+     *
+     * @param {string} status - The delivery event status string.
+     * @returns {Function} A chalk color function to wrap the status display text.
+     */
+    private statusColor;
+}

package/dist/commands/logs/index.js

@@ -0,0 +1,82 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { BaseCommand } from '../../lib/base-command.js';
+import { API_ENDPOINTS } from '../../lib/constants.js';
+export default class Logs extends BaseCommand {
+    static description = 'View email send logs and delivery events';
+    static examples = [
+        '<%= config.bin %> logs',
+        '<%= config.bin %> logs --email sarah@example.com',
+        '<%= config.bin %> logs --failed',
+        '<%= config.bin %> logs --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        email: Flags.string({ description: 'Filter logs by contact email' }),
+        failed: Flags.boolean({ default: false, description: 'Show only failed/bounced events' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Logs);
+        await this.ensureAuth();
+        const params = {};
+        if (flags.email)
+            params.email = flags.email;
+        if (flags.failed)
+            params.failed = 'true';
+        const response = await this.apiClient.get(API_ENDPOINTS.LOGS, params);
+        if (!response.ok) {
+            this.handleApiError(response);
+        }
+        const { entries } = response.data;
+        if (flags.json) {
+            this.log(JSON.stringify(response.data, null, 2));
+            return;
+        }
+        this.log(`\n  ${'Time'.padEnd(18)}${'Email'.padEnd(24)}${'Status'.padEnd(10)}Contact`);
+        this.log(`  ${'─'.repeat(68)}`);
+        if (entries?.length) {
+            for (const entry of entries) {
+                const time = (entry.timestamp || '').padEnd(18);
+                const emailId = (entry.emailId || '').padEnd(24);
+                const statusColor = this.statusColor(entry.status);
+                const status = statusColor((entry.status || '').padEnd(10));
+                const contact = entry.contact || '';
+                this.log(`  ${time}${emailId}${status}${contact}`);
+                if (entry.reason) {
+                    this.log(`  ${' '.repeat(52)}${chalk.dim(`(reason: ${entry.reason})`)}`);
+                }
+            }
+        }
+        else {
+            this.log(`  ${chalk.dim('No log entries found.')}`);
+        }
+        this.log('');
+    }
+    /**
+     * Returns the appropriate chalk color function based on the delivery status.
+     * Green for sent/opened/clicked, red for bounced/failed, yellow for skipped.
+     *
+     * @param {string} status - The delivery event status string.
+     * @returns {Function} A chalk color function to wrap the status display text.
+     */
+    statusColor(status) {
+        switch (status) {
+            case 'bounced':
+            case 'complained':
+            case 'failed': {
+                return chalk.red;
+            }
+            case 'clicked':
+            case 'opened':
+            case 'sent': {
+                return chalk.green;
+            }
+            case 'skipped': {
+                return chalk.yellow;
+            }
+            default: {
+                return chalk.white;
+            }
+        }
+    }
+}