@mailmodo/cli 0.0.54-beta.pr56.91 → 0.0.55-beta.pr57.92

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

@@ -0,0 +1,52 @@
+import chalk from 'chalk';
+function statusColor(status) {
+    switch (status) {
+        case 'bounced':
+        case 'complained':
+        case 'failed': {
+            return chalk.red;
+        }
+        case 'clicked':
+        case 'opened':
+        case 'sent': {
+            return chalk.green;
+        }
+        case 'skipped': {
+            return chalk.yellow;
+        }
+        default: {
+            return chalk.white;
+        }
+    }
+}
+function renderEntries(ctx, entries) {
+    for (const entry of entries) {
+        const time = (entry.timestamp || '').padEnd(18);
+        const templateId = (entry.emailId || '').padEnd(24);
+        const colorFn = statusColor(entry.status);
+        const status = colorFn((entry.status || '').padEnd(10));
+        const contact = entry.contact || '';
+        ctx.log(`  ${time}${templateId}${status}${contact}`);
+        if (entry.reason) {
+            const label = entry.status === 'skipped' ? 'condition not met' : 'reason';
+            ctx.log(`  ${' '.repeat(52)}${chalk.dim(`(${label}: ${entry.reason})`)}`);
+        }
+    }
+}
+export function renderLogs(ctx, data) {
+    const { entries, limit, page, total } = data;
+    ctx.log(`\n  ${'Time'.padEnd(18)}${'Email'.padEnd(24)}${'Status'.padEnd(10)}Contact`);
+    ctx.log(`  ${'─'.repeat(68)}`);
+    if (entries?.length) {
+        renderEntries(ctx, entries);
+        const totalPages = Math.ceil(total / limit);
+        ctx.log(`\n  Page ${page} of ${totalPages}  ·  ${total} total entries`);
+        if (page < totalPages) {
+            ctx.log(`  ${chalk.dim(`Next: --page ${page + 1}`)}`);
+        }
+    }
+    else {
+        ctx.log(`  ${chalk.dim('No log entries found.')}`);
+    }
+    ctx.log('');
+}

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

