@mailmodo/cli 0.0.56-beta.pr58.99 → 0.0.56

package/dist/commands/deploy/index.js

@@ -3,7 +3,7 @@ import { confirm } from '@inquirer/prompts';
 import chalk from 'chalk';
 import { BaseCommand } from '../../lib/base-command.js';
 import { API_ENDPOINTS } from '../../lib/constants.js';
-import { MISSING_TEMPLATES, restoredFromServerHint, } from '../../lib/messages.js';
+import { MISSING_TEMPLATES } from '../../lib/messages.js';
 import { buildDeployPayload } from '../../lib/commands/deploy/payload.js';
 import { logDeploySuccessInstructions, logPreDeploySummary, } from '../../lib/commands/deploy/output.js';
 import { pauseSequence, resumeSequence, } from '../../lib/commands/deploy/sequence-status.js';
@@ -44,10 +44,8 @@ export default class Deploy extends BaseCommand {
         const yamlConfig = await this.ensureYaml();
         const missingIds = getMissingTemplateIds(yamlConfig);
         if (missingIds.length > 0) {
-            const result = await handleMissingTemplates(ctx, yamlConfig, missingIds, baseFlags);
-            if (result === 'restored')
-                ctx.log(`\n  ${chalk.green('✓')} ${restoredFromServerHint(missingIds)}\n`);
-            else if (result === 'regenerated')
+            const regenerated = await handleMissingTemplates(ctx, yamlConfig, missingIds, baseFlags);
+            if (regenerated)
                 ctx.log(`\n  ${chalk.green('✓')} ${MISSING_TEMPLATES.REVIEW_HINT}\n`);
             return;
         }
@@ -71,7 +69,6 @@ export default class Deploy extends BaseCommand {
         if (!response.ok)
             ctx.onApiError(response);
         await ctx.syncYaml();
-        await ctx.syncTemplates(yamlConfig);
         if (flags.json) {
             this.log(JSON.stringify({
                 deployed: response.data.deployed,
@@ -89,7 +86,6 @@ export default class Deploy extends BaseCommand {
             collectDomainInputs: (yaml, skip) => this.collectDomainSetupInputs(yaml, skip),
             error: (msg) => this.error(msg),
             exit: (code) => this.exit(code),
-            fetchTemplate: (emailId) => this.getTemplateFromServer(emailId),
             get: (path, params) => this.apiClient.get(path, params),
             getBillingCap: async () => {
                 const s = await this.fetchBillingStatus();
@@ -101,7 +97,6 @@ export default class Deploy extends BaseCommand {
             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),
-            syncTemplates: (yaml) => this.syncTemplatesToServer(yaml),
             syncYaml: () => this.syncYamlToServer(),
         };
     }

package/dist/commands/edit/index.js

@@ -1,6 +1,6 @@
 import { Args, Flags } from '@oclif/core';
 import { BaseCommand } from '../../lib/base-command.js';
-import { getTemplateFilename, loadTemplate, } from '../../lib/yaml-config.js';
+import { getTemplateFilename, loadTemplate } from '../../lib/yaml-config.js';
 import { handleMissingTemplates } from '../../lib/templates/missing-templates.js';
 import { askChangeDescription, runEditStep, } from '../../lib/commands/edit/flow.js';
 export default class Edit extends BaseCommand {
@@ -63,7 +63,6 @@ export default class Edit extends BaseCommand {
             post: (path, body) => this.apiClient.post(path, body),
             runCommand: (id, argv) => this.config.runCommand(id, argv),
             spinner: (text, json, work) => this.withApiSpinner({ json, text }, work),
-            syncTemplate: (emailId) => this.syncTemplateToServer(emailId),
             syncYaml: () => this.syncYamlToServer(),
         };
     }
@@ -71,12 +70,10 @@ export default class Edit extends BaseCommand {
         return {
             error: (msg) => this.error(msg),
             exit: (code) => this.exit(code),
-            fetchTemplate: (emailId) => this.getTemplateFromServer(emailId),
             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),
-            syncTemplates: (yaml) => this.syncTemplatesToServer(yaml),
             syncYaml: () => this.syncYamlToServer(),
         };
     }

package/dist/commands/init/index.js

@@ -39,7 +39,6 @@ export default class Init extends BaseCommand {
         await applyMonthlyCap(ctx, yamlConfig);
         await saveAllTemplates(analysisPayload.recommendedEmails, generatedEmails);
         await ctx.syncYaml();
-        await this.syncTemplatesToServer(yamlConfig);
         logInitSuccess(ctx, {
             brand: analysisPayload.brand,
             emailConfigs,

package/dist/commands/preview/index.js

@@ -82,12 +82,10 @@ export default class Preview extends BaseCommand {
         return {
             error: (msg) => this.error(msg),
             exit: (code) => this.exit(code),
-            fetchTemplate: (emailId) => this.getTemplateFromServer(emailId),
             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),
-            syncTemplates: (yaml) => this.syncTemplatesToServer(yaml),
             syncYaml: () => this.syncYamlToServer(),
         };
     }

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

@@ -80,11 +80,8 @@ export declare abstract class BaseCommand extends Command {
      * successfully written, `false` otherwise (file already present, server 404,
      * or any network error). Silent — never throws.
      *
-     * After ensuring the YAML is available, also silently restores any template
-     * files that are missing from the local mailmodo/ folder, so a returning user
-     * gets both their config and templates back without having to run init again.
-     *
-     * Used by `mailmodo login` right after the API key is validated.
+     * Used by `mailmodo login` right after the API key is validated so a returning
+     * user automatically gets their config back without having to run `init` again.
      */
     protected recoverYamlAfterLogin(client: ApiClient): Promise<boolean>;
     /**
@@ -93,34 +90,6 @@ export declare abstract class BaseCommand extends Command {
      * always succeeds regardless of sync failures.
      */
     protected syncYamlToServer(): Promise<void>;
-    /**
-     * Bulk-uploads all template HTML files referenced in the YAML to the server
-     * as a backup. Best-effort: silently ignores all errors so the originating
-     * command always succeeds regardless of sync failures.
-     * Called after init, deploy, and AI regeneration.
-     */
-    protected syncTemplatesToServer(yaml: MailmodoYaml): Promise<void>;
-    /**
-     * Uploads a single template's HTML files to the server for incremental sync.
-     * Best-effort: silently ignores all errors. Called after the edit command
-     * applies changes to a specific template.
-     */
-    protected syncTemplateToServer(emailId: string): Promise<void>;
-    /**
-     * Fetches a single backed-up template from the server and writes it to the
-     * local mailmodo/ folder. Returns true if the template was successfully
-     * restored, false if it is not backed up or on any error.
-     * Used as the `ctx.fetchTemplate` bridge passed to handleMissingTemplates.
-     */
-    protected getTemplateFromServer(emailId: string): Promise<boolean>;
-    /**
-     * Silently restores any template files missing from disk by fetching them
-     * from the server. Uses the bulk endpoint when all templates are missing
-     * (single round-trip), or individual per-ID requests when only a subset is
-     * missing to avoid overwriting files that are already present. Best-effort —
-     * never throws.
-     */
-    private fetchMissingTemplates;
     /**
      * Handles a failed API response by mapping HTTP status codes to
      * user-friendly error messages and exiting the process.

package/dist/lib/base-command.js

@@ -8,8 +8,6 @@ import ora from 'ora';
 import { ApiClient } from './api-client.js';
 import { loadConfig } from './config.js';
 import { API_ENDPOINTS, IS_DEV_MODE, YAML_FILE } from './constants.js';
-import { syncTemplatesToServer, syncTemplateToServer, fetchTemplatesFromServer, fetchTemplateFromServer, } from './templates/sync.js';
-import { getMissingTemplateIds } from './templates/missing-templates.js';
 import { ERRORS, INFO, PROMPTS, quotaExhaustedMessage, recordLabel, VALIDATION, } from './messages.js';
 import { loadYaml, saveYaml } from './yaml-config.js';
 export const FREE_TIER = 'free';
@@ -139,22 +137,13 @@ export class BaseCommand extends Command {
      * successfully written, `false` otherwise (file already present, server 404,
      * or any network error). Silent — never throws.
      *
-     * After ensuring the YAML is available, also silently restores any template
-     * files that are missing from the local mailmodo/ folder, so a returning user
-     * gets both their config and templates back without having to run init again.
-     *
-     * Used by `mailmodo login` right after the API key is validated.
+     * Used by `mailmodo login` right after the API key is validated so a returning
+     * user automatically gets their config back without having to run `init` again.
      */
     async recoverYamlAfterLogin(client) {
-        let yamlRestored = false;
-        if (!existsSync(join(process.cwd(), YAML_FILE))) {
-            yamlRestored = await this.fetchAndWriteYaml(client);
-        }
-        // Always check for missing templates, whether YAML was just restored or already present
-        const yaml = await loadYaml();
-        if (yaml)
-            await this.fetchMissingTemplates(client, yaml);
-        return yamlRestored;
+        if (existsSync(join(process.cwd(), YAML_FILE)))
+            return false;
+        return this.fetchAndWriteYaml(client);
     }
     /**
      * Uploads the current local mailmodo.yaml to the server as a backup.
@@ -184,92 +173,6 @@ export class BaseCommand extends Command {
             // Silently ignore — local file remains authoritative
         }
     }
-    /**
-     * Bulk-uploads all template HTML files referenced in the YAML to the server
-     * as a backup. Best-effort: silently ignores all errors so the originating
-     * command always succeeds regardless of sync failures.
-     * Called after init, deploy, and AI regeneration.
-     */
-    async syncTemplatesToServer(yaml) {
-        try {
-            let client = this.apiClient;
-            if (!client) {
-                const envKey = process.env.MAILMODO_API_KEY;
-                const apiKey = envKey ?? (await loadConfig())?.apiKey;
-                if (!apiKey)
-                    return;
-                client = new ApiClient(apiKey);
-            }
-            await syncTemplatesToServer(client, yaml);
-        }
-        catch {
-            // Silently ignore — local files remain authoritative
-        }
-    }
-    /**
-     * Uploads a single template's HTML files to the server for incremental sync.
-     * Best-effort: silently ignores all errors. Called after the edit command
-     * applies changes to a specific template.
-     */
-    async syncTemplateToServer(emailId) {
-        try {
-            let client = this.apiClient;
-            if (!client) {
-                const envKey = process.env.MAILMODO_API_KEY;
-                const apiKey = envKey ?? (await loadConfig())?.apiKey;
-                if (!apiKey)
-                    return;
-                client = new ApiClient(apiKey);
-            }
-            await syncTemplateToServer(client, emailId);
-        }
-        catch {
-            // Silently ignore — local files remain authoritative
-        }
-    }
-    /**
-     * Fetches a single backed-up template from the server and writes it to the
-     * local mailmodo/ folder. Returns true if the template was successfully
-     * restored, false if it is not backed up or on any error.
-     * Used as the `ctx.fetchTemplate` bridge passed to handleMissingTemplates.
-     */
-    async getTemplateFromServer(emailId) {
-        try {
-            let client = this.apiClient;
-            if (!client) {
-                const envKey = process.env.MAILMODO_API_KEY;
-                const apiKey = envKey ?? (await loadConfig())?.apiKey;
-                if (!apiKey)
-                    return false;
-                client = new ApiClient(apiKey);
-            }
-            return fetchTemplateFromServer(client, emailId);
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Silently restores any template files missing from disk by fetching them
-     * from the server. Uses the bulk endpoint when all templates are missing
-     * (single round-trip), or individual per-ID requests when only a subset is
-     * missing to avoid overwriting files that are already present. Best-effort —
-     * never throws.
-     */
-    async fetchMissingTemplates(client, yaml) {
-        try {
-            const missingIds = getMissingTemplateIds(yaml);
-            if (missingIds.length === 0)
-                return;
-            // Use bulk endpoint when every template is missing; per-ID otherwise
-            await (missingIds.length === yaml.emails.length
-                ? fetchTemplatesFromServer(client, yaml)
-                : Promise.all(missingIds.map((id) => fetchTemplateFromServer(client, id))));
-        }
-        catch {
-            // best-effort, silently ignore
-        }
-    }
     /**
      * Handles a failed API response by mapping HTTP status codes to
      * user-friendly error messages and exiting the process.

package/dist/lib/commands/edit/diff.js

@@ -42,12 +42,12 @@ export function buildDiffPreview(email, updated, templateHtml) {
     diff.subject = subjectChanged
         ? { new: updated.subject, old: email.subject }
         : { unchanged: true, value: email.subject };
-    if (email.previewText || updated.previewText) {
+    if (email.previewText ?? updated.previewText) {
         diff.previewText = previewChanged
             ? { new: updated.previewText, old: email.previewText }
             : { unchanged: true, value: email.previewText };
     }
-    if (templateHtml || updated.html) {
+    if (templateHtml ?? updated.html) {
         const oldText = templateHtml
             ? truncate(stripHtml(templateHtml), 500)
             : null;

package/dist/lib/commands/edit/persist.js

@@ -20,13 +20,12 @@ async function persistChanges(ctx, editCtx, updated) {
         await saveTemplate(editCtx.templateFilename, updated.html);
     }
     await ctx.syncYaml();
-    await ctx.syncTemplate(editCtx.email.id);
 }
-function logJsonResult(ctx, email, updated, oldSubject, oldPreviewText) {
+function logJsonResult(ctx, email, updated, oldSubject) {
     ctx.log(JSON.stringify({
         diff: {
-            previewText: updated.previewText && updated.previewText !== oldPreviewText
-                ? { new: updated.previewText, old: oldPreviewText }
+            previewText: updated.previewText && updated.previewText !== email.previewText
+                ? { new: updated.previewText, old: email.previewText }
                 : undefined,
             subject: oldSubject === email.subject
                 ? undefined
@@ -52,11 +51,10 @@ async function handleAcceptOutput(ctx, email) {
 export async function finalizeEdit(ctx, editCtx, opts) {
     const { flags, updated } = opts;
     const oldSubject = editCtx.email.subject;
-    const oldPreviewText = editCtx.email.previewText;
     applyEmailChanges(editCtx.email, updated);
     await persistChanges(ctx, editCtx, updated);
     if (flags.json) {
-        logJsonResult(ctx, editCtx.email, updated, oldSubject, oldPreviewText);
+        logJsonResult(ctx, editCtx.email, updated, oldSubject);
     }
     else if (flags.yes) {
         ctx.log(`\n  Updated ${chalk.green('mailmodo.yaml')}\n`);

package/dist/lib/commands/edit/types.d.ts

@@ -33,6 +33,5 @@ export type EditCtx = {
     post<T>(path: string, body?: unknown): Promise<ApiResponse<T>>;
     runCommand(id: string, argv: string[]): Promise<void>;
     spinner<T>(text: string, json: boolean, work: () => Promise<T>): Promise<T>;
-    syncTemplate(emailId: string): Promise<void>;
     syncYaml(): Promise<void>;
 };

package/dist/lib/commands/emails/editor.js

@@ -27,7 +27,7 @@ export async function openTemplateInEditor(ctx, template) {
                 stdio: 'inherit',
             });
             child.on('error', () => resolve(false));
-            child.on('close', (code) => resolve(code === 0));
+            child.on('close', () => resolve(true));
         });
         if (launched)
             return;

package/dist/lib/commands/init/analysis.js

@@ -4,12 +4,8 @@ import { API_ENDPOINTS } from '../../constants.js';
 import { isValidUrl } from '../../utils.js';
 import { logAnalysisSummary } from './output.js';
 export async function promptProductUrl(flagUrl) {
-    if (flagUrl) {
-        if (!isValidUrl(flagUrl)) {
-            throw new Error(`Invalid URL: "${flagUrl}". Please enter a valid URL (e.g., https://myapp.com)`);
-        }
+    if (flagUrl)
         return flagUrl;
-    }
     return input({
         message: 'What is your product URL?',
         validate(value) {

package/dist/lib/commands/preview/types.d.ts

@@ -1,9 +1,7 @@
 import type { ApiResponse } from '../../api-client.js';
-import type { MailmodoYaml } from '../../yaml-config.js';
 export type PreviewCtx = {
     error(msg: string): never;
     exit(code?: number): never;
-    fetchTemplate(emailId: string): Promise<boolean>;
     log(msg?: string): void;
     onApiError(resp: {
         error?: string;
@@ -11,7 +9,6 @@ export type PreviewCtx = {
     }): never;
     post<T>(path: string, body?: unknown): Promise<ApiResponse<T>>;
     spinner<T>(text: string, json: boolean, work: () => Promise<T>): Promise<T>;
-    syncTemplates(yaml: MailmodoYaml): Promise<void>;
     syncYaml(): Promise<void>;
 };
 export type PreviewEmail = {

package/dist/lib/constants.d.ts

@@ -4,12 +4,11 @@
  * when this is true so end users never see internal request metadata.
  */
 export declare const IS_DEV_MODE: boolean;
-export declare const API_BASE_URL: string;
+export declare const API_BASE_URL = "https://app-vertex-debug.azurewebsites.net";
 export declare const API_ENDPOINTS: Readonly<{
     ANALYTICS: "/analytics";
     ANALYZE: "/analyze";
     ASSETS_LOGO: "/assets/logo";
-    ASSETS_TEMPLATES: "/assets/templates";
     ASSETS_YAML: "/assets/yaml";
     AUTH_VALIDATE: "/auth/validate";
     BILLING_CAP: "/billing/cap";
@@ -31,7 +30,7 @@ export declare const API_ENDPOINTS: Readonly<{
     SEQUENCES_SDK: "/sequences/sdk";
     SEQUENCES_VALIDATE: "/sequences/validate";
 }>;
-export declare const LOGIN_URL: string;
+export declare const LOGIN_URL = "https://app-vertex-debug.azurewebsites.net/signup.html";
 export declare const PREVIEW_PORT = 3421;
 export declare const DEFAULT_BRAND_COLOR = "#1A56DB";
 export declare const TEMPLATES_DIR = "mailmodo";

package/dist/lib/constants.js

@@ -1,12 +1,13 @@
 /** Set by `bin/dev.js` when running the CLI locally (tsx bootstrap). */
 const DEV_API_BASE_URL = 'https://app-vertex-debug.azurewebsites.net';
-const PRODUCTION_API_BASE_URL = 'https://api.mailmodo.dev';
 /**
  * True when the CLI is running in a dev/debug context. Verbose request
  * diagnostics (URL, status, response body, error code) are only surfaced
  * when this is true so end users never see internal request metadata.
  */
 export const IS_DEV_MODE = Boolean(process.env.MAILMODO_DEV_TSX || process.env.MAILMODO_DEBUG);
+// const PRODUCTION_API_BASE_URL = 'https://api.mailmodo.com';
+const PRODUCTION_API_BASE_URL = 'https://app-vertex-debug.azurewebsites.net';
 export const API_BASE_URL = process.env.MAILMODO_DEV_TSX
     ? DEV_API_BASE_URL
     : PRODUCTION_API_BASE_URL;
@@ -14,7 +15,6 @@ export const API_ENDPOINTS = Object.freeze({
     ANALYTICS: '/analytics',
     ANALYZE: '/analyze',
     ASSETS_LOGO: '/assets/logo',
-    ASSETS_TEMPLATES: '/assets/templates',
     ASSETS_YAML: '/assets/yaml',
     AUTH_VALIDATE: '/auth/validate',
     BILLING_CAP: '/billing/cap',
@@ -36,8 +36,9 @@ export const API_ENDPOINTS = Object.freeze({
     SEQUENCES_SDK: '/sequences/sdk',
     SEQUENCES_VALIDATE: '/sequences/validate',
 });
-const DEV_LOGIN_URL = 'https://app-vertex-debug.azurewebsites.net/signup';
-const PRODUCTION_LOGIN_URL = 'https://app.mailmodo.dev/signup';
+const DEV_LOGIN_URL = 'https://app-vertex-debug.azurewebsites.net/signup.html';
+// const PRODUCTION_LOGIN_URL = 'https://mailmodo.com/cli';
+const PRODUCTION_LOGIN_URL = 'https://app-vertex-debug.azurewebsites.net/signup.html';
 export const LOGIN_URL = process.env.MAILMODO_DEV_TSX
     ? DEV_LOGIN_URL
     : PRODUCTION_LOGIN_URL;

package/dist/lib/messages.d.ts

@@ -63,7 +63,6 @@ export declare const DEPLOY: {
     readonly SDK_ONBOARDING_HEADER: string;
     readonly SUCCESS: `${string} Emails are live.`;
 };
-export declare function restoredFromServerHint(ids: string[]): string;
 export declare function pauseSuccess(sequenceId: string): string;
 export declare function pauseAlready(sequenceId: string): string;
 export declare function resumeSuccess(sequenceId: string): string;

package/dist/lib/messages.js

@@ -63,27 +63,6 @@ export const DEPLOY = {
     SDK_ONBOARDING_HEADER: chalk.bold('ADD THIS TO YOUR APP (one-time only):'),
     SUCCESS: `${chalk.green('Deployed.')} Emails are live.`,
 };
-export function restoredFromServerHint(ids) {
-    if (ids.length === 1) {
-        const [id] = ids;
-        return (`Template ${chalk.cyan(id)} was not found locally and has been refreshed from the server.\n` +
-            `  Review it with ${chalk.cyan(`mailmodo preview ${id}`)}, then run ${chalk.cyan('mailmodo deploy')} again.`);
-    }
-    const header = 'Template ID';
-    const colWidth = Math.max(header.length, ...ids.map((id) => id.length));
-    const pad = (s) => s.padEnd(colWidth);
-    const hr = '─'.repeat(colWidth + 2);
-    const table = [
-        `  ┌${hr}┐`,
-        `  │ ${chalk.bold(pad(header))} │`,
-        `  ├${hr}┤`,
-        ...ids.map((id) => `  │ ${chalk.cyan(pad(id))} │`),
-        `  └${hr}┘`,
-    ].join('\n');
-    return (`${ids.length} templates were not found locally and have been refreshed from the server:\n\n` +
-        `${table}\n\n` +
-        `  Review each with ${chalk.cyan('mailmodo preview <id>')}, then run ${chalk.cyan('mailmodo deploy')} again.`);
-}
 export function pauseSuccess(sequenceId) {
     return `Sequence ${chalk.cyan(sequenceId)} paused. Run ${chalk.cyan(`mailmodo deploy --resume ${sequenceId}`)} to resume.`;
 }

package/dist/lib/templates/missing-templates.d.ts

@@ -1,19 +1,5 @@
 import { type MailmodoYaml } from '../yaml-config.js';
 import type { DeployFlags } from '../commands/deploy/types.js';
 import type { RegenCtx } from './types.js';
-/**
- * Returns the IDs of emails whose template file does not exist on disk.
- * Resolves the correct filename for each email by accounting for per-email
- * and project-level style settings (branded vs. plain).
- */
 export declare function getMissingTemplateIds(yamlConfig: MailmodoYaml): string[];
-/**
- * Handles the case where one or more template files are missing before a
- * command can proceed. First attempts a silent server restore for all missing
- * IDs; if the server has backups for all of them the command continues without
- * any user interaction. Only falls through to an interactive prompt (or an
- * immediate error in --json / --yes mode) for files the server also does not have.
- * Returns true if the situation was resolved (restored or regenerated), false
- * if the user chose to abort.
- */
-export declare function handleMissingTemplates(ctx: RegenCtx, yamlConfig: MailmodoYaml, missingIds: string[], flags: DeployFlags): Promise<'regenerated' | 'restored' | false>;
+export declare function handleMissingTemplates(ctx: RegenCtx, yamlConfig: MailmodoYaml, missingIds: string[], flags: DeployFlags): Promise<boolean>;

package/dist/lib/templates/missing-templates.js

@@ -2,56 +2,44 @@ import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { select } from '@inquirer/prompts';
 import chalk from 'chalk';
-import { TEMPLATES_DIR } from '../constants.js';
+import { API_ENDPOINTS, TEMPLATES_DIR } from '../constants.js';
 import { MISSING_TEMPLATES } from '../messages.js';
-import { getTemplateFilename } from '../yaml-config.js';
-import { regenerateMissingTemplates } from './regenerate.js';
-/**
- * Returns the IDs of emails whose template file does not exist on disk.
- * Resolves the correct filename for each email by accounting for per-email
- * and project-level style settings (branded vs. plain).
- */
+import { getTemplateFilename, saveTemplate, } from '../yaml-config.js';
+import { buildRegeneratePayload } from '../commands/deploy/payload.js';
 export function getMissingTemplateIds(yamlConfig) {
     return yamlConfig.emails
         .filter((e) => !existsSync(join(process.cwd(), TEMPLATES_DIR, getTemplateFilename(e.id, e.style, yamlConfig.project?.emailStyle))))
         .map((e) => e.id);
 }
-/**
- * Attempts to restore each missing template from the server without showing
- * any prompt or message to the user. Returns the IDs that could not be
- * restored — either because the server has no backup or a network error occurred.
- */
-async function silentlyRestoreFromServer(ctx, missingIds) {
-    const results = await Promise.all(missingIds.map((id) => ctx.fetchTemplate(id)));
-    // Keep only the IDs where the server fetch returned false (not restored)
-    return missingIds.filter((_, i) => !results[i]);
+async function regenerateMissingTemplates(ctx, yamlConfig, missingIds, flags) {
+    const response = await ctx.spinner(`  ${MISSING_TEMPLATES.REGENERATE_SPINNER}`, flags.json, () => ctx.post(API_ENDPOINTS.GENERATE, buildRegeneratePayload(yamlConfig, missingIds)));
+    if (!response.ok)
+        ctx.onApiError(response);
+    const saves = [];
+    for (const email of response.data?.emails ?? []) {
+        if (!/^[\w-]+$/.test(email.id))
+            continue;
+        if (email.html)
+            saves.push(saveTemplate(`${email.id}.html`, email.html));
+        if (email.plainHtml)
+            saves.push(saveTemplate(`${email.id}_plain.html`, email.plainHtml));
+    }
+    await Promise.all(saves);
+    await ctx.syncYaml();
 }
-/**
- * Handles the case where one or more template files are missing before a
- * command can proceed. First attempts a silent server restore for all missing
- * IDs; if the server has backups for all of them the command continues without
- * any user interaction. Only falls through to an interactive prompt (or an
- * immediate error in --json / --yes mode) for files the server also does not have.
- * Returns true if the situation was resolved (restored or regenerated), false
- * if the user chose to abort.
- */
 export async function handleMissingTemplates(ctx, yamlConfig, missingIds, flags) {
-    // Try to silently recover from server before interrupting the user
-    const stillMissing = await silentlyRestoreFromServer(ctx, missingIds);
-    if (stillMissing.length === 0)
-        return 'restored';
     if (flags.json) {
         ctx.log(JSON.stringify({
             error: 'missing_templates',
             message: MISSING_TEMPLATES.YES_ERROR,
-            missingTemplates: stillMissing.map((id) => `${id}.html`),
+            missingTemplates: missingIds.map((id) => `${id}.html`),
         }, null, 2));
         ctx.exit(1);
     }
     if (flags.yes)
         ctx.error(MISSING_TEMPLATES.YES_ERROR);
     ctx.log(`\n  ${MISSING_TEMPLATES.HEADER}`);
-    for (const id of stillMissing)
+    for (const id of missingIds)
         ctx.log(`  ${chalk.red('✗')} mailmodo/${id}.html`);
     ctx.log(`\n  ${MISSING_TEMPLATES.REGENERATE_NOTE}\n`);
     const action = await select({
@@ -68,6 +56,6 @@ export async function handleMissingTemplates(ctx, yamlConfig, missingIds, flags)
         ctx.log(`\n  ${MISSING_TEMPLATES.ABORT_HINT}\n`);
         return false;
     }
-    await regenerateMissingTemplates(ctx, yamlConfig, stillMissing, flags);
-    return 'regenerated';
+    await regenerateMissingTemplates(ctx, yamlConfig, missingIds, flags);
+    return true;
 }

package/dist/lib/templates/types.d.ts

@@ -1,9 +1,7 @@
 import type { ApiResponse } from '../api-client.js';
-import type { MailmodoYaml } from '../yaml-config.js';
 export type RegenCtx = {
     error(msg: string): never;
     exit(code?: number): never;
-    fetchTemplate(emailId: string): Promise<boolean>;
     log(msg?: string): void;
     onApiError(resp: {
         error?: string;
@@ -11,6 +9,5 @@ export type RegenCtx = {
     }): never;
     post<T = Record<string, unknown>>(path: string, body?: Record<string, unknown> | unknown): Promise<ApiResponse<T>>;
     spinner<T>(text: string, json: boolean, work: () => Promise<T>): Promise<T>;
-    syncTemplates(yaml: MailmodoYaml): Promise<void>;
     syncYaml(): Promise<void>;
 };

package/oclif.manifest.json

@@ -765,5 +765,5 @@
       ]
     }
   },
-  "version": "0.0.56-beta.pr58.99"
+  "version": "0.0.56"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mailmodo/cli",
   "description": "Email lifecycle automation for the AI-native builder generation.",
-  "version": "0.0.56-beta.pr58.99",
+  "version": "0.0.56",
   "author": "provishalk",
   "bin": {
     "mailmodo": "bin/run.js"

package/dist/lib/templates/regenerate.d.ts

@@ -1,10 +0,0 @@
-import { type MailmodoYaml } from '../yaml-config.js';
-import type { DeployFlags } from '../commands/deploy/types.js';
-import type { RegenCtx } from './types.js';
-/**
- * Calls POST /email/generate with the missing email IDs, writes the returned
- * HTML files to disk, then syncs both the YAML and all templates to the server.
- * Called when the user chooses "Re-generate via AI" from the missing-template
- * prompt, or when no server backup exists to restore from.
- */
-export declare function regenerateMissingTemplates(ctx: RegenCtx, yamlConfig: MailmodoYaml, missingIds: string[], flags: DeployFlags): Promise<void>;

package/dist/lib/templates/regenerate.js

@@ -1,29 +0,0 @@
-import { API_ENDPOINTS } from '../constants.js';
-import { saveTemplate } from '../yaml-config.js';
-import { buildRegeneratePayload } from '../commands/deploy/payload.js';
-import { MISSING_TEMPLATES } from '../messages.js';
-/**
- * Calls POST /email/generate with the missing email IDs, writes the returned
- * HTML files to disk, then syncs both the YAML and all templates to the server.
- * Called when the user chooses "Re-generate via AI" from the missing-template
- * prompt, or when no server backup exists to restore from.
- */
-export async function regenerateMissingTemplates(ctx, yamlConfig, missingIds, flags) {
-    const response = await ctx.spinner(`  ${MISSING_TEMPLATES.REGENERATE_SPINNER}`, flags.json, () => ctx.post(API_ENDPOINTS.GENERATE, buildRegeneratePayload(yamlConfig, missingIds)));
-    if (!response.ok)
-        ctx.onApiError(response);
-    const saves = [];
-    for (const email of response.data?.emails ?? []) {
-        // Guard against path traversal: only allow alphanumeric, dash, and underscore IDs
-        if (!/^[\w-]+$/.test(email.id))
-            continue;
-        if (email.html)
-            saves.push(saveTemplate(`${email.id}.html`, email.html));
-        if (email.plainHtml)
-            saves.push(saveTemplate(`${email.id}_plain.html`, email.plainHtml));
-    }
-    await Promise.all(saves);
-    await ctx.syncYaml();
-    // Back up the freshly generated templates so the server reflects the new state
-    await ctx.syncTemplates(yamlConfig);
-}

package/dist/lib/templates/sync.d.ts

@@ -1,33 +0,0 @@
-import type { ApiClient } from '../api-client.js';
-import { type MailmodoYaml } from '../yaml-config.js';
-/**
- * Bulk-uploads all template HTML files referenced in the YAML to the server
- * as a backup. Only files present on disk are sent; any extra files in the
- * mailmodo/ folder that are not listed in the YAML are intentionally skipped.
- * All files are read in parallel before building the multipart payload.
- */
-export declare function syncTemplatesToServer(client: ApiClient, yaml: MailmodoYaml): Promise<void>;
-/**
- * Uploads a single template's HTML files to the server for incremental sync.
- * Used by the edit command after a change so only the modified template is
- * re-uploaded instead of the full set. The branded HTML (`html` field) is
- * required by the API; the plain variant (`plainHtml`) is uploaded only if
- * its file exists on disk.
- */
-export declare function syncTemplateToServer(client: ApiClient, emailId: string): Promise<void>;
-/**
- * Downloads all backed-up templates from the server and writes them to the
- * local mailmodo/ folder. Only templates whose emailId appears in the YAML
- * are written to disk — extra templates stored on the server (e.g. from a
- * previous project state) are intentionally ignored to keep the local folder
- * in sync with the current YAML.
- * Returns true if at least one file was written, false otherwise.
- */
-export declare function fetchTemplatesFromServer(client: ApiClient, yaml: MailmodoYaml): Promise<boolean>;
-/**
- * Downloads a single backed-up template from the server by emailId and writes
- * it to the local mailmodo/ folder. Returns true if the template was found and
- * written successfully, false if it has not been backed up or on any error.
- * The plain HTML variant is only written if the server returned a non-empty value.
- */
-export declare function fetchTemplateFromServer(client: ApiClient, emailId: string): Promise<boolean>;

package/dist/lib/templates/sync.js

@@ -1,106 +0,0 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { readFile } from 'node:fs/promises';
-import { API_ENDPOINTS, TEMPLATES_DIR } from '../constants.js';
-import { saveTemplate } from '../yaml-config.js';
-/**
- * Bulk-uploads all template HTML files referenced in the YAML to the server
- * as a backup. Only files present on disk are sent; any extra files in the
- * mailmodo/ folder that are not listed in the YAML are intentionally skipped.
- * All files are read in parallel before building the multipart payload.
- */
-export async function syncTemplatesToServer(client, yaml) {
-    // Collect filenames for both branded and plain variants, filtered to those that exist on disk
-    const filenames = yaml.emails
-        .flatMap((email) => [`${email.id}.html`, `${email.id}_plain.html`])
-        .filter((f) => existsSync(join(process.cwd(), TEMPLATES_DIR, f)));
-    if (filenames.length === 0)
-        return;
-    // Read all files in parallel to avoid sequential await-in-loop
-    const files = await Promise.all(filenames.map(async (f) => ({
-        content: await readFile(join(process.cwd(), TEMPLATES_DIR, f), 'utf8'),
-        name: f,
-    })));
-    // API expects multipart fields keyed by the template filename (e.g. abc123.html)
-    const formData = new FormData();
-    for (const { name, content } of files) {
-        formData.append(name, new Blob([content], { type: 'text/html' }), name);
-    }
-    await client.postFormData(API_ENDPOINTS.ASSETS_TEMPLATES, formData);
-}
-/**
- * Uploads a single template's HTML files to the server for incremental sync.
- * Used by the edit command after a change so only the modified template is
- * re-uploaded instead of the full set. The branded HTML (`html` field) is
- * required by the API; the plain variant (`plainHtml`) is uploaded only if
- * its file exists on disk.
- */
-export async function syncTemplateToServer(client, emailId) {
-    const htmlPath = join(process.cwd(), TEMPLATES_DIR, `${emailId}.html`);
-    // API requires the branded HTML field; skip entirely if the file is absent
-    if (!existsSync(htmlPath))
-        return;
-    const formData = new FormData();
-    const html = await readFile(htmlPath, 'utf8');
-    formData.append('html', new Blob([html], { type: 'text/html' }), `${emailId}.html`);
-    const plainPath = join(process.cwd(), TEMPLATES_DIR, `${emailId}_plain.html`);
-    if (existsSync(plainPath)) {
-        const plainHtml = await readFile(plainPath, 'utf8');
-        formData.append('plainHtml', new Blob([plainHtml], { type: 'text/html' }), `${emailId}_plain.html`);
-    }
-    await client.postFormData(`${API_ENDPOINTS.ASSETS_TEMPLATES}/${emailId}`, formData);
-}
-/**
- * Downloads all backed-up templates from the server and writes them to the
- * local mailmodo/ folder. Only templates whose emailId appears in the YAML
- * are written to disk — extra templates stored on the server (e.g. from a
- * previous project state) are intentionally ignored to keep the local folder
- * in sync with the current YAML.
- * Returns true if at least one file was written, false otherwise.
- */
-export async function fetchTemplatesFromServer(client, yaml) {
-    try {
-        const resp = await client.get(API_ENDPOINTS.ASSETS_TEMPLATES);
-        if (!resp.ok || !resp.data?.templates?.length)
-            return false;
-        // Build a set of valid IDs from the YAML to filter out stale server entries
-        const validIds = new Set(yaml.emails.map((e) => e.id));
-        const saves = [];
-        for (const t of resp.data.templates) {
-            if (!validIds.has(t.emailId))
-                continue;
-            // The API returns an empty string when a variant was never stored; skip those
-            if (t.html)
-                saves.push(saveTemplate(`${t.emailId}.html`, t.html));
-            if (t.plainHtml)
-                saves.push(saveTemplate(`${t.emailId}_plain.html`, t.plainHtml));
-        }
-        await Promise.all(saves);
-        return saves.length > 0;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Downloads a single backed-up template from the server by emailId and writes
- * it to the local mailmodo/ folder. Returns true if the template was found and
- * written successfully, false if it has not been backed up or on any error.
- * The plain HTML variant is only written if the server returned a non-empty value.
- */
-export async function fetchTemplateFromServer(client, emailId) {
-    try {
-        const resp = await client.get(`${API_ENDPOINTS.ASSETS_TEMPLATES}/${emailId}`);
-        // A missing or empty html field means the template was never backed up
-        if (!resp.ok || !resp.data?.html)
-            return false;
-        await saveTemplate(`${emailId}.html`, resp.data.html);
-        // plainHtml is empty string when no plain variant is stored; skip in that case
-        if (resp.data.plainHtml)
-            await saveTemplate(`${emailId}_plain.html`, resp.data.plainHtml);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}