@mailmodo/cli 0.0.54 → 0.0.55-beta.pr57.92

package/dist/lib/commands/deploy/payload.js

@@ -0,0 +1,95 @@
+import { loadTemplate, } from '../../yaml-config.js';
+import { DEFAULT_BRAND_COLOR } from '../../constants.js';
+export function mapEmailToPayload(email) {
+    return {
+        condition: email.condition || null,
+        ctaText: email.ctaText || '',
+        delay: email.delay,
+        goal: email.goal || '',
+        id: email.id,
+        isReminder: false,
+        previewText: email.previewText || '',
+        priority: 'medium',
+        subject: email.subject,
+        trigger: email.trigger,
+    };
+}
+function buildBrandSection(project) {
+    return {
+        colors: [project?.brandColor || DEFAULT_BRAND_COLOR],
+        logoUrl: project?.logoUrl || '',
+    };
+}
+function buildProductSection(project) {
+    return {
+        businessType: project?.type || '',
+        description: project?.description || '',
+        pricingModel: project?.pricingModel || '',
+        productName: project?.name || '',
+        saasModel: project?.saasModel || '',
+        targetUser: project?.targetUser || '',
+        url: project?.url || '',
+    };
+}
+function buildSenderSection(project) {
+    return {
+        address: project?.address || '',
+        domain: project?.domain || '',
+        fromEmail: project?.fromEmail || '',
+        fromName: project?.fromName || '',
+        replyTo: project?.replyTo || project?.fromEmail || '',
+    };
+}
+export function buildProjectPayload(project, monthlyCap) {
+    return {
+        brand: buildBrandSection(project),
+        emailStyle: project?.emailStyle || 'branded',
+        ...(monthlyCap === undefined ? {} : { monthlyCap }),
+        product: buildProductSection(project),
+        senderDetails: buildSenderSection(project),
+        ...(project?.webhookUrl ? { webhookUrl: project.webhookUrl } : {}),
+    };
+}
+export function buildRegeneratePayload(yamlConfig, missingIds) {
+    const { emails, project } = yamlConfig;
+    const idSet = new Set(missingIds);
+    const targets = emails.filter((e) => idSet.has(e.id));
+    return {
+        brand: {
+            color: project.brandColor || DEFAULT_BRAND_COLOR,
+            logoUrl: project.logoUrl || '',
+        },
+        businessType: project.type || '',
+        description: project.description || '',
+        events: [...new Set(targets.map((e) => e.trigger))],
+        pricingModel: project.pricingModel || '',
+        productName: project.name || '',
+        recommendedEmails: targets.map((e) => ({
+            condition: e.condition || null,
+            delay: String(e.delay ?? '0'),
+            goal: e.goal || '',
+            id: e.id,
+            isReminder: false,
+            priority: 'medium',
+            trigger: e.trigger,
+        })),
+        saasModel: project.saasModel || '',
+        targetUser: project.targetUser || '',
+    };
+}
+export async function buildDeployPayload(ctx, yamlConfig) {
+    const [emailsWithHtml, monthlyCap] = await Promise.all([
+        Promise.all(yamlConfig.emails.map(async (email) => {
+            const html = (await loadTemplate(`${email.id}.html`)) || '';
+            const plainHtml = (await loadTemplate(`${email.id}_plain.html`)) || html;
+            return { ...mapEmailToPayload(email), html, plainHtml };
+        })),
+        yamlConfig.project.monthlyCap === undefined
+            ? ctx.getBillingCap()
+            : Promise.resolve(yamlConfig.project.monthlyCap),
+    ]);
+    return {
+        ...buildProjectPayload(yamlConfig.project, monthlyCap),
+        emails: emailsWithHtml,
+    };
+}

package/dist/lib/commands/deploy/sequence-status.d.ts

@@ -0,0 +1,3 @@
+import type { DeployCtx, DeployFlags } from './types.js';
+export declare function pauseSequence(ctx: DeployCtx, sequenceId: string, flags: DeployFlags): Promise<void>;
+export declare function resumeSequence(ctx: DeployCtx, sequenceId: string, flags: DeployFlags): Promise<void>;

package/dist/lib/commands/deploy/sequence-status.js

