@mailmodo/cli 0.0.56 → 0.0.57-beta.pr59.109

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

@@ -1,7 +1,7 @@
 import { Flags } from '@oclif/core';
 import { BaseCommand } from '../../lib/base-command.js';
 import { API_ENDPOINTS } from '../../lib/constants.js';
-import { loadYaml, saveYaml } from '../../lib/yaml-config.js';
+import { loadYaml, saveYaml, } from '../../lib/yaml-config.js';
 import { analyzeProduct, promptProductUrl, } from '../../lib/commands/init/analysis.js';
 import { confirmOverwrite, logInitSuccess, } from '../../lib/commands/init/output.js';
 import { applyMonthlyCap, buildEmailConfigs, buildYamlConfig, preserveUserFields, saveAllTemplates, } from '../../lib/commands/init/payload.js';
@@ -20,6 +20,13 @@ export default class Init extends BaseCommand {
         await this.ensureAuth();
         const ctx = this.makeCtx();
         const baseFlags = { json: flags.json, yes: flags.yes };
+        let serverYaml = null;
+        if (this.isBlankDirectory()) {
+            const result = await this.promptInitServerRestore(baseFlags);
+            if (result.restored)
+                return;
+            serverYaml = result.serverYaml;
+        }
         const existing = await loadYaml();
         if (!(await confirmOverwrite(ctx, baseFlags, existing)))
             return;
@@ -33,12 +40,14 @@ export default class Init extends BaseCommand {
         const generatedEmails = generateResponse.data?.emails || [];
         const emailConfigs = buildEmailConfigs(analysisPayload, generatedEmails);
         const yamlConfig = buildYamlConfig(analysisPayload, emailConfigs, productUrl);
-        if (existing)
-            preserveUserFields(yamlConfig, existing);
+        const fieldSource = existing ?? serverYaml;
+        if (fieldSource)
+            preserveUserFields(yamlConfig, fieldSource);
         await saveYaml(yamlConfig);
         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/commands/report/index.d.ts

@@ -0,0 +1,22 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class Report extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        contact: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'email-id': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        event: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        from: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'group-by': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        page: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        preset: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        sequence: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        to: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private makeCtx;
+}

package/dist/commands/report/index.js

@@ -0,0 +1,123 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../lib/base-command.js';
+import { API_ENDPOINTS } from '../../lib/constants.js';
+import { REPORTS } from '../../lib/messages.js';
+import { buildReportPayload } from '../../lib/commands/report/payload.js';
+import { renderReport } from '../../lib/commands/report/output.js';
+import { promptReportFlags } from '../../lib/commands/report/prompt.js';
+export default class Report extends BaseCommand {
+    static description = 'Fetch an email analytics report';
+    static examples = [
+        '<%= config.bin %> report --preset last7d',
+        '<%= config.bin %> report --preset last30d --group-by emailId',
+        '<%= config.bin %> report --from YYYY-MM-DD --to YYYY-MM-DD --output timeseries',
+        '<%= config.bin %> report --preset last7d --output entries --page 1',
+        '<%= config.bin %> report --preset last30d --sequence welcome-flow --event opened',
+        '<%= config.bin %> report --preset last7d --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        contact: Flags.string({
+            description: 'Filter by contact email (repeatable)',
+            multiple: true,
+        }),
+        'email-id': Flags.string({
+            description: 'Filter by email template ID (repeatable)',
+            multiple: true,
+        }),
+        event: Flags.string({
+            description: 'Filter by event type (repeatable)',
+            multiple: true,
+            options: [
+                'bounced',
+                'clicked',
+                'complained',
+                'delivered',
+                'opened',
+                'sent',
+                'skipped',
+                'unsubscribed',
+            ],
+        }),
+        from: Flags.string({
+            description: 'Start of time range, inclusive (YYYY-MM-DD)',
+            exclusive: ['preset'],
+        }),
+        'group-by': Flags.string({
+            default: 'none',
+            description: 'Group results by dimension',
+            options: [
+                'contact',
+                'day',
+                'emailId',
+                'hour',
+                'none',
+                'sequenceId',
+                'status',
+            ],
+        }),
+        limit: Flags.integer({
+            default: 50,
+            description: 'Entries per page, max 200 (entries output only)',
+            max: 200,
+        }),
+        output: Flags.string({
+            default: 'summary',
+            description: 'Output shape: summary | entries | timeseries',
+            options: ['entries', 'summary', 'timeseries'],
+        }),
+        page: Flags.integer({
+            default: 1,
+            description: 'Page number (entries output only)',
+        }),
+        preset: Flags.string({
+            description: 'Relative time range preset',
+            exclusive: ['from', 'to'],
+            options: [
+                'last30d',
+                'last7d',
+                'last90d',
+                'lastMonth',
+                'thisMonth',
+                'today',
+                'yesterday',
+            ],
+        }),
+        sequence: Flags.string({
+            description: 'Filter by sequence ID (repeatable)',
+            multiple: true,
+        }),
+        to: Flags.string({
+            description: 'End of time range, exclusive (YYYY-MM-DD)',
+            exclusive: ['preset'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Report);
+        await this.ensureAuth();
+        if ((flags.from && !flags.to) || (!flags.from && flags.to)) {
+            this.error(REPORTS.FROM_TO_REQUIRED);
+        }
+        const resolved = flags.json
+            ? flags
+            : await promptReportFlags(flags);
+        const ctx = this.makeCtx();
+        const payload = buildReportPayload(resolved, (m) => this.error(m));
+        const response = await ctx.spinner(REPORTS.FETCH_SPINNER, flags.json, () => ctx.post(API_ENDPOINTS.REPORTS, payload));
+        if (!response.ok)
+            ctx.onApiError(response);
+        if (flags.json) {
+            this.log(JSON.stringify(response.data, null, 2));
+            return;
+        }
+        renderReport(ctx, response.data, resolved.output);
+    }
+    makeCtx() {
+        return {
+            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),
+        };
+    }
+}

