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

package/dist/lib/commands/contacts/actions.d.ts

@@ -0,0 +1,3 @@
+import type { ContactsCtx } from './types.js';
+export declare function showSummary(ctx: ContactsCtx, json: boolean): Promise<void>;
+export declare function searchContact(ctx: ContactsCtx, email: string, json: boolean): Promise<void>;

package/dist/lib/commands/contacts/actions.js

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import { API_ENDPOINTS } from '../../constants.js';
+export async function showSummary(ctx, json) {
+    const response = await ctx.spinner('  Loading contacts...', json, () => ctx.get(API_ENDPOINTS.CONTACTS));
+    if (!response.ok) {
+        ctx.onApiError(response);
+    }
+    const { data } = response;
+    if (json) {
+        ctx.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    ctx.log(`\n  Total: ${chalk.bold(String(data.total ?? 0))}  ` +
+        `Active: ${chalk.green(String(data.active ?? 0))}  ` +
+        `Unsubscribed: ${chalk.yellow(String(data.unsubscribed ?? 0))}  ` +
+        `Bounced: ${chalk.red(String(data.bounced ?? 0))}\n`);
+}
+export async function searchContact(ctx, email, json) {
+    const encodedEmail = encodeURIComponent(email);
+    const response = await ctx.spinner('  Looking up contact...', json, () => ctx.get(`${API_ENDPOINTS.CONTACTS}/${encodedEmail}`));
+    if (!response.ok) {
+        if (response.status === 404) {
+            if (json) {
+                ctx.log(JSON.stringify({ email, error: 'Contact not found' }, null, 2));
+            }
+            else {
+                ctx.log(`\n  Contact '${email}' not found.\n`);
+            }
+            return;
+        }
+        ctx.onApiError(response);
+    }
+    const contact = response.data;
+    if (json) {
+        ctx.log(JSON.stringify(contact, null, 2));
+        return;
+    }
+    ctx.log(`\n  ${chalk.bold('Email:')}       ${contact.email}`);
+    ctx.log(`  ${chalk.bold('Status:')}      ${contact.status}`);
+    ctx.log(`  ${chalk.bold('Added:')}       ${contact.added}`);
+    ctx.log(`  ${chalk.bold('Next email:')}  ${contact.nextEmail || 'None'}`);
+    if (contact.properties && Object.keys(contact.properties).length > 0) {
+        ctx.log(`  ${chalk.bold('Properties:')}`);
+        for (const [key, value] of Object.entries(contact.properties)) {
+            ctx.log(`    ${key}: ${String(value)}`);
+        }
+    }
+    ctx.log('');
+}

package/dist/lib/commands/contacts/export-delete.d.ts

@@ -0,0 +1,9 @@
+import type { ContactsCtx } from './types.js';
+export declare function exportContacts(ctx: ContactsCtx, opts: {
+    json: boolean;
+}): Promise<void>;
+export declare function deleteContact(ctx: ContactsCtx, opts: {
+    email: string;
+    json: boolean;
+    skipConfirm: boolean;
+}): Promise<void>;

package/dist/lib/commands/contacts/export-delete.js

@@ -0,0 +1,51 @@
+import { confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { API_ENDPOINTS } from '../../constants.js';
+export async function exportContacts(ctx, opts) {
+    const { json } = opts;
+    const response = await ctx.spinner('  Preparing contact export...', json, () => ctx.get(API_ENDPOINTS.CONTACTS_EXPORT));
+    if (!response.ok) {
+        ctx.onApiError(response);
+    }
+    if (json) {
+        ctx.log(JSON.stringify(response.data, null, 2));
+        return;
+    }
+    ctx.log(`\n  ${chalk.green('✓')} Contact export started.`);
+    const { downloadUrl, status } = response.data;
+    if (!downloadUrl) {
+        ctx.log(`\n  Export status: ${status ?? 'unknown'}. No download URL yet.\n`);
+        return;
+    }
+    const fileResult = await ctx.spinner('  Downloading CSV file...', json, () => ctx.getPublicFile(downloadUrl.trim()));
+    if (!fileResult.ok) {
+        ctx.error(`Download failed: ${fileResult.status} ${fileResult.error ?? ''}\n  URL: ${fileResult.debug.fullUrl}`);
+    }
+    const outputPath = resolve('contacts.csv');
+    await writeFile(outputPath, Buffer.from(fileResult.body));
+    ctx.log(`\n  ${chalk.green('✓')} Contact export saved to ${chalk.cyan(outputPath)}\n`);
+}
+export async function deleteContact(ctx, opts) {
+    const { email, json, skipConfirm } = opts;
+    if (!skipConfirm) {
+        const confirmed = await confirm({
+            default: false,
+            message: `Permanently delete ${email} and all their data? This cannot be undone.`,
+        });
+        if (!confirmed) {
+            ctx.log('\n  Delete cancelled.\n');
+            return;
+        }
+    }
+    const response = await ctx.spinner('  Deleting contact...', json, () => ctx.delete(`${API_ENDPOINTS.CONTACTS}/${encodeURIComponent(email)}`));
+    if (!response.ok) {
+        ctx.onApiError(response);
+    }
+    if (json) {
+        ctx.log(JSON.stringify({ deleted: true, email }, null, 2));
+        return;
+    }
+    ctx.log(`\n  ${chalk.green('✓')} Contact ${email} permanently deleted.\n`);
+}

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

@@ -0,0 +1,35 @@
+import type { ApiResponse } from '../../api-client.js';
+import type { FileFetchResult } from '../../fetch-file.js';
+export interface ContactSummaryResponse {
+    active: number;
+    bounced: number;
+    total: number;
+    unsubscribed: number;
+}
+export interface ContactDetailResponse {
+    added: string;
+    email: string;
+    nextEmail: null | string;
+    properties: Record<string, unknown>;
+    status: string;
+}
+export interface ContactExportResponse {
+    downloadUrl: string;
+    status: string;
+}
+export type ContactsFlags = {
+    json: boolean;
+    yes: boolean;
+};
+export type ContactsCtx = {
+    delete<T = Record<string, unknown>>(path: string): Promise<ApiResponse<T>>;
+    error(msg: string): never;
+    get<T>(path: string, params?: Record<string, string>): Promise<ApiResponse<T>>;
+    getPublicFile(url: string): Promise<FileFetchResult>;
+    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/contacts/types.js

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

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

@@ -1,4 +1,4 @@
-import type { MailmodoYaml } from '../yaml-config.js';
+import type { MailmodoYaml } from '../../yaml-config.js';
 import type { DeployCtx, DeployFlags, ValidateResponse } from './types.js';
 export declare function validateDeploySequence(ctx: DeployCtx, payload: object, flags: {
     json: boolean;

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