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

package/dist/lib/commands/billing/checkout-status.d.ts

@@ -0,0 +1,3 @@
+import type { BillingCtx } from './types.js';
+export declare function startCheckout(ctx: BillingCtx, jsonOutput: boolean): Promise<void>;
+export declare function showStatus(ctx: BillingCtx, jsonOutput: boolean, statusOnly: boolean): Promise<void>;

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/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/{deploy → commands/deploy}/domain-setup.d.ts

@@ -1,4 +1,4 @@
-import type { MailmodoYaml } from '../yaml-config.js';
+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;

package/dist/lib/{deploy → commands/deploy}/domain-setup.js

@@ -1,7 +1,7 @@
 import { confirm, input } from '@inquirer/prompts';
 import chalk from 'chalk';
-import { API_ENDPOINTS } from '../constants.js';
-import { ERRORS, INFO, PROMPTS } from '../messages.js';
+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) {

package/dist/lib/{deploy → commands/deploy}/output.d.ts

@@ -1,4 +1,4 @@
-import type { MailmodoYaml } from '../yaml-config.js';
+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;

package/dist/lib/{deploy → commands/deploy}/output.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
-import { SDK_IMPORT_SNIPPET, SDK_INSTALL_COMMAND } from '../constants.js';
-import { DEPLOY, SEPARATOR } from '../messages.js';
+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}`);

package/dist/lib/{deploy → commands/deploy}/payload.d.ts

@@ -1,4 +1,4 @@
-import { type EmailConfig, type MailmodoYaml, type ProjectConfig } from '../yaml-config.js';
+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;

package/dist/lib/{deploy → commands/deploy}/payload.js

@@ -1,5 +1,5 @@
-import { loadTemplate, } from '../yaml-config.js';
-import { DEFAULT_BRAND_COLOR } from '../constants.js';
+import { loadTemplate, } from '../../yaml-config.js';
+import { DEFAULT_BRAND_COLOR } from '../../constants.js';
 export function mapEmailToPayload(email) {
     return {
         condition: email.condition || null,

package/dist/lib/{deploy → commands/deploy}/sequence-status.js

@@ -1,6 +1,6 @@
 import { confirm } from '@inquirer/prompts';
-import { API_ENDPOINTS } from '../constants.js';
-import { INFO, pauseAlready, pauseSuccess, PROMPTS, resumeAlready, resumeSuccess, } from '../messages.js';
+import { API_ENDPOINTS } from '../../constants.js';
+import { INFO, pauseAlready, pauseSuccess, PROMPTS, resumeAlready, resumeSuccess, } from '../../messages.js';
 function sequenceStatusPath(sequenceId) {
     return `${API_ENDPOINTS.SEQUENCES}/${encodeURIComponent(sequenceId)}/status`;
 }

package/dist/lib/{deploy → commands/deploy}/types.d.ts

@@ -1,6 +1,6 @@
-import type { ApiResponse } from '../api-client.js';
-import type { MailmodoYaml } from '../yaml-config.js';
-import type { RegenCtx } from '../templates/types.js';
+import type { ApiResponse } from '../../api-client.js';
+import type { MailmodoYaml } from '../../yaml-config.js';
+import type { RegenCtx } from '../../templates/types.js';
 export interface EmailDiffEntry {
     changedFields?: string[];
     id: string;
@@ -85,4 +85,4 @@ export type DeployCtx = RegenCtx & {
     spinner<T>(text: string, json: boolean, work: () => Promise<T>): Promise<T>;
     syncYaml(): Promise<void>;
 };
-export { type RegenCtx } from '../templates/types.js';
+export { type RegenCtx } from '../../templates/types.js';

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

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

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

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

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

@@ -0,0 +1,68 @@
+import chalk from 'chalk';
+function statusColor(status) {
+    if (status === 'active')
+        return chalk.green;
+    if (status === 'paused')
+        return chalk.yellow;
+    return chalk.white;
+}
+function colWidth(rows, key, header) {
+    return Math.max(...rows.map((r) => r[key].length), header.length) + 2;
+}
+function formatDate(iso) {
+    if (!iso)
+        return '';
+    const parsed = new Date(iso);
+    if (Number.isNaN(parsed.getTime()))
+        return iso;
+    return parsed.toISOString().slice(0, 10);
+}
+function logEmptyState(ctx) {
+    ctx.log(`\n  ${chalk.dim('No deployed sequences yet.')}`);
+    ctx.log(`  Run ${chalk.cyan('mailmodo deploy')} to deploy one.\n`);
+}
+function logTableHeader(ctx, count, widths) {
+    ctx.log(`\n  ${chalk.bold(String(count))} deployed ${count === 1 ? 'sequence' : 'sequences'}:\n`);
+    ctx.log(`  ${chalk.bold('Product'.padEnd(widths.product))}` +
+        `${chalk.bold('Status'.padEnd(widths.status))}` +
+        `${chalk.bold('Emails'.padEnd(widths.emails))}` +
+        `${chalk.bold('Sequence ID'.padEnd(widths.sequenceId))}` +
+        `${chalk.bold('Updated')}`);
+    ctx.log(`  ${'─'.repeat(widths.product + widths.status + widths.emails + widths.sequenceId + widths.updated)}`);
+}
+function logTableRows(ctx, rows, widths) {
+    for (const row of rows) {
+        const status = statusColor(row.status)(row.status.padEnd(widths.status));
+        ctx.log(`  ${row.product.padEnd(widths.product)}` +
+            `${status}` +
+            `${row.emails.padEnd(widths.emails)}` +
+            `${chalk.cyan(row.sequenceId.padEnd(widths.sequenceId))}` +
+            `${chalk.dim(row.updated)}`);
+    }
+}
+export function renderDeploymentsTable(ctx, data) {
+    const sequences = data.sequences ?? [];
+    if (sequences.length === 0) {
+        logEmptyState(ctx);
+        return;
+    }
+    const rows = sequences.map((seq) => ({
+        emails: String(seq.emailCount ?? 0),
+        product: seq.productName ?? '',
+        sequenceId: seq.sequenceId ?? '',
+        status: seq.status ?? '',
+        updated: formatDate(seq.updatedAt),
+    }));
+    const widths = {
+        emails: colWidth(rows, 'emails', 'Emails'),
+        product: colWidth(rows, 'product', 'Product'),
+        sequenceId: colWidth(rows, 'sequenceId', 'Sequence ID'),
+        status: colWidth(rows, 'status', 'Status'),
+        updated: colWidth(rows, 'updated', 'Updated'),
+    };
+    logTableHeader(ctx, sequences.length, widths);
+    logTableRows(ctx, rows, widths);
+    ctx.log('');
+    ctx.log(`  Pause:  ${chalk.cyan('mailmodo deploy --pause <sequence-id>')}`);
+    ctx.log(`  Resume: ${chalk.cyan('mailmodo deploy --resume <sequence-id>')}\n`);
+}

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

@@ -0,0 +1,24 @@
+import type { ApiResponse } from '../../api-client.js';
+export interface Deployment {
+    createdAt: string;
+    emailCount: number;
+    productName: string;
+    senderDomain: string;
+    sequenceId: string;
+    status: 'active' | 'paused';
+    triggers: string[];
+    updatedAt: string;
+}
+export interface DeploymentsResponse {
+    sequences: Deployment[];
+    total: number;
+}
+export type DeploymentsCtx = {
+    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/deployments/types.js

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

package/dist/lib/commands/domain/setup.d.ts

@@ -0,0 +1,8 @@
+import type { DomainCtx, DomainFlags } from './types.js';
+import type { MailmodoYaml } from '../../yaml-config.js';
+export declare function setupDomain(ctx: DomainCtx, yamlConfig: MailmodoYaml, flags: DomainFlags): Promise<void>;
+export declare function showDomainStatus(ctx: DomainCtx, opts: {
+    domain: string;
+    json: boolean;
+}): Promise<void>;
+export declare function getDomainOrError(ctx: DomainCtx, yamlConfig: MailmodoYaml): string;