package/dist/lib/api-client.d.ts

@@ -8,6 +8,8 @@ export interface ApiRequestDebugInfo {
     causeCode?: string;
     /** Fully resolved request URL (origin, path, and query string). */
     fullUrl: string;
+    /** Truncated JSON summary of the request body sent, when present. */
+    requestBody?: string;
     /** Truncated JSON summary of a non-empty error response body, when available. */
     responseSummary?: string;
 }

package/dist/lib/api-client.js

@@ -82,12 +82,12 @@ export class ApiClient {
             const data = await response.json().catch(() => ({}));
             if (!response.ok) {
                 const errorData = data;
-                const summary = summarizeResponseBody(data);
                 return {
                     data: data,
                     debug: {
                         ...debug,
-                        responseSummary: summary,
+                        requestBody: summarizeResponseBody(body),
+                        responseSummary: summarizeResponseBody(data),
                     },
                     error: errorData?.message ||
                         errorData?.error ||

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

@@ -68,28 +68,56 @@ 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<{
+        restored: boolean;
+        serverYaml: MailmodoYaml | null;
+    }>;
     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,15 +1,17 @@
 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 { loadYaml, saveYaml } from './yaml-config.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, parseYamlText, saveYaml, } from './yaml-config.js';
 export const FREE_TIER = 'free';
 /**
  * Abstract base command providing shared functionality for all Mailmodo CLI commands.
@@ -90,11 +92,90 @@ 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 { restored: false, serverYaml: null };
+        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 { restored: false, serverYaml: parseYamlText(yamlText) };
+        }
+        await writeFile(join(process.cwd(), YAML_FILE), yamlText);
+        const yaml = await loadYaml();
+        if (!yaml)
+            return { restored: false, serverYaml: null };
+        const client = this.apiClient;
+        if (client)
+            await this.fetchMissingTemplates(client, yaml);
+        this.log(`\n  ${BLANK_DIR.RESTORED_INIT}\n`);
+        return { restored: true, serverYaml: yaml };
+    }
     async fetchAndWriteYaml(client) {
         try {
             const response = await client.getRawText(API_ENDPOINTS.ASSETS_YAML);
@@ -131,20 +212,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 +240,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.
@@ -405,6 +558,9 @@ export class BaseCommand extends Command {
             status > 0
                 ? chalk.dim(`  Status: ${String(status)}`)
                 : chalk.dim('  Status: (No HTTP response — network or client error)'),
+            ...(debug.requestBody
+                ? [chalk.dim(`  Payload: ${debug.requestBody}`)]
+                : []),
             ...(debug.responseSummary
                 ? [chalk.dim(`  Response: ${debug.responseSummary}`)]
                 : []),

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;