@@ -0,0 +1,56 @@
+import { confirm } from '@inquirer/prompts';
+import { API_ENDPOINTS } from '../../constants.js';
+import { INFO, pauseAlready, pauseSuccess, PROMPTS, resumeAlready, resumeSuccess, } from '../../messages.js';
+function sequenceStatusPath(sequenceId) {
+    return `${API_ENDPOINTS.SEQUENCES}/${encodeURIComponent(sequenceId)}/status`;
+}
+async function updateSequenceStatus(ctx, opts) {
+    const response = await ctx.spinner(opts.spinnerText, opts.flags.json, () => ctx.post(sequenceStatusPath(opts.sequenceId), {
+        status: opts.status,
+    }));
+    if (!response.ok)
+        ctx.onApiError(response);
+    return response.data;
+}
+export async function pauseSequence(ctx, sequenceId, flags) {
+    if (!flags.yes) {
+        const confirmed = await confirm({
+            default: false,
+            message: PROMPTS.PAUSE_CONFIRM,
+        });
+        if (!confirmed) {
+            ctx.log(`\n  ${INFO.PAUSE_CANCELLED}\n`);
+            return;
+        }
+    }
+    const data = await updateSequenceStatus(ctx, {
+        flags,
+        sequenceId,
+        spinnerText: '  Pausing sequence...',
+        status: 'paused',
+    });
+    if (flags.json) {
+        ctx.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    const msg = data.alreadyInStatus
+        ? pauseAlready(data.sequenceId || sequenceId)
+        : pauseSuccess(data.sequenceId || sequenceId);
+    ctx.log(`\n  ${msg}\n`);
+}
+export async function resumeSequence(ctx, sequenceId, flags) {
+    const data = await updateSequenceStatus(ctx, {
+        flags,
+        sequenceId,
+        spinnerText: '  Resuming sequence...',
+        status: 'active',
+    });
+    if (flags.json) {
+        ctx.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    const msg = data.alreadyInStatus
+        ? resumeAlready(data.sequenceId || sequenceId)
+        : resumeSuccess(data.sequenceId || sequenceId);
+    ctx.log(`\n  ${msg}\n`);
+}

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

@@ -0,0 +1,88 @@
+import type { ApiResponse } from '../../api-client.js';
+import type { MailmodoYaml } from '../../yaml-config.js';
+import type { RegenCtx } from '../../templates/types.js';
+export interface EmailDiffEntry {
+    changedFields?: string[];
+    id: string;
+    subject?: string;
+    trigger?: string;
+}
+export interface ValidateResponse {
+    diff: null | {
+        added: EmailDiffEntry[];
+        hasChanges: boolean;
+        modified: EmailDiffEntry[];
+        removed: EmailDiffEntry[];
+        unchanged: EmailDiffEntry[];
+    };
+    error: null | string;
+    existingDeployment: boolean;
+    isValid: boolean;
+}
+export interface SdkSnippet {
+    examples: {
+        identify: string;
+        track: string;
+    };
+    identifyCalls: string[];
+    install: string;
+    trackCalls: string[];
+}
+export interface DeployResponse {
+    deployed: boolean;
+    diff: {
+        added: EmailDiffEntry[];
+        hasChanges: boolean;
+        modified: EmailDiffEntry[];
+        removed: EmailDiffEntry[];
+        unchanged: EmailDiffEntry[];
+    };
+    emailsLive: number;
+    sdkSnippet: SdkSnippet;
+    sequenceId: string;
+}
+export type DeployFlags = {
+    json: boolean;
+    yes: boolean;
+};
+export type DeployCtx = RegenCtx & {
+    collectDomainInputs(yaml: MailmodoYaml, skip: boolean): Promise<{
+        address: string;
+        domain: string;
+        fromEmail: string;
+        fromName: string;
+        replyTo: string;
+    }>;
+    error(msg: string): never;
+    exit(code?: number): never;
+    get<T = Record<string, unknown>>(path: string, params?: Record<string, string>): Promise<ApiResponse<T>>;
+    getBillingCap(): Promise<number | undefined>;
+    log(msg?: string): void;
+    onApiError(resp: {
+        error?: string;
+        status: number;
+    }): never;
+    post<T = Record<string, unknown>>(path: string, body?: Record<string, unknown> | unknown): Promise<ApiResponse<T>>;
+    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>;
+    syncYaml(): Promise<void>;
+};
+export { type RegenCtx } from '../../templates/types.js';

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

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

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

@@ -0,0 +1,2 @@
+import type { DeploymentsCtx, DeploymentsResponse } from './types.js';
+export declare function renderDeploymentsTable(ctx: DeploymentsCtx, data: DeploymentsResponse): void;

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

@@ -0,0 +1,68 @@
+import chalk from 'chalk';
+function statusColor(status) {
+    if (status === 'active')
+        return chalk.green;
+    if (status === 'paused')
+        return chalk.yellow;
+    return chalk.white;
+}
+function colWidth(rows, key, header) {
+    return Math.max(...rows.map((r) => r[key].length), header.length) + 2;
+}
+function formatDate(iso) {
+    if (!iso)
+        return '';
+    const parsed = new Date(iso);
+    if (Number.isNaN(parsed.getTime()))
+        return iso;
+    return parsed.toISOString().slice(0, 10);
+}
+function logEmptyState(ctx) {
+    ctx.log(`\n  ${chalk.dim('No deployed sequences yet.')}`);
+    ctx.log(`  Run ${chalk.cyan('mailmodo deploy')} to deploy one.\n`);
+}
+function logTableHeader(ctx, count, widths) {
+    ctx.log(`\n  ${chalk.bold(String(count))} deployed ${count === 1 ? 'sequence' : 'sequences'}:\n`);
+    ctx.log(`  ${chalk.bold('Product'.padEnd(widths.product))}` +
+        `${chalk.bold('Status'.padEnd(widths.status))}` +
+        `${chalk.bold('Emails'.padEnd(widths.emails))}` +
+        `${chalk.bold('Sequence ID'.padEnd(widths.sequenceId))}` +
+        `${chalk.bold('Updated')}`);
+    ctx.log(`  ${'─'.repeat(widths.product + widths.status + widths.emails + widths.sequenceId + widths.updated)}`);
+}
+function logTableRows(ctx, rows, widths) {
+    for (const row of rows) {
+        const status = statusColor(row.status)(row.status.padEnd(widths.status));
+        ctx.log(`  ${row.product.padEnd(widths.product)}` +
+            `${status}` +
+            `${row.emails.padEnd(widths.emails)}` +
+            `${chalk.cyan(row.sequenceId.padEnd(widths.sequenceId))}` +
+            `${chalk.dim(row.updated)}`);
+    }
+}
+export function renderDeploymentsTable(ctx, data) {
+    const sequences = data.sequences ?? [];
+    if (sequences.length === 0) {
+        logEmptyState(ctx);
+        return;
+    }
+    const rows = sequences.map((seq) => ({
+        emails: String(seq.emailCount ?? 0),
+        product: seq.productName ?? '',
+        sequenceId: seq.sequenceId ?? '',
+        status: seq.status ?? '',
+        updated: formatDate(seq.updatedAt),
+    }));
+    const widths = {
+        emails: colWidth(rows, 'emails', 'Emails'),
+        product: colWidth(rows, 'product', 'Product'),
+        sequenceId: colWidth(rows, 'sequenceId', 'Sequence ID'),
+        status: colWidth(rows, 'status', 'Status'),
+        updated: colWidth(rows, 'updated', 'Updated'),
+    };
+    logTableHeader(ctx, sequences.length, widths);
+    logTableRows(ctx, rows, widths);
+    ctx.log('');
+    ctx.log(`  Pause:  ${chalk.cyan('mailmodo deploy --pause <sequence-id>')}`);
+    ctx.log(`  Resume: ${chalk.cyan('mailmodo deploy --resume <sequence-id>')}\n`);
+}

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

@@ -0,0 +1,24 @@
+import type { ApiResponse } from '../../api-client.js';
+export interface Deployment {
+    createdAt: string;
+    emailCount: number;
+    productName: string;
+    senderDomain: string;
+    sequenceId: string;
+    status: 'active' | 'paused';
+    triggers: string[];
+    updatedAt: string;
+}
+export interface DeploymentsResponse {
+    sequences: Deployment[];
+    total: number;
+}
+export type DeploymentsCtx = {
+    get<T = Record<string, unknown>>(path: string, params?: Record<string, string>): Promise<ApiResponse<T>>;
+    log(msg?: string): void;
+    onApiError(resp: {
+        error?: string;
+        status: number;
+    }): never;
+    spinner<T>(text: string, json: boolean, work: () => Promise<T>): Promise<T>;
+};

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

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

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

@@ -0,0 +1,8 @@
+import type { DomainCtx, DomainFlags } from './types.js';
+import type { MailmodoYaml } from '../../yaml-config.js';
+export declare function setupDomain(ctx: DomainCtx, yamlConfig: MailmodoYaml, flags: DomainFlags): Promise<void>;
+export declare function showDomainStatus(ctx: DomainCtx, opts: {
+    domain: string;
+    json: boolean;
+}): Promise<void>;
+export declare function getDomainOrError(ctx: DomainCtx, yamlConfig: MailmodoYaml): string;

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>;