@mailmodo/cli 0.0.54-beta.pr56.91 → 0.0.54

package/dist/commands/billing/index.js

@@ -68,14 +68,12 @@ export default class Billing extends BaseCommand {
         }
         this.log(`\n  ${chalk.bold('Stripe Checkout')} — add or update your payment method.`);
         this.log(`  ${chalk.dim(checkoutUrl)}\n`);
-        if (!process.env.CI) {
-            try {
-                await open(checkoutUrl);
-                this.log(`  ${INFO.BROWSER_OPENING}\n`);
-            }
-            catch {
-                this.log(`  ${INFO.BROWSER_OPEN_FAILED}\n`);
-            }
+        try {
+            await open(checkoutUrl);
+            this.log(`  ${INFO.BROWSER_OPENING}\n`);
+        }
+        catch {
+            this.log(`  ${INFO.BROWSER_OPEN_FAILED}\n`);
         }
     }
     async showStatus(jsonOutput, statusOnly) {
@@ -178,7 +176,6 @@ export default class Billing extends BaseCommand {
             return;
         yamlConfig.project.monthlyCap = capBlocks;
         await saveYaml(yamlConfig);
-        await this.syncYamlToServer();
     }
     pluralize(word, count) {
         return count === 1 ? word : `${word}s`;

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

@@ -8,6 +8,37 @@ export default class Deploy extends BaseCommand {
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
+    private fetchDomainVerifyForDeploy;
     run(): Promise<void>;
-    private makeCtx;
+    private validateSequence;
+    /**
+     * Calls `POST /sequences/{id}/status` with `{ status: "paused" }` and prints
+     * a confirmation-aware success/no-op message. Skips the prompt entirely when
+     * `--yes` is set so the command stays scriptable. `--json` always emits the
+     * raw server payload (sequenceId, status, alreadyInStatus).
+     */
+    private pauseSequence;
+    /**
+     * Calls `POST /sequences/{id}/status` with `{ status: "active" }`. No prompt
+     * — resuming is the safe direction (it does not start sends that weren't
+     * already queued). `--json` always emits the raw server payload (sequenceId,
+     * status, alreadyInStatus).
+     */
+    private resumeSequence;
+    private updateSequenceStatus;
+    private sequenceStatusPath;
+    private buildDeployPayload;
+    private resolveMonthlyCapForDeploy;
+    private mapEmailToPayload;
+    private buildBrandSection;
+    private buildProductSection;
+    private buildSenderSection;
+    private buildProjectPayload;
+    private confirmDeploy;
+    private ensureDomainReady;
+    private logPreDeploySummary;
+    private logDiff;
+    private logDeploySuccessInstructions;
+    private runDomainSetup;
+    private verifyDomain;
 }

package/dist/commands/deploy/index.js

@@ -1,14 +1,10 @@
 import { Flags } from '@oclif/core';
-import { confirm } from '@inquirer/prompts';
+import { confirm, input } from '@inquirer/prompts';
 import chalk from 'chalk';
 import { BaseCommand } from '../../lib/base-command.js';
-import { API_ENDPOINTS } from '../../lib/constants.js';
-import { MISSING_TEMPLATES } from '../../lib/messages.js';
-import { buildDeployPayload } from '../../lib/deploy/payload.js';
-import { logDeploySuccessInstructions, logPreDeploySummary, } from '../../lib/deploy/output.js';
-import { pauseSequence, resumeSequence, } from '../../lib/deploy/sequence-status.js';
-import { ensureDomainReady, validateDeploySequence, } from '../../lib/deploy/domain-setup.js';
-import { getMissingTemplateIds, handleMissingTemplates, } from '../../lib/templates/missing-templates.js';
+import { API_ENDPOINTS, DEFAULT_BRAND_COLOR, SDK_IMPORT_SNIPPET, SDK_INSTALL_COMMAND, } from '../../lib/constants.js';
+import { ERRORS, INFO, pauseAlready, pauseSuccess, PROMPTS, resumeAlready, resumeSuccess, SEPARATOR, } from '../../lib/messages.js';
+import { loadTemplate, } from '../../lib/yaml-config.js';
 export default class Deploy extends BaseCommand {
     static description = 'Deploy, pause, or resume an email sequence';
     static examples = [
@@ -28,47 +24,37 @@ export default class Deploy extends BaseCommand {
             exclusive: ['pause'],
         }),
     };
+    fetchDomainVerifyForDeploy(jsonOutput, domain) {
+        return this.withApiSpinner({ json: jsonOutput, text: '  Checking domain verification...' }, () => this.apiClient.get(API_ENDPOINTS.DOMAIN_VERIFY, {
+            domain: domain || '',
+        }));
+    }
     async run() {
         const { flags } = await this.parse(Deploy);
         await this.ensureAuth();
-        const ctx = this.makeCtx();
         const baseFlags = { json: flags.json, yes: flags.yes };
         if (flags.pause) {
-            await pauseSequence(ctx, flags.pause, baseFlags);
+            await this.pauseSequence(flags.pause, baseFlags);
             return;
         }
         if (flags.resume) {
-            await resumeSequence(ctx, flags.resume, baseFlags);
+            await this.resumeSequence(flags.resume, baseFlags);
             return;
         }
         const yamlConfig = await this.ensureYaml();
-        const missingIds = getMissingTemplateIds(yamlConfig);
-        if (missingIds.length > 0) {
-            const regenerated = await handleMissingTemplates(ctx, yamlConfig, missingIds, baseFlags);
-            if (regenerated)
-                ctx.log(`\n  ${chalk.green('✓')} ${MISSING_TEMPLATES.REVIEW_HINT}\n`);
-            return;
-        }
-        const domainReady = await ensureDomainReady(ctx, yamlConfig, baseFlags);
+        const domainReady = await this.ensureDomainReady(yamlConfig, flags);
         if (!domainReady)
             return;
-        const payload = await buildDeployPayload(ctx, yamlConfig);
-        const validateResult = await validateDeploySequence(ctx, payload, baseFlags);
-        logPreDeploySummary(ctx, yamlConfig, validateResult, flags.json);
-        if (!flags.yes) {
-            const proceed = await confirm({
-                default: true,
-                message: `Deploy ${yamlConfig.emails.length} emails?`,
-            });
-            if (!proceed) {
-                this.log('\n  Deploy cancelled.\n');
-                return;
-            }
+        const payload = await this.buildDeployPayload(yamlConfig);
+        const validateResult = await this.validateSequence(payload, flags);
+        this.logPreDeploySummary(yamlConfig, validateResult, flags.json);
+        const confirmed = await this.confirmDeploy(yamlConfig, flags);
+        if (!confirmed)
+            return;
+        const response = await this.withApiSpinner({ json: flags.json, text: '  Deploying email sequences...' }, () => this.apiClient.post(API_ENDPOINTS.SEQUENCES_DEPLOY, payload));
+        if (!response.ok) {
+            this.handleApiError(response);
         }
-        const response = await ctx.spinner('  Deploying email sequences...', flags.json, () => ctx.post(API_ENDPOINTS.SEQUENCES_DEPLOY, payload));
-        if (!response.ok)
-            ctx.onApiError(response);
-        await ctx.syncYaml();
         if (flags.json) {
             this.log(JSON.stringify({
                 deployed: response.data.deployed,
@@ -79,25 +65,290 @@ export default class Deploy extends BaseCommand {
             }, null, 2));
             return;
         }
-        logDeploySuccessInstructions(ctx, response.data.sdkSnippet);
+        this.logDeploySuccessInstructions(response.data.sdkSnippet);
     }
-    makeCtx() {
+    async validateSequence(payload, flags) {
+        const response = await this.withApiSpinner({ json: flags.json, text: '  Validating sequence...' }, () => this.apiClient.post(API_ENDPOINTS.SEQUENCES_VALIDATE, payload));
+        if (!response.ok) {
+            if (response.data.error === 'senderDomainNotFound') {
+                this.error(ERRORS.DOMAIN_NOT_REGISTERED);
+            }
+            if (response.data.error === 'senderDomainNotVerified') {
+                this.error(ERRORS.DOMAIN_NOT_VERIFIED);
+            }
+            this.handleApiError(response);
+        }
+        return response.data;
+    }
+    /**
+     * Calls `POST /sequences/{id}/status` with `{ status: "paused" }` and prints
+     * a confirmation-aware success/no-op message. Skips the prompt entirely when
+     * `--yes` is set so the command stays scriptable. `--json` always emits the
+     * raw server payload (sequenceId, status, alreadyInStatus).
+     */
+    async pauseSequence(sequenceId, flags) {
+        if (!flags.yes) {
+            const confirmed = await confirm({
+                default: false,
+                message: PROMPTS.PAUSE_CONFIRM,
+            });
+            if (!confirmed) {
+                this.log(`\n  ${INFO.PAUSE_CANCELLED}\n`);
+                return;
+            }
+        }
+        const data = await this.updateSequenceStatus(sequenceId, 'paused', flags, '  Pausing sequence...');
+        if (flags.json) {
+            this.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        const message = data.alreadyInStatus
+            ? pauseAlready(data.sequenceId || sequenceId)
+            : pauseSuccess(data.sequenceId || sequenceId);
+        this.log(`\n  ${message}\n`);
+    }
+    /**
+     * Calls `POST /sequences/{id}/status` with `{ status: "active" }`. No prompt
+     * — resuming is the safe direction (it does not start sends that weren't
+     * already queued). `--json` always emits the raw server payload (sequenceId,
+     * status, alreadyInStatus).
+     */
+    async resumeSequence(sequenceId, flags) {
+        const data = await this.updateSequenceStatus(sequenceId, 'active', flags, '  Resuming sequence...');
+        if (flags.json) {
+            this.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        const message = data.alreadyInStatus
+            ? resumeAlready(data.sequenceId || sequenceId)
+            : resumeSuccess(data.sequenceId || sequenceId);
+        this.log(`\n  ${message}\n`);
+    }
+    async updateSequenceStatus(sequenceId, status, flags, spinnerText) {
+        const response = await this.withApiSpinner({ json: flags.json, text: spinnerText }, () => this.apiClient.post(this.sequenceStatusPath(sequenceId), { status }));
+        if (!response.ok) {
+            this.handleApiError(response);
+        }
+        return response.data;
+    }
+    sequenceStatusPath(sequenceId) {
+        return `${API_ENDPOINTS.SEQUENCES}/${encodeURIComponent(sequenceId)}/status`;
+    }
+    async buildDeployPayload(yamlConfig) {
+        const [emailsWithHtml, monthlyCap] = await Promise.all([
+            Promise.all(yamlConfig.emails.map(async (email) => {
+                const html = (await loadTemplate(`${email.id}.html`)) || '';
+                const plainHtml = (await loadTemplate(`${email.id}_plain.html`)) || html;
+                return { ...this.mapEmailToPayload(email), html, plainHtml };
+            })),
+            this.resolveMonthlyCapForDeploy(yamlConfig.project.monthlyCap),
+        ]);
+        return {
+            ...this.buildProjectPayload(yamlConfig.project, monthlyCap),
+            emails: emailsWithHtml,
+        };
+    }
+    async resolveMonthlyCapForDeploy(yamlMonthlyCap) {
+        if (yamlMonthlyCap !== undefined)
+            return yamlMonthlyCap;
+        const billingStatus = await this.fetchBillingStatus();
+        return billingStatus?.cap?.inBlocks ?? undefined;
+    }
+    mapEmailToPayload(email) {
+        return {
+            condition: email.condition || null,
+            ctaText: email.ctaText || '',
+            delay: email.delay,
+            goal: email.goal || '',
+            id: email.id,
+            isReminder: false,
+            previewText: email.previewText || '',
+            priority: 'medium',
+            subject: email.subject,
+            trigger: email.trigger,
+        };
+    }
+    buildBrandSection(project) {
         return {
-            collectDomainInputs: (yaml, skip) => this.collectDomainSetupInputs(yaml, skip),
-            error: (msg) => this.error(msg),
-            exit: (code) => this.exit(code),
-            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),
-            onApiError: (r) => this.handleApiError(r),
-            post: (path, body) => this.apiClient.post(path, body),
-            registerDomainAndSave: (yaml, inputs, json) => this.registerDomain(yaml, inputs, json),
-            showDnsRecords: (records, url, json) => this.logDnsRecords(records, url, json),
-            spinner: (text, json, work) => this.withApiSpinner({ json, text }, work),
-            syncYaml: () => this.syncYamlToServer(),
+            colors: [project?.brandColor || DEFAULT_BRAND_COLOR],
+            logoUrl: project?.logoUrl || '',
         };
     }
+    buildProductSection(project) {
+        return {
+            businessType: project?.type || '',
+            description: project?.description || '',
+            pricingModel: project?.pricingModel || '',
+            productName: project?.name || '',
+            saasModel: project?.saasModel || '',
+            targetUser: project?.targetUser || '',
+            url: project?.url || '',
+        };
+    }
+    buildSenderSection(project) {
+        return {
+            address: project?.address || '',
+            domain: project?.domain || '',
+            fromEmail: project?.fromEmail || '',
+            fromName: project?.fromName || '',
+            replyTo: project?.replyTo || project?.fromEmail || '',
+        };
+    }
+    buildProjectPayload(project, monthlyCap) {
+        return {
+            brand: this.buildBrandSection(project),
+            emailStyle: project?.emailStyle || 'branded',
+            ...(monthlyCap === undefined ? {} : { monthlyCap }),
+            product: this.buildProductSection(project),
+            senderDetails: this.buildSenderSection(project),
+            ...(project?.webhookUrl ? { webhookUrl: project.webhookUrl } : {}),
+        };
+    }
+    async confirmDeploy(yamlConfig, flags) {
+        if (flags.yes)
+            return true;
+        const proceed = await confirm({
+            default: true,
+            message: `Deploy ${yamlConfig.emails.length} emails?`,
+        });
+        if (!proceed) {
+            this.log('\n  Deploy cancelled.\n');
+        }
+        return proceed;
+    }
+    async ensureDomainReady(yamlConfig, flags) {
+        const domainVerify = await this.fetchDomainVerifyForDeploy(flags.json, yamlConfig.project?.domain);
+        if (domainVerify.ok && domainVerify.data?.domainStatus === 'VERIFIED') {
+            return true;
+        }
+        if (yamlConfig.project?.domain) {
+            if (!flags.json) {
+                this.log(`\n  ${INFO.DOMAIN_PENDING_VERIFICATION}\n`);
+            }
+            return false;
+        }
+        if (!flags.json) {
+            this.log(`\n  No sending domain set up yet.`);
+            this.log(`  You need a verified domain before sending emails.`);
+            this.log(`  This is a one-time setup. Takes about 5 minutes.\n`);
+        }
+        if (!flags.yes) {
+            const setupNow = await confirm({
+                default: true,
+                message: 'Set up your sending domain now?',
+            });
+            if (!setupNow) {
+                this.log(`\n  ${INFO.SEQUENCES_NOT_DEPLOYED}`);
+                this.log(`  Emails will not send until your domain is verified.`);
+                this.log(`  ${INFO.DOMAIN_NOT_DEPLOYED_HINT}\n`);
+                return false;
+            }
+        }
+        return this.runDomainSetup(yamlConfig, flags);
+    }
+    logPreDeploySummary(yamlConfig, validateResult, jsonOutput) {
+        if (jsonOutput)
+            return;
+        this.log(`\n  ${chalk.green('✓')} Domain: ${yamlConfig.project?.domain || 'verified'}\n`);
+        if (!validateResult.existingDeployment || !validateResult.diff) {
+            this.log(`  Deploying:`);
+            for (const email of yamlConfig.emails) {
+                this.log(`  ${chalk.green('+')} ${email.id.padEnd(24)} ${email.trigger}`);
+            }
+        }
+        else {
+            this.logDiff(validateResult.diff);
+        }
+        this.log('');
+    }
+    logDiff(diff) {
+        if (!diff.hasChanges) {
+            this.log(`  No changes from last deployment.`);
+            return;
+        }
+        this.log(`  Changes vs. last deployment:`);
+        for (const email of diff.added) {
+            this.log(`  ${chalk.green('+')} ${email.id.padEnd(24)} ${email.trigger || ''}`);
+        }
+        for (const email of diff.removed) {
+            this.log(`  ${chalk.red('-')} ${email.id.padEnd(24)} ${email.trigger || ''}`);
+        }
+        for (const email of diff.modified) {
+            const fields = email.changedFields?.join(', ') || '';
+            this.log(`  ${chalk.yellow('~')} ${email.id.padEnd(24)} ${fields}`);
+        }
+        if (diff.unchanged.length > 0) {
+            this.log(`  ${chalk.dim(`∙ ${diff.unchanged.length} unchanged`)}`);
+        }
+    }
+    logDeploySuccessInstructions(sdkSnippet) {
+        this.log(`  ${chalk.green('Deployed.')} Emails are live.\n`);
+        this.log(`  ${SEPARATOR}`);
+        this.log(`  ${chalk.bold('ADD THIS TO YOUR APP (one-time only):')}`);
+        this.log(`  ${SEPARATOR}\n`);
+        this.log(`  ${chalk.cyan(sdkSnippet.install ?? SDK_INSTALL_COMMAND)}\n`);
+        this.log(`  ${chalk.dim(SDK_IMPORT_SNIPPET)}\n`);
+        if (sdkSnippet.examples) {
+            this.log(`  ${chalk.dim('// Example usage:')}`);
+            this.log(`  ${chalk.dim(sdkSnippet.examples.track)}`);
+            this.log(`  ${chalk.dim(sdkSnippet.examples.identify)}\n`);
+        }
+        const trackCalls = [...new Set(sdkSnippet.trackCalls ?? [])];
+        for (const call of trackCalls) {
+            this.log(`  ${chalk.dim(call)}`);
+        }
+        if (trackCalls.length > 0)
+            this.log('');
+        const identifyCalls = [...new Set(sdkSnippet.identifyCalls ?? [])];
+        for (const call of identifyCalls) {
+            this.log(`  ${chalk.dim(call)}`);
+        }
+        if (identifyCalls.length > 0)
+            this.log('');
+        this.log(`  Full SDK docs: ${chalk.cyan('mailmodo.com/docs/sdk')}\n`);
+        this.log(`  ${SEPARATOR}\n`);
+    }
+    async runDomainSetup(yamlConfig, flags) {
+        const inputs = await this.collectDomainSetupInputs(yamlConfig, flags.yes);
+        const { dnsRecords, dnsGuideUrl } = await this.registerDomain(yamlConfig, inputs, flags.json);
+        this.logDnsRecords(dnsRecords, dnsGuideUrl, flags.json);
+        if (flags.yes) {
+            return this.verifyDomain(flags.json, inputs.domain);
+        }
+        const action = await input({
+            default: '',
+            message: PROMPTS.ENTER_AFTER_RECORDS,
+        });
+        if (action.toLowerCase() === 'skip') {
+            this.log(`\n  ${INFO.SEQUENCES_NOT_DEPLOYED}`);
+            this.log(`  ${INFO.DOMAIN_NOT_DEPLOYED_HINT}\n`);
+            return false;
+        }
+        return this.verifyDomain(flags.json, inputs.domain);
+    }
+    async verifyDomain(jsonOutput, domain) {
+        const verify = await this.withApiSpinner({ json: jsonOutput, text: '  Checking DNS...' }, () => this.apiClient.get(API_ENDPOINTS.DOMAIN_VERIFY, {
+            domain,
+        }));
+        if (!verify.ok) {
+            this.handleApiError(verify);
+        }
+        const { dkim, dmarc, dnsGuideUrl, domainStatus, returnPath } = verify.data;
+        const allPassed = domainStatus === 'VERIFIED';
+        if (!jsonOutput) {
+            this.log(`  DKIM         ${dkim ? chalk.green('✓') : chalk.red('✗')}`);
+            this.log(`  DMARC        ${dmarc ? chalk.green('✓') : chalk.red('✗')}`);
+            this.log(`  Return-Path  ${returnPath ? chalk.green('✓') : chalk.red('✗')}`);
+            if (allPassed) {
+                this.log(`\n  ${chalk.green('Domain verified.')} Continuing deploy...\n`);
+            }
+            else {
+                this.log(`\n  ${INFO.DNS_RECORDS_FAILED}`);
+                this.log(`\n  ${INFO.DNS_FIX_AND_VERIFY}`);
+                if (dnsGuideUrl)
+                    this.log(`  Help: ${chalk.cyan(dnsGuideUrl)}\n`);
+            }
+        }
+        return allPassed;
+    }
 }

package/dist/commands/edit/index.js

@@ -4,7 +4,6 @@ import chalk from 'chalk';
 import { BaseCommand } from '../../lib/base-command.js';
 import { API_ENDPOINTS } from '../../lib/constants.js';
 import { loadTemplate, getTemplateFilename, saveTemplate, saveYaml, } from '../../lib/yaml-config.js';
-import { handleMissingTemplates } from '../../lib/templates/missing-templates.js';
 export default class Edit extends BaseCommand {
     static args = {
         id: Args.string({
@@ -44,23 +43,6 @@ export default class Edit extends BaseCommand {
             json: flags.json ?? false,
             yes: flags.yes ?? false,
         };
-        if (!ctx.templateHtml) {
-            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], editFlags);
-            if (!regenerated)
-                return;
-            ctx.templateHtml = await loadTemplate(templateFilename);
-            if (!ctx.templateHtml)
-                this.error('Template regeneration failed.');
-        }
         const initialChange = flags.change?.trim() || (await this.askChangeDescription());
         await this.runEditStep(ctx, initialChange, editFlags);
     }
@@ -143,7 +125,6 @@ export default class Edit extends BaseCommand {
         if (updated.html) {
             await saveTemplate(ctx.templateFilename, updated.html);
         }
-        await this.syncYamlToServer();
     }
     logJsonResult(email, updated, oldSubject) {
         this.log(JSON.stringify({

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

@@ -9,6 +9,5 @@ export default class Init extends BaseCommand {
     };
     run(): Promise<void>;
     private persistMonthlyCap;
-    private preserveUserFields;
     private confirmOverwriteIfNeeded;
 }

package/dist/commands/init/index.js

@@ -35,8 +35,7 @@ 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)))
+        if (!(await this.confirmOverwriteIfNeeded(flags)))
             return;
         let productUrl = flags.url;
         if (!productUrl) {
@@ -148,8 +147,6 @@ export default class Init extends BaseCommand {
                 webhookUrl: '',
             },
         };
-        if (existing)
-            this.preserveUserFields(yamlConfig, existing);
         await saveYaml(yamlConfig);
         await this.persistMonthlyCap(yamlConfig);
         const templateSaves = analysisPayload.recommendedEmails.flatMap((rec, index) => {
@@ -164,7 +161,6 @@ export default class Init extends BaseCommand {
             return saves;
         });
         await Promise.all(templateSaves);
-        await this.syncYamlToServer();
         if (flags.json) {
             this.log(JSON.stringify({
                 brandDetected: analysisPayload.brand,
@@ -185,26 +181,8 @@ export default class Init extends BaseCommand {
             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) {
+    async confirmOverwriteIfNeeded(flags) {
+        const existing = await loadYaml();
         if (!existing)
             return true;
         if (flags.yes)

package/dist/commands/login/index.js

@@ -27,14 +27,11 @@ export default class Login extends BaseCommand {
         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;
                 }
@@ -43,13 +40,8 @@ export default class Login extends BaseCommand {
                     ? 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`);
+                this.log(`  ${chalk.dim('1.')} Run ${chalk.cyan('mailmodo init')} to generate an email sequence.`);
+                this.log(`  ${chalk.dim('2.')} Run ${chalk.cyan('mailmodo logout')} to log in with another account.\n`);
                 return;
             }
         }
@@ -87,7 +79,6 @@ export default class Login extends BaseCommand {
             email,
             totalFreeRemaining,
         });
-        const yamlRestored = await this.recoverYamlAfterLogin(client);
         if (flags.json) {
             this.log(JSON.stringify({
                 email,
@@ -95,7 +86,6 @@ export default class Login extends BaseCommand {
                 totalFreeRemaining,
                 paidEmailsRemaining,
                 status: 'authenticated',
-                yamlRestored,
             }, null, 2));
             return;
         }
@@ -107,11 +97,6 @@ export default class Login extends BaseCommand {
         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`);
-        }
+        this.log(`  Next: Run ${chalk.cyan("'mailmodo init'")} to generate your email sequences.\n`);
     }
 }