@mailmodo/cli 0.0.53 → 0.0.54-beta.pr56.87

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

@@ -46,6 +46,11 @@ export declare class ApiClient {
      * Bearer auth as other requests; does not parse JSON.
      */
     getFile(url: string): Promise<FileFetchResult>;
+    /**
+     * GET an endpoint and return the raw response body as a string (e.g. YAML files).
+     * Uses Bearer auth; does not parse JSON.
+     */
+    getRawText(path: string): Promise<ApiResponse<string>>;
     /**
      * GET an external URL (e.g. blob storage) without auth headers.
      */

package/dist/lib/api-client.js

@@ -135,6 +135,51 @@ export class ApiClient {
     async getFile(url) {
         return fetchFileWithBearerAuth(url, this.apiKey);
     }
+    /**
+     * GET an endpoint and return the raw response body as a string (e.g. YAML files).
+     * Uses Bearer auth; does not parse JSON.
+     */
+    async getRawText(path) {
+        const url = this.resolveUrl(path);
+        const debug = this.requestDebug(url);
+        try {
+            const response = await fetch(url.toString(), {
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    'User-Agent': '@mailmodo/cli',
+                },
+                method: 'GET',
+            });
+            const text = await response.text().catch(() => '');
+            if (!response.ok) {
+                return {
+                    data: '',
+                    debug: {
+                        ...debug,
+                        ...(text ? { responseSummary: text.slice(0, 200) } : {}),
+                    },
+                    error: text || `Request failed with status ${response.status}`,
+                    ok: false,
+                    status: response.status,
+                };
+            }
+            return { data: text, ok: true, status: response.status };
+        }
+        catch (error) {
+            const err = error;
+            const isConnectionError = err?.cause?.code === 'ECONNREFUSED' || err?.cause?.code === 'ENOTFOUND';
+            const causeCode = err?.cause?.code;
+            return {
+                data: '',
+                debug: { ...debug, ...(causeCode ? { causeCode } : {}) },
+                error: isConnectionError
+                    ? 'Cannot connect to Mailmodo API. The API service may not be available yet.'
+                    : err?.message || 'An unexpected network error occurred.',
+                ok: false,
+                status: 0,
+            };
+        }
+    }
     /**
      * GET an external URL (e.g. blob storage) without auth headers.
      */

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

@@ -60,12 +60,35 @@ export declare abstract class BaseCommand extends Command {
     }, work: () => Promise<T>): Promise<T>;
     /**
      * Loads and returns the mailmodo.yaml configuration from the current directory.
-     * Exits with an error if the file is not found, directing the user to run init.
+     * If the file is not found locally and the API client is available, attempts to
+     * restore it from the server. Exits with an error if the file cannot be found
+     * or restored, directing the user to run init.
      *
      * @returns {Promise<MailmodoYaml>} The parsed mailmodo.yaml containing project
      *   settings and all email sequence definitions.
      */
     protected ensureYaml(): Promise<MailmodoYaml>;
