@mailmodo/cli 0.0.30 → 0.0.31-beta.pr33.55

package/dist/commands/emails/index.js

@@ -1,5 +1,8 @@
-import { input } from '@inquirer/prompts';
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import { confirm, input } from '@inquirer/prompts';
 import chalk from 'chalk';
+import open from 'open';
 import { BaseCommand } from '../../lib/base-command.js';
 export default class Emails extends BaseCommand {
     static description = 'List and view configured email sequences';
@@ -61,7 +64,53 @@ export default class Emails extends BaseCommand {
                     this.log(`  ${chalk.bold('Goal:')}     ${email.goal}`);
                 }
                 this.log('');
+                const openIt = await confirm({
+                    default: true,
+                    message: 'Open template in editor?',
+                });
+                if (openIt) {
+                    await this.openTemplateInEditor(email.template);
+                }
             }
         }
     }
+    async openTemplateInEditor(template) {
+        const templatePath = join(process.cwd(), template);
+        this.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', () => resolve(true));
+            });
+            if (launched)
+                return;
+        }
+        if (await this.trySpawnEditor('code', templatePath))
+            return;
+        try {
+            await open(templatePath);
+        }
+        catch {
+            this.log(`  ${chalk.dim(`Could not open editor. Open the file manually: ${templatePath}`)}`);
+        }
+    }
+    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);
+            });
+        });
+    }
 }

package/dist/commands/init/index.js

