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

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 } from '../../lib/messages.js';
+import { MISSING_TEMPLATES, restoredFromServerHint, } 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,8 +44,10 @@ export default class Deploy extends BaseCommand {
         const yamlConfig = await this.ensureYaml();
         const missingIds = getMissingTemplateIds(yamlConfig);
         if (missingIds.length > 0) {
-            const regenerated = await handleMissingTemplates(ctx, yamlConfig, missingIds, baseFlags);
-            if (regenerated)
+            const result = await handleMissingTemplates(ctx, yamlConfig, missingIds, baseFlags);
+            if (result === 'restored')
+                ctx.log(`\n  ${chalk.green('✓')} ${restoredFromServerHint(missingIds)}\n`);
+            else if (result === 'regenerated')
                 ctx.log(`\n  ${chalk.green('✓')} ${MISSING_TEMPLATES.REVIEW_HINT}\n`);
             return;
         }
@@ -69,6 +71,7 @@ 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,
@@ -86,6 +89,7 @@ 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();
@@ -97,6 +101,7 @@ 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,6 +63,7 @@ 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(),
         };
     }
@@ -70,10 +71,12 @@ 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

@@ -20,6 +20,11 @@ export default class Init extends BaseCommand {
         await this.ensureAuth();
         const ctx = this.makeCtx();
         const baseFlags = { json: flags.json, yes: flags.yes };
+        if (this.isBlankDirectory()) {
+            const restored = await this.promptInitServerRestore(baseFlags);
+            if (restored)
+                return;
+        }
         const existing = await loadYaml();
         if (!(await confirmOverwrite(ctx, baseFlags, existing)))
             return;
@@ -39,6 +44,7 @@ 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/login/index.js

@@ -27,9 +27,7 @@ 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);
-                logAlreadyLoggedIn(ctx, existing, yamlRestored, { json: flags.json });
+                logAlreadyLoggedIn(ctx, existing, { json: flags.json });
                 return;
             }
         }
@@ -42,8 +40,7 @@ export default class Login extends BaseCommand {
         }
         const { email, totalFreeRemaining, paidEmailsRemaining, plan } = response.data;
         await saveConfig({ apiKey: trimmedKey, email, totalFreeRemaining });
