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

package/dist/lib/commands/init/analysis.js

@@ -0,0 +1,73 @@
+import { editor, input, select } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { API_ENDPOINTS } from '../../constants.js';
+import { isValidUrl } from '../../utils.js';
+import { logAnalysisSummary } from './output.js';
+export async function promptProductUrl(flagUrl) {
+    if (flagUrl) {
+        if (!isValidUrl(flagUrl)) {
+            throw new Error(`Invalid URL: "${flagUrl}". Please enter a valid URL (e.g., https://myapp.com)`);
+        }
+        return flagUrl;
+    }
+    return input({
+        message: 'What is your product URL?',
+        validate(value) {
+            if (!value?.trim())
+                return 'URL is required';
+            if (isValidUrl(value))
+                return true;
+            return 'Please enter a valid URL (e.g., https://myapp.com)';
+        },
+    });
+}
+export async function analyzeProduct(ctx, productUrl, flags) {
+    const response = await ctx.spinner('  Analyzing your product — scraping homepage, pricing, features', flags.json, () => ctx.post(API_ENDPOINTS.ANALYZE, { url: productUrl }));
+    if (!response.ok) {
+        ctx.onAiQuotaError(response, 'init');
+        ctx.onApiError(response);
+    }
+    const analysis = response.data;
+    const shouldShow = !flags.json || !flags.yes;
+    if (shouldShow) {
+        const logLine = flags.json && !flags.yes ? ctx.logToStderr : ctx.log;
+        logAnalysisSummary(analysis, logLine);
+    }
+    if (flags.yes)
+        return analysis;
+    return promptConfirmAnalysis(ctx, analysis);
+}
+async function promptConfirmAnalysis(ctx, analysis) {
+    const userAction = await select({
+        choices: [
+            { name: 'Yes - continue with this result', value: 'yes' },
+            { name: 'No - stop here', value: 'no' },
+            { name: 'Edit - update the result before continuing', value: 'edit' },
+        ],
+        message: 'Does this look right?',
+    });
+    if (userAction === 'no') {
+        ctx.log(`\n  Stopped. Run ${chalk.cyan('mailmodo init')} again when you are ready.\n`);
+        return null;
+    }
+    if (userAction === 'edit') {
+        const edited = await editor({
+            default: JSON.stringify(analysis, null, 2),
+            message: 'Edit the analysis JSON. Save and close to continue.',
+            postfix: '.json',
+            validate(value) {
+                if (!value?.trim())
+                    return 'Edited analysis cannot be empty';
+                try {
+                    JSON.parse(value);
+                    return true;
+                }
+                catch {
+                    return 'Please provide valid JSON';
+                }
+            },
+        });
+        return JSON.parse(edited);
+    }
+    return analysis;
+}

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

@@ -0,0 +1,12 @@
+import type { EmailConfig, MailmodoYaml } from '../../yaml-config.js';
+import type { AnalysisResult, InitCtx, InitFlags } from './types.js';
+type SuccessOpts = {
+    brand: AnalysisResult['brand'];
+    emailConfigs: EmailConfig[];
+    emailStyle: string | undefined;
+    json: boolean;
+};
+export declare function logAnalysisSummary(analysis: AnalysisResult, logLine: (message?: string) => void): void;
+export declare function confirmOverwrite(ctx: InitCtx, flags: InitFlags, existing: MailmodoYaml | null): Promise<boolean>;
+export declare function logInitSuccess(ctx: InitCtx, opts: SuccessOpts): void;
+export {};

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

