@mailmodo/cli 0.0.55 → 0.0.56-beta.pr58.100

package/dist/lib/commands/domain/setup.js

@@ -0,0 +1,53 @@
+import { input } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { API_ENDPOINTS } from '../../constants.js';
+import { ERRORS, PROMPTS, SEPARATOR } from '../../messages.js';
+import { verifyDomain } from './verify.js';
+async function promptAndVerify(ctx, domain) {
+    const action = await input({
+        default: '',
+        message: PROMPTS.ENTER_AFTER_RECORDS,
+    });
+    if (action.toLowerCase() !== 'skip') {
+        await verifyDomain(ctx, { domain, json: false });
+    }
+}
+export async function setupDomain(ctx, yamlConfig, flags) {
+    ctx.log(`\n  ${SEPARATOR}`);
+    ctx.log(`  ${chalk.bold('DOMAIN SETUP')}`);
+    ctx.log(`  ${SEPARATOR}\n`);
+    const inputs = await ctx.collectDomainInputs(yamlConfig, flags.yes);
+    const { dnsRecords, dnsGuideUrl } = await ctx.registerDomainAndSave(yamlConfig, inputs, flags.json);
+    if (flags.json) {
+        ctx.log(JSON.stringify({ dnsRecords, domain: inputs.domain }, null, 2));
+        return;
+    }
+    ctx.showDnsRecords(dnsRecords, dnsGuideUrl, flags.json);
+    if (!flags.yes) {
+        await promptAndVerify(ctx, inputs.domain);
+    }
+}
+export async function showDomainStatus(ctx, opts) {
+    const response = await ctx.spinner('  Loading domain status...', opts.json, () => ctx.get(API_ENDPOINTS.DOMAIN_STATUS, {
+        domain: opts.domain,
+    }));
+    if (!response.ok) {
+        ctx.onApiError(response);
+    }
+    const { data } = response;
+    if (opts.json) {
+        ctx.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    ctx.log(`\n  Domain: ${chalk.bold(data.domain || 'not configured')}`);
+    ctx.log(`  Status: ${data.verified ? chalk.green('✓ verified') : chalk.red('✗ not verified')}`);
+    ctx.log(`  Bounce rate: ${data.bounceRate ?? 'N/A'}%`);
+    ctx.log(`  Spam rate:   ${data.spamRate ?? 'N/A'}%\n`);
+}
+export function getDomainOrError(ctx, yamlConfig) {
+    const domain = yamlConfig.project?.domain;
+    if (!domain) {
+        ctx.error(ERRORS.DOMAIN_NOT_CONFIGURED);
+    }
+    return domain;
+}

package/dist/lib/commands/domain/types.d.ts

@@ -0,0 +1,56 @@
+import type { ApiResponse } from '../../api-client.js';
+import type { MailmodoYaml } from '../../yaml-config.js';
+export interface DomainVerifyResponse {
+    dkim: boolean;
+    dmarc: boolean;
+    dnsGuideUrl?: string;
+    returnPath: boolean;
+    domainStatus: string;
+}
+export interface DomainStatusResponse {
+    bounceRate: number;
+    domain: string;
+    spamRate: number;
+    status: string;
+    verified: boolean;
+}
+export type DomainFlags = {
+    json: boolean;
+    yes: boolean;
+};
+export type DomainCtx = {
+    collectDomainInputs(yaml: MailmodoYaml, skip: boolean): Promise<{
+        address: string;
+        domain: string;
+        fromEmail: string;
+        fromName: string;
+        replyTo: string;
+    }>;
+    error(msg: string): never;
+    get<T>(path: string, params?: Record<string, string>): Promise<ApiResponse<T>>;
+    log(msg?: string): void;
+    onApiError(resp: {
+        error?: string;
+        status: number;
+    }): never;
+    registerDomainAndSave(yaml: MailmodoYaml, inputs: {
+        address: string;
+        domain: string;
+        fromEmail: string;
+        fromName?: string;
+        replyTo?: string;
+    }, json: boolean): Promise<{
+        dnsGuideUrl?: string;
+        dnsRecords: Array<{
+            host: string;
+            type: string;
+            value: string;
+        }>;
+    }>;
+    showDnsRecords(records: Array<{
+        host: string;
+        type: string;
+        value: string;
+    }>, guideUrl: string | undefined, json: boolean): void;
+    spinner<T>(text: string, json: boolean, work: () => Promise<T>): Promise<T>;
+};

package/dist/lib/commands/domain/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/commands/domain/verify.d.ts

@@ -0,0 +1,5 @@
+import type { DomainCtx } from './types.js';
+export declare function verifyDomain(ctx: DomainCtx, opts: {
+    domain: string;
+    json: boolean;
+}): Promise<void>;

package/dist/lib/commands/domain/verify.js

@@ -0,0 +1,50 @@
+import chalk from 'chalk';
+import { API_ENDPOINTS } from '../../constants.js';
+import { INFO } from '../../messages.js';
+function logDkimMistakes(ctx) {
+    ctx.log(`\n  DKIM common mistakes:`);
+    ctx.log(`  - Using CNAME instead of TXT record type`);
+    ctx.log(`  - Including the full domain in the Host field`);
+    ctx.log(`  - Cloudflare: proxy must be OFF (grey cloud, not orange)`);
+}
+function logReturnPathMistakes(ctx) {
+    ctx.log(`\n  Return Path common mistakes:`);
+    ctx.log(`  - Missing or incorrect CNAME for mm-bounce subdomain`);
+    ctx.log(`  - Cloudflare: proxy must be OFF (grey cloud, not orange)`);
+}
+function logVerifyFailure(ctx, dkim, returnPath, dnsGuideUrl) {
+    ctx.log(`\n  ${INFO.DNS_RECORDS_FAILED}`);
+    if (!dkim) {
+        logDkimMistakes(ctx);
+    }
+    if (!returnPath) {
+        logReturnPathMistakes(ctx);
+    }
+    ctx.log(`\n  ${INFO.DNS_FIX_AND_VERIFY}`);
+    if (dnsGuideUrl) {
+        ctx.log(`  Help: ${chalk.cyan(dnsGuideUrl)}\n`);
+    }
+}
+export async function verifyDomain(ctx, opts) {
+    const response = await ctx.spinner('  Checking DNS...', opts.json, () => ctx.get(API_ENDPOINTS.DOMAIN_VERIFY, {
+        domain: opts.domain,
+    }));
+    if (!response.ok) {
+        ctx.onApiError(response);
+    }
+    const { dkim, dmarc, dnsGuideUrl, returnPath, domainStatus } = response.data;
+    if (opts.json) {
+        ctx.log(JSON.stringify({ dkim, dmarc, returnPath, domainStatus }, null, 2));
+        return;
+    }
+    ctx.log(`  DKIM         ${dkim ? chalk.green('✓') : chalk.red('✗  Not found')}`);
+    ctx.log(`  DMARC        ${dmarc ? chalk.green('✓') : chalk.red('✗  Not found')}`);
+    ctx.log(`  Return Path  ${returnPath ? chalk.green('✓') : chalk.red('✗  Not found')}`);
+    const allPassed = domainStatus === 'VERIFIED';
+    if (allPassed) {
+        ctx.log(`\n  ${chalk.green('✓')} Domain verified.\n`);
+    }
+    else {
+        logVerifyFailure(ctx, dkim, returnPath, dnsGuideUrl);
+    }
+}

package/dist/lib/commands/edit/diff.d.ts

@@ -0,0 +1,7 @@
+import type { EmailConfig } from '../../yaml-config.js';
+import type { EditResponse } from './types.js';
+export declare function stripHtml(html: string): string;
+export declare function truncate(text: string, max: number): string;
+export declare function showFieldDiff(log: (msg?: string) => void, label: string, oldVal: string | undefined, newVal: string | undefined): boolean;
+export declare function showHtmlChange(log: (msg?: string) => void, oldHtml: null | string, newHtml: string | undefined): boolean;
+export declare function buildDiffPreview(email: EmailConfig, updated: EditResponse, templateHtml: null | string): Record<string, unknown>;

package/dist/lib/commands/edit/diff.js

@@ -0,0 +1,65 @@
+import chalk from 'chalk';
+export function stripHtml(html) {
+    return html
+        .replaceAll(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+        .replaceAll(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+        .replaceAll(/<[^>]+>/g, ' ')
+        .replaceAll('&nbsp;', ' ')
+        .replaceAll('&amp;', '&')
+        .replaceAll('&lt;', '<')
+        .replaceAll('&gt;', '>')
+        .replaceAll(/\s+/g, ' ')
+        .trim();
+}
+export function truncate(text, max) {
+    return text.length > max ? `${text.slice(0, max)}…` : text;
+}
+export function showFieldDiff(log, label, oldVal, newVal) {
+    if (!newVal || oldVal === newVal)
+        return false;
+    log(`\n  ${label}:`);
+    if (oldVal)
+        log(`  ${chalk.red(`- ${oldVal}`)}`);
+    log(`  ${chalk.green(`+ ${newVal}`)}`);
+    return true;
+}
+export function showHtmlChange(log, oldHtml, newHtml) {
+    if (!newHtml || oldHtml === newHtml)
+        return false;
+    log(`\n  HTML Body:`);
+    const MAX = 500;
+    if (oldHtml) {
+        log(`  ${chalk.red(`- ${truncate(stripHtml(oldHtml), MAX)}`)}`);
+    }
+    log(`  ${chalk.green(`+ ${truncate(stripHtml(newHtml), MAX)}`)}`);
+    return true;
+}
+export function buildDiffPreview(email, updated, templateHtml) {
+    const subjectChanged = Boolean(updated.subject) && updated.subject !== email.subject;
+    const previewChanged = Boolean(updated.previewText) && updated.previewText !== email.previewText;
+    const htmlChanged = Boolean(updated.html) && updated.html !== templateHtml;
+    const diff = {};
+    diff.subject = subjectChanged
+        ? { new: updated.subject, old: email.subject }
+        : { unchanged: true, value: email.subject };
+    if (email.previewText || updated.previewText) {
+        diff.previewText = previewChanged
+            ? { new: updated.previewText, old: email.previewText }
+            : { unchanged: true, value: email.previewText };
+    }
+    if (templateHtml || updated.html) {
+        const oldText = templateHtml
+            ? truncate(stripHtml(templateHtml), 500)
+            : null;
+        const newText = updated.html
+            ? truncate(stripHtml(updated.html), 500)
+            : null;
+        diff.html = htmlChanged
+            ? { new: newText, old: oldText }
+            : { unchanged: true, value: oldText };
+    }
+    if (updated.ctaText) {
+        diff.ctaText = { new: updated.ctaText };
+    }
+    return { diff };
+}

package/dist/lib/commands/edit/display.d.ts

@@ -0,0 +1,5 @@
+import type { EmailConfig } from '../../yaml-config.js';
+import type { EditResponse } from './types.js';
+type Log = (msg?: string) => void;
+export declare function showChangeSummary(log: Log, email: EmailConfig, updated: EditResponse, templateHtml: null | string): void;
+export {};

package/dist/lib/commands/edit/display.js

@@ -0,0 +1,53 @@
+import chalk from 'chalk';
+import { showFieldDiff, showHtmlChange, stripHtml, truncate } from './diff.js';
+function showUnchangedField(log, label, value) {
+    if (!value)
+        return;
+    log(`\n  ${label}:`);
+    log(`  ${chalk.dim(value)}`);
+}
+function showUnchangedHtml(log, templateHtml) {
+    if (!templateHtml)
+        return;
+    log(`\n  HTML Body:`);
+    log(`  ${chalk.dim(truncate(stripHtml(templateHtml), 500))}`);
+}
+function showSuggestedChanges(log, content, changed) {
+    const { email, templateHtml, updated } = content;
+    log('\n  Suggested Changes:');
+    if (changed.subject)
+        showFieldDiff(log, 'Subject', email.subject, updated.subject);
+    if (changed.preview)
+        showFieldDiff(log, 'Preview Text', email.previewText, updated.previewText);
+    if (changed.html)
+        showHtmlChange(log, templateHtml, updated.html);
+    if (changed.cta)
+        showFieldDiff(log, 'CTA Text', undefined, updated.ctaText);
+    if (!changed.subject && !changed.preview && !changed.html && !changed.cta) {
+        log(`\n  ${chalk.dim('No changes detected.')}`);
+    }
+}
+function showUnchanged(log, email, templateHtml, changed) {
+    const hasContent = !changed.subject ||
+        (!changed.preview && Boolean(email.previewText)) ||
+        (!changed.html && Boolean(templateHtml));
+    if (!hasContent)
+        return;
+    log('\n  Unchanged:');
+    if (!changed.subject)
+        showUnchangedField(log, 'Subject', email.subject);
+    if (!changed.preview)
+        showUnchangedField(log, 'Preview Text', email.previewText);
+    if (!changed.html)
+        showUnchangedHtml(log, templateHtml);
+}
+export function showChangeSummary(log, email, updated, templateHtml) {
+    const changed = {
+        cta: Boolean(updated.ctaText),
+        html: Boolean(updated.html) && updated.html !== templateHtml,
+        preview: Boolean(updated.previewText) && updated.previewText !== email.previewText,
+        subject: Boolean(updated.subject) && updated.subject !== email.subject,
+    };
+    showSuggestedChanges(log, { email, templateHtml, updated }, changed);
+    showUnchanged(log, email, templateHtml, changed);
+}

package/dist/lib/commands/edit/flow.d.ts

@@ -0,0 +1,8 @@
+import type { EditContext, EditCtx, EditFlags, EditResponse } from './types.js';
+export declare function askChangeDescription(): Promise<string>;
+export declare function promptEditAction(): Promise<'accept' | 'retry' | 'skip'>;
+export declare function handleUserAction(ctx: EditCtx, editCtx: EditContext, opts: {
+    flags: EditFlags;
+    updated: EditResponse;
+}): Promise<void>;
+export declare function runEditStep(ctx: EditCtx, editCtx: EditContext, changeDescription: string, flags: EditFlags): Promise<void>;

package/dist/lib/commands/edit/flow.js

@@ -0,0 +1,70 @@
+import { input, select } from '@inquirer/prompts';
+import { API_ENDPOINTS } from '../../constants.js';
+import { buildDiffPreview } from './diff.js';
+import { showChangeSummary } from './display.js';
+import { finalizeEdit } from './persist.js';
+export async function askChangeDescription() {
+    return input({
+        message: 'What do you want to change?',
+        validate: (value) => (value?.trim() ? true : 'Please describe the change'),
+    });
+}
+export async function promptEditAction() {
+    return select({
+        message: 'Accept, try again, or skip?',
+        choices: [
+            { name: 'Accept', value: 'accept' },
+            { name: 'Try again', value: 'retry' },
+            { name: 'Skip', value: 'skip' },
+        ],
+    });
+}
+function buildEditApiBody(changeDescription, email, templateHtml) {
+    return {
+        changeRequest: changeDescription,
+        currentEmail: {
+            condition: email.condition,
+            goal: email.goal,
+            html: templateHtml,
+            id: email.id,
+            previewText: email.previewText,
+            subject: email.subject,
+            trigger: email.trigger,
+        },
+    };
+}
+export async function handleUserAction(ctx, editCtx, opts) {
+    const { flags, updated } = opts;
+    ctx.log('');
+    const action = await promptEditAction();
+    if (action === 'skip') {
+        ctx.log('\n  Changes discarded.\n');
+        return;
+    }
+    if (action === 'retry') {
+        const newChange = await askChangeDescription();
+        await runEditStep(ctx, editCtx, newChange, flags);
+        return;
+    }
+    await finalizeEdit(ctx, editCtx, { flags, updated });
+}
+export async function runEditStep(ctx, editCtx, changeDescription, flags) {
+    const body = buildEditApiBody(changeDescription, editCtx.email, editCtx.templateHtml);
+    const response = await ctx.spinner('  Applying AI edits...', flags.json, () => ctx.post(API_ENDPOINTS.EDIT, body));
+    if (!response.ok) {
+        ctx.handleAiQuotaError(response, 'edit');
+        ctx.onApiError(response);
+    }
+    const updated = response.data;
+    if (flags.json) {
+        ctx.log(JSON.stringify(buildDiffPreview(editCtx.email, updated, editCtx.templateHtml), null, 2));
+    }
+    else {
+        showChangeSummary(ctx.log, editCtx.email, updated, editCtx.templateHtml);
+    }
+    if (flags.yes) {
+        await finalizeEdit(ctx, editCtx, { flags, updated });
+        return;
+    }
+    await handleUserAction(ctx, editCtx, { flags, updated });
+}

package/dist/lib/commands/edit/persist.d.ts

@@ -0,0 +1,5 @@
+import type { EditContext, EditCtx, EditFlags, EditResponse } from './types.js';
+export declare function finalizeEdit(ctx: EditCtx, editCtx: EditContext, opts: {
+    flags: EditFlags;
+    updated: EditResponse;
+}): Promise<void>;

package/dist/lib/commands/edit/persist.js

@@ -0,0 +1,67 @@
+import { confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { saveTemplate, saveYaml, } from '../../yaml-config.js';
+function applyEmailChanges(email, updated) {
+    if (updated.subject)
+        email.subject = updated.subject;
+    if (updated.previewText)
+        email.previewText = updated.previewText;
+    if (updated.ctaText)
+        email.ctaText = updated.ctaText;
+}
+async function persistChanges(ctx, editCtx, updated) {
+    const updatedYaml = {
+        ...editCtx.yamlConfig,
+        emails: [...editCtx.yamlConfig.emails],
+    };
+    updatedYaml.emails[editCtx.emailIndex] = editCtx.email;
+    await saveYaml(updatedYaml);
+    if (updated.html) {
+        await saveTemplate(editCtx.templateFilename, updated.html);
+    }
+    await ctx.syncYaml();
+    await ctx.syncTemplate(editCtx.email.id);
+}
+function logJsonResult(ctx, email, updated, oldSubject, oldPreviewText) {
+    ctx.log(JSON.stringify({
+        diff: {
+            previewText: updated.previewText && updated.previewText !== oldPreviewText
+                ? { new: updated.previewText, old: oldPreviewText }
+                : undefined,
+            subject: oldSubject === email.subject
+                ? undefined
+                : { new: email.subject, old: oldSubject },
+        },
+        email,
+        status: 'updated',
+    }, null, 2));
+}
+async function handleAcceptOutput(ctx, email) {
+    ctx.log(`\n  Updated ${chalk.green('mailmodo.yaml')}`);
+    const shouldPreview = await confirm({
+        default: true,
+        message: 'Preview the change?',
+    });
+    if (shouldPreview) {
+        await ctx.runCommand('preview', [email.id]);
+    }
+    else {
+        ctx.log(`  Run: ${chalk.cyan(`mailmodo preview ${email.id}`)}\n`);
+    }
+}
+export async function finalizeEdit(ctx, editCtx, opts) {
+    const { flags, updated } = opts;
+    const oldSubject = editCtx.email.subject;
+    const oldPreviewText = editCtx.email.previewText;
+    applyEmailChanges(editCtx.email, updated);
+    await persistChanges(ctx, editCtx, updated);
+    if (flags.json) {
+        logJsonResult(ctx, editCtx.email, updated, oldSubject, oldPreviewText);
+    }
+    else if (flags.yes) {
+        ctx.log(`\n  Updated ${chalk.green('mailmodo.yaml')}\n`);
+    }
+    else {
+        await handleAcceptOutput(ctx, editCtx.email);
+    }
+}

package/dist/lib/commands/edit/types.d.ts

@@ -0,0 +1,38 @@
+import type { ApiResponse } from '../../api-client.js';
+import type { EmailConfig, MailmodoYaml } from '../../yaml-config.js';
+export interface EditResponse {
+    ctaText?: string;
+    html?: string;
+    previewText?: string;
+    subject?: string;
+}
+export interface EditContext {
+    email: EmailConfig;
+    emailIndex: number;
+    templateFilename: string;
+    templateHtml: null | string;
+    yamlConfig: MailmodoYaml;
+}
+export type EditFlags = {
+    json: boolean;
+    yes: boolean;
+};
+export type EditCtx = {
+    error(msg: string): never;
+    exit(code?: number): never;
+    handleAiQuotaError(resp: {
+        data?: unknown;
+        error?: string;
+        status: number;
+    }, feature: 'edit'): void;
+    log(msg?: string): void;
+    onApiError(resp: {
+        error?: string;
+        status: number;
+    }): never;
+    post<T>(path: string, body?: unknown): Promise<ApiResponse<T>>;
+    runCommand(id: string, argv: string[]): Promise<void>;
+    spinner<T>(text: string, json: boolean, work: () => Promise<T>): Promise<T>;
+    syncTemplate(emailId: string): Promise<void>;
+    syncYaml(): Promise<void>;
+};

package/dist/lib/commands/edit/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/commands/emails/editor.d.ts

@@ -0,0 +1,2 @@
+import type { EmailsCtx } from './types.js';
+export declare function openTemplateInEditor(ctx: EmailsCtx, template: string): Promise<void>;

package/dist/lib/commands/emails/editor.js

@@ -0,0 +1,43 @@
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import open from 'open';
+function trySpawnEditor(editor, filePath) {
+    const [cmd, args] = process.platform === 'win32'
+        ? ['cmd.exe', ['/c', editor, filePath]]
+        : [editor, [filePath]];
+    return new Promise((resolve) => {
+        const child = spawn(cmd, [...args], { stdio: 'ignore' });
+        child.on('error', () => {
+            resolve(false);
+        });
+        child.on('close', (code) => {
+            resolve(code === 0);
+        });
+    });
+}
+export async function openTemplateInEditor(ctx, template) {
+    const templatePath = join(process.cwd(), template);
+    ctx.log(`\n  Opening ${template}...\n`);
+    const editor = process.env.VISUAL || process.env.EDITOR;
+    if (editor) {
+        const [cmd, ...editorArgs] = editor.trim().split(/\s+/);
+        const launched = await new Promise((resolve) => {
+            const child = spawn(cmd, [...editorArgs, templatePath], {
+                stdio: 'inherit',
+            });
+            child.on('error', () => resolve(false));
+            child.on('close', (code) => resolve(code === 0));
+        });
+        if (launched)
+            return;
+    }
+    if (await trySpawnEditor('code', templatePath))
+        return;
+    try {
+        await open(templatePath);
+    }
+    catch {
+        ctx.log(`  ${chalk.dim(`Could not open editor. Open the file manually: ${templatePath}`)}`);
+    }
+}

package/dist/lib/commands/emails/output.d.ts

@@ -0,0 +1,4 @@
+import type { EmailConfig } from '../../yaml-config.js';
+import type { EmailsCtx } from './types.js';
+export declare function renderEmailTable(ctx: EmailsCtx, emails: EmailConfig[]): void;
+export declare function renderEmailDetail(ctx: EmailsCtx, email: EmailConfig): void;

package/dist/lib/commands/emails/output.js

@@ -0,0 +1,36 @@
+import chalk from 'chalk';
+export function renderEmailTable(ctx, emails) {
+    ctx.log(`\n  ${chalk.bold(String(emails.length))} emails configured in mailmodo.yaml:\n`);
+    const idColW = Math.max(...emails.map((e) => e.id.length), 'ID'.length) + 2;
+    const triggerColW = Math.max(...emails.map((e) => e.trigger.length), 'Trigger'.length) + 2;
+    const delayColW = Math.max(...emails.map((e) => String(e.delay).length), 'Delay'.length) + 2;
+    const hasConditions = emails.some((e) => e.condition);
+    ctx.log(`  ${chalk.bold('ID'.padEnd(idColW))}${chalk.bold('Trigger'.padEnd(triggerColW))}${chalk.bold('Delay'.padEnd(delayColW))}${hasConditions ? chalk.bold('Condition') : ''}`);
+    ctx.log(`  ${'─'.repeat(idColW + triggerColW + delayColW + (hasConditions ? 'Condition'.length : 0))}`);
+    for (const email of emails) {
+        const id = chalk.cyan(email.id.padEnd(idColW));
+        const trigger = email.trigger.padEnd(triggerColW);
+        const delay = String(email.delay).padEnd(delayColW);
+        const condition = email.condition ? chalk.dim(email.condition) : '';
+        ctx.log(`  ${id}${trigger}${delay}${condition}`);
+    }
+    ctx.log('');
+}
+export function renderEmailDetail(ctx, email) {
+    ctx.log('');
+    ctx.log(`  ${chalk.bold('ID:')}       ${email.id}`);
+    ctx.log(`  ${chalk.bold('Trigger:')}  ${email.trigger}`);
+    ctx.log(`  ${chalk.bold('Delay:')}    ${email.delay === 0 || email.delay === '0' ? '0 (immediate)' : email.delay}`);
+    ctx.log(`  ${chalk.bold('Subject:')}  ${email.subject}`);
+    ctx.log(`  ${chalk.bold('Template:')} ${email.template}`);
+    if (email.style) {
+        ctx.log(`  ${chalk.bold('Style:')}    ${email.style}`);
+    }
+    if (email.condition) {
+        ctx.log(`  ${chalk.bold('Condition:')} ${email.condition}`);
+    }
+    if (email.goal) {
+        ctx.log(`  ${chalk.bold('Goal:')}     ${email.goal}`);
+    }
+    ctx.log('');
+}

package/dist/lib/commands/emails/types.d.ts

@@ -0,0 +1,3 @@
+export type EmailsCtx = {
+    log(msg?: string): void;
+};

package/dist/lib/commands/emails/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/commands/init/analysis.d.ts

@@ -0,0 +1,3 @@
+import type { AnalysisResult, InitCtx, InitFlags } from './types.js';
+export declare function promptProductUrl(flagUrl?: string): Promise<string>;
+export declare function analyzeProduct(ctx: InitCtx, productUrl: string, flags: InitFlags): Promise<AnalysisResult | null>;