@mailmodo/cli 0.0.54 → 0.0.55-beta.pr57.93

package/dist/lib/commands/billing/checkout-status.js

@@ -0,0 +1,63 @@
+import chalk from 'chalk';
+import open from 'open';
+import { FREE_TIER } from '../../base-command.js';
+import { API_ENDPOINTS } from '../../constants.js';
+import { INFO } from '../../messages.js';
+import { formatAutoCharge, formatCap, formatCurrency, formatPaymentMethod, formatUsageBlock, } from './format.js';
+export async function startCheckout(ctx, jsonOutput) {
+    const response = await ctx.spinner('  Creating checkout session...', jsonOutput, () => ctx.post(API_ENDPOINTS.BILLING_CHECKOUT));
+    if (!response.ok) {
+        ctx.onApiError(response);
+    }
+    const { checkoutUrl } = response.data;
+    if (jsonOutput) {
+        ctx.log(JSON.stringify({ checkoutUrl }, null, 2));
+        return;
+    }
+    ctx.log(`\n  ${chalk.bold('Stripe Checkout')} — add or update your payment method.`);
+    ctx.log(`  ${chalk.dim(checkoutUrl)}\n`);
+    if (!process.env.CI) {
+        try {
+            await open(checkoutUrl);
+            ctx.log(`  ${INFO.BROWSER_OPENING}\n`);
+        }
+        catch {
+            ctx.log(`  ${INFO.BROWSER_OPEN_FAILED}\n`);
+        }
+    }
+}
+function logStatusFields(ctx, data) {
+    ctx.log('');
+    ctx.log(`  Tier:          ${data.tier}`);
+    ctx.log(`  Payment:       ${formatPaymentMethod(data)}`);
+    ctx.log(`  Auto-charge:   ${formatAutoCharge(data)}`);
+    if (data.tier !== FREE_TIER) {
+        ctx.log(`  Monthly cap:   ${formatCap(data.cap)}`);
+    }
+    ctx.log(`  Total spent:   ${formatCurrency(data.totalSpent, data.spentCurrency)}`);
+    if (data.activeBlocks.length === 0) {
+        ctx.log('  Active blocks: none');
+    }
+    else {
+        ctx.log('  Active blocks:');
+        for (const block of data.activeBlocks) {
+            ctx.log(`    - ${formatUsageBlock(block)}`);
+        }
+    }
+    ctx.log('');
+}
+export async function showStatus(ctx, jsonOutput, statusOnly) {
+    const response = await ctx.spinner('  Loading billing status...', jsonOutput, () => ctx.get(API_ENDPOINTS.BILLING_STATUS));
+    if (!response.ok) {
+        ctx.onApiError(response);
+    }
+    const { data } = response;
+    if (jsonOutput) {
+        ctx.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    logStatusFields(ctx, data);
+    if (!data.hasPaymentMethod && !statusOnly) {
+        await startCheckout(ctx, jsonOutput);
+    }
+}

package/dist/lib/commands/billing/format.d.ts

@@ -0,0 +1,7 @@
+import type { BillingCap, BillingStatusResponse, BillingUsageBlock } from './types.js';
+export declare function pluralize(word: string, count: number): string;
+export declare function formatAutoCharge(data: BillingStatusResponse): string;
+export declare function formatCap(cap: BillingCap): string;
+export declare function formatCurrency(amount: number | string, currency: string): string;
+export declare function formatPaymentMethod(data: BillingStatusResponse): string;
+export declare function formatUsageBlock(block: BillingUsageBlock): string;

package/dist/lib/commands/billing/format.js

@@ -0,0 +1,63 @@
+export function pluralize(word, count) {
+    return count === 1 ? word : `${word}s`;
+}
+export function formatAutoCharge(data) {
+    if (!data.autoChargeEnabled) {
+        return 'disabled';
+    }
+    if (typeof data.autoChargeBlockCount !== 'number') {
+        return 'enabled';
+    }
+    return `enabled (${data.autoChargeBlockCount} ${pluralize('block', data.autoChargeBlockCount)})`;
+}
+export function formatCap(cap) {
+    const hasBlocks = typeof cap.inBlocks === 'number';
+    const hasEmails = typeof cap.inEmails === 'number';
+    if (hasBlocks && hasEmails) {
+        return `${cap.inBlocks} ${pluralize('block', cap.inBlocks)} (${cap.inEmails.toLocaleString()} ${pluralize('email', cap.inEmails)})`;
+    }
+    if (hasBlocks) {
+        return `${cap.inBlocks} ${pluralize('block', cap.inBlocks)}`;
+    }
+    if (hasEmails) {
+        return `${cap.inEmails.toLocaleString()} ${pluralize('email', cap.inEmails)}`;
+    }
+    return 'not set';
+}
+export function formatCurrency(amount, currency) {
+    const numericAmount = typeof amount === 'number' ? amount : Number.parseFloat(amount);
+    const normalizedCurrency = currency.toUpperCase();
+    if (Number.isFinite(numericAmount)) {
+        try {
+            return new Intl.NumberFormat('en-US', {
+                currency: normalizedCurrency,
+                style: 'currency',
+            }).format(numericAmount);
+        }
+        catch {
+            return `${numericAmount.toFixed(2)} ${normalizedCurrency}`;
+        }
+    }
+    return `${String(amount)} ${normalizedCurrency}`;
+}
+export function formatPaymentMethod(data) {
+    if (!data.hasPaymentMethod) {
+        return 'No payment method on file';
+    }
+    const primaryMethod = data.paymentMethod[0];
+    if (!primaryMethod) {
+        return 'Payment method on file';
+    }
+    const brand = primaryMethod.brand || 'Card';
+    return primaryMethod.last4
+        ? `${brand} ending ${primaryMethod.last4}`
+        : `${brand} on file`;
+}
+export function formatUsageBlock(block) {
+    const allowance = block.blockAllowance ?? Math.max(block.blocksCount * block.blockSize, 0);
+    const used = Math.max(block.emailsSent ?? 0, 0);
+    const activationSuffix = block.activatedAt
+        ? `, activated at ${new Date(block.activatedAt).toLocaleDateString('en-US')}`
+        : '';
+    return `${block.type} block (${used + allowance}): ${used} ${pluralize('email', used)} sent, ${allowance} ${pluralize('email', allowance)} remaining${activationSuffix}`;
+}

package/dist/lib/commands/billing/purchase-cap.d.ts

@@ -0,0 +1,7 @@
+import type { BillingCtx } from './types.js';
+export declare function purchaseBlocks(ctx: BillingCtx, blocksCount: number, jsonOutput: boolean): Promise<void>;
+export declare function setCap(ctx: BillingCtx, opts: {
+    autoChargeBlockCount?: number;
+    cap: number;
+    json: boolean;
+}): Promise<void>;

package/dist/lib/commands/billing/purchase-cap.js

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+import { FREE_TIER } from '../../base-command.js';
+import { API_ENDPOINTS } from '../../constants.js';
+import { loadYaml, saveYaml } from '../../yaml-config.js';
+import { pluralize } from './format.js';
+async function persistMonthlyCap(ctx, capBlocks) {
+    const yamlConfig = await loadYaml();
+    if (!yamlConfig)
+        return;
+    if (yamlConfig.project.monthlyCap === capBlocks)
+        return;
+    yamlConfig.project.monthlyCap = capBlocks;
+    await saveYaml(yamlConfig);
+    await ctx.syncYaml();
+}
+export async function purchaseBlocks(ctx, blocksCount, jsonOutput) {
+    if (blocksCount < 1) {
+        ctx.error('Purchase block count must be at least 1 block.');
+    }
+    const response = await ctx.spinner('  Initiating block purchase...', jsonOutput, () => ctx.post(API_ENDPOINTS.BILLING_PURCHASE, {
+        blocksCount,
+    }));
+    if (!response.ok) {
+        ctx.onApiError(response);
+    }
+    if (jsonOutput) {
+        ctx.log(JSON.stringify(response.data, null, 2));
+        return;
+    }
+    ctx.log(`\n  ${chalk.green('✓')} ${response.data.message}`);
+    ctx.log(`  Blocks:        ${blocksCount} ${pluralize('block', blocksCount)}`);
+    ctx.log(`  Payment intent:${` ${chalk.dim(response.data.paymentIntentId)}`}`);
+    ctx.log('');
+}
+export async function setCap(ctx, opts) {
+    ctx.validateBillingCapInputs({
+        autoChargeBlockCount: opts.autoChargeBlockCount,
+        cap: opts.cap,
+    });
+    const tier = await ctx.fetchBillingTier();
+    if (tier === FREE_TIER) {
+        ctx.warnFreeTierCapBlocked(opts.json);
+        return;
+    }
+    const data = await ctx.applyBillingCap(opts);
+    await persistMonthlyCap(ctx, data.capBlocks);
+    if (opts.json) {
+        ctx.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    ctx.log(`\n  ${chalk.green('✓')} ${data.message}`);
+    ctx.log(`  Monthly cap:   ${chalk.bold(String(data.capBlocks))} ${pluralize('block', data.capBlocks)} (${data.capEmails.toLocaleString()} emails)`);
+    if (data.autoChargeBlockCount !== undefined) {
+        ctx.log(`  Auto-charge:   ${data.autoChargeBlockCount} ${pluralize('block', data.autoChargeBlockCount)}`);
+    }
+    ctx.log('');
+}

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

@@ -0,0 +1,72 @@
+import type { ApiResponse } from '../../api-client.js';
+import type { BillingCapUpdateResult } from '../../base-command.js';
+export type { BillingCapUpdateResult } from '../../base-command.js';
+export interface BillingCap {
+    capUpdatedAt: null | string;
+    inBlocks: null | number;
+    inEmails: null | number;
+}
+export interface BillingPaymentMethod {
+    brand?: string;
+    last4?: string;
+    type?: string;
+}
+export interface BillingUsageBlock {
+    activatedAt?: string;
+    blockAllowance?: number;
+    blockSize: number;
+    blocksCount: number;
+    emailsSent: number;
+    id: string;
+    status: string;
+    type: string;
+}
+export interface BillingStatusResponse {
+    activeBlocks: BillingUsageBlock[];
+    autoChargeBlockCount: null | number;
+    autoChargeEnabled: boolean;
+    cap: BillingCap;
+    hasPaymentMethod: boolean;
+    paymentMethod: BillingPaymentMethod[];
+    spentCurrency: string;
+    tier: string;
+    totalSpent: number | string;
+}
+export interface CheckoutResponse {
+    checkoutUrl: string;
+}
+export interface BillingPurchaseResponse {
+    message: string;
+    paymentIntentId: string;
+}
+export type BillingFlags = {
+    'auto-charge-block-count'?: number;
+    cap?: number;
+    checkout: boolean;
+    json: boolean;
+    purchase?: number;
+    status: boolean;
+};
+export type BillingCtx = {
+    applyBillingCap(opts: {
+        autoChargeBlockCount?: number;
+        cap: number;
+        json: boolean;
+    }): Promise<BillingCapUpdateResult>;
+    error(msg: string): never;
+    fetchBillingTier(): Promise<null | string>;
+    get<T>(path: string, params?: Record<string, string>): Promise<ApiResponse<T>>;
+    log(msg?: string): void;
+    onApiError(resp: {
+        error?: string;
+        status: number;
+    }): never;
+    post<T>(path: string, body?: unknown): Promise<ApiResponse<T>>;
+    spinner<T>(text: string, json: boolean, work: () => Promise<T>): Promise<T>;
+    syncYaml(): Promise<void>;
+    validateBillingCapInputs(opts: {
+        autoChargeBlockCount?: number;
+        cap: number;
+    }): void;
+    warnFreeTierCapBlocked(json: boolean): void;
+};

package/dist/lib/commands/billing/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/commands/contacts/actions.d.ts

@@ -0,0 +1,3 @@
+import type { ContactsCtx } from './types.js';
+export declare function showSummary(ctx: ContactsCtx, json: boolean): Promise<void>;
+export declare function searchContact(ctx: ContactsCtx, email: string, json: boolean): Promise<void>;

package/dist/lib/commands/contacts/actions.js

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import { API_ENDPOINTS } from '../../constants.js';
+export async function showSummary(ctx, json) {
+    const response = await ctx.spinner('  Loading contacts...', json, () => ctx.get(API_ENDPOINTS.CONTACTS));
+    if (!response.ok) {
+        ctx.onApiError(response);
+    }
+    const { data } = response;
+    if (json) {
+        ctx.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    ctx.log(`\n  Total: ${chalk.bold(String(data.total ?? 0))}  ` +
+        `Active: ${chalk.green(String(data.active ?? 0))}  ` +
+        `Unsubscribed: ${chalk.yellow(String(data.unsubscribed ?? 0))}  ` +
+        `Bounced: ${chalk.red(String(data.bounced ?? 0))}\n`);
+}
+export async function searchContact(ctx, email, json) {
+    const encodedEmail = encodeURIComponent(email);
+    const response = await ctx.spinner('  Looking up contact...', json, () => ctx.get(`${API_ENDPOINTS.CONTACTS}/${encodedEmail}`));
+    if (!response.ok) {
+        if (response.status === 404) {
+            if (json) {
+                ctx.log(JSON.stringify({ email, error: 'Contact not found' }, null, 2));
+            }
+            else {
+                ctx.log(`\n  Contact '${email}' not found.\n`);
+            }
+            return;
+        }
+        ctx.onApiError(response);
+    }
+    const contact = response.data;
+    if (json) {
+        ctx.log(JSON.stringify(contact, null, 2));
+        return;
+    }
+    ctx.log(`\n  ${chalk.bold('Email:')}       ${contact.email}`);
+    ctx.log(`  ${chalk.bold('Status:')}      ${contact.status}`);
+    ctx.log(`  ${chalk.bold('Added:')}       ${contact.added}`);
+    ctx.log(`  ${chalk.bold('Next email:')}  ${contact.nextEmail || 'None'}`);
+    if (contact.properties && Object.keys(contact.properties).length > 0) {
+        ctx.log(`  ${chalk.bold('Properties:')}`);
+        for (const [key, value] of Object.entries(contact.properties)) {
+            ctx.log(`    ${key}: ${String(value)}`);
+        }
+    }
+    ctx.log('');
+}

package/dist/lib/commands/contacts/export-delete.d.ts

@@ -0,0 +1,9 @@
+import type { ContactsCtx } from './types.js';
+export declare function exportContacts(ctx: ContactsCtx, opts: {
+    json: boolean;
+}): Promise<void>;
+export declare function deleteContact(ctx: ContactsCtx, opts: {
+    email: string;
+    json: boolean;
+    skipConfirm: boolean;
+}): Promise<void>;

package/dist/lib/commands/contacts/export-delete.js

@@ -0,0 +1,51 @@
+import { confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { API_ENDPOINTS } from '../../constants.js';
+export async function exportContacts(ctx, opts) {
+    const { json } = opts;
+    const response = await ctx.spinner('  Preparing contact export...', json, () => ctx.get(API_ENDPOINTS.CONTACTS_EXPORT));
+    if (!response.ok) {
+        ctx.onApiError(response);
+    }
+    if (json) {
+        ctx.log(JSON.stringify(response.data, null, 2));
+        return;
+    }
+    ctx.log(`\n  ${chalk.green('✓')} Contact export started.`);
+    const { downloadUrl, status } = response.data;
+    if (!downloadUrl) {
+        ctx.log(`\n  Export status: ${status ?? 'unknown'}. No download URL yet.\n`);
+        return;
+    }
+    const fileResult = await ctx.spinner('  Downloading CSV file...', json, () => ctx.getPublicFile(downloadUrl.trim()));
+    if (!fileResult.ok) {
+        ctx.error(`Download failed: ${fileResult.status} ${fileResult.error ?? ''}\n  URL: ${fileResult.debug.fullUrl}`);
+    }
+    const outputPath = resolve('contacts.csv');
+    await writeFile(outputPath, Buffer.from(fileResult.body));
+    ctx.log(`\n  ${chalk.green('✓')} Contact export saved to ${chalk.cyan(outputPath)}\n`);
+}
+export async function deleteContact(ctx, opts) {
+    const { email, json, skipConfirm } = opts;
+    if (!skipConfirm) {
+        const confirmed = await confirm({
+            default: false,
+            message: `Permanently delete ${email} and all their data? This cannot be undone.`,
+        });
+        if (!confirmed) {
+            ctx.log('\n  Delete cancelled.\n');
+            return;
+        }
+    }
+    const response = await ctx.spinner('  Deleting contact...', json, () => ctx.delete(`${API_ENDPOINTS.CONTACTS}/${encodeURIComponent(email)}`));
+    if (!response.ok) {
+        ctx.onApiError(response);
+    }
+    if (json) {
+        ctx.log(JSON.stringify({ deleted: true, email }, null, 2));
+        return;
+    }
+    ctx.log(`\n  ${chalk.green('✓')} Contact ${email} permanently deleted.\n`);
+}

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

@@ -0,0 +1,35 @@
+import type { ApiResponse } from '../../api-client.js';
+import type { FileFetchResult } from '../../fetch-file.js';
+export interface ContactSummaryResponse {
+    active: number;
+    bounced: number;
+    total: number;
+    unsubscribed: number;
+}
+export interface ContactDetailResponse {
+    added: string;
+    email: string;
+    nextEmail: null | string;
+    properties: Record<string, unknown>;
+    status: string;
+}
+export interface ContactExportResponse {
+    downloadUrl: string;
+    status: string;
+}
+export type ContactsFlags = {
+    json: boolean;
+    yes: boolean;
+};
+export type ContactsCtx = {
+    delete<T = Record<string, unknown>>(path: string): Promise<ApiResponse<T>>;
+    error(msg: string): never;
+    get<T>(path: string, params?: Record<string, string>): Promise<ApiResponse<T>>;
+    getPublicFile(url: string): Promise<FileFetchResult>;
+    log(msg?: string): void;
+    onApiError(resp: {
+        error?: string;
+        status: number;
+    }): never;
+    spinner<T>(text: string, json: boolean, work: () => Promise<T>): Promise<T>;
+};

package/dist/lib/commands/contacts/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/commands/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/commands/deploy/domain-setup.js

@@ -0,0 +1,82 @@
+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)
+        ctx.onApiError(check);
+    if (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/commands/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/commands/deploy/output.js

@@ -0,0 +1,61 @@
+import chalk from 'chalk';
+import { SDK_IMPORT_SNIPPET, SDK_INSTALL_COMMAND } from '../../constants.js';
+import { DEPLOY, SEPARATOR } from '../../messages.js';
+export function logDiff(ctx, diff) {
+    if (!diff.hasChanges) {
+        ctx.log(`  ${DEPLOY.NO_CHANGES}`);
+        return;
+    }
+    ctx.log(`  ${DEPLOY.CHANGES_HEADER}`);
+    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(`  ${DEPLOY.DEPLOYING_HEADER}`);
+        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(`  ${DEPLOY.SUCCESS}\n`);
+    ctx.log(`  ${SEPARATOR}`);
+    ctx.log(`  ${DEPLOY.SDK_ONBOARDING_HEADER}`);
+    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(`  ${DEPLOY.SDK_EXAMPLE_COMMENT}`);
+        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(`  ${DEPLOY.SDK_DOCS_HINT}\n`);
+    ctx.log(`  ${SEPARATOR}\n`);
+}

package/dist/lib/commands/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>;