@@ -0,0 +1,39 @@
+import chalk from 'chalk';
+import { confirm } from '@inquirer/prompts';
+export function logAnalysisSummary(analysis, logLine) {
+    logLine(`  Detected:`);
+    logLine(`  - Type:    ${analysis.businessType} — ${analysis.description}`);
+    logLine(`  - Model:   ${analysis.pricingModel}`);
+    logLine(`  - Users:   ${analysis.targetUser}`);
+    if (analysis.events?.length) {
+        logLine(`  - Events:  ${analysis.events.join(', ')}`);
+    }
+    logLine('');
+}
+export async function confirmOverwrite(ctx, flags, existing) {
+    if (!existing || flags.yes)
+        return true;
+    ctx.log(`\n  ${chalk.yellow('⚠')}  ${chalk.bold('mailmodo.yaml already exists.')}`);
+    ctx.log(`  Running init will overwrite your current project configuration and all email templates.\n`);
+    const proceed = await confirm({
+        default: false,
+        message: 'Overwrite existing configuration and templates?',
+    });
+    if (!proceed) {
+        ctx.log(`\n  Init cancelled. Run ${chalk.cyan('mailmodo edit')} to modify individual emails.\n`);
+    }
+    return proceed;
+}
+export function logInitSuccess(ctx, opts) {
+    if (opts.json) {
+        ctx.log(JSON.stringify({
+            brandDetected: opts.brand,
+            emails: opts.emailConfigs,
+            emailsCreated: opts.emailConfigs.length,
+            style: opts.emailStyle,
+        }, null, 2));
+        return;
+    }
+    ctx.log(`  Created ${chalk.green('mailmodo.yaml')} + ${chalk.green(String(opts.emailConfigs.length))} email templates in ${chalk.green('/mailmodo')}\n`);
+    ctx.log(`  Run ${chalk.cyan("'mailmodo emails'")} to review.\n`);
+}

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

@@ -0,0 +1,8 @@
+import { type EmailConfig, type MailmodoYaml } from '../../yaml-config.js';
+import type { AnalysisResult, GeneratedEmail, InitCtx } from './types.js';
+export declare function buildEmailConfig(rec: AnalysisResult['recommendedEmails'][number], generated: GeneratedEmail | undefined, productName: string): EmailConfig;
+export declare function buildEmailConfigs(analysisPayload: AnalysisResult, generatedEmails: GeneratedEmail[]): EmailConfig[];
+export declare function buildYamlConfig(analysisPayload: AnalysisResult, emailConfigs: EmailConfig[], productUrl: string): MailmodoYaml;
+export declare function preserveUserFields(config: MailmodoYaml, existing: MailmodoYaml): void;
+export declare function applyMonthlyCap(ctx: InitCtx, yamlConfig: MailmodoYaml): Promise<void>;
+export declare function saveAllTemplates(recommendedEmails: AnalysisResult['recommendedEmails'], generatedEmails: GeneratedEmail[]): Promise<void>;

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

