@mailmodo/cli 0.0.55-beta.pr57.93 → 0.0.55

package/dist/commands/init/index.js

@@ -1,10 +1,27 @@
 import { Flags } from '@oclif/core';
+import { confirm, editor, input, select } from '@inquirer/prompts';
+import chalk from 'chalk';
 import { BaseCommand } from '../../lib/base-command.js';
-import { API_ENDPOINTS } from '../../lib/constants.js';
-import { loadYaml, saveYaml } from '../../lib/yaml-config.js';
-import { analyzeProduct, promptProductUrl, } from '../../lib/commands/init/analysis.js';
-import { confirmOverwrite, logInitSuccess, } from '../../lib/commands/init/output.js';
-import { applyMonthlyCap, buildEmailConfigs, buildYamlConfig, preserveUserFields, saveAllTemplates, } from '../../lib/commands/init/payload.js';
+import { API_ENDPOINTS, DEFAULT_BRAND_COLOR } from '../../lib/constants.js';
+import { loadYaml, saveTemplate, saveYaml, } from '../../lib/yaml-config.js';
+import { isValidUrl, normalizeTrigger } from '../../lib/utils.js';
+/**
+ * Prints the human-readable analysis summary using the provided line writer.
+ * Use stderr when `--json` is set so stdout stays free for machine-readable JSON.
+ *
+ * @param analysis - Parsed analyze API payload.
+ * @param logLine - Line writer (typically bound `this.log` or `this.logToStderr`).
+ */
+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 default class Init extends BaseCommand {
     static description = 'Analyze your product and generate email sequences';
     static examples = [
@@ -18,48 +35,189 @@ export default class Init extends BaseCommand {
     async run() {
         const { flags } = await this.parse(Init);
         await this.ensureAuth();
-        const ctx = this.makeCtx();
-        const baseFlags = { json: flags.json, yes: flags.yes };
         const existing = await loadYaml();
-        if (!(await confirmOverwrite(ctx, baseFlags, existing)))
+        if (!(await this.confirmOverwriteIfNeeded(flags, existing)))
             return;
-        const productUrl = await promptProductUrl(flags.url);
-        const analysisPayload = await analyzeProduct(ctx, productUrl, baseFlags);
-        if (!analysisPayload)
-            return;
-        const generateResponse = await ctx.spinner('  Generating email templates...', flags.json, () => ctx.post(API_ENDPOINTS.GENERATE, { ...analysisPayload }));
-        if (!generateResponse.ok)
-            ctx.onApiError(generateResponse);
+        let productUrl = flags.url;
+        if (!productUrl) {
+            productUrl = await 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)';
+                },
+            });
+        }
+        const analysisResponse = await this.withApiSpinner({
+            json: flags.json,
+            text: '  Analyzing your product — scraping homepage, pricing, features',
+        }, () => this.apiClient.post(API_ENDPOINTS.ANALYZE, {
+            url: productUrl,
+        }));
+        if (!analysisResponse.ok) {
+            this.handleAiQuotaError(analysisResponse, 'init');
+            this.handleApiError(analysisResponse);
+        }
+        const analysis = analysisResponse.data;
+        const shouldShowAnalysisSummary = !flags.json || !flags.yes;
+        if (shouldShowAnalysisSummary) {
+            const logSummary = flags.json && !flags.yes
+                ? this.logToStderr.bind(this)
+                : this.log.bind(this);
+            logAnalysisSummary(analysis, logSummary);
+        }
+        let analysisPayload = analysis;
+        if (!flags.yes) {
+            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') {
+                this.log(`\n  Stopped. Run ${chalk.cyan('mailmodo init')} again when you are ready.\n`);
+                return;
+            }
+            if (userAction === 'edit') {
+                const editedAnalysis = 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';
+                        }
+                    },
+                });
+                analysisPayload = JSON.parse(editedAnalysis);
+            }
+        }
+        const generateResponse = await this.withApiSpinner({
+            json: flags.json,
+            text: '  Generating email templates...',
+        }, () => this.apiClient.post(API_ENDPOINTS.GENERATE, {
+            ...analysisPayload,
+        }));
+        if (!generateResponse.ok) {
+            this.handleApiError(generateResponse);
+        }
         const generatedEmails = generateResponse.data?.emails || [];
-        const emailConfigs = buildEmailConfigs(analysisPayload, generatedEmails);
-        const yamlConfig = buildYamlConfig(analysisPayload, emailConfigs, productUrl);
+        const emailConfigs = analysisPayload.recommendedEmails.map((rec, index) => {
+            const generated = generatedEmails[index];
+            return {
+                delay: rec.delay || '0',
+                id: rec.id,
+                trigger: normalizeTrigger(rec.trigger, analysisPayload.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,
+            };
+        });
+        const yamlConfig = {
+            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: '',
+            },
+        };
         if (existing)