@@ -0,0 +1,23 @@
+import type { ApiResponse } from '../../api-client.js';
+export interface LogEntry {
+    contact: string;
+    emailId: string;
+    reason?: string;
+    status: string;
+    timestamp: string;
+}
+export interface LogsResponse {
+    entries: LogEntry[];
+    limit: number;
+    page: number;
+    total: number;
+}
+export type LogsCtx = {
+    get<T = Record<string, unknown>>(path: string, params?: Record<string, string>): Promise<ApiResponse<T>>;
+    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/logs/types.js

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

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

@@ -0,0 +1,11 @@
+import type { PreviewCtx, PreviewEmail } from './types.js';
+export declare function renderText(ctx: PreviewCtx, email: PreviewEmail, opts: {
+    jsonOutput: boolean;
+    sampleData: Record<string, string>;
+    templateHtml: string;
+}): Promise<void>;
+export declare function sendTestEmail(ctx: PreviewCtx, email: PreviewEmail, html: string, opts: {
+    domain: string | undefined;
+    jsonOutput: boolean;
+    toAddress: string;
+}): Promise<void>;

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

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+import { API_ENDPOINTS } from '../../constants.js';
+import { htmlToText, renderTemplate } from './render.js';
+export async function renderText(ctx, email, opts) {
+    const { jsonOutput, sampleData, templateHtml } = opts;
+    const plainText = htmlToText(renderTemplate(templateHtml, sampleData));
+    if (jsonOutput) {
+        ctx.log(JSON.stringify({
+            body: plainText,
+            id: email.id,
+            previewText: email.previewText,
+            subject: email.subject,
+        }, null, 2));
+        return;
+    }
+    ctx.log(`\n  ${chalk.bold('SUBJECT:')}  ${email.subject}`);
+    if (email.previewText) {
+        ctx.log(`  ${chalk.bold('PREVIEW:')}  ${email.previewText}`);
+    }
+    ctx.log(`\n${plainText}\n`);
+}
+export async function sendTestEmail(ctx, email, html, opts) {
+    const { domain, jsonOutput, toAddress } = opts;
+    const response = await ctx.spinner('  Sending test email...', jsonOutput, () => ctx.post(`${API_ENDPOINTS.PREVIEW}/send`, {
+        domain,
+        html,
+        subject: email.subject,
+        to: toAddress,
+    }));
+    if (!response.ok) {
+        ctx.onApiError(response);
+    }
+    const { note, sentTo, sentVia, status } = response.data;
+    if (jsonOutput) {
+        ctx.log(JSON.stringify({ note, sentTo, sentVia, status }, null, 2));
+        return;
+    }
+    ctx.log(`\n  ${chalk.green('✓')} Test email sent to ${chalk.cyan(sentTo)} via ${chalk.cyan(sentVia)}.`);
+    if (note) {
+        ctx.log(`  ${chalk.dim(note)}`);
+    }
+    ctx.log('');
+}

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

@@ -0,0 +1,3 @@
+export declare const SAMPLE_DATA: Record<string, string>;
+export declare function renderTemplate(html: string, data: Record<string, string>): string;
+export declare function htmlToText(html: string): string;

package/dist/lib/commands/preview/render.js

@@ -0,0 +1,30 @@
+/* eslint-disable camelcase */
+export const SAMPLE_DATA = Object.freeze({
+    app_url: 'https://yourapp.com',
+    cta_url: 'https://yourapp.com/action',
+    first_name: 'Sarah',
+    product_name: 'YourApp',
+    unsubscribe_url: '#',
+});
+/* eslint-enable camelcase */
+export function renderTemplate(html, data) {
+    return html.replaceAll(/\{\{(\w+)\}\}/g, (match, key) => data[key] || match);
+}
+export function htmlToText(html) {
+    return html
+        .replaceAll(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+        .replaceAll(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+        .replaceAll(/<br\s*\/?>/gi, '\n')
+        .replaceAll(/<\/p>/gi, '\n\n')
+        .replaceAll(/<\/div>/gi, '\n')
+        .replaceAll(/<\/tr>/gi, '\n')
+        .replaceAll(/<\/li>/gi, '\n')
+        .replaceAll(/<[^>]+>/g, '')
+        .replaceAll('&nbsp;', ' ')
+        .replaceAll('&amp;', '&')
+        .replaceAll('&lt;', '<')
+        .replaceAll('&gt;', '>')
+        .replaceAll('&quot;', '"')
+        .replaceAll(/\n{3,}/g, '\n\n')
+        .trim();
+}

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

@@ -0,0 +1,8 @@
+import type { PreviewCtx, PreviewEmail } from './types.js';
+export declare function findAvailablePort(startPort: number, endPort?: number): Promise<number>;
+export declare function startPreviewServer(ctx: PreviewCtx, email: PreviewEmail, opts: {
+    effectiveStyle: 'branded' | 'plain';
+    jsonOutput: boolean;
+    rendered: string;
+    sampleData: Record<string, string>;
+}): Promise<void>;

package/dist/lib/commands/preview/server.js

@@ -0,0 +1,63 @@
+import { createServer } from 'node:http';
+import chalk from 'chalk';
+import open from 'open';
+import { PREVIEW_PORT } from '../../constants.js';
+import { INFO } from '../../messages.js';
+import { buildWrapperHtml } from './wrapper-html.js';
+export async function findAvailablePort(startPort, endPort = startPort + 10) {
+    if (startPort > endPort) {
+        throw new Error(`No available port found starting from port ${endPort - 10}`);
+    }
+    const available = await new Promise((resolve) => {
+        const probe = createServer();
+        probe.once('error', () => resolve(false));
+        probe.once('listening', () => probe.close(() => resolve(true)));
+        probe.listen(startPort);
+    });
+    return available ? startPort : findAvailablePort(startPort + 1, endPort);
+}
+export async function startPreviewServer(ctx, email, opts) {
+    const { effectiveStyle, jsonOutput, rendered, sampleData } = opts;
+    const wrapperHtml = buildWrapperHtml(email, rendered, sampleData, effectiveStyle);
+    const port = await findAvailablePort(PREVIEW_PORT);
+    if (!jsonOutput && port !== PREVIEW_PORT) {
+        ctx.log(`\n  ${chalk.yellow('!')} Port ${PREVIEW_PORT} is already in use. Opening preview on port ${chalk.cyan(String(port))}.`);
+    }
+    if (jsonOutput) {
+        ctx.log(JSON.stringify({
+            id: email.id,
+            style: effectiveStyle,
+            url: `http://localhost:${port}`,
+        }, null, 2));
+    }
+    const server = createServer((_req, res) => {
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(wrapperHtml);
+    });
+    await new Promise((resolve) => {
+        server.listen(port, () => resolve());
+    });
+    const url = `http://localhost:${port}`;
+    if (!jsonOutput) {
+        ctx.log(`\n  Style: ${chalk.cyan(effectiveStyle)}`);
+        ctx.log(`  Preview server at ${chalk.cyan(url)}`);
+        ctx.log(`  ${INFO.BROWSER_OPENING}\n`);
+        ctx.log(`  ${chalk.dim('Press Ctrl+C to stop the preview server.')}\n`);
+    }
+    try {
+        await open(url);
+    }
+    catch {
+        if (!jsonOutput) {
+            ctx.log(`  ${INFO.BROWSER_OPEN_FAILED}`);
+        }
+    }
+    await new Promise((resolve) => {
+        const shutdown = () => {
+            server.closeAllConnections?.();
+            server.close(() => resolve());
+        };
+        process.once('SIGINT', shutdown);
+        process.once('SIGTERM', shutdown);
+    });
+}

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

@@ -0,0 +1,19 @@
+import type { ApiResponse } from '../../api-client.js';
+export type PreviewCtx = {
+    error(msg: string): never;
+    exit(code?: number): never;
+    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>;
+};
+export type PreviewEmail = {
+    id: string;
+    previewText?: string;
+    style?: string;
+    subject: string;
+};

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

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

package/dist/lib/commands/preview/wrapper-html.d.ts

@@ -0,0 +1,2 @@
+import type { PreviewEmail } from './types.js';
+export declare function buildWrapperHtml(email: PreviewEmail, rendered: string, sampleData: Record<string, string>, effectiveStyle: 'branded' | 'plain'): string;

package/dist/lib/commands/preview/wrapper-html.js

@@ -0,0 +1,35 @@
+export function buildWrapperHtml(email, rendered, sampleData, effectiveStyle) {
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Preview: ${email.subject}</title>
+  <style>
+    body { margin: 0; padding: 2rem; background: #f5f5f5; font-family: system-ui; }
+    .preview-bar { background: #1a1a2e; color: #fff; padding: 0.75rem 1.5rem; border-radius: 0.5rem;
+      margin-bottom: 1.5rem; display: flex; justify-content: space-between; align-items: center; }
+    .preview-bar h3 { margin: 0; font-size: 0.875rem; }
+    .preview-bar span { font-size: 0.75rem; opacity: 0.7; }
+    .email-frame { background: #fff; max-width: 40rem; margin: 0 auto; border-radius: 0.5rem;
+      box-shadow: 0 0.125rem 0.5rem rgba(0,0,0,0.1); overflow: hidden; }
+    .email-header { padding: 1rem 1.5rem; border-bottom: 1px solid #eee; }
+    .email-header .subject { font-weight: 600; font-size: 1rem; }
+    .email-header .meta { font-size: 0.75rem; color: #666; margin-top: 0.25rem; }
+    .email-body { padding: 1.5rem; }
+  </style>
+</head>
+<body>
+  <div class="preview-bar">
+    <h3>Mailmodo Preview — ${email.id}</h3>
+    <span>Style: ${effectiveStyle} · Press Ctrl+C in terminal to stop</span>
+  </div>
+  <div class="email-frame">
+    <div class="email-header">
+      <div class="subject">${email.subject}</div>
+      <div class="meta">To: ${sampleData.first_name} · From: ${sampleData.product_name}</div>
+    </div>
+    <div class="email-body">${rendered}</div>
+  </div>
+</body>
+</html>`;
+}

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

@@ -0,0 +1,2 @@
+import type { SdkCtx, SdkSnippetsResponse } from './types.js';
+export declare function renderSdkSnippets(ctx: SdkCtx, data: SdkSnippetsResponse): void;

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

@@ -0,0 +1,42 @@
+import chalk from 'chalk';
+import { SDK_IMPORT_SNIPPET, SDK_INSTALL_COMMAND } from '../../constants.js';
+import { SEPARATOR } from '../../messages.js';
+function renderCallBlock(ctx, label, calls) {
+    if (calls.length === 0)
+        return;
+    ctx.log(`  ${chalk.dim(label)}`);
+    for (const call of calls) {
+        ctx.log(`  ${chalk.dim(call)}`);
+    }
+}
+function renderSequenceBlock(ctx, snippet) {
+    const productName = snippet.productName || 'Unnamed sequence';
+    ctx.log(`  ${chalk.bold(productName)} ${chalk.dim(`(${snippet.sequenceId})`)}`);
+    const trackCalls = [...new Set(snippet.sdkSnippet?.trackCalls ?? [])];
+    const identifyCalls = [...new Set(snippet.sdkSnippet?.identifyCalls ?? [])];
+    renderCallBlock(ctx, '// track() calls', trackCalls);
+    renderCallBlock(ctx, '// identify() calls', identifyCalls);
+    if (trackCalls.length === 0 && identifyCalls.length === 0) {
+        ctx.log(`  ${chalk.dim('No track() or identify() calls available.')}`);
+    }
+}
+export function renderSdkSnippets(ctx, data) {
+    const snippets = data.sdkSnippets ?? [];
+    if (snippets.length === 0) {
+        ctx.log(`\n  ${chalk.dim('No active deployed sequences.')}`);
+        ctx.log(`  Run ${chalk.cyan('mailmodo deploy')} to deploy one.\n`);
+        return;
+    }
+    ctx.log(`\n  ${chalk.bold(String(snippets.length))} active ${snippets.length === 1 ? 'sequence' : 'sequences'}:\n`);
+    ctx.log(`  ${SEPARATOR}`);
+    ctx.log(`  ${chalk.bold('SDK EVENT REFERENCE')}`);
+    ctx.log(`  ${SEPARATOR}\n`);
+    ctx.log(`  ${chalk.cyan(SDK_INSTALL_COMMAND)}\n`);
+    ctx.log(`  ${chalk.dim(SDK_IMPORT_SNIPPET)}\n`);
+    for (const [index, snippet] of snippets.entries()) {
+        renderSequenceBlock(ctx, snippet);
+        if (index < snippets.length - 1)
+            ctx.log('');
+    }
+    ctx.log(`  ${SEPARATOR}\n`);
+}

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

@@ -0,0 +1,21 @@
+import type { ApiResponse } from '../../api-client.js';
+export interface SdkSnippetEntry {
+    productName: string;
+    sdkSnippet: {
+        identifyCalls: string[];
+        trackCalls: string[];
+    };
+    sequenceId: string;
+}
+export interface SdkSnippetsResponse {
+    sdkSnippets: SdkSnippetEntry[];
+}
+export type SdkCtx = {
+    get<T = Record<string, unknown>>(path: string, params?: Record<string, string>): Promise<ApiResponse<T>>;
+    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/sdk/types.js

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

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

@@ -0,0 +1,10 @@
+import type { SettingsCtx, SettingsYaml } from './types.js';
+export declare function applyMonthlyCapChange(ctx: SettingsCtx, yamlConfig: SettingsYaml, opts: {
+    isJson: boolean;
+    knownTier: null | string;
+    rawValue: string;
+}): Promise<void>;
+export declare function applySetFlag(ctx: SettingsCtx, yamlConfig: SettingsYaml, opts: {
+    isJson: boolean;
+    setFlag: string;
+}): Promise<void>;

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

@@ -0,0 +1,56 @@
+import chalk from 'chalk';
+import { FREE_TIER } from '../../base-command.js';
+import { INFO } from '../../messages.js';
+import { settingKeyToProp } from '../../utils.js';
+import { saveYaml } from '../../yaml-config.js';
+export async function applyMonthlyCapChange(ctx, yamlConfig, opts) {
+    const parsed = Number(opts.rawValue);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        ctx.error('monthly_cap must be a positive integer (blocks).');
+    }
+    await ctx.ensureAuth();
+    const tier = opts.knownTier ?? (await ctx.fetchBillingTier());
+    if (tier === FREE_TIER) {
+        ctx.warnFreeTierCapBlocked(opts.isJson);
+        return;
+    }
+    const data = await ctx.applyBillingCap({ cap: parsed, json: opts.isJson });
+    yamlConfig.project.monthlyCap = data.capBlocks;
+    await saveYaml(yamlConfig);
+    await ctx.syncYaml();
+    if (opts.isJson) {
+        ctx.log(JSON.stringify({ monthlyCap: data.capBlocks, status: 'updated' }, null, 2));
+        return;
+    }
+    ctx.log(`\n  ${chalk.green('✓')} monthly_cap updated to ${chalk.cyan(String(data.capBlocks))} (${data.capEmails.toLocaleString()} emails)\n`);
+}
+export async function applySetFlag(ctx, yamlConfig, opts) {
+    const { project } = yamlConfig;
+    const eqIndex = opts.setFlag.indexOf('=');
+    if (eqIndex === -1) {
+        ctx.error('Invalid format. Use --set key=value (e.g., --set brand_color=#0F3460)');
+    }
+    const key = opts.setFlag.slice(0, eqIndex).trim();
+    const propKey = settingKeyToProp(key);
+    const value = opts.setFlag.slice(eqIndex + 1).trim();
+    if (!(propKey in project) && key !== 'logo_file') {
+        ctx.error(`Unknown setting: ${key}`);
+    }
+    if (propKey === 'monthlyCap') {
+        await applyMonthlyCapChange(ctx, yamlConfig, {
+            isJson: opts.isJson,
+            knownTier: null,
+            rawValue: value,
+        });
+        return;
+    }
+    project[propKey] = value;
+    await saveYaml(yamlConfig);
+    await ctx.syncYaml();
+    if (opts.isJson) {
+        ctx.log(JSON.stringify({ [propKey]: value, status: 'updated' }, null, 2));
+        return;
+    }
+    ctx.log(`\n  ${chalk.green('✓')} ${key} updated to ${chalk.cyan(value)}`);
+    ctx.log(`  ${INFO.DEPLOY_TO_APPLY}\n`);
+}

package/dist/lib/commands/settings/display.d.ts

@@ -0,0 +1,15 @@
+import type { SettingsCtx } from './types.js';
+export declare const SETTINGS_GROUPS: Readonly<{
+    billing: string[];
+    brand: string[];
+    domain: string[];
+    identity: string[];
+    integrations: string[];
+}>;
+export declare const SETUP_HINTS: Record<string, string>;
+export declare function fetchDomainVerified(ctx: SettingsCtx, domain: string | undefined): Promise<boolean | null>;
+export declare function displaySettingsGroup(ctx: SettingsCtx, group: string, opts: {
+    domainVerified: boolean | null;
+    keys: string[];
+    project: Record<string, unknown>;
+}): void;

package/dist/lib/commands/settings/display.js

@@ -0,0 +1,69 @@
+import chalk from 'chalk';
+import { API_ENDPOINTS } from '../../constants.js';
+import { settingKeyToProp } from '../../utils.js';
+export const SETTINGS_GROUPS = Object.freeze({
+    billing: ['monthly_cap'],
+    brand: ['email_style', 'brand_color', 'logo_url', 'logo_file'],
+    domain: ['domain', 'address'],
+    identity: ['from_name', 'from_email', 'reply_to'],
+    integrations: ['webhook_url'],
+});
+export const SETUP_HINTS = {
+    address: "'mailmodo domain'",
+    domain: "'mailmodo domain'",
+    monthlyCap: "'mailmodo billing --cap <n>'",
+};
+export async function fetchDomainVerified(ctx, domain) {
+    if (!domain)
+        return null;
+    try {
+        await ctx.ensureAuth();
+        const response = await ctx.get(API_ENDPOINTS.DOMAIN_STATUS, { domain });
+        if (!response.ok) {
+            ctx.log(`  ${chalk.dim('Could not fetch domain status. Run')} ${chalk.cyan("'mailmodo domain --status'")} ${chalk.dim('to check manually.')}`);
+            return null;
+        }
+        return response.data?.verified === true;
+    }
+    catch {
+        ctx.log(`  ${chalk.dim('Could not reach API for domain status. Skipping verification check.')}`);
+        return null;
+    }
+}
+function domainDisplay(key, value, domainVerified) {
+    let v = value ? String(value) : chalk.dim('(not set)');
+    if (key === 'domain' && value && domainVerified === true)
+        v += `  ${chalk.green('✓ verified')}`;
+    if (key === 'domain' && value && domainVerified === false)
+        v += `  ${chalk.red('✗ not verified')}`;
+    return v;
+}
+export function displaySettingsGroup(ctx, group, opts) {
+    const { domainVerified, keys, project } = opts;
+    const availableKeys = keys.filter((key) => (group === 'brand' && key === 'logo_file') ||
+        settingKeyToProp(key) in project);
+    const groupTitle = `  ${chalk.bold(group.charAt(0).toUpperCase() + group.slice(1))}`;
+    if (availableKeys.length === 0) {
+        const hint = SETUP_HINTS[settingKeyToProp(keys[0])];
+        if (hint) {
+            ctx.log(groupTitle);
+            ctx.log(`  ${'─'.repeat(49)}`);
+            ctx.log(`  ${chalk.dim(`Run ${hint} to configure.`)}`);
+            ctx.log('');
+        }
+        return;
+    }
+    ctx.log(groupTitle);
+    ctx.log(`  ${'─'.repeat(49)}`);
+    for (const key of availableKeys) {
+        ctx.log(`  ${key.padEnd(16)} ${domainDisplay(key, project[settingKeyToProp(key)], domainVerified)}`);
+    }
+    const missingKeys = keys.filter((key) => !(settingKeyToProp(key) in project) &&
+        !(group === 'brand' && key === 'logo_file'));
+    for (const key of missingKeys) {
+        const hint = SETUP_HINTS[settingKeyToProp(key)];
+        if (hint)
+            ctx.log(`  ${key.padEnd(16)} ${chalk.dim(`(run ${hint} to set up)`)}`);
+    }
+    ctx.log('');
+}

package/dist/lib/commands/settings/logo-domain.d.ts

@@ -0,0 +1,3 @@
+import type { SettingsCtx, SettingsYaml } from './types.js';
+export declare function handleLogoUpload(ctx: SettingsCtx, yamlConfig: SettingsYaml): Promise<void>;
+export declare function handleDomainChange(ctx: SettingsCtx, yamlConfig: SettingsYaml): Promise<void>;

package/dist/lib/commands/settings/logo-domain.js

@@ -0,0 +1,47 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { input } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { API_ENDPOINTS } from '../../constants.js';
+import { saveYaml } from '../../yaml-config.js';
+const MIME_TYPES = {
+    jpeg: 'image/jpeg',
+    jpg: 'image/jpeg',
+    png: 'image/png',
+    svg: 'image/svg+xml',
+};
+export async function handleLogoUpload(ctx, yamlConfig) {
+    const logoPath = await input({ message: 'Path to logo file:' });
+    const resolvedPath = resolve(logoPath);
+    if (!existsSync(resolvedPath)) {
+        ctx.log(`\n  File not found: ${resolvedPath}\n`);
+        return;
+    }
+    await ctx.ensureAuth();
+    const fileBuffer = await readFile(resolvedPath);
+    const ext = resolvedPath.split('.').pop()?.toLowerCase();
+    const mimeType = MIME_TYPES[ext ?? ''] ?? 'application/octet-stream';
+    const formData = new FormData();
+    formData.append('logo', new Blob([new Uint8Array(fileBuffer)], { type: mimeType }), logoPath.split(/[/\\]/).pop() || 'logo.png');
+    const response = await ctx.spinner('  Uploading logo file...', false, () => ctx.postFormData(API_ENDPOINTS.ASSETS_LOGO, formData));
+    if (!response.ok) {
+        ctx.onApiError(response);
+    }
+    yamlConfig.project.logoUrl = response.data?.url || '';
+    yamlConfig.project.logoFile = logoPath;
+    await saveYaml(yamlConfig);
+    await ctx.syncYaml();
+    ctx.log(`\n  Logo uploaded and hosted at:`);
+    ctx.log(`  ${chalk.cyan(String(response.data?.url))}`);
+    ctx.log(`  Run ${chalk.cyan("'mailmodo deploy'")} to apply to all branded emails.\n`);
+}
+export async function handleDomainChange(ctx, yamlConfig) {
+    await ctx.ensureAuth();
+    const inputs = await ctx.collectDomainInputs(yamlConfig, false);
+    const { dnsRecords, dnsGuideUrl } = await ctx.registerDomainAndSave(yamlConfig, inputs, false);
+    ctx.log(`\n  Domain and sender details updated. You will need to re-verify.`);
+    ctx.showDnsRecords(dnsRecords, dnsGuideUrl, false);
+    ctx.log(`  Run ${chalk.cyan("'mailmodo domain --verify'")} once records are added.`);
+    ctx.log(`  Emails will not send until the new domain is verified.`);
+}

package/dist/lib/commands/settings/prompt.d.ts

@@ -0,0 +1,2 @@
+import type { SettingsCtx, SettingsYaml } from './types.js';
+export declare function promptEditSetting(ctx: SettingsCtx, yamlConfig: SettingsYaml, tier: null | string): Promise<void>;