@@ -0,0 +1,78 @@
+import { DEFAULT_BRAND_COLOR } from '../../constants.js';
+import { saveTemplate, saveYaml, } from '../../yaml-config.js';
+import { normalizeTrigger } from '../../utils.js';
+export function buildEmailConfig(rec, generated, productName) {
+    return {
+        delay: rec.delay || '0',
+        id: rec.id,
+        trigger: normalizeTrigger(rec.trigger, productName),
+        ...(rec.condition ? { condition: rec.condition } : {}),
+        subject: generated?.subject || `Email for ${rec.id}`,
+        template: `mailmodo/${rec.id}.html`,
+        ...(generated?.previewText ? { previewText: generated.previewText } : {}),
+        ...(generated?.ctaText ? { ctaText: generated.ctaText } : {}),
+        goal: rec.goal,
+    };
+}
+export function buildEmailConfigs(analysisPayload, generatedEmails) {
+    return analysisPayload.recommendedEmails.map((rec, index) => buildEmailConfig(rec, generatedEmails[index], analysisPayload.productName));
+}
+export function buildYamlConfig(analysisPayload, emailConfigs, productUrl) {
+    return {
+        emails: emailConfigs,
+        project: {
+            brandColor: analysisPayload.brand?.color || DEFAULT_BRAND_COLOR,
+            description: analysisPayload.description,
+            emailStyle: 'plain',
+            fromEmail: '',
+            fromName: `Team ${analysisPayload.productName}`,
+            logoUrl: analysisPayload.brand?.logoUrl || '',
+            name: analysisPayload.productName,
+            pricingModel: analysisPayload.pricingModel,
+            replyTo: '',
+            saasModel: analysisPayload.saasModel,
+            targetUser: analysisPayload.targetUser,
+            type: analysisPayload.businessType,
+            url: productUrl,
+            webhookUrl: '',
+        },
+    };
+}
+export function preserveUserFields(config, existing) {
+    const p = existing.project;
+    if (p.fromEmail)
+        config.project.fromEmail = p.fromEmail;
+    if (p.replyTo)
+        config.project.replyTo = p.replyTo;
+    if (p.fromName)
+        config.project.fromName = p.fromName;
+    if (p.webhookUrl)
+        config.project.webhookUrl = p.webhookUrl;
+    if (p.emailStyle)
+        config.project.emailStyle = p.emailStyle;
+    if (p.domain)
+        config.project.domain = p.domain;
+    if (p.address)
+        config.project.address = p.address;
+    if (p.logoFile)
+        config.project.logoFile = p.logoFile;
+}
+export async function applyMonthlyCap(ctx, yamlConfig) {
+    const monthlyCap = await ctx.getBillingCap();
+    if (monthlyCap !== null && monthlyCap !== undefined) {
+        yamlConfig.project.monthlyCap = monthlyCap;
+        await saveYaml(yamlConfig);
+    }
+}
+export async function saveAllTemplates(recommendedEmails, generatedEmails) {
+    const saves = recommendedEmails.flatMap((rec, index) => {
+        const gen = generatedEmails[index];
+        const result = [];
+        if (gen?.html)
+            result.push(saveTemplate(`${rec.id}.html`, gen.html));
+        if (gen?.plainHtml)
+            result.push(saveTemplate(`${rec.id}_plain.html`, gen.plainHtml));
+        return result;
+    });
+    await Promise.all(saves);
+}

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

@@ -0,0 +1,57 @@
+import type { ApiResponse } from '../../api-client.js';
+import type { AiQuotaFeature } from '../../base-command.js';
+export interface AnalysisResult {
+    brand: {
+        color: string;
+        logoUrl: string;
+    };
+    businessType: string;
+    description: string;
+    events: string[];
+    pricingModel: string;
+    productName: string;
+    recommendedEmails: Array<{
+        condition: null | string;
+        delay: string;
+        goal: string;
+        id: string;
+        isReminder: boolean;
+        priority: string;
+        trigger: string;
+    }>;
+    saasModel: string;
+    targetUser: string;
+}
+export interface GeneratedEmail {
+    ctaText: string;
+    html: string;
+    id: string;
+    plainHtml: string;
+    previewText: string;
+    subject: string;
+}
+export interface GenerateResult {
+    emails: GeneratedEmail[];
+}
+export type InitFlags = {
+    json: boolean;
+    yes: boolean;
+};
+export type InitCtx = {
+    get<T>(path: string, params?: Record<string, string>): Promise<ApiResponse<T>>;
+    getBillingCap(): Promise<number | undefined>;
+    log(msg?: string): void;
+    logToStderr(msg?: string): void;
+    onAiQuotaError(resp: {
+        data?: unknown;
+        error?: string;
+        status: number;
+    }, feature: AiQuotaFeature): void;
+    onApiError(resp: {
+        error?: string;
+        status: number;
+    }): never;
+    post<T>(path: string, body?: unknown): Promise<ApiResponse<T>>;
+    spinner<T>(text: string, json: boolean, work: () => Promise<T>): Promise<T>;
+    syncYaml(): Promise<void>;
+};

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

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

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

