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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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;