+    /**
+     * 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>;
     /**
      * 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,10 +1,13 @@
+import { existsSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import { input } from '@inquirer/prompts';
 import { Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
 import ora from 'ora';
 import { ApiClient } from './api-client.js';
 import { loadConfig } from './config.js';
-import { API_ENDPOINTS, IS_DEV_MODE } from './constants.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';
 export const FREE_TIER = 'free';
@@ -76,17 +79,92 @@ export class BaseCommand extends Command {
     }
     /**
      * Loads and returns the mailmodo.yaml configuration from the current directory.
-     * Exits with an error if the file is not found, directing the user to run init.
+     * If the file is not found locally and the API client is available, attempts to
+     * restore it from the server. Exits with an error if the file cannot be found
+     * or restored, directing the user to run init.
      *
      * @returns {Promise<MailmodoYaml>} The parsed mailmodo.yaml containing project
      *   settings and all email sequence definitions.
      */
     async ensureYaml() {
         const config = await loadYaml();
-        if (!config) {
-            this.error(ERRORS.NO_YAML);
+        if (config)
+            return config;
+        const restored = await this.restoreYamlFromServer();
+        if (restored)
+            return restored;
+        this.error(ERRORS.NO_YAML);
+    }
+    /**
+     * 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.
+     */
+    async restoreYamlFromServer() {
+        if (!this.apiClient)
+            return null;
+        try {
+            const response = await this.apiClient.getRawText(API_ENDPOINTS.ASSETS_YAML);
+            if (!response.ok || !response.data)
+                return null;
+            const filePath = join(process.cwd(), YAML_FILE);
+            await writeFile(filePath, response.data);
+            this.log(INFO.YAML_RESTORED_FROM_SERVER);
+            return loadYaml();
+        }
+        catch {
+            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;
+        try {
+            const response = await client.getRawText(API_ENDPOINTS.ASSETS_YAML);
+            if (!response.ok || !response.data)
+                return false;
+            await writeFile(join(process.cwd(), YAML_FILE), response.data);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 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.
+     */
+    async syncYamlToServer() {
+        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);
+            }
+            const filePath = join(process.cwd(), YAML_FILE);
+            if (!existsSync(filePath))
+                return;
+            const content = await readFile(filePath, 'utf8');
+            const blob = new Blob([content], { type: 'application/yaml' });
+            const formData = new FormData();
+            formData.append('yaml', blob, YAML_FILE);
+            await client.postFormData(API_ENDPOINTS.ASSETS_YAML, formData);
+        }
+        catch {
+            // Silently ignore — local file remains authoritative
         }
-        return config;
     }
     /**
      * Handles a failed API response by mapping HTTP status codes to
@@ -276,6 +354,7 @@ export class BaseCommand extends Command {
         if (inputs.replyTo)
             yamlConfig.project.replyTo = inputs.replyTo;
         await saveYaml(yamlConfig);
+        await this.syncYamlToServer();
         return {
             dnsGuideUrl: response.data?.dnsGuideUrl,
             dnsRecords: response.data?.dnsRecords || [],

package/dist/lib/constants.d.ts

@@ -9,6 +9,7 @@ export declare const API_ENDPOINTS: Readonly<{
     ANALYTICS: "/analytics";
     ANALYZE: "/analyze";
     ASSETS_LOGO: "/assets/logo";
+    ASSETS_YAML: "/assets/yaml";
     AUTH_VALIDATE: "/auth/validate";
     BILLING_CAP: "/billing/cap";
     BILLING_CHECKOUT: "/billing/checkout";
@@ -26,6 +27,7 @@ export declare const API_ENDPOINTS: Readonly<{
     PREVIEW: "/preview";
     SEQUENCES: "/sequences";
     SEQUENCES_DEPLOY: "/sequences/deploy";
+    SEQUENCES_SDK: "/sequences/sdk";
     SEQUENCES_VALIDATE: "/sequences/validate";
 }>;
 export declare const LOGIN_URL = "https://app-vertex-debug.azurewebsites.net/signup.html";
@@ -33,3 +35,6 @@ export declare const PREVIEW_PORT = 3421;
 export declare const DEFAULT_BRAND_COLOR = "#1A56DB";
 export declare const TEMPLATES_DIR = "mailmodo";
 export declare const YAML_FILE = "mailmodo.yaml";
+export declare const SDK_PACKAGE_NAME = "@mailmodo/sdk";
+export declare const SDK_INSTALL_COMMAND = "npm install @mailmodo/sdk";
+export declare const SDK_IMPORT_SNIPPET = "import { track, identify } from '@mailmodo/sdk'";

package/dist/lib/constants.js

@@ -15,6 +15,7 @@ export const API_ENDPOINTS = Object.freeze({
     ANALYTICS: '/analytics',
     ANALYZE: '/analyze',
     ASSETS_LOGO: '/assets/logo',
+    ASSETS_YAML: '/assets/yaml',
     AUTH_VALIDATE: '/auth/validate',
     BILLING_CAP: '/billing/cap',
     BILLING_CHECKOUT: '/billing/checkout',
@@ -32,6 +33,7 @@ export const API_ENDPOINTS = Object.freeze({
     PREVIEW: '/preview',
     SEQUENCES: '/sequences',
     SEQUENCES_DEPLOY: '/sequences/deploy',
+    SEQUENCES_SDK: '/sequences/sdk',
     SEQUENCES_VALIDATE: '/sequences/validate',
 });
 const DEV_LOGIN_URL = 'https://app-vertex-debug.azurewebsites.net/signup.html';
@@ -44,3 +46,6 @@ export const PREVIEW_PORT = 3421;
 export const DEFAULT_BRAND_COLOR = '#1A56DB';
 export const TEMPLATES_DIR = 'mailmodo';
 export const YAML_FILE = 'mailmodo.yaml';
+export const SDK_PACKAGE_NAME = '@mailmodo/sdk';
+export const SDK_INSTALL_COMMAND = `npm install ${SDK_PACKAGE_NAME}`;
+export const SDK_IMPORT_SNIPPET = `import { track, identify } from '${SDK_PACKAGE_NAME}'`;

package/dist/lib/deploy/domain-setup.d.ts

@@ -0,0 +1,8 @@
+import type { MailmodoYaml } from '../yaml-config.js';
+import type { DeployCtx, DeployFlags, ValidateResponse } from './types.js';
+export declare function validateDeploySequence(ctx: DeployCtx, payload: object, flags: {
+    json: boolean;
+}): Promise<ValidateResponse>;
+export declare function verifyDomain(ctx: DeployCtx, jsonOutput: boolean, domain: string): Promise<boolean>;
+export declare function runDomainSetup(ctx: DeployCtx, yamlConfig: MailmodoYaml, flags: DeployFlags): Promise<boolean>;
+export declare function ensureDomainReady(ctx: DeployCtx, yamlConfig: MailmodoYaml, flags: DeployFlags): Promise<boolean>;

package/dist/lib/deploy/domain-setup.js

@@ -0,0 +1,80 @@
+import { confirm, input } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { API_ENDPOINTS } from '../constants.js';
+import { ERRORS, INFO, PROMPTS } from '../messages.js';
+export async function validateDeploySequence(ctx, payload, flags) {
+    const res = await ctx.spinner('  Validating sequence...', flags.json, () => ctx.post(API_ENDPOINTS.SEQUENCES_VALIDATE, payload));
+    if (!res.ok) {
+        if (res.data.error === 'senderDomainNotFound')
+            ctx.error(ERRORS.DOMAIN_NOT_REGISTERED);
+        if (res.data.error === 'senderDomainNotVerified')
+            ctx.error(ERRORS.DOMAIN_NOT_VERIFIED);
+        ctx.onApiError(res);
+    }
+    return res.data;
+}
+export async function verifyDomain(ctx, jsonOutput, domain) {
+    const res = await ctx.spinner('  Checking DNS...', jsonOutput, () => ctx.get(API_ENDPOINTS.DOMAIN_VERIFY, { domain }));
+    if (!res.ok)
+        ctx.onApiError(res);
+    const { dkim, dmarc, dnsGuideUrl, domainStatus, returnPath } = res.data;
+    const allPassed = domainStatus === 'VERIFIED';
+    if (!jsonOutput) {
+        ctx.log(`  DKIM         ${dkim ? chalk.green('✓') : chalk.red('✗')}`);
+        ctx.log(`  DMARC        ${dmarc ? chalk.green('✓') : chalk.red('✗')}`);
+        ctx.log(`  Return-Path  ${returnPath ? chalk.green('✓') : chalk.red('✗')}`);
+        if (allPassed) {
+            ctx.log(`\n  ${chalk.green('Domain verified.')} Continuing deploy...\n`);
+        }
+        else {
+            ctx.log(`\n  ${INFO.DNS_RECORDS_FAILED}\n  ${INFO.DNS_FIX_AND_VERIFY}`);
+            if (dnsGuideUrl)
+                ctx.log(`  Help: ${chalk.cyan(dnsGuideUrl)}\n`);
+        }
+    }
+    return allPassed;
+}
+export async function runDomainSetup(ctx, yamlConfig, flags) {
+    const inputs = await ctx.collectDomainInputs(yamlConfig, flags.yes);
+    const { dnsRecords, dnsGuideUrl } = await ctx.registerDomainAndSave(yamlConfig, inputs, flags.json);
+    ctx.showDnsRecords(dnsRecords, dnsGuideUrl, flags.json);
+    if (flags.yes)
+        return verifyDomain(ctx, flags.json, inputs.domain);
+    const action = await input({
+        default: '',
+        message: PROMPTS.ENTER_AFTER_RECORDS,
+    });
+    if (action.toLowerCase() === 'skip') {
+        ctx.log(`\n  ${INFO.SEQUENCES_NOT_DEPLOYED}\n  ${INFO.DOMAIN_NOT_DEPLOYED_HINT}\n`);
+        return false;
+    }
+    return verifyDomain(ctx, flags.json, inputs.domain);
+}
+export async function ensureDomainReady(ctx, yamlConfig, flags) {
+    const check = await ctx.spinner('  Checking domain verification...', flags.json, () => ctx.get(API_ENDPOINTS.DOMAIN_VERIFY, {
+        domain: yamlConfig.project?.domain || '',
+    }));
+    if (check.ok && check.data?.domainStatus === 'VERIFIED')
+        return true;
+    if (yamlConfig.project?.domain) {
+        if (!flags.json)
+            ctx.log(`\n  ${INFO.DOMAIN_PENDING_VERIFICATION}\n`);
+        return false;
+    }
+    if (!flags.json) {
+        ctx.log(`\n  No sending domain set up yet.`);
+        ctx.log(`  You need a verified domain before sending emails.`);
+        ctx.log(`  This is a one-time setup. Takes about 5 minutes.\n`);
+    }
+    if (!flags.yes) {
+        const go = await confirm({
+            default: true,
+            message: 'Set up your sending domain now?',
+        });
+        if (!go) {
+            ctx.log(`\n  ${INFO.SEQUENCES_NOT_DEPLOYED}\n  Emails will not send until your domain is verified.\n  ${INFO.DOMAIN_NOT_DEPLOYED_HINT}\n`);
+            return false;
+        }
+    }
+    return runDomainSetup(ctx, yamlConfig, flags);
+}

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

@@ -0,0 +1,4 @@
+import { type MailmodoYaml } from '../yaml-config.js';
+import type { DeployCtx, DeployFlags } from './types.js';
+export declare function getMissingTemplateIds(yamlConfig: MailmodoYaml): string[];
+export declare function handleMissingTemplates(ctx: DeployCtx, yamlConfig: MailmodoYaml, missingIds: string[], flags: DeployFlags): Promise<void>;

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

@@ -0,0 +1,57 @@
+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 { MISSING_TEMPLATES } from '../messages.js';
+import { saveTemplate } from '../yaml-config.js';
+import { buildRegeneratePayload } from './payload.js';
+export function getMissingTemplateIds(yamlConfig) {
+    return yamlConfig.emails
+        .filter((e) => !existsSync(join(process.cwd(), TEMPLATES_DIR, `${e.id}.html`)))
+        .map((e) => e.id);
+}
+async function regenerateMissingTemplates(ctx, yamlConfig, missingIds, flags) {
+    const response = await ctx.spinner('  Regenerating email templates...', 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 (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();
+    ctx.log(`\n  ${chalk.green('✓')} ${MISSING_TEMPLATES.REVIEW_HINT}\n`);
+}
+export async function handleMissingTemplates(ctx, yamlConfig, missingIds, flags) {
+    if (flags.json) {
+        ctx.log(JSON.stringify({
+            error: 'missing_templates',
+            message: MISSING_TEMPLATES.YES_ERROR,
+            missingTemplates: missingIds.map((id) => `${id}.html`),
+        }, null, 2));
+        ctx.exit(1);
+        return;
+    }
+    if (flags.yes)
+        ctx.error(MISSING_TEMPLATES.YES_ERROR);
+    ctx.log(`\n  ${MISSING_TEMPLATES.HEADER}`);
+    for (const id of missingIds)
+        ctx.log(`  ${chalk.red('✗')} mailmodo/${id}.html`);
+    ctx.log(`\n  ${MISSING_TEMPLATES.REGENERATE_NOTE}\n`);
+    const action = await select({
+        choices: [
+            { name: 'Re-generate via AI', value: 'regenerate' },
+            { name: 'Abort (restore from version control)', value: 'abort' },
+        ],
+        message: 'What would you like to do?',
+    });
+    if (action === 'abort') {
+        ctx.log(`\n  ${MISSING_TEMPLATES.ABORT_HINT}\n`);
+        return;
+    }
+    await regenerateMissingTemplates(ctx, yamlConfig, missingIds, flags);
+}

package/dist/lib/deploy/output.d.ts

@@ -0,0 +1,5 @@
+import type { MailmodoYaml } from '../yaml-config.js';
+import type { DeployCtx, SdkSnippet, ValidateResponse } from './types.js';
+export declare function logDiff(ctx: DeployCtx, diff: NonNullable<ValidateResponse['diff']>): void;
+export declare function logPreDeploySummary(ctx: DeployCtx, yamlConfig: MailmodoYaml, validateResult: ValidateResponse, jsonOutput: boolean): void;
+export declare function logDeploySuccessInstructions(ctx: DeployCtx, sdkSnippet: SdkSnippet): void;

package/dist/lib/deploy/output.js

@@ -0,0 +1,61 @@
+import chalk from 'chalk';
+import { SDK_IMPORT_SNIPPET, SDK_INSTALL_COMMAND } from '../constants.js';
+import { SEPARATOR } from '../messages.js';
+export function logDiff(ctx, diff) {
+    if (!diff.hasChanges) {
+        ctx.log(`  No changes from last deployment.`);
+        return;
+    }
+    ctx.log(`  Changes vs. last deployment:`);
+    for (const email of diff.added) {
+        ctx.log(`  ${chalk.green('+')} ${email.id.padEnd(24)} ${email.trigger || ''}`);
+    }
+    for (const email of diff.removed) {
+        ctx.log(`  ${chalk.red('-')} ${email.id.padEnd(24)} ${email.trigger || ''}`);
+    }
+    for (const email of diff.modified) {
+        ctx.log(`  ${chalk.yellow('~')} ${email.id.padEnd(24)} ${email.changedFields?.join(', ') || ''}`);
+    }
+    if (diff.unchanged.length > 0)
+        ctx.log(`  ${chalk.dim(`∙ ${diff.unchanged.length} unchanged`)}`);
+}
+export function logPreDeploySummary(ctx, yamlConfig, validateResult, jsonOutput) {
+    if (jsonOutput)
+        return;
+    ctx.log(`\n  ${chalk.green('✓')} Domain: ${yamlConfig.project?.domain || 'verified'}\n`);
+    if (!validateResult.existingDeployment || !validateResult.diff) {
+        ctx.log(`  Deploying:`);
+        for (const email of yamlConfig.emails) {
+            ctx.log(`  ${chalk.green('+')} ${email.id.padEnd(24)} ${email.trigger}`);
+        }
+    }
+    else {
+        logDiff(ctx, validateResult.diff);
+    }
+    ctx.log('');
+}
+export function logDeploySuccessInstructions(ctx, sdkSnippet) {
+    ctx.log(`  ${chalk.green('Deployed.')} Emails are live.\n`);
+    ctx.log(`  ${SEPARATOR}`);
+    ctx.log(`  ${chalk.bold('ADD THIS TO YOUR APP (one-time only):')}`);
+    ctx.log(`  ${SEPARATOR}\n`);
+    ctx.log(`  ${chalk.cyan(sdkSnippet.install ?? SDK_INSTALL_COMMAND)}\n`);
+    ctx.log(`  ${chalk.dim(SDK_IMPORT_SNIPPET)}\n`);
+    if (sdkSnippet.examples) {
+        ctx.log(`  ${chalk.dim('// Example usage:')}`);
+        ctx.log(`  ${chalk.dim(sdkSnippet.examples.track)}`);
+        ctx.log(`  ${chalk.dim(sdkSnippet.examples.identify)}\n`);
+    }
+    const trackCalls = [...new Set(sdkSnippet.trackCalls ?? [])];
+    for (const call of trackCalls)
+        ctx.log(`  ${chalk.dim(call)}`);
+    if (trackCalls.length > 0)
+        ctx.log('');
+    const identifyCalls = [...new Set(sdkSnippet.identifyCalls ?? [])];
+    for (const call of identifyCalls)
+        ctx.log(`  ${chalk.dim(call)}`);
+    if (identifyCalls.length > 0)
+        ctx.log('');
+    ctx.log(`  Full SDK docs: ${chalk.cyan('mailmodo.com/docs/sdk')}\n`);
+    ctx.log(`  ${SEPARATOR}\n`);
+}

package/dist/lib/deploy/payload.d.ts

@@ -0,0 +1,41 @@
+import { type EmailConfig, type MailmodoYaml, type ProjectConfig } from '../yaml-config.js';
+import type { DeployCtx } from './types.js';
+export declare function mapEmailToPayload(email: EmailConfig): {
+    condition: string | null;
+    ctaText: string;
+    delay: string | number;
+    goal: string;
+    id: string;
+    isReminder: boolean;
+    previewText: string;
+    priority: string;
+    subject: string;
+    trigger: string;
+};
+export declare function buildProjectPayload(project: ProjectConfig, monthlyCap: number | undefined): {
+    webhookUrl?: string | undefined;
+    product: {
+        businessType: string;
+        description: string;
+        pricingModel: string;
+        productName: string;
+        saasModel: string;
+        targetUser: string;
+        url: string;
+    };
+    senderDetails: {
+        address: string;
+        domain: string;
+        fromEmail: string;
+        fromName: string;
+        replyTo: string;
+    };
+    monthlyCap?: number | undefined;
+    brand: {
+        colors: string[];
+        logoUrl: string;
+    };
+    emailStyle: "branded" | "plain";
+};
+export declare function buildRegeneratePayload(yamlConfig: MailmodoYaml, missingIds: string[]): Record<string, unknown>;
+export declare function buildDeployPayload(ctx: DeployCtx, yamlConfig: MailmodoYaml): Promise<object>;

package/dist/lib/deploy/payload.js

@@ -0,0 +1,95 @@
+import { loadTemplate, } from '../yaml-config.js';
+import { DEFAULT_BRAND_COLOR } from '../constants.js';
+export function mapEmailToPayload(email) {
+    return {
+        condition: email.condition || null,
+        ctaText: email.ctaText || '',
+        delay: email.delay,
+        goal: email.goal || '',
+        id: email.id,
+        isReminder: false,
+        previewText: email.previewText || '',
+        priority: 'medium',
+        subject: email.subject,
+        trigger: email.trigger,
+    };
+}
+function buildBrandSection(project) {
+    return {
+        colors: [project?.brandColor || DEFAULT_BRAND_COLOR],
+        logoUrl: project?.logoUrl || '',
+    };
+}
+function buildProductSection(project) {
+    return {
+        businessType: project?.type || '',
+        description: project?.description || '',
+        pricingModel: project?.pricingModel || '',
+        productName: project?.name || '',
+        saasModel: project?.saasModel || '',
+        targetUser: project?.targetUser || '',
+        url: project?.url || '',
+    };
+}
+function buildSenderSection(project) {
+    return {
+        address: project?.address || '',
+        domain: project?.domain || '',
+        fromEmail: project?.fromEmail || '',
+        fromName: project?.fromName || '',
+        replyTo: project?.replyTo || project?.fromEmail || '',
+    };
+}
+export function buildProjectPayload(project, monthlyCap) {
+    return {
+        brand: buildBrandSection(project),
+        emailStyle: project?.emailStyle || 'branded',
+        ...(monthlyCap === undefined ? {} : { monthlyCap }),
+        product: buildProductSection(project),
+        senderDetails: buildSenderSection(project),
+        ...(project?.webhookUrl ? { webhookUrl: project.webhookUrl } : {}),
+    };
+}
+export function buildRegeneratePayload(yamlConfig, missingIds) {
+    const { emails, project } = yamlConfig;
+    const idSet = new Set(missingIds);
+    const targets = emails.filter((e) => idSet.has(e.id));
+    return {
+        brand: {
+            color: project.brandColor || DEFAULT_BRAND_COLOR,
+            logoUrl: project.logoUrl || '',
+        },
+        businessType: project.type || '',
+        description: project.description || '',
+        events: [...new Set(targets.map((e) => e.trigger))],
+        pricingModel: project.pricingModel || '',
+        productName: project.name || '',
+        recommendedEmails: targets.map((e) => ({
+            condition: e.condition || null,
+            delay: String(e.delay ?? '0'),
+            goal: e.goal || '',
+            id: e.id,
+            isReminder: false,
+            priority: 'medium',
+            trigger: e.trigger,
+        })),
+        saasModel: project.saasModel || '',
+        targetUser: project.targetUser || '',
+    };
+}
+export async function buildDeployPayload(ctx, yamlConfig) {
+    const [emailsWithHtml, monthlyCap] = await Promise.all([
+        Promise.all(yamlConfig.emails.map(async (email) => {
+            const html = (await loadTemplate(`${email.id}.html`)) || '';
+            const plainHtml = (await loadTemplate(`${email.id}_plain.html`)) || html;
+            return { ...mapEmailToPayload(email), html, plainHtml };
+        })),
+        yamlConfig.project.monthlyCap === undefined
+            ? ctx.getBillingCap()
+            : Promise.resolve(yamlConfig.project.monthlyCap),
+    ]);
+    return {
+        ...buildProjectPayload(yamlConfig.project, monthlyCap),
+        emails: emailsWithHtml,
+    };
+}

package/dist/lib/deploy/sequence-status.d.ts

@@ -0,0 +1,3 @@
+import type { DeployCtx, DeployFlags } from './types.js';
+export declare function pauseSequence(ctx: DeployCtx, sequenceId: string, flags: DeployFlags): Promise<void>;
+export declare function resumeSequence(ctx: DeployCtx, sequenceId: string, flags: DeployFlags): Promise<void>;