@@ -139,7 +139,7 @@ export default class Init extends BaseCommand {
             project: {
                 brandColor: analysisPayload.brand?.color || DEFAULT_BRAND_COLOR,
                 description: analysisPayload.description,
-                emailStyle: 'branded',
+                emailStyle: 'plain',
                 fromEmail: '',
                 fromName: `Team ${analysisPayload.productName}`,
                 logoUrl: analysisPayload.brand?.logoUrl || '',

package/dist/commands/login/index.js

@@ -5,6 +5,7 @@ import { BaseCommand } from '../../lib/base-command.js';
 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';
 export default class Login extends BaseCommand {
     static description = 'Authenticate with Mailmodo using your API key';
     static examples = [
@@ -47,10 +48,10 @@ export default class Login extends BaseCommand {
             this.log(`\n  Get your free API key at: ${chalk.cyan(LOGIN_URL)}\n`);
             try {
                 await open(LOGIN_URL);
-                this.log('  Opening in browser...\n');
+                this.log(`  ${INFO.BROWSER_OPENING}\n`);
             }
             catch {
-                this.log(`  ${chalk.dim('Could not open browser. Visit the URL above manually.')}\n`);
+                this.log(`  ${INFO.BROWSER_OPEN_FAILED}\n`);
             }
             apiKey = await input({
                 message: 'Paste your API key:',

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

@@ -23,8 +23,12 @@ export default class Preview extends BaseCommand {
      */
     private sendTestEmail;
     /**
-     * Starts a local HTTP server on PREVIEW_PORT to serve the rendered email
-     * template, then opens the user's default browser to view it.
+     * 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;
 }

package/dist/commands/preview/index.js

@@ -4,7 +4,8 @@ import chalk from 'chalk';
 import open from 'open';
 import { BaseCommand } from '../../lib/base-command.js';
 import { API_ENDPOINTS, PREVIEW_PORT } from '../../lib/constants.js';
-import { loadTemplate } from '../../lib/yaml-config.js';
+import { INFO } from '../../lib/messages.js';
+import { loadTemplate, getEmailStyle, getTemplateFilename, } from '../../lib/yaml-config.js';
 /* eslint-disable camelcase */
 const SAMPLE_DATA = Object.freeze({
     app_url: 'https://yourapp.com',
@@ -84,7 +85,8 @@ export default class Preview extends BaseCommand {
             app_url: yamlConfig.project?.url || 'https://yourapp.com', // eslint-disable-line camelcase
             product_name: yamlConfig.project?.name || 'YourApp', // eslint-disable-line camelcase
         };
-        const templateHtml = await loadTemplate(`${email.id}.html`);
+        const effectiveStyle = getEmailStyle(email.style, yamlConfig.project?.emailStyle);
+        const templateHtml = await loadTemplate(getTemplateFilename(email.id, email.style, yamlConfig.project?.emailStyle));
         if (flags.send) {
             const rendered = templateHtml
                 ? renderTemplate(templateHtml, sampleData)
@@ -100,7 +102,10 @@ export default class Preview extends BaseCommand {
             await this.renderText(email, templateHtml, sampleData, flags.json);
             return;
         }
-        await this.startPreviewServer(email, templateHtml, sampleData, flags.json);
+        await this.startPreviewServer(email, templateHtml, sampleData, {
+            effectiveStyle,
+            jsonOutput: flags.json,
+        });
     }
     /**
      * Renders a plain text version of the email to stdout. Used by AI agents
@@ -154,10 +159,28 @@ export default class Preview extends BaseCommand {
         this.log('');
     }
     /**
-     * Starts a local HTTP server on PREVIEW_PORT to serve the rendered email
-     * template, then opens the user's default browser to view it.
+     * Probes ports starting at startPort and returns the first one not in use.
      */
-    async startPreviewServer(email, templateHtml, sampleData, jsonOutput) {
+    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 = templateHtml
             ? renderTemplate(templateHtml, sampleData)
             : '<p>No template found.</p>';
@@ -183,7 +206,7 @@ export default class Preview extends BaseCommand {
 <body>
   <div class="preview-bar">
     <h3>Mailmodo Preview — ${email.id}</h3>
-    <span>Style: ${email.style || 'branded'} · Press Ctrl+C in terminal to stop</span>
+    <span>Style: ${effectiveStyle} · Press Ctrl+C in terminal to stop</span>
   </div>
   <div class="email-frame">
     <div class="email-header">
@@ -194,11 +217,15 @@ export default class Preview extends BaseCommand {
   </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: email.style || 'branded',
-                url: `http://localhost:${PREVIEW_PORT}`,
+                style: effectiveStyle,
+                url: `http://localhost:${port}`,
             }, null, 2));
         }
         const server = createServer((_req, res) => {
@@ -206,13 +233,13 @@ export default class Preview extends BaseCommand {
             res.end(wrapperHtml);
         });
         await new Promise((resolve) => {
-            server.listen(PREVIEW_PORT, () => resolve());
+            server.listen(port, () => resolve());
         });
-        const url = `http://localhost:${PREVIEW_PORT}`;
+        const url = `http://localhost:${port}`;
         if (!jsonOutput) {
-            this.log(`\n  Style: ${chalk.cyan(email.style || 'branded')}`);
+            this.log(`\n  Style: ${chalk.cyan(effectiveStyle)}`);
             this.log(`  Preview server at ${chalk.cyan(url)}`);
-            this.log(`  Opening in browser...\n`);
+            this.log(`  ${INFO.BROWSER_OPENING}\n`);
             this.log(`  ${chalk.dim('Press Ctrl+C to stop the preview server.')}\n`);
         }
         try {
@@ -220,7 +247,7 @@ export default class Preview extends BaseCommand {
         }
         catch {
             if (!jsonOutput) {
-                this.log(`  ${chalk.dim('Could not open browser. Visit the URL above manually.')}`);
+                this.log(`  ${INFO.BROWSER_OPEN_FAILED}`);
             }
         }
         await new Promise((resolve) => {

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

@@ -20,14 +20,7 @@ export default class Settings extends BaseCommand {
      * Returns true/false for verified/unverified, or null if unavailable.
      */
     private fetchDomainVerified;
-    /**
-     * Handles domain change: collects the new domain, sender email, and
-     * business address, calls the API to register them, displays the required
-     * DNS records, and saves the updated config. Emails won't send until the
-     * domain is re-verified.
-     */
     private handleDomainChange;
-    private recordLabel;
     /**
      * Handles the logo file upload flow: validates the local file exists,
      * reads it, uploads to Mailmodo CDN via API, and updates both logoFile

package/dist/commands/settings/index.js

@@ -6,6 +6,7 @@ import { readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { BaseCommand } from '../../lib/base-command.js';
 import { API_ENDPOINTS } from '../../lib/constants.js';
+import { INFO } from '../../lib/messages.js';
 import { saveYaml } from '../../lib/yaml-config.js';
 const SETTINGS_GROUPS = Object.freeze({
     billing: ['monthly_cap'],
@@ -80,7 +81,7 @@ export default class Settings extends BaseCommand {
             return;
         }
         this.log(`\n  ${chalk.green('✓')} ${key} updated to ${chalk.cyan(value)}`);
-        this.log(`  Run ${chalk.cyan("'mailmodo deploy'")} to apply.\n`);
+        this.log(`  ${INFO.DEPLOY_TO_APPLY}\n`);
     }
     displaySettingsGroup(group, keys, project, domainVerified) {
         const availableKeys = keys.filter((key) => {
@@ -169,7 +170,7 @@ export default class Settings extends BaseCommand {
             project.emailStyle = style;
             await saveYaml(yamlConfig);
             this.log(`\n  ${chalk.green('✓')} email_style updated to ${chalk.cyan(style)}`);
-            this.log(`  Run ${chalk.cyan("'mailmodo deploy'")} to apply.\n`);
+            this.log(`  ${INFO.DEPLOY_TO_APPLY}\n`);
             return;
         }
         const newValue = await input({
@@ -178,7 +179,7 @@ export default class Settings extends BaseCommand {
         project[editPropKey] =
             editPropKey === 'monthlyCap' ? Number(newValue) : newValue;
         await saveYaml(yamlConfig);
-        this.log(`\n  ${chalk.green('✓')} Updated. Run ${chalk.cyan("'mailmodo deploy'")} to apply.\n`);
+        this.log(`\n  ${chalk.green('✓')} Updated. ${INFO.DEPLOY_TO_APPLY}\n`);
     }
     /**
      * Fetches the domain verification status from the API.
@@ -201,58 +202,14 @@ export default class Settings extends BaseCommand {
             return null;
         }
     }
-    /**
-     * Handles domain change: collects the new domain, sender email, and
-     * business address, calls the API to register them, displays the required
-     * DNS records, and saves the updated config. Emails won't send until the
-     * domain is re-verified.
-     */
     async handleDomainChange(yamlConfig) {
-        const newDomain = await input({
-            message: 'New domain:',
-            validate: (v) => (v?.trim() ? true : 'Domain is required'),
-        });
-        const newFromEmail = await input({
-            default: yamlConfig.project.fromEmail || '',
-            message: 'Sender email (from address):',
-            validate: (v) => (v?.includes('@') ? true : 'Please enter a valid email'),
-        });
-        const newAddress = await input({
-            default: yamlConfig.project.address || '',
-            message: 'Business address (required by law):',
-            validate: (v) => (v?.trim() ? true : 'Address is required'),
-        });
         await this.ensureAuth();
-        const response = await this.apiClient.post(API_ENDPOINTS.DOMAIN, {
-            address: newAddress,
-            domain: newDomain,
-            fromEmail: newFromEmail,
-        });
-        if (!response.ok) {
-            this.handleApiError(response);
-        }
-        const records = response.data?.dnsRecords || [];
-        const dnsGuideUrl = response.data?.dnsGuideUrl;
-        yamlConfig.project.domain = newDomain;
-        yamlConfig.project.fromEmail = newFromEmail;
-        yamlConfig.project.address = newAddress;
-        await saveYaml(yamlConfig);
-        this.log(`\n  Domain, sender email, and business address updated. You will need to re-verify.`);
-        this.log(`  New DNS records:\n`);
-        for (const [i, record] of records.entries()) {
-            this.log(`  ${chalk.bold(`RECORD ${i + 1} — ${this.recordLabel(i)}`)}`);
-            this.log(`  Type:   ${record.type}`);
-            this.log(`  Host:   ${record.host}`);
-            this.log(`  Value:  ${record.value}\n`);
-        }
+        const inputs = await this.collectDomainSetupInputs(yamlConfig, false);
+        const { dnsRecords, dnsGuideUrl } = await this.registerDomain(yamlConfig, inputs, false);
+        this.log(`\n  Domain and sender details updated. You will need to re-verify.`);
+        this.logDnsRecords(dnsRecords, dnsGuideUrl, false);
         this.log(`  Run ${chalk.cyan("'mailmodo domain --verify'")} once records are added.`);
         this.log(`  Emails will not send until the new domain is verified.`);
-        if (dnsGuideUrl)
-            this.log(`  Help: ${chalk.cyan(dnsGuideUrl)}\n`);
-    }
-    recordLabel(index) {
-        const labels = ['DKIM', 'DMARC', 'Return Path'];
-        return labels[index] || `Record ${index + 1}`;
     }
     /**
      * Handles the logo file upload flow: validates the local file exists,

package/dist/lib/base-command.d.ts

@@ -69,5 +69,31 @@ export declare abstract class BaseCommand extends Command {
      * @param {{ status: number; debug?: ApiRequestDebugInfo }} response - Failed API response.
      * @returns {string} Message plus indented Request details for troubleshooting.
      */
+    protected collectDomainSetupInputs(yamlConfig: MailmodoYaml, skipPrompts: boolean): Promise<{
+        address: string;
+        domain: string;
+        fromEmail: string;
+        fromName: string;
+        replyTo: string;
+    }>;
+    protected registerDomain(yamlConfig: MailmodoYaml, inputs: {
+        address: string;
+        domain: string;
+        fromEmail: string;
+        fromName?: string;
+        replyTo?: string;
+    }, json: boolean): Promise<{
+        dnsGuideUrl?: string;
+        dnsRecords: Array<{
+            host: string;
+            type: string;
+            value: string;
+        }>;
+    }>;
+    protected logDnsRecords(records: Array<{
+        host: string;
+        type: string;
+        value: string;
+    }>, guideUrl: string | undefined, json: boolean): void;
     private formatApiFailure;
 }

package/dist/lib/base-command.js

@@ -1,9 +1,12 @@
+import { input } from '@inquirer/prompts';
 import { Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
 import ora from 'ora';
 import { ApiClient } from './api-client.js';
 import { loadConfig } from './config.js';
-import { loadYaml } from './yaml-config.js';
+import { API_ENDPOINTS } from './constants.js';
+import { ERRORS, INFO, PROMPTS, recordLabel, VALIDATION } from './messages.js';
+import { loadYaml, saveYaml } from './yaml-config.js';
 /**
  * Abstract base command providing shared functionality for all Mailmodo CLI commands.
  * Subclasses inherit --json and --yes base flags, authentication enforcement,
@@ -35,7 +38,7 @@ export class BaseCommand extends Command {
         }
         const config = await loadConfig();
         if (!config?.apiKey) {
-            this.error(`Not logged in. Run ${chalk.cyan('mailmodo login')} to authenticate.`);
+            this.error(ERRORS.NOT_LOGGED_IN);
         }
         this.apiClient = new ApiClient(config.apiKey);
         return config;
@@ -80,7 +83,7 @@ export class BaseCommand extends Command {
     async ensureYaml() {
         const config = await loadYaml();
         if (!config) {
-            this.error(`No mailmodo.yaml found. Run ${chalk.cyan('mailmodo init')} first.`);
+            this.error(ERRORS.NO_YAML);
         }
         return config;
     }
@@ -96,12 +99,12 @@ export class BaseCommand extends Command {
      */
     handleApiError(response) {
         if (response.status === 401) {
-            this.error(this.formatApiFailure(`Invalid API key. Run ${chalk.cyan('mailmodo login')} to re-authenticate.`, response));
+            this.error(this.formatApiFailure(ERRORS.INVALID_API_KEY, response));
         }
         if (response.status === 429) {
-            this.error(this.formatApiFailure('Rate limit exceeded. Please try again later.', response));
+            this.error(this.formatApiFailure(ERRORS.RATE_LIMIT, response));
         }
-        this.error(this.formatApiFailure(response.error || 'An unexpected API error occurred.', response));
+        this.error(this.formatApiFailure(response.error || ERRORS.UNEXPECTED_API, response));
     }
     /**
      * Builds the terminal error string for a failed API call, appending request
@@ -111,6 +114,86 @@ export class BaseCommand extends Command {
      * @param {{ status: number; debug?: ApiRequestDebugInfo }} response - Failed API response.
      * @returns {string} Message plus indented Request details for troubleshooting.
      */
+    async collectDomainSetupInputs(yamlConfig, skipPrompts) {
+        if (skipPrompts) {
+            const domain = yamlConfig.project?.domain || '';
+            if (!domain) {
+                this.error('Domain is required. Set it in mailmodo.yaml or use interactive mode.');
+            }
+            return {
+                address: yamlConfig.project?.address || '',
+                domain,
+                fromEmail: yamlConfig.project?.fromEmail || '',
+                fromName: yamlConfig.project?.fromName || '',
+                replyTo: yamlConfig.project?.replyTo || '',
+            };
+        }
+        const domain = await input({
+            default: yamlConfig.project?.domain,
+            message: PROMPTS.DOMAIN,
+            validate: (v) => (v?.trim() ? true : VALIDATION.DOMAIN_REQUIRED),
+        });
+        const fromEmail = await input({
+            default: yamlConfig.project?.fromEmail,
+            message: PROMPTS.SENDER_EMAIL,
+            validate: (v) => (v?.includes('@') ? true : VALIDATION.EMAIL_INVALID),
+        });
+        const fromName = await input({
+            default: yamlConfig.project?.fromName || '',
+            message: PROMPTS.FROM_NAME,
+        });
+        const replyTo = await input({
+            default: yamlConfig.project?.replyTo || '',
+            message: PROMPTS.REPLY_TO,
+        });
+        const address = await input({
+            default: yamlConfig.project?.address,
+            message: PROMPTS.BUSINESS_ADDRESS,
+            validate: (v) => (v?.trim() ? true : VALIDATION.ADDRESS_REQUIRED),
+        });
+        return { address, domain, fromEmail, fromName, replyTo };
+    }
+    async registerDomain(yamlConfig, inputs, json) {
+        const apiPayload = {
+            address: inputs.address,
+            domain: inputs.domain,
+            fromEmail: inputs.fromEmail,
+        };
+        if (inputs.fromName)
+            apiPayload.fromName = inputs.fromName;
+        if (inputs.replyTo)
+            apiPayload.replyTo = inputs.replyTo;
+        const response = await this.withApiSpinner({ json, text: '  Configuring domain...' }, () => this.apiClient.post(API_ENDPOINTS.DOMAIN, apiPayload));
+        if (!response.ok) {
+            this.handleApiError(response);
+        }
+        yamlConfig.project.domain = inputs.domain;
+        yamlConfig.project.fromEmail = inputs.fromEmail;
+        yamlConfig.project.address = inputs.address;
+        if (inputs.fromName)
+            yamlConfig.project.fromName = inputs.fromName;
+        if (inputs.replyTo)
+            yamlConfig.project.replyTo = inputs.replyTo;
+        await saveYaml(yamlConfig);
+        return {
+            dnsGuideUrl: response.data?.dnsGuideUrl,
+            dnsRecords: response.data?.dnsRecords || [],
+        };
+    }
+    logDnsRecords(records, guideUrl, json) {
+        if (json)
+            return;
+        this.log(`\n  Add these ${records.length} DNS records to your domain provider:\n`);
+        for (const [i, record] of records.entries()) {
+            this.log(`  ${chalk.bold(`RECORD ${i + 1} — ${recordLabel(i)}`)}`);
+            this.log(`  Type:   ${record.type}`);
+            this.log(`  Host:   ${record.host}`);
+            this.log(`  Value:  ${record.value}\n`);
+        }
+        this.log(`  ${INFO.DNS_PROPAGATION}`);
+        if (guideUrl)
+            this.log(`  Full guide: ${chalk.cyan(guideUrl)}\n`);
+    }
     formatApiFailure(message, response) {
         const { debug, status } = response;
         if (!debug) {

package/dist/lib/config.d.ts

@@ -1,7 +1,6 @@
 export interface MailmodoConfig {
     accountName?: string;
     apiKey: string;
-    domain?: string;
     email?: string;
     freeRemaining?: number;
 }

package/dist/lib/messages.d.ts

@@ -0,0 +1,36 @@
+export declare const SEPARATOR: string;
+export declare const VALIDATION: {
+    readonly ADDRESS_REQUIRED: "Address is required";
+    readonly DOMAIN_REQUIRED: "Domain is required";
+    readonly EMAIL_INVALID: "Please enter a valid email";
+};
+export declare const PROMPTS: {
+    readonly BUSINESS_ADDRESS: "Business address (required by law):";
+    readonly DOMAIN: "What domain will you send from?";
+    readonly ENTER_AFTER_RECORDS: "Press Enter once you've added the records, or 'skip'.";
+    readonly FROM_NAME: "Display name (optional, shown as sender name):";
+    readonly REPLY_TO: "Reply-to address (optional, press Enter to use sender email):";
+    readonly SENDER_EMAIL: "Sender email address:";
+};
+export declare const ERRORS: {
+    readonly DOMAIN_NOT_CONFIGURED: `No domain configured. Run ${string} to set up your sending domain.`;
+    readonly DOMAIN_NOT_REGISTERED: `Sending domain not registered. Run: ${string}`;
+    readonly DOMAIN_NOT_VERIFIED: `Sending domain not verified. Run: ${string}`;
+    readonly INVALID_API_KEY: `Invalid API key. Run ${string} to re-authenticate.`;
+    readonly NOT_LOGGED_IN: `Not logged in. Run ${string} to authenticate.`;
+    readonly NO_YAML: `No mailmodo.yaml found. Run ${string} first.`;
+    readonly RATE_LIMIT: "Rate limit exceeded. Please try again later.";
+    readonly UNEXPECTED_API: "An unexpected API error occurred.";
+};
+export declare const INFO: {
+    readonly BROWSER_OPEN_FAILED: string;
+    readonly BROWSER_OPENING: "Opening in browser...";
+    readonly DEPLOY_TO_APPLY: `Run ${string} to apply.`;
+    readonly DNS_FIX_AND_VERIFY: `Fix the records and run ${string} again.`;
+    readonly DNS_PROPAGATION: "DNS changes take 5–30 minutes to propagate.";
+    readonly DNS_RECORDS_FAILED: string;
+    readonly DOMAIN_NOT_DEPLOYED_HINT: `When ready, run: ${string}
+  Then: ${string}`;
+    readonly SEQUENCES_NOT_DEPLOYED: `Sequences saved but ${string}.`;
+};
+export declare function recordLabel(index: number): string;

package/dist/lib/messages.js

@@ -0,0 +1,39 @@
+import chalk from 'chalk';
+export const SEPARATOR = '─'.repeat(53);
+export const VALIDATION = {
+    ADDRESS_REQUIRED: 'Address is required',
+    DOMAIN_REQUIRED: 'Domain is required',
+    EMAIL_INVALID: 'Please enter a valid email',
+};
+export const PROMPTS = {
+    BUSINESS_ADDRESS: 'Business address (required by law):',
+    DOMAIN: 'What domain will you send from?',
+    ENTER_AFTER_RECORDS: "Press Enter once you've added the records, or 'skip'.",
+    FROM_NAME: 'Display name (optional, shown as sender name):',
+    REPLY_TO: 'Reply-to address (optional, press Enter to use sender email):',
+    SENDER_EMAIL: 'Sender email address:',
+};
+export const ERRORS = {
+    DOMAIN_NOT_CONFIGURED: `No domain configured. Run ${chalk.cyan('mailmodo domain')} to set up your sending domain.`,
+    DOMAIN_NOT_REGISTERED: `Sending domain not registered. Run: ${chalk.cyan('mailmodo domain')}`,
+    DOMAIN_NOT_VERIFIED: `Sending domain not verified. Run: ${chalk.cyan('mailmodo domain --verify')}`,
+    INVALID_API_KEY: `Invalid API key. Run ${chalk.cyan('mailmodo login')} to re-authenticate.`,
+    NOT_LOGGED_IN: `Not logged in. Run ${chalk.cyan('mailmodo login')} to authenticate.`,
+    NO_YAML: `No mailmodo.yaml found. Run ${chalk.cyan('mailmodo init')} first.`,
+    RATE_LIMIT: 'Rate limit exceeded. Please try again later.',
+    UNEXPECTED_API: 'An unexpected API error occurred.',
+};
+export const INFO = {
+    BROWSER_OPEN_FAILED: chalk.dim('Could not open browser. Visit the URL above manually.'),
+    BROWSER_OPENING: 'Opening in browser...',
+    DEPLOY_TO_APPLY: `Run ${chalk.cyan("'mailmodo deploy'")} to apply.`,
+    DNS_FIX_AND_VERIFY: `Fix the records and run ${chalk.cyan('mailmodo domain --verify')} again.`,
+    DNS_PROPAGATION: 'DNS changes take 5–30 minutes to propagate.',
+    DNS_RECORDS_FAILED: chalk.yellow('Some records failed.'),
+    DOMAIN_NOT_DEPLOYED_HINT: `When ready, run: ${chalk.cyan('mailmodo domain')}\n  Then: ${chalk.cyan('mailmodo deploy')}`,
+    SEQUENCES_NOT_DEPLOYED: `Sequences saved but ${chalk.yellow('NOT deployed')}.`,
+};
+export function recordLabel(index) {
+    const labels = ['DKIM', 'DMARC', 'Return Path'];
+    return labels[index] || `Record ${index + 1}`;
+}

package/dist/lib/yaml-config.d.ts

@@ -68,3 +68,5 @@ export declare function saveTemplate(filename: string, html: string, cwd?: strin
  *   or null if the file doesn't exist or can't be read.
  */
 export declare function loadTemplate(filename: string, cwd?: string): Promise<null | string>;
+export declare function getEmailStyle(emailStyle?: 'branded' | 'plain', projectStyle?: 'branded' | 'plain'): 'branded' | 'plain';
+export declare function getTemplateFilename(emailId: string, emailStyle?: 'branded' | 'plain', projectStyle?: 'branded' | 'plain'): string;

package/dist/lib/yaml-config.js

@@ -72,3 +72,10 @@ export async function loadTemplate(filename, cwd) {
         return null;
     }
 }
+export function getEmailStyle(emailStyle, projectStyle) {
+    return emailStyle ?? projectStyle ?? 'branded';
+}
+export function getTemplateFilename(emailId, emailStyle, projectStyle) {
+    const style = getEmailStyle(emailStyle, projectStyle);
+    return style === 'plain' ? `${emailId}_plain.html` : `${emailId}.html`;
+}