@@ -0,0 +1,8 @@
+import type { LoginCtx, ValidateResponse } from './types.js';
+import type { MailmodoConfig } from '../../config.js';
+export declare function logAlreadyLoggedIn(ctx: LoginCtx, existing: MailmodoConfig, opts: {
+    json: boolean;
+}): void;
+export declare function logLoginSuccess(ctx: LoginCtx, data: Pick<ValidateResponse, 'email' | 'paidEmailsRemaining' | 'plan' | 'totalFreeRemaining'>, opts: {
+    json: boolean;
+}): void;

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

@@ -0,0 +1,40 @@
+import chalk from 'chalk';
+export function logAlreadyLoggedIn(ctx, existing, opts) {
+    if (opts.json) {
+        ctx.log(JSON.stringify({
+            email: existing.email ?? null,
+            status: 'already_logged_in',
+            totalFreeRemaining: existing.totalFreeRemaining ?? null,
+        }, null, 2));
+        return;
+    }
+    ctx.log('\n  You are already logged in.\n');
+    const emailDisplay = existing.email?.trim()
+        ? chalk.green(existing.email.trim())
+        : chalk.dim('(unknown)');
+    ctx.log(`  Email: ${emailDisplay}\n`);
+    ctx.log(`  ${chalk.dim('1.')} Run ${chalk.cyan('mailmodo init')} to generate an email sequence.`);
+    ctx.log(`  ${chalk.dim('2.')} Run ${chalk.cyan('mailmodo logout')} to log in with another account.\n`);
+}
+export function logLoginSuccess(ctx, data, opts) {
+    const { email, plan, totalFreeRemaining, paidEmailsRemaining } = data;
+    if (opts.json) {
+        ctx.log(JSON.stringify({
+            email,
+            paidEmailsRemaining,
+            plan,
+            status: 'authenticated',
+            totalFreeRemaining,
+        }, null, 2));
+        return;
+    }
+    ctx.log(`\n  Logged in as ${chalk.green(email)}`);
+    if (plan === 'free') {
+        ctx.log(`  Free tier: ${chalk.cyan(String(totalFreeRemaining))} emails remaining`);
+        ctx.log('  No credit card required.\n');
+    }
+    if (plan === 'paid') {
+        ctx.log(`  Current paid block: ${chalk.cyan(String(paidEmailsRemaining))} emails remaining\n`);
+    }
+    ctx.log(`  Next: Run ${chalk.cyan("'mailmodo init'")} to generate your email sequences.\n`);
+}

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