-            preserveUserFields(yamlConfig, existing);
+            this.preserveUserFields(yamlConfig, existing);
         await saveYaml(yamlConfig);
-        await applyMonthlyCap(ctx, yamlConfig);
-        await saveAllTemplates(analysisPayload.recommendedEmails, generatedEmails);
-        await ctx.syncYaml();
-        logInitSuccess(ctx, {
-            brand: analysisPayload.brand,
-            emailConfigs,
-            emailStyle: yamlConfig.project.emailStyle,
-            json: flags.json,
+        await this.persistMonthlyCap(yamlConfig);
+        const templateSaves = analysisPayload.recommendedEmails.flatMap((rec, index) => {
+            const generated = generatedEmails[index];
+            const saves = [];
+            if (generated?.html) {
+                saves.push(saveTemplate(`${rec.id}.html`, generated.html));
+            }
+            if (generated?.plainHtml) {
+                saves.push(saveTemplate(`${rec.id}_plain.html`, generated.plainHtml));
+            }
+            return saves;
         });
+        await Promise.all(templateSaves);
+        await this.syncYamlToServer();
+        if (flags.json) {
+            this.log(JSON.stringify({
+                brandDetected: analysisPayload.brand,
+                emails: emailConfigs,
+                emailsCreated: emailConfigs.length,
+                style: yamlConfig.project.emailStyle,
+            }, null, 2));
+            return;
+        }
+        this.log(`  Created ${chalk.green('mailmodo.yaml')} + ${chalk.green(String(emailConfigs.length))} email templates in ${chalk.green('/mailmodo')}\n`);
+        this.log(`  Run ${chalk.cyan("'mailmodo emails'")} to review.\n`);
     }
-    makeCtx() {
-        return {
-            get: (path, params) => this.apiClient.get(path, params),
-            getBillingCap: async () => {
-                const s = await this.fetchBillingStatus();
-                return s?.cap?.inBlocks ?? undefined;
-            },
-            log: (msg) => this.log(msg),
-            logToStderr: (msg) => this.logToStderr(msg ?? ''),
-            onAiQuotaError: (r, feature) => this.handleAiQuotaError(r, feature),
-            onApiError: (r) => this.handleApiError(r),
-            post: (path, body) => this.apiClient.post(path, body),
-            spinner: (text, json, work) => this.withApiSpinner({ json, text }, work),
-            syncYaml: () => this.syncYamlToServer(),
-        };
+    async persistMonthlyCap(yamlConfig) {
+        const billingStatus = await this.fetchBillingStatus();
+        const monthlyCap = billingStatus?.cap?.inBlocks;
+        if (monthlyCap !== null && monthlyCap !== undefined) {
+            yamlConfig.project.monthlyCap = monthlyCap;
+            await saveYaml(yamlConfig);
+        }
+    }
+    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;
+    }
+    async confirmOverwriteIfNeeded(flags, existing) {
+        if (!existing)
+            return true;
+        if (flags.yes)
+            return true;
+        this.log(`\n  ${chalk.yellow('⚠')}  ${chalk.bold('mailmodo.yaml already exists.')}`);
+        this.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) {
+            this.log(`\n  Init cancelled. Run ${chalk.cyan('mailmodo edit')} to modify individual emails.\n`);
+        }
+        return proceed;
     }
 }

package/dist/commands/login/index.d.ts

@@ -7,6 +7,4 @@ export default class Login extends BaseCommand {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    private makeCtx;
-    private promptForApiKey;
 }

package/dist/commands/login/index.js

@@ -6,7 +6,6 @@ import { ApiClient } from '../../lib/api-client.js';
 import { loadConfig, saveConfig } from '../../lib/config.js';
 import { API_ENDPOINTS, LOGIN_URL } from '../../lib/constants.js';
 import { INFO } from '../../lib/messages.js';
