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

package/dist/commands/init/index.js

@@ -1,27 +1,10 @@
 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, 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('');
-}
+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';
 export default class Init extends BaseCommand {
     static description = 'Analyze your product and generate email sequences';
     static examples = [
@@ -35,189 +18,54 @@ export default class Init extends BaseCommand {
     async run() {
         const { flags } = await this.parse(Init);
         await this.ensureAuth();
-        const existing = await loadYaml();
-        if (!(await this.confirmOverwriteIfNeeded(flags, existing)))
-            return;
-        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`);
+        const ctx = this.makeCtx();
+        const baseFlags = { json: flags.json, yes: flags.yes };
+        if (this.isBlankDirectory()) {
+            const restored = await this.promptInitServerRestore(baseFlags);
+            if (restored)
                 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 existing = await loadYaml();
+        if (!(await confirmOverwrite(ctx, baseFlags, 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);
         const generatedEmails = generateResponse.data?.emails || [];
-        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: '',
-            },
-        };
+        const emailConfigs = buildEmailConfigs(analysisPayload, generatedEmails);
+        const yamlConfig = buildYamlConfig(analysisPayload, emailConfigs, productUrl);
         if (existing)
-            this.preserveUserFields(yamlConfig, existing);
+            preserveUserFields(yamlConfig, existing);
         await saveYaml(yamlConfig);
-        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 applyMonthlyCap(ctx, yamlConfig);
+        await saveAllTemplates(analysisPayload.recommendedEmails, generatedEmails);
+        await ctx.syncYaml();
+        await this.syncTemplatesToServer(yamlConfig);
+        logInitSuccess(ctx, {
+            brand: analysisPayload.brand,
+            emailConfigs,
+            emailStyle: yamlConfig.project.emailStyle,
+            json: flags.json,
         });
-        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`);
     }
-    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;
+    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(),
+        };
     }
 }

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

@@ -7,4 +7,6 @@ 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,6 +6,7 @@ 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'
@@ -18,100 +19,52 @@ 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);
-                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`);
+                logAlreadyLoggedIn(ctx, existing, { json: flags.json });
                 return;
             }
         }
-        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 apiKey = envKey ?? (await this.promptForApiKey());
         const trimmedKey = apiKey.trim();
         const client = new ApiClient(trimmedKey);
-        const response = await this.withApiSpinner({ json: flags.json, text: '  Validating API key...' }, () => client.get(API_ENDPOINTS.AUTH_VALIDATE));
+        const response = await ctx.spinner('  Validating API key...', flags.json, () => client.get(API_ENDPOINTS.AUTH_VALIDATE));
         if (!response.ok) {
-            this.handleApiError(response);
+            ctx.onApiError(response);
         }
         const { email, totalFreeRemaining, paidEmailsRemaining, plan } = response.data;
-        await saveConfig({
-            apiKey: trimmedKey,
-            email,
-            totalFreeRemaining,
-        });
-        const yamlRestored = await this.recoverYamlAfterLogin(client);
-        if (flags.json) {
-            this.log(JSON.stringify({
-                email,
-                plan,
-                totalFreeRemaining,
-                paidEmailsRemaining,
-                status: 'authenticated',
-                yamlRestored,
-            }, null, 2));
-            return;
-        }
-        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`);
+        await saveConfig({ apiKey: trimmedKey, email, totalFreeRemaining });
+        logLoginSuccess(ctx, { email, paidEmailsRemaining, plan, totalFreeRemaining }, { 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`);
         }
-        else {
-            this.log(`  Next: Run ${chalk.cyan("'mailmodo init'")} to generate your email sequences.\n`);
+        catch {
+            this.log(`  ${INFO.BROWSER_OPEN_FAILED}\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,12 +11,5 @@ export default class Logs extends BaseCommand {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    /**
-     * 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;
+    private makeCtx;
 }

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,6 +29,7 @@ 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),
@@ -37,66 +38,22 @@ export default class Logs extends BaseCommand {
             params.email = flags.email;
         if (flags.failed)
             params.failed = 'true';
-        const response = await this.withApiSpinner({ json: flags.json, text: '  Loading email logs...' }, () => this.apiClient.get(API_ENDPOINTS.LOGS, params));
+        const response = await ctx.spinner('  Loading email logs...', flags.json, () => ctx.get(API_ENDPOINTS.LOGS, params));
         if (!response.ok) {
-            this.handleApiError(response);
+            ctx.onApiError(response);
         }
-        const { entries, limit, page, total } = response.data;
         if (flags.json) {
             this.log(JSON.stringify(response.data, null, 2));
             return;
         }
-        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('');
+        renderLogs(ctx, response.data);
     }
-    /**
-     * 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;
-            }
-        }
+    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),
+        };
     }
 }

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

@@ -12,23 +12,5 @@ export default class Preview extends BaseCommand {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    /**
-     * 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;
+    private makeCtx;
 }