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

package/dist/lib/{deploy → commands/deploy}/domain-setup.js

@@ -1,7 +1,7 @@
 import { confirm, input } from '@inquirer/prompts';
 import chalk from 'chalk';
-import { API_ENDPOINTS } from '../constants.js';
-import { ERRORS, INFO, PROMPTS } from '../messages.js';
+import { API_ENDPOINTS } from '../../constants.js';
+import { ERRORS, INFO, PROMPTS } from '../../messages.js';
 export async function validateDeploySequence(ctx, payload, flags) {
     const res = await ctx.spinner('  Validating sequence...', flags.json, () => ctx.post(API_ENDPOINTS.SEQUENCES_VALIDATE, payload));
     if (!res.ok) {

package/dist/lib/{deploy → commands/deploy}/output.d.ts

@@ -1,4 +1,4 @@
-import type { MailmodoYaml } from '../yaml-config.js';
+import type { MailmodoYaml } from '../../yaml-config.js';
 import type { DeployCtx, SdkSnippet, ValidateResponse } from './types.js';
 export declare function logDiff(ctx: DeployCtx, diff: NonNullable<ValidateResponse['diff']>): void;
 export declare function logPreDeploySummary(ctx: DeployCtx, yamlConfig: MailmodoYaml, validateResult: ValidateResponse, jsonOutput: boolean): void;

package/dist/lib/{deploy → commands/deploy}/output.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
-import { SDK_IMPORT_SNIPPET, SDK_INSTALL_COMMAND } from '../constants.js';
-import { DEPLOY, SEPARATOR } from '../messages.js';
+import { SDK_IMPORT_SNIPPET, SDK_INSTALL_COMMAND } from '../../constants.js';
+import { DEPLOY, SEPARATOR } from '../../messages.js';
 export function logDiff(ctx, diff) {
     if (!diff.hasChanges) {
         ctx.log(`  ${DEPLOY.NO_CHANGES}`);

package/dist/lib/{deploy → commands/deploy}/payload.d.ts

@@ -1,4 +1,4 @@
-import { type EmailConfig, type MailmodoYaml, type ProjectConfig } from '../yaml-config.js';
+import { type EmailConfig, type MailmodoYaml, type ProjectConfig } from '../../yaml-config.js';
 import type { DeployCtx } from './types.js';
 export declare function mapEmailToPayload(email: EmailConfig): {
     condition: string | null;

package/dist/lib/{deploy → commands/deploy}/payload.js

@@ -1,5 +1,5 @@
-import { loadTemplate, } from '../yaml-config.js';
-import { DEFAULT_BRAND_COLOR } from '../constants.js';
+import { loadTemplate, } from '../../yaml-config.js';
+import { DEFAULT_BRAND_COLOR } from '../../constants.js';
 export function mapEmailToPayload(email) {
     return {
         condition: email.condition || null,

package/dist/lib/{deploy → commands/deploy}/sequence-status.js

@@ -1,6 +1,6 @@
 import { confirm } from '@inquirer/prompts';
-import { API_ENDPOINTS } from '../constants.js';
-import { INFO, pauseAlready, pauseSuccess, PROMPTS, resumeAlready, resumeSuccess, } from '../messages.js';
+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`;
 }

package/dist/lib/{deploy → commands/deploy}/types.d.ts

@@ -1,6 +1,6 @@
-import type { ApiResponse } from '../api-client.js';
-import type { MailmodoYaml } from '../yaml-config.js';
-import type { RegenCtx } from '../templates/types.js';
+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;
@@ -85,4 +85,4 @@ export type DeployCtx = RegenCtx & {
     spinner<T>(text: string, json: boolean, work: () => Promise<T>): Promise<T>;
     syncYaml(): Promise<void>;
 };
-export { type RegenCtx } from '../templates/types.js';
+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>;

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);
+    }
+}