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

package/dist/commands/preview/index.js

@@ -1,10 +1,57 @@
 import { Args, Flags } from '@oclif/core';
+import { createServer } from 'node:http';
+import chalk from 'chalk';
+import open from 'open';
 import { BaseCommand } from '../../lib/base-command.js';
-import { handleMissingTemplates } from '../../lib/templates/missing-templates.js';
+import { API_ENDPOINTS, PREVIEW_PORT } from '../../lib/constants.js';
+import { INFO } from '../../lib/messages.js';
 import { loadTemplate, getEmailStyle, getTemplateFilename, } from '../../lib/yaml-config.js';
-import { renderText, sendTestEmail, } from '../../lib/commands/preview/actions.js';
-import { SAMPLE_DATA, renderTemplate, } from '../../lib/commands/preview/render.js';
-import { startPreviewServer } from '../../lib/commands/preview/server.js';
+import { handleMissingTemplates } from '../../lib/templates/missing-templates.js';
+/* eslint-disable camelcase */
+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 */
+/**
+ * Replaces all {{variable}} template placeholders in the HTML string
+ * with corresponding values from the sample data map.
+ *
+ * @param {string} html - Raw HTML template with {{variable}} placeholders.
+ * @param {Record<string, string>} data - Key-value map of template variable replacements.
+ * @returns {string} HTML with all recognized placeholders replaced.
+ */
+function renderTemplate(html, data) {
+    return html.replaceAll(/\{\{(\w+)\}\}/g, (match, key) => data[key] || match);
+}
+/**
+ * Strips HTML tags and decodes common HTML entities to produce
+ * a readable plain text representation of an email.
+ *
+ * @param {string} html - The HTML content to convert.
+ * @returns {string} Plain text with tags removed and entities decoded.
+ */
+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();
+}
 export default class Preview extends BaseCommand {
     static args = {
         id: Args.string({ description: 'Email template ID to preview' }),
@@ -34,29 +81,34 @@ export default class Preview extends BaseCommand {
         if (!email) {
             this.error(`Template '${templateId}' not found in mailmodo.yaml.`);
         }
-        /* eslint-disable camelcase */
         const sampleData = {
             ...SAMPLE_DATA,
-            app_url: yamlConfig.project?.url || 'https://yourapp.com',
-            product_name: yamlConfig.project?.name || 'YourApp',
+            app_url: yamlConfig.project?.url || 'https://yourapp.com', // eslint-disable-line camelcase
+            product_name: yamlConfig.project?.name || 'YourApp', // eslint-disable-line camelcase
         };
-        /* eslint-enable camelcase */
         const effectiveStyle = getEmailStyle(email.style, yamlConfig.project?.emailStyle);
         const templateFilename = getTemplateFilename(email.id, email.style, yamlConfig.project?.emailStyle);
         let templateHtml = await loadTemplate(templateFilename);
         if (!templateHtml) {
             await this.ensureAuth();
-            const regenerated = await handleMissingTemplates(this.makeCtx(), yamlConfig, [email.id], { json: flags.json, yes: flags.yes });
+            const regenCtx = {
+                error: (msg) => this.error(msg),
+                exit: (code) => this.exit(code),
+                log: (msg) => this.log(msg),
+                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(),
+            };
+            const regenerated = await handleMissingTemplates(regenCtx, yamlConfig, [email.id], { json: flags.json, yes: flags.yes });
             if (!regenerated)
                 return;
             templateHtml = await loadTemplate(templateFilename);
             if (!templateHtml)
                 this.error('Template regeneration failed.');
         }
-        const ctx = this.makeCtx();
         if (flags.send) {
-            await this.ensureAuth();
-            await sendTestEmail(ctx, email, renderTemplate(templateHtml, sampleData), {
+            await this.sendTestEmail(email, renderTemplate(templateHtml, sampleData), {
                 domain: yamlConfig.project?.domain,
                 jsonOutput: flags.json,
                 toAddress: flags.send,
@@ -64,29 +116,159 @@ export default class Preview extends BaseCommand {
             return;
         }
         if (flags.text) {
-            await renderText(ctx, email, {
-                jsonOutput: flags.json,
-                sampleData,
-                templateHtml,
-            });
+            await this.renderText(email, templateHtml, sampleData, flags.json);
             return;
         }
-        await startPreviewServer(ctx, email, {
+        await this.startPreviewServer(email, templateHtml, sampleData, {
             effectiveStyle,
             jsonOutput: flags.json,
-            rendered: renderTemplate(templateHtml, sampleData),
-            sampleData,
         });
     }
-    makeCtx() {
-        return {
-            error: (msg) => this.error(msg),
-            exit: (code) => this.exit(code),
-            log: (msg) => this.log(msg),
-            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(),
-        };
+    /**
+     * Renders a plain text version of the email to stdout. Used by AI agents
+     * and CI pipelines that cannot open a browser.
+     */
+    async renderText(email, templateHtml, sampleData, jsonOutput) {
+        const plainText = htmlToText(renderTemplate(templateHtml, sampleData));
+        if (jsonOutput) {
+            this.log(JSON.stringify({
+                body: plainText,
+                id: email.id,
+                previewText: email.previewText,
+                subject: email.subject,
+            }, null, 2));
+            return;
+        }
+        this.log(`\n  ${chalk.bold('SUBJECT:')}  ${email.subject}`);
+        if (email.previewText) {
+            this.log(`  ${chalk.bold('PREVIEW:')}  ${email.previewText}`);
+        }
+        this.log(`\n${plainText}\n`);
+    }
+    /**
+     * Calls the API to send a test email to the specified address.
+     * Before domain verification, tests send via the mailmodo.com domain.
+     */
+    async sendTestEmail(email, html, opts) {
+        const { domain, jsonOutput, toAddress } = opts;
+        await this.ensureAuth();
+        const response = await this.withApiSpinner({ json: jsonOutput, text: '  Sending test email...' }, () => this.apiClient.post(`${API_ENDPOINTS.PREVIEW}/send`, {
+            domain,
+            html,
+            subject: email.subject,
+            to: toAddress,
+        }));
+        if (!response.ok) {
+            this.handleApiError(response);
+        }
+        const { note, sentTo, sentVia, status } = response.data;
+        if (jsonOutput) {
+            this.log(JSON.stringify({ note, sentTo, sentVia, status }, null, 2));
+            return;
+        }
+        this.log(`\n  ${chalk.green('✓')} Test email sent to ${chalk.cyan(sentTo)} via ${chalk.cyan(sentVia)}.`);
+        if (note) {
+            this.log(`  ${chalk.dim(note)}`);
+        }
+        this.log('');
+    }
+    /**
+     * Probes ports starting at startPort and returns the first one not in use.
+     */
+    async 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
+            : this.findAvailablePort(startPort + 1, endPort);
+    }
+    /**
+     * Starts a local HTTP server to serve the rendered email template,
+     * then opens the user's default browser to view it.
+     */
+    async startPreviewServer(email, templateHtml, sampleData, opts) {
+        const { effectiveStyle, jsonOutput } = opts;
+        const rendered = renderTemplate(templateHtml, sampleData);
+        const wrapperHtml = `<!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>`;
+        const port = await this.findAvailablePort(PREVIEW_PORT);
+        if (!jsonOutput && port !== PREVIEW_PORT) {
+            this.log(`\n  ${chalk.yellow('!')} Port ${PREVIEW_PORT} is already in use. Opening preview on port ${chalk.cyan(String(port))}.`);
+        }
+        if (jsonOutput) {
+            this.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) {
+            this.log(`\n  Style: ${chalk.cyan(effectiveStyle)}`);
+            this.log(`  Preview server at ${chalk.cyan(url)}`);
+            this.log(`  ${INFO.BROWSER_OPENING}\n`);
+            this.log(`  ${chalk.dim('Press Ctrl+C to stop the preview server.')}\n`);
+        }
+        try {
+            await open(url);
+        }
+        catch {
+            if (!jsonOutput) {
+                this.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/commands/sdk/index.d.ts

@@ -8,5 +8,7 @@ export default class Sdk extends BaseCommand {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    private makeCtx;
+    private renderSnippets;
+    private renderSequenceBlock;
+    private renderCallBlock;
 }

package/dist/commands/sdk/index.js

@@ -1,7 +1,8 @@
 import { Flags } from '@oclif/core';
+import chalk from 'chalk';
 import { BaseCommand } from '../../lib/base-command.js';
-import { API_ENDPOINTS } from '../../lib/constants.js';
-import { renderSdkSnippets } from '../../lib/commands/sdk/output.js';
+import { API_ENDPOINTS, SDK_IMPORT_SNIPPET, SDK_INSTALL_COMMAND, } from '../../lib/constants.js';
+import { SEPARATOR } from '../../lib/messages.js';
 export default class Sdk extends BaseCommand {
     static description = 'Show the SDK track() / identify() reference for deployed sequences';
     static examples = [
@@ -18,25 +19,56 @@ export default class Sdk extends BaseCommand {
     async run() {
         const { flags } = await this.parse(Sdk);
         await this.ensureAuth();
-        const ctx = this.makeCtx();
         const params = flags['sequence-id']
             ? { sequenceId: flags['sequence-id'] }
             : undefined;
-        const response = await ctx.spinner('  Loading SDK reference...', flags.json, () => ctx.get(API_ENDPOINTS.SEQUENCES_SDK, params));
-        if (!response.ok)
-            ctx.onApiError(response);
+        const response = await this.withApiSpinner({ json: flags.json, text: '  Loading SDK reference...' }, () => this.apiClient.get(API_ENDPOINTS.SEQUENCES_SDK, params));
+        if (!response.ok) {
+            this.handleApiError(response);
+        }
         if (flags.json) {
             this.log(JSON.stringify(response.data, null, 2));
             return;
         }
-        renderSdkSnippets(ctx, response.data);
+        this.renderSnippets(response.data);
+    }
+    renderSnippets(data) {
+        const snippets = data.sdkSnippets ?? [];
+        if (snippets.length === 0) {
+            this.log(`\n  ${chalk.dim('No active deployed sequences.')}`);
+            this.log(`  Run ${chalk.cyan('mailmodo deploy')} to deploy one.\n`);
+            return;
+        }
+        this.log(`\n  ${chalk.bold(String(snippets.length))} active ${snippets.length === 1 ? 'sequence' : 'sequences'}:\n`);
+        this.log(`  ${SEPARATOR}`);
+        this.log(`  ${chalk.bold('SDK EVENT REFERENCE')}`);
+        this.log(`  ${SEPARATOR}\n`);
+        this.log(`  ${chalk.cyan(SDK_INSTALL_COMMAND)}\n`);
+        this.log(`  ${chalk.dim(SDK_IMPORT_SNIPPET)}\n`);
+        for (const [index, snippet] of snippets.entries()) {
+            this.renderSequenceBlock(snippet);
+            if (index < snippets.length - 1)
+                this.log('');
+        }
+        this.log(`  ${SEPARATOR}\n`);
     }
-    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),
-        };
+    renderSequenceBlock(snippet) {
+        const productName = snippet.productName || 'Unnamed sequence';
+        this.log(`  ${chalk.bold(productName)} ${chalk.dim(`(${snippet.sequenceId})`)}`);
+        const trackCalls = [...new Set(snippet.sdkSnippet?.trackCalls ?? [])];
+        const identifyCalls = [...new Set(snippet.sdkSnippet?.identifyCalls ?? [])];
+        this.renderCallBlock('// track() calls', trackCalls);
+        this.renderCallBlock('// identify() calls', identifyCalls);
+        if (trackCalls.length === 0 && identifyCalls.length === 0) {
+            this.log(`  ${chalk.dim('No track() or identify() calls available.')}`);
+        }
+    }
+    renderCallBlock(label, calls) {
+        if (calls.length === 0)
+            return;
+        this.log(`  ${chalk.dim(label)}`);
+        for (const call of calls) {
+            this.log(`  ${chalk.dim(call)}`);
+        }
     }
 }

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

@@ -8,5 +8,26 @@ export default class Settings extends BaseCommand {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    private makeCtx;
+    private applySetFlag;
+    private applyMonthlyCapChange;
+    private displaySettingsGroup;
+    /**
+     * Prompts the user to pick a setting key to edit and dispatches
+     * to the appropriate handler for that key.
+     */
+    private promptEditSetting;
+    /**
+     * Fetches the domain verification status from the API.
+     * Returns true/false for verified/unverified, or null if unavailable.
+     */
+    private fetchDomainVerified;
+    private handleDomainChange;
+    /**
+     * Handles the logo file upload flow: validates the local file exists,
+     * reads it, uploads to Mailmodo CDN via API, and updates both logoFile
+     * and logoUrl in the project config.
+     *
+     * @param {import('../../lib/yaml-config.js').MailmodoYaml} yamlConfig - The full YAML config to update and save.
+     */
+    private handleLogoUpload;
 }