-import { logAlreadyLoggedIn, logLoginSuccess, } from '../../lib/commands/login/output.js';
 export default class Login extends BaseCommand {
     static description = 'Authenticate with Mailmodo using your API key';
     static examples = process.platform === 'win32'
@@ -19,55 +18,100 @@ export default class Login extends BaseCommand {
             '<%= config.bin %> login',
             'MAILMODO_API_KEY=YOUR_API_KEY <%= config.bin %> login',
         ];
-    static flags = { ...BaseCommand.baseFlags };
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
     async run() {
         const { flags } = await this.parse(Login);
-        const ctx = this.makeCtx();
         const envKey = process.env.MAILMODO_API_KEY;
         if (!envKey) {
             const existing = await loadConfig();
             if (existing?.apiKey) {
                 const existingClient = new ApiClient(existing.apiKey);
                 const yamlRestored = await this.recoverYamlAfterLogin(existingClient);
-                logAlreadyLoggedIn(ctx, existing, yamlRestored, { json: flags.json });
+                if (flags.json) {
+                    this.log(JSON.stringify({
+                        email: existing.email ?? null,
+                        status: 'already_logged_in',
+                        totalFreeRemaining: existing.totalFreeRemaining ?? null,
+                        yamlRestored,
+                    }, null, 2));
+                    return;
+                }
+                this.log('\n  You are already logged in.\n');
+                const emailDisplay = existing.email?.trim()
+                    ? chalk.green(existing.email.trim())
+                    : chalk.dim('(unknown)');
+                this.log(`  Email: ${emailDisplay}\n`);
+                if (yamlRestored) {
+                    this.log(`  ${INFO.YAML_RESTORED_ON_LOGIN}`);
+                }
+                else {
+                    this.log(`  ${chalk.dim('1.')} Run ${chalk.cyan('mailmodo init')} to generate an email sequence.`);
+                }
+                this.log(`  ${chalk.dim(yamlRestored ? '1.' : '2.')} Run ${chalk.cyan('mailmodo logout')} to log in with another account.\n`);
                 return;
             }
         }
-        const apiKey = envKey ?? (await this.promptForApiKey());
+        let apiKey = envKey;
+        if (apiKey) {
+            this.log('Detected MAILMODO_API_KEY from environment.');
+        }
+        else {
+            this.log(`\n  Get your free API key at: ${chalk.cyan(LOGIN_URL)}\n`);
+            try {
+                await open(LOGIN_URL);
+                this.log(`  ${INFO.BROWSER_OPENING}\n`);
+            }
+            catch {
+                this.log(`  ${INFO.BROWSER_OPEN_FAILED}\n`);
+            }
+            apiKey = await input({
+                message: 'Paste your API key:',
+                validate(value) {
+                    if (!value?.trim())
+                        return 'API key is required';
+                    return true;
+                },
+            });
+        }
         const trimmedKey = apiKey.trim();
         const client = new ApiClient(trimmedKey);
-        const response = await ctx.spinner('  Validating API key...', flags.json, () => client.get(API_ENDPOINTS.AUTH_VALIDATE));
+        const response = await this.withApiSpinner({ json: flags.json, text: '  Validating API key...' }, () => client.get(API_ENDPOINTS.AUTH_VALIDATE));
         if (!response.ok) {
-            ctx.onApiError(response);
+            this.handleApiError(response);
         }
         const { email, totalFreeRemaining, paidEmailsRemaining, plan } = response.data;
-        await saveConfig({ apiKey: trimmedKey, email, totalFreeRemaining });
+        await saveConfig({
+            apiKey: trimmedKey,
+            email,
+            totalFreeRemaining,
+        });
         const yamlRestored = await this.recoverYamlAfterLogin(client);
-        logLoginSuccess(ctx, { email, paidEmailsRemaining, plan, totalFreeRemaining }, yamlRestored, { json: flags.json });
-    }
-    makeCtx() {
-        return {
-            log: (msg) => this.log(msg),
-            onApiError: (r) => this.handleApiError(r),
-            spinner: (text, json, work) => this.withApiSpinner({ json, text }, work),
-        };
-    }
-    async promptForApiKey() {
-        this.log(`\n  Get your free API key at: ${chalk.cyan(LOGIN_URL)}\n`);
-        try {
-            await open(LOGIN_URL);
-            this.log(`  ${INFO.BROWSER_OPENING}\n`);
+        if (flags.json) {
+            this.log(JSON.stringify({
+                email,
+                plan,
+                totalFreeRemaining,
+                paidEmailsRemaining,
+                status: 'authenticated',
+                yamlRestored,
+            }, null, 2));
+            return;
         }
-        catch {
-            this.log(`  ${INFO.BROWSER_OPEN_FAILED}\n`);
+        this.log(`\n  Logged in as ${chalk.green(email)}`);
+        if (plan === 'free') {
+            this.log(`  Free tier: ${chalk.cyan(String(totalFreeRemaining))} emails remaining`);
+            this.log('  No credit card required.\n');
+        }
+        if (plan === 'paid') {
+            this.log(`  Current paid block: ${chalk.cyan(String(paidEmailsRemaining))} emails remaining\n`);
+        }
+        if (yamlRestored) {
+            this.log(`  ${INFO.YAML_RESTORED_ON_LOGIN}\n`);
+        }
+        else {
+            this.log(`  Next: Run ${chalk.cyan("'mailmodo init'")} to generate your email sequences.\n`);
         }
-        return input({
-            message: 'Paste your API key:',
-            validate(value) {
-                if (!value?.trim())
-                    return 'API key is required';
-                return true;
-            },
-        });
     }
 }

package/dist/commands/logs/index.d.ts

@@ -11,5 +11,12 @@ export default class Logs extends BaseCommand {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    private makeCtx;
+    /**
+     * Returns the appropriate chalk color function based on the delivery status.
+     * Green for sent/opened/clicked, red for bounced/failed, yellow for skipped.
+     *
+     * @param {string} status - The delivery event status string.
+     * @returns {Function} A chalk color function to wrap the status display text.
+     */
+    private statusColor;
 }

package/dist/commands/logs/index.js

@@ -1,7 +1,7 @@
 import { Flags } from '@oclif/core';
+import chalk from 'chalk';
 import { BaseCommand } from '../../lib/base-command.js';
 import { API_ENDPOINTS } from '../../lib/constants.js';
-import { renderLogs } from '../../lib/commands/logs/output.js';
 export default class Logs extends BaseCommand {
     static description = 'View email send logs and delivery events';
     static examples = [
@@ -29,7 +29,6 @@ export default class Logs extends BaseCommand {
     async run() {
         const { flags } = await this.parse(Logs);
         await this.ensureAuth();
-        const ctx = this.makeCtx();
         const params = {
             limit: String(flags.limit),
             page: String(flags.page),
@@ -38,22 +37,66 @@ export default class Logs extends BaseCommand {
             params.email = flags.email;
         if (flags.failed)
             params.failed = 'true';
-        const response = await ctx.spinner('  Loading email logs...', flags.json, () => ctx.get(API_ENDPOINTS.LOGS, params));
+        const response = await this.withApiSpinner({ json: flags.json, text: '  Loading email logs...' }, () => this.apiClient.get(API_ENDPOINTS.LOGS, params));
         if (!response.ok) {
-            ctx.onApiError(response);
+            this.handleApiError(response);
         }
+        const { entries, limit, page, total } = response.data;
         if (flags.json) {
             this.log(JSON.stringify(response.data, null, 2));
             return;
         }
-        renderLogs(ctx, response.data);
+        this.log(`\n  ${'Time'.padEnd(18)}${'Email'.padEnd(24)}${'Status'.padEnd(10)}Contact`);
+        this.log(`  ${'─'.repeat(68)}`);
+        if (entries?.length) {
+            for (const entry of entries) {
+                const time = (entry.timestamp || '').padEnd(18);
+                const templateId = (entry.emailId || '').padEnd(24);
+                const statusColor = this.statusColor(entry.status);
+                const status = statusColor((entry.status || '').padEnd(10));
+                const contact = entry.contact || '';
+                this.log(`  ${time}${templateId}${status}${contact}`);
+                if (entry.reason) {
+                    const label = entry.status === 'skipped' ? 'condition not met' : 'reason';
+                    this.log(`  ${' '.repeat(52)}${chalk.dim(`(${label}: ${entry.reason})`)}`);
+                }
+            }
+            const totalPages = Math.ceil(total / limit);
+            this.log(`\n  Page ${page} of ${totalPages}  ·  ${total} total entries`);
+            if (page < totalPages) {
+                this.log(`  ${chalk.dim(`Next: --page ${page + 1}`)}`);
+            }
+        }
+        else {
+            this.log(`  ${chalk.dim('No log entries found.')}`);
+        }
+        this.log('');
     }
-    makeCtx() {
-        return {
-            get: (path, params) => this.apiClient.get(path, params),
-            log: (msg) => this.log(msg),
-            onApiError: (r) => this.handleApiError(r),
-            spinner: (text, json, work) => this.withApiSpinner({ json, text }, work),
-        };
+    /**
+     * Returns the appropriate chalk color function based on the delivery status.
+     * Green for sent/opened/clicked, red for bounced/failed, yellow for skipped.
+     *
+     * @param {string} status - The delivery event status string.
+     * @returns {Function} A chalk color function to wrap the status display text.
+     */
+    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;
+            }
+        }
     }
 }

package/dist/commands/preview/index.d.ts

@@ -12,5 +12,23 @@ export default class Preview extends BaseCommand {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    private makeCtx;
+    /**
+     * Renders a plain text version of the email to stdout. Used by AI agents
+     * and CI pipelines that cannot open a browser.
+     */
+    private renderText;
+    /**
+     * Calls the API to send a test email to the specified address.
+     * Before domain verification, tests send via the mailmodo.com domain.
+     */
+    private sendTestEmail;
+    /**
+     * Probes ports starting at startPort and returns the first one not in use.
+     */
+    private findAvailablePort;
+    /**
+     * Starts a local HTTP server to serve the rendered email template,
+     * then opens the user's default browser to view it.
+     */
+    private startPreviewServer;
 }