-        const yamlRestored = await this.recoverYamlAfterLogin(client);
-        logLoginSuccess(ctx, { email, paidEmailsRemaining, plan, totalFreeRemaining }, yamlRestored, { json: flags.json });
+        logLoginSuccess(ctx, { email, paidEmailsRemaining, plan, totalFreeRemaining }, { json: flags.json });
     }
     makeCtx() {
         return {

package/dist/commands/preview/index.js

@@ -82,10 +82,12 @@ 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

@@ -68,28 +68,53 @@ export declare abstract class BaseCommand extends Command {
      *   settings and all email sequence definitions.
      */
     protected ensureYaml(): Promise<MailmodoYaml>;
+    protected isBlankDirectory(): boolean;
+    protected fetchYamlText(): Promise<null | string>;
+    private promptBlankDirRestore;
+    protected promptInitServerRestore(flags: {
+        json?: boolean;
+        yes?: boolean;
+    }): Promise<boolean>;
     private fetchAndWriteYaml;
     /**
      * Attempts to fetch mailmodo.yaml from the server and save it locally.
      * Returns null silently on any failure so callers can fall through to an error.
      */
     private restoreYamlFromServer;
-    /**
-     * If `mailmodo.yaml` is absent from the current directory, attempts to restore
-     * it from the server using the given client. Returns `true` if the file was
-     * successfully written, `false` otherwise (file already present, server 404,
-     * or any network error). Silent — never throws.
-     *
-     * 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>;
     /**
      * Uploads the current local mailmodo.yaml to the server as a backup.
      * Best-effort: silently ignores all errors so the originating 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

@@ -1,14 +1,16 @@
 import { existsSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { input } from '@inquirer/prompts';
+import { input, select } 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 { API_ENDPOINTS, IS_DEV_MODE, YAML_FILE } from './constants.js';
-import { ERRORS, INFO, PROMPTS, quotaExhaustedMessage, recordLabel, VALIDATION, } from './messages.js';
+import { API_ENDPOINTS, IS_DEV_MODE, TEMPLATES_DIR, YAML_FILE, } from './constants.js';
+import { syncTemplatesToServer, syncTemplateToServer, fetchTemplatesFromServer, fetchTemplateFromServer, } from './templates/sync.js';
+import { getMissingTemplateIds } from './templates/missing-templates.js';
+import { BLANK_DIR, ERRORS, INFO, PROMPTS, quotaExhaustedMessage, recordLabel, VALIDATION, } from './messages.js';
 import { loadYaml, saveYaml } from './yaml-config.js';
 export const FREE_TIER = 'free';
 /**
@@ -90,11 +92,89 @@ export class BaseCommand extends Command {
         const config = await loadYaml();
         if (config)
             return config;
+        if (this.isBlankDirectory())
+            return this.promptBlankDirRestore();
         const restored = await this.restoreYamlFromServer();
         if (restored)
             return restored;
         this.error(ERRORS.NO_YAML);
     }
+    isBlankDirectory() {
+        return (!existsSync(join(process.cwd(), YAML_FILE)) &&
+            !existsSync(join(process.cwd(), TEMPLATES_DIR)));
+    }
+    async fetchYamlText() {
+        try {
+            let client = this.apiClient;
+            if (!client) {
+                const apiKey = process.env.MAILMODO_API_KEY ?? (await loadConfig())?.apiKey;
+                if (!apiKey)
+                    return null;
+                client = new ApiClient(apiKey);
+            }
+            const response = await client.getRawText(API_ENDPOINTS.ASSETS_YAML);
+            return response.ok && response.data ? response.data : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async promptBlankDirRestore() {
+        const yamlText = await this.fetchYamlText();
+        if (!yamlText)
+            this.error(ERRORS.NO_YAML);
+        const autoRestore = this.argv.includes('--yes') || this.argv.includes('--json');
+        if (!autoRestore) {
+            this.log(`\n  ${BLANK_DIR.PROMPT}\n`);
+            const choice = await select({
+                choices: [
+                    { name: BLANK_DIR.CHOICE_RESTORE, value: 'restore' },
+                    { name: BLANK_DIR.CHOICE_SKIP, value: 'skip' },
+                ],
+                message: 'How would you like to proceed?',
+            });
+            if (choice === 'skip') {
+                this.log(`\n  ${BLANK_DIR.SKIP_HINT}\n`);
+                this.exit(0);
+            }
+        }
+        await writeFile(join(process.cwd(), YAML_FILE), yamlText);
+        this.logToStderr(INFO.YAML_RESTORED_FROM_SERVER);
+        const yaml = await loadYaml();
+        if (!yaml)
+            this.error(ERRORS.NO_YAML);
+        const client = this.apiClient;
+        if (client)
+            await this.fetchMissingTemplates(client, yaml);
+        return yaml;
+    }
+    async promptInitServerRestore(flags) {
+        const yamlText = await this.fetchYamlText();
+        if (!yamlText)
+            return false;
+        let shouldRestore = Boolean(flags.yes || flags.json);
+        if (!shouldRestore) {
+            const choice = await select({
+                choices: [
+                    { name: BLANK_DIR.CHOICE_RESTORE_INIT, value: 'restore' },
+                    { name: BLANK_DIR.CHOICE_FRESH, value: 'fresh' },
+                ],
+                message: BLANK_DIR.PROMPT_INIT,
+            });
+            shouldRestore = choice === 'restore';
+        }
+        if (!shouldRestore)
+            return false;
+        await writeFile(join(process.cwd(), YAML_FILE), yamlText);
+        const yaml = await loadYaml();
+        if (!yaml)
+            return false;
+        const client = this.apiClient;
+        if (client)
+            await this.fetchMissingTemplates(client, yaml);
+        this.log(`\n  ${BLANK_DIR.RESTORED_INIT}\n`);
+        return true;
+    }
     async fetchAndWriteYaml(client) {
         try {
             const response = await client.getRawText(API_ENDPOINTS.ASSETS_YAML);
@@ -131,20 +211,6 @@ export class BaseCommand extends Command {
             return null;
         }
     }
-    /**
-     * If `mailmodo.yaml` is absent from the current directory, attempts to restore
-     * it from the server using the given client. Returns `true` if the file was
-     * successfully written, `false` otherwise (file already present, server 404,
-     * or any network error). Silent — never throws.
-     *
-     * 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) {
-        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.
      * Best-effort: silently ignores all errors so the originating command
@@ -173,6 +239,92 @@ 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,12 +20,13 @@ 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) {
+function logJsonResult(ctx, email, updated, oldSubject, oldPreviewText) {
     ctx.log(JSON.stringify({
         diff: {
-            previewText: updated.previewText && updated.previewText !== email.previewText
-                ? { new: updated.previewText, old: email.previewText }
+            previewText: updated.previewText && updated.previewText !== oldPreviewText
+                ? { new: updated.previewText, old: oldPreviewText }
                 : undefined,
             subject: oldSubject === email.subject
                 ? undefined
@@ -51,10 +52,11 @@ 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);
+        logJsonResult(ctx, editCtx.email, updated, oldSubject, oldPreviewText);
     }
     else if (flags.yes) {
         ctx.log(`\n  Updated ${chalk.green('mailmodo.yaml')}\n`);

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

@@ -33,5 +33,6 @@ 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', () => resolve(true));
+            child.on('close', (code) => resolve(code === 0));
         });
         if (launched)
             return;

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

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

package/dist/lib/commands/login/output.d.ts

@@ -1,8 +1,8 @@
 import type { LoginCtx, ValidateResponse } from './types.js';
 import type { MailmodoConfig } from '../../config.js';
-export declare function logAlreadyLoggedIn(ctx: LoginCtx, existing: MailmodoConfig, yamlRestored: boolean, opts: {
+export declare function logAlreadyLoggedIn(ctx: LoginCtx, existing: MailmodoConfig, opts: {
     json: boolean;
 }): void;
-export declare function logLoginSuccess(ctx: LoginCtx, data: Pick<ValidateResponse, 'email' | 'paidEmailsRemaining' | 'plan' | 'totalFreeRemaining'>, yamlRestored: boolean, opts: {
+export declare function logLoginSuccess(ctx: LoginCtx, data: Pick<ValidateResponse, 'email' | 'paidEmailsRemaining' | 'plan' | 'totalFreeRemaining'>, opts: {
     json: boolean;
 }): void;

package/dist/lib/commands/login/output.js

@@ -1,12 +1,10 @@
 import chalk from 'chalk';
-import { INFO } from '../../messages.js';
-export function logAlreadyLoggedIn(ctx, existing, yamlRestored, opts) {
+export function logAlreadyLoggedIn(ctx, existing, opts) {
     if (opts.json) {
         ctx.log(JSON.stringify({
             email: existing.email ?? null,
             status: 'already_logged_in',
             totalFreeRemaining: existing.totalFreeRemaining ?? null,
-            yamlRestored,
         }, null, 2));
         return;
     }
@@ -15,15 +13,10 @@ export function logAlreadyLoggedIn(ctx, existing, yamlRestored, opts) {
         ? chalk.green(existing.email.trim())
         : chalk.dim('(unknown)');
     ctx.log(`  Email: ${emailDisplay}\n`);
-    if (yamlRestored) {
-        ctx.log(`  ${INFO.YAML_RESTORED_ON_LOGIN}`);
-    }
-    else {
-        ctx.log(`  ${chalk.dim('1.')} Run ${chalk.cyan('mailmodo init')} to generate an email sequence.`);
-    }
-    ctx.log(`  ${chalk.dim(yamlRestored ? '1.' : '2.')} Run ${chalk.cyan('mailmodo logout')} to log in with another account.\n`);
+    ctx.log(`  ${chalk.dim('1.')} Run ${chalk.cyan('mailmodo init')} to generate an email sequence.`);
+    ctx.log(`  ${chalk.dim('2.')} Run ${chalk.cyan('mailmodo logout')} to log in with another account.\n`);
 }
-export function logLoginSuccess(ctx, data, yamlRestored, opts) {
+export function logLoginSuccess(ctx, data, opts) {
     const { email, plan, totalFreeRemaining, paidEmailsRemaining } = data;
     if (opts.json) {
         ctx.log(JSON.stringify({
@@ -32,7 +25,6 @@ export function logLoginSuccess(ctx, data, yamlRestored, opts) {
             plan,
             status: 'authenticated',
             totalFreeRemaining,
-            yamlRestored,
         }, null, 2));
         return;
     }
@@ -44,10 +36,5 @@ export function logLoginSuccess(ctx, data, yamlRestored, opts) {
     if (plan === 'paid') {
         ctx.log(`  Current paid block: ${chalk.cyan(String(paidEmailsRemaining))} emails remaining\n`);
     }
-    if (yamlRestored) {
-        ctx.log(`  ${INFO.YAML_RESTORED_ON_LOGIN}\n`);
-    }
-    else {
-        ctx.log(`  Next: Run ${chalk.cyan("'mailmodo init'")} to generate your email sequences.\n`);
-    }
+    ctx.log(`  Next: Run ${chalk.cyan("'mailmodo init'")} to generate your email sequences.\n`);
 }

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

@@ -1,7 +1,9 @@
 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;
@@ -9,6 +11,7 @@ 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,11 +4,12 @@
  * 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 = "https://app-vertex-debug.azurewebsites.net";
+export declare const API_BASE_URL: string;
 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";
@@ -30,7 +31,7 @@ export declare const API_ENDPOINTS: Readonly<{
     SEQUENCES_SDK: "/sequences/sdk";
     SEQUENCES_VALIDATE: "/sequences/validate";
 }>;
-export declare const LOGIN_URL = "https://app-vertex-debug.azurewebsites.net/signup.html";
+export declare const LOGIN_URL: string;
 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,13 +1,12 @@
 /** 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;
@@ -15,6 +14,7 @@ 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,9 +36,8 @@ 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.html';
-// const PRODUCTION_LOGIN_URL = 'https://mailmodo.com/cli';
-const PRODUCTION_LOGIN_URL = 'https://app-vertex-debug.azurewebsites.net/signup.html';
+const DEV_LOGIN_URL = 'https://app-vertex-debug.azurewebsites.net/signup';
+const PRODUCTION_LOGIN_URL = 'https://app.mailmodo.dev/signup';
 export const LOGIN_URL = process.env.MAILMODO_DEV_TSX
     ? DEV_LOGIN_URL
     : PRODUCTION_LOGIN_URL;

package/dist/lib/messages.d.ts

@@ -13,6 +13,16 @@ export declare const PROMPTS: {
     readonly REPLY_TO: "Reply-to address (optional, press Enter to use sender email):";
     readonly SENDER_EMAIL: "Sender email address:";
 };
+export declare const BLANK_DIR: {
+    readonly CHOICE_FRESH: "Start fresh — create a new project here";
+    readonly CHOICE_RESTORE: "Restore project files from server";
+    readonly CHOICE_RESTORE_INIT: "Restore existing project files from server";
+    readonly CHOICE_SKIP: "Skip — I'll navigate to my project directory manually";
+    readonly PROMPT: "No mailmodo.yaml or templates found in this directory.";
+    readonly PROMPT_INIT: "A project was found on the server. What would you like to do?";
+    readonly RESTORED_INIT: `Project restored from server. Run ${string} to re-deploy, or ${string} to review your emails.`;
+    readonly SKIP_HINT: `Navigate to your project directory and run your command there, or run ${string} to start a new project here.`;
+};
 export declare const MISSING_TEMPLATES: {
     readonly ABORT_HINT: `Restore the missing files from version control, then run ${string} again.`;
     readonly CHOICE_ABORT: "Abort (restore from version control)";
@@ -63,6 +73,7 @@ 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

@@ -14,6 +14,16 @@ export const PROMPTS = {
     REPLY_TO: 'Reply-to address (optional, press Enter to use sender email):',
     SENDER_EMAIL: 'Sender email address:',
 };
+export const BLANK_DIR = {
+    CHOICE_FRESH: 'Start fresh — create a new project here',
+    CHOICE_RESTORE: 'Restore project files from server',
+    CHOICE_RESTORE_INIT: 'Restore existing project files from server',
+    CHOICE_SKIP: "Skip — I'll navigate to my project directory manually",
+    PROMPT: 'No mailmodo.yaml or templates found in this directory.',
+    PROMPT_INIT: 'A project was found on the server. What would you like to do?',
+    RESTORED_INIT: `Project restored from server. Run ${chalk.cyan('mailmodo deploy')} to re-deploy, or ${chalk.cyan('mailmodo emails')} to review your emails.`,
+    SKIP_HINT: `Navigate to your project directory and run your command there, or run ${chalk.cyan('mailmodo init')} to start a new project here.`,
+};
 export const MISSING_TEMPLATES = {
     ABORT_HINT: `Restore the missing files from version control, then run ${chalk.cyan('mailmodo deploy')} again.`,
     CHOICE_ABORT: 'Abort (restore from version control)',
@@ -63,6 +73,27 @@ 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,5 +1,19 @@
 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[];
-export declare function handleMissingTemplates(ctx: RegenCtx, yamlConfig: MailmodoYaml, missingIds: string[], flags: DeployFlags): Promise<boolean>;
+/**
+ * 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>;

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

@@ -2,44 +2,56 @@ import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { select } from '@inquirer/prompts';
 import chalk from 'chalk';
-import { API_ENDPOINTS, TEMPLATES_DIR } from '../constants.js';
+import { TEMPLATES_DIR } from '../constants.js';
 import { MISSING_TEMPLATES } from '../messages.js';
-import { getTemplateFilename, saveTemplate, } from '../yaml-config.js';
-import { buildRegeneratePayload } from '../commands/deploy/payload.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).
+ */
 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);
 }
-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();
+/**
+ * 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]);
 }
+/**
+ * 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: missingIds.map((id) => `${id}.html`),
+            missingTemplates: stillMissing.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 missingIds)
+    for (const id of stillMissing)
         ctx.log(`  ${chalk.red('✗')} mailmodo/${id}.html`);
     ctx.log(`\n  ${MISSING_TEMPLATES.REGENERATE_NOTE}\n`);
     const action = await select({
@@ -56,6 +68,6 @@ export async function handleMissingTemplates(ctx, yamlConfig, missingIds, flags)
         ctx.log(`\n  ${MISSING_TEMPLATES.ABORT_HINT}\n`);
         return false;
     }
-    await regenerateMissingTemplates(ctx, yamlConfig, missingIds, flags);
-    return true;
+    await regenerateMissingTemplates(ctx, yamlConfig, stillMissing, flags);
+    return 'regenerated';
 }

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,106 @@
+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;
+    }
+}

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

@@ -1,7 +1,9 @@
 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;
@@ -9,5 +11,6 @@ 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.55-beta.pr57.93"
+  "version": "0.0.56-beta.pr58.100"
 }

package/package.json

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