@@ -0,0 +1,19 @@
+export interface ValidateResponse {
+    createdOn: string;
+    email: string;
+    id: string;
+    isPaidUser: boolean;
+    isVerified: boolean;
+    paidEmailsRemaining: number;
+    plan: string;
+    totalEmailsSent: number;
+    totalFreeRemaining: number;
+}
+export type LoginCtx = {
+    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/login/types.js

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

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

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

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

@@ -0,0 +1,52 @@
+import chalk from 'chalk';
+function statusColor(status) {
+    switch (status) {
+        case 'bounced':
+        case 'complained':
+        case 'failed': {
+            return chalk.red;
+        }
+        case 'clicked':
+        case 'opened':
+        case 'sent': {
+            return chalk.green;
+        }
+        case 'skipped': {
+            return chalk.yellow;
+        }
+        default: {
+            return chalk.white;
+        }
+    }
+}
+function renderEntries(ctx, entries) {
+    for (const entry of entries) {
+        const time = (entry.timestamp || '').padEnd(18);
+        const templateId = (entry.emailId || '').padEnd(24);
+        const colorFn = statusColor(entry.status);
+        const status = colorFn((entry.status || '').padEnd(10));
+        const contact = entry.contact || '';
+        ctx.log(`  ${time}${templateId}${status}${contact}`);
+        if (entry.reason) {
+            const label = entry.status === 'skipped' ? 'condition not met' : 'reason';
+            ctx.log(`  ${' '.repeat(52)}${chalk.dim(`(${label}: ${entry.reason})`)}`);
+        }
+    }
+}
+export function renderLogs(ctx, data) {
+    const { entries, limit, page, total } = data;
+    ctx.log(`\n  ${'Time'.padEnd(18)}${'Email'.padEnd(24)}${'Status'.padEnd(10)}Contact`);
+    ctx.log(`  ${'─'.repeat(68)}`);
+    if (entries?.length) {
+        renderEntries(ctx, entries);
+        const totalPages = Math.ceil(total / limit);
+        ctx.log(`\n  Page ${page} of ${totalPages}  ·  ${total} total entries`);
+        if (page < totalPages) {
+            ctx.log(`  ${chalk.dim(`Next: --page ${page + 1}`)}`);
+        }
+    }
+    else {
+        ctx.log(`  ${chalk.dim('No log entries found.')}`);
+    }
+    ctx.log('');
+}

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

@@ -0,0 +1,23 @@
+import type { ApiResponse } from '../../api-client.js';
+export interface LogEntry {
+    contact: string;
+    emailId: string;
+    reason?: string;
+    status: string;
+    timestamp: string;
+}
+export interface LogsResponse {
+    entries: LogEntry[];
+    limit: number;
+    page: number;
+    total: number;
+}
+export type LogsCtx = {
+    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/logs/types.js

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

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

@@ -0,0 +1,11 @@
+import type { PreviewCtx, PreviewEmail } from './types.js';
+export declare function renderText(ctx: PreviewCtx, email: PreviewEmail, opts: {
+    jsonOutput: boolean;
+    sampleData: Record<string, string>;
+    templateHtml: string;
+}): Promise<void>;
+export declare function sendTestEmail(ctx: PreviewCtx, email: PreviewEmail, html: string, opts: {
+    domain: string | undefined;
+    jsonOutput: boolean;
+    toAddress: string;
+}): Promise<void>;

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

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+import { API_ENDPOINTS } from '../../constants.js';
+import { htmlToText, renderTemplate } from './render.js';
+export async function renderText(ctx, email, opts) {
+    const { jsonOutput, sampleData, templateHtml } = opts;
+    const plainText = htmlToText(renderTemplate(templateHtml, sampleData));
+    if (jsonOutput) {
+        ctx.log(JSON.stringify({
+            body: plainText,
+            id: email.id,
+            previewText: email.previewText,
+            subject: email.subject,
+        }, null, 2));
+        return;
+    }
+    ctx.log(`\n  ${chalk.bold('SUBJECT:')}  ${email.subject}`);
+    if (email.previewText) {
+        ctx.log(`  ${chalk.bold('PREVIEW:')}  ${email.previewText}`);
+    }
+    ctx.log(`\n${plainText}\n`);
+}
+export async function sendTestEmail(ctx, email, html, opts) {
+    const { domain, jsonOutput, toAddress } = opts;
+    const response = await ctx.spinner('  Sending test email...', jsonOutput, () => ctx.post(`${API_ENDPOINTS.PREVIEW}/send`, {
+        domain,
+        html,
+        subject: email.subject,
+        to: toAddress,
+    }));
+    if (!response.ok) {
+        ctx.onApiError(response);
+    }
+    const { note, sentTo, sentVia, status } = response.data;
+    if (jsonOutput) {
+        ctx.log(JSON.stringify({ note, sentTo, sentVia, status }, null, 2));
+        return;
+    }
+    ctx.log(`\n  ${chalk.green('✓')} Test email sent to ${chalk.cyan(sentTo)} via ${chalk.cyan(sentVia)}.`);
+    if (note) {
+        ctx.log(`  ${chalk.dim(note)}`);
+    }
+    ctx.log('');
+}

package/dist/lib/commands/preview/render.d.ts

@@ -0,0 +1,3 @@
+export declare const SAMPLE_DATA: Record<string, string>;
+export declare function renderTemplate(html: string, data: Record<string, string>): string;
+export declare function htmlToText(html: string): string;

package/dist/lib/commands/preview/render.js

@@ -0,0 +1,30 @@
+/* eslint-disable camelcase */
+export const SAMPLE_DATA = Object.freeze({
+    app_url: 'https://yourapp.com',
+    cta_url: 'https://yourapp.com/action',
+    first_name: 'Sarah',
+    product_name: 'YourApp',
+    unsubscribe_url: '#',
+});
+/* eslint-enable camelcase */
+export function renderTemplate(html, data) {
+    return html.replaceAll(/\{\{(\w+)\}\}/g, (match, key) => data[key] || match);
+}
+export function htmlToText(html) {
+    return html
+        .replaceAll(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+        .replaceAll(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+        .replaceAll(/<br\s*\/?>/gi, '\n')
+        .replaceAll(/<\/p>/gi, '\n\n')
+        .replaceAll(/<\/div>/gi, '\n')
+        .replaceAll(/<\/tr>/gi, '\n')
+        .replaceAll(/<\/li>/gi, '\n')
+        .replaceAll(/<[^>]+>/g, '')
+        .replaceAll('&nbsp;', ' ')
+        .replaceAll('&amp;', '&')
+        .replaceAll('&lt;', '<')
+        .replaceAll('&gt;', '>')
+        .replaceAll('&quot;', '"')
+        .replaceAll(/\n{3,}/g, '\n\n')
+        .trim();
+}

package/dist/lib/commands/preview/server.d.ts

@@ -0,0 +1,8 @@
+import type { PreviewCtx, PreviewEmail } from './types.js';
+export declare function findAvailablePort(startPort: number, endPort?: number): Promise<number>;
+export declare function startPreviewServer(ctx: PreviewCtx, email: PreviewEmail, opts: {
+    effectiveStyle: 'branded' | 'plain';
+    jsonOutput: boolean;
+    rendered: string;
+    sampleData: Record<string, string>;
+}): Promise<void>;

package/dist/lib/commands/preview/server.js

@@ -0,0 +1,63 @@
+import { createServer } from 'node:http';
+import chalk from 'chalk';
+import open from 'open';
+import { PREVIEW_PORT } from '../../constants.js';
+import { INFO } from '../../messages.js';
+import { buildWrapperHtml } from './wrapper-html.js';
+export async function findAvailablePort(startPort, endPort = startPort + 10) {
+    if (startPort > endPort) {
+        throw new Error(`No available port found starting from port ${endPort - 10}`);
+    }
+    const available = await new Promise((resolve) => {
+        const probe = createServer();
+        probe.once('error', () => resolve(false));
+        probe.once('listening', () => probe.close(() => resolve(true)));
+        probe.listen(startPort);
+    });
+    return available ? startPort : findAvailablePort(startPort + 1, endPort);
+}
+export async function startPreviewServer(ctx, email, opts) {
+    const { effectiveStyle, jsonOutput, rendered, sampleData } = opts;
+    const wrapperHtml = buildWrapperHtml(email, rendered, sampleData, effectiveStyle);
+    const port = await findAvailablePort(PREVIEW_PORT);
+    if (!jsonOutput && port !== PREVIEW_PORT) {
+        ctx.log(`\n  ${chalk.yellow('!')} Port ${PREVIEW_PORT} is already in use. Opening preview on port ${chalk.cyan(String(port))}.`);
+    }
+    if (jsonOutput) {
+        ctx.log(JSON.stringify({
+            id: email.id,
+            style: effectiveStyle,
+            url: `http://localhost:${port}`,
+        }, null, 2));
+    }
+    const server = createServer((_req, res) => {
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(wrapperHtml);
+    });
+    await new Promise((resolve) => {
+        server.listen(port, () => resolve());
+    });
+    const url = `http://localhost:${port}`;
+    if (!jsonOutput) {
+        ctx.log(`\n  Style: ${chalk.cyan(effectiveStyle)}`);
+        ctx.log(`  Preview server at ${chalk.cyan(url)}`);
+        ctx.log(`  ${INFO.BROWSER_OPENING}\n`);
+        ctx.log(`  ${chalk.dim('Press Ctrl+C to stop the preview server.')}\n`);
+    }
+    try {
+        await open(url);
+    }
+    catch {
+        if (!jsonOutput) {
+            ctx.log(`  ${INFO.BROWSER_OPEN_FAILED}`);
+        }
+    }
+    await new Promise((resolve) => {
+        const shutdown = () => {
+            server.closeAllConnections?.();
+            server.close(() => resolve());
+        };
+        process.once('SIGINT', shutdown);
+        process.once('SIGTERM', shutdown);
+    });
+}

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

@@ -0,0 +1,22 @@
+import type { ApiResponse } from '../../api-client.js';
+import type { MailmodoYaml } from '../../yaml-config.js';
+export type PreviewCtx = {
+    error(msg: string): never;
+    exit(code?: number): never;
+    fetchTemplate(emailId: string): Promise<boolean>;
+    log(msg?: string): void;
+    onApiError(resp: {
+        error?: string;
+        status: number;
+    }): never;
+    post<T>(path: string, body?: unknown): Promise<ApiResponse<T>>;
+    spinner<T>(text: string, json: boolean, work: () => Promise<T>): Promise<T>;
+    syncTemplates(yaml: MailmodoYaml): Promise<void>;
+    syncYaml(): Promise<void>;
+};
+export type PreviewEmail = {
+    id: string;
+    previewText?: string;
+    style?: string;
+    subject: string;
+};

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

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

package/dist/lib/commands/preview/wrapper-html.d.ts

@@ -0,0 +1,2 @@
+import type { PreviewEmail } from './types.js';
+export declare function buildWrapperHtml(email: PreviewEmail, rendered: string, sampleData: Record<string, string>, effectiveStyle: 'branded' | 'plain'): string;

package/dist/lib/commands/preview/wrapper-html.js

@@ -0,0 +1,35 @@
+export function buildWrapperHtml(email, rendered, sampleData, effectiveStyle) {
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Preview: ${email.subject}</title>
+  <style>
+    body { margin: 0; padding: 2rem; background: #f5f5f5; font-family: system-ui; }
+    .preview-bar { background: #1a1a2e; color: #fff; padding: 0.75rem 1.5rem; border-radius: 0.5rem;
+      margin-bottom: 1.5rem; display: flex; justify-content: space-between; align-items: center; }
+    .preview-bar h3 { margin: 0; font-size: 0.875rem; }
+    .preview-bar span { font-size: 0.75rem; opacity: 0.7; }
+    .email-frame { background: #fff; max-width: 40rem; margin: 0 auto; border-radius: 0.5rem;
+      box-shadow: 0 0.125rem 0.5rem rgba(0,0,0,0.1); overflow: hidden; }
+    .email-header { padding: 1rem 1.5rem; border-bottom: 1px solid #eee; }
+    .email-header .subject { font-weight: 600; font-size: 1rem; }
+    .email-header .meta { font-size: 0.75rem; color: #666; margin-top: 0.25rem; }
+    .email-body { padding: 1.5rem; }
+  </style>
+</head>
+<body>
+  <div class="preview-bar">
+    <h3>Mailmodo Preview — ${email.id}</h3>
+    <span>Style: ${effectiveStyle} · Press Ctrl+C in terminal to stop</span>
+  </div>
+  <div class="email-frame">
+    <div class="email-header">
+      <div class="subject">${email.subject}</div>
+      <div class="meta">To: ${sampleData.first_name} · From: ${sampleData.product_name}</div>
+    </div>
+    <div class="email-body">${rendered}</div>
+  </div>
+</body>
+</html>`;
+}