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

package/dist/lib/commands/edit/persist.js

@@ -20,12 +20,13 @@ async function persistChanges(ctx, editCtx, updated) {
         await saveTemplate(editCtx.templateFilename, updated.html);
     }
     await ctx.syncYaml();
+    await ctx.syncTemplate(editCtx.email.id);
 }
-function logJsonResult(ctx, email, updated, oldSubject) {
+function logJsonResult(ctx, email, updated, oldSubject, oldPreviewText) {
     ctx.log(JSON.stringify({
         diff: {
-            previewText: updated.previewText && updated.previewText !== email.previewText
-                ? { new: updated.previewText, old: email.previewText }
+            previewText: updated.previewText && updated.previewText !== oldPreviewText
+                ? { new: updated.previewText, old: oldPreviewText }
                 : undefined,
             subject: oldSubject === email.subject
                 ? undefined
@@ -51,10 +52,11 @@ async function handleAcceptOutput(ctx, email) {
 export async function finalizeEdit(ctx, editCtx, opts) {
     const { flags, updated } = opts;
     const oldSubject = editCtx.email.subject;
+    const oldPreviewText = editCtx.email.previewText;
     applyEmailChanges(editCtx.email, updated);
     await persistChanges(ctx, editCtx, updated);
     if (flags.json) {
-        logJsonResult(ctx, editCtx.email, updated, oldSubject);
+        logJsonResult(ctx, editCtx.email, updated, oldSubject, oldPreviewText);
     }
     else if (flags.yes) {
         ctx.log(`\n  Updated ${chalk.green('mailmodo.yaml')}\n`);

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

@@ -33,5 +33,6 @@ export type EditCtx = {
     post<T>(path: string, body?: unknown): Promise<ApiResponse<T>>;
     runCommand(id: string, argv: string[]): Promise<void>;
     spinner<T>(text: string, json: boolean, work: () => Promise<T>): Promise<T>;
+    syncTemplate(emailId: string): Promise<void>;
     syncYaml(): Promise<void>;
 };

package/dist/lib/commands/emails/editor.js

@@ -27,7 +27,7 @@ export async function openTemplateInEditor(ctx, template) {
                 stdio: 'inherit',
             });
             child.on('error', () => resolve(false));
-            child.on('close', () => resolve(true));
+            child.on('close', (code) => resolve(code === 0));
         });
         if (launched)
             return;

package/dist/lib/commands/init/analysis.js

@@ -4,8 +4,12 @@ import { API_ENDPOINTS } from '../../constants.js';
 import { isValidUrl } from '../../utils.js';
 import { logAnalysisSummary } from './output.js';
 export async function promptProductUrl(flagUrl) {
-    if (flagUrl)
+    if (flagUrl) {
+        if (!isValidUrl(flagUrl)) {
+            throw new Error(`Invalid URL: "${flagUrl}". Please enter a valid URL (e.g., https://myapp.com)`);
+        }
         return flagUrl;
+    }
     return input({
         message: 'What is your product URL?',
         validate(value) {

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

@@ -1,8 +1,8 @@
 import type { LoginCtx, ValidateResponse } from './types.js';
 import type { MailmodoConfig } from '../../config.js';
-export declare function logAlreadyLoggedIn(ctx: LoginCtx, existing: MailmodoConfig, yamlRestored: boolean, opts: {
+export declare function logAlreadyLoggedIn(ctx: LoginCtx, existing: MailmodoConfig, opts: {
     json: boolean;
 }): void;
-export declare function logLoginSuccess(ctx: LoginCtx, data: Pick<ValidateResponse, 'email' | 'paidEmailsRemaining' | 'plan' | 'totalFreeRemaining'>, yamlRestored: boolean, opts: {
+export declare function logLoginSuccess(ctx: LoginCtx, data: Pick<ValidateResponse, 'email' | 'paidEmailsRemaining' | 'plan' | 'totalFreeRemaining'>, opts: {
     json: boolean;
 }): void;

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

@@ -1,12 +1,10 @@
 import chalk from 'chalk';
-import { INFO } from '../../messages.js';
-export function logAlreadyLoggedIn(ctx, existing, yamlRestored, opts) {
+export function logAlreadyLoggedIn(ctx, existing, opts) {
     if (opts.json) {
         ctx.log(JSON.stringify({
             email: existing.email ?? null,
             status: 'already_logged_in',
             totalFreeRemaining: existing.totalFreeRemaining ?? null,
-            yamlRestored,
         }, null, 2));
         return;
     }
@@ -15,15 +13,10 @@ export function logAlreadyLoggedIn(ctx, existing, yamlRestored, opts) {
         ? chalk.green(existing.email.trim())
         : chalk.dim('(unknown)');
     ctx.log(`  Email: ${emailDisplay}\n`);
-    if (yamlRestored) {
-        ctx.log(`  ${INFO.YAML_RESTORED_ON_LOGIN}`);
-    }
-    else {
-        ctx.log(`  ${chalk.dim('1.')} Run ${chalk.cyan('mailmodo init')} to generate an email sequence.`);
-    }
-    ctx.log(`  ${chalk.dim(yamlRestored ? '1.' : '2.')} Run ${chalk.cyan('mailmodo logout')} to log in with another account.\n`);
+    ctx.log(`  ${chalk.dim('1.')} Run ${chalk.cyan('mailmodo init')} to generate an email sequence.`);
+    ctx.log(`  ${chalk.dim('2.')} Run ${chalk.cyan('mailmodo logout')} to log in with another account.\n`);
 }
-export function logLoginSuccess(ctx, data, yamlRestored, opts) {
+export function logLoginSuccess(ctx, data, opts) {
     const { email, plan, totalFreeRemaining, paidEmailsRemaining } = data;
     if (opts.json) {
         ctx.log(JSON.stringify({
@@ -32,7 +25,6 @@ export function logLoginSuccess(ctx, data, yamlRestored, opts) {
             plan,
             status: 'authenticated',
             totalFreeRemaining,
-            yamlRestored,
         }, null, 2));
         return;
     }
@@ -44,10 +36,5 @@ export function logLoginSuccess(ctx, data, yamlRestored, opts) {
     if (plan === 'paid') {
         ctx.log(`  Current paid block: ${chalk.cyan(String(paidEmailsRemaining))} emails remaining\n`);
     }
-    if (yamlRestored) {
-        ctx.log(`  ${INFO.YAML_RESTORED_ON_LOGIN}\n`);
-    }
-    else {
-        ctx.log(`  Next: Run ${chalk.cyan("'mailmodo init'")} to generate your email sequences.\n`);
-    }
+    ctx.log(`  Next: Run ${chalk.cyan("'mailmodo init'")} to generate your email sequences.\n`);
 }

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

@@ -1,7 +1,9 @@
 import type { ApiResponse } from '../../api-client.js';
+import type { MailmodoYaml } from '../../yaml-config.js';
 export type PreviewCtx = {
     error(msg: string): never;
     exit(code?: number): never;
+    fetchTemplate(emailId: string): Promise<boolean>;
     log(msg?: string): void;
     onApiError(resp: {
         error?: string;
@@ -9,6 +11,7 @@ export type PreviewCtx = {
     }): never;
     post<T>(path: string, body?: unknown): Promise<ApiResponse<T>>;
     spinner<T>(text: string, json: boolean, work: () => Promise<T>): Promise<T>;
+    syncTemplates(yaml: MailmodoYaml): Promise<void>;
     syncYaml(): Promise<void>;
 };
 export type PreviewEmail = {

package/dist/lib/commands/report/output-entries.d.ts

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

package/dist/lib/commands/report/output-entries.js

@@ -0,0 +1,59 @@
+import chalk from 'chalk';
+const TIME_W = 18;
+const EMAIL_W = 24;
+const SEQ_W = 12;
+const STATUS_W = 14;
+const CONTACT_COL = TIME_W + EMAIL_W + SEQ_W + STATUS_W;
+function statusColor(status) {
+    switch (status) {
+        case 'bounced':
+        case 'complained': {
+            return chalk.red;
+        }
+        case 'clicked':
+        case 'delivered':
+        case 'opened':
+        case 'sent': {
+            return chalk.green;
+        }
+        case 'skipped': {
+            return chalk.yellow;
+        }
+        default: {
+            return chalk.white;
+        }
+    }
+}
+function truncate(s, width) {
+    return s.length > width ? s.slice(0, width - 1) + '…' : s;
+}
+function shortSeq(id) {
+    return id.length > 8 ? id.slice(0, 8) + '…' : id;
+}
+export function renderEntries(ctx, data) {
+    const { entries, limit, page, total } = data;
+    ctx.log(`\n  ${'Time'.padEnd(TIME_W)}${'Template'.padEnd(EMAIL_W)}` +
+        `${'Sequence'.padEnd(SEQ_W)}${'Status'.padEnd(STATUS_W)}Contact`);
+    ctx.log(`  ${'─'.repeat(CONTACT_COL + 28)}`);
+    if (!entries?.length) {
+        ctx.log(`  ${chalk.dim('No entries found.')}`);
+        ctx.log('');
+        return;
+    }
+    for (const entry of entries) {
+        const time = (entry.timestamp || '').padEnd(TIME_W);
+        const email = truncate(entry.emailId || '', EMAIL_W - 2).padEnd(EMAIL_W);
+        const seq = chalk.dim(shortSeq(entry.sequenceId || '').padEnd(SEQ_W));
+        const status = statusColor(entry.status)((entry.status || '').padEnd(STATUS_W));
+        ctx.log(`  ${time}${email}${seq}${status}${entry.contact || ''}`);
+        if (entry.reason) {
+            const label = entry.status === 'skipped' ? 'condition not met' : 'reason';
+            ctx.log(`  ${' '.repeat(CONTACT_COL)}${chalk.dim(`└ ${label}: ${entry.reason}`)}`);
+        }
+    }
+    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}`)}`);
+    ctx.log('');
+}

package/dist/lib/commands/report/output-timeseries.d.ts

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

package/dist/lib/commands/report/output-timeseries.js

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+function fmtRate(n) {
+    return (n * 100).toFixed(1) + '%';
+}
+export function renderTimeseries(ctx, data) {
+    const { bucket, series, timeRange } = data;
+    const from = timeRange.from.slice(0, 10);
+    const to = timeRange.to.slice(0, 10);
+    ctx.log(`\n  ${chalk.dim(`Bucket: ${bucket}  (${from} → ${to})`)}`);
+    ctx.log(`\n  ${'Time'.padEnd(22)}${'Sent'.padEnd(7)}${'Delivered'.padEnd(11)}${'Opened'.padEnd(8)}${'Clicked'.padEnd(9)}${'OpenRate'.padEnd(10)}${'ClickRate'.padEnd(10)}BounceRate`);
+    ctx.log(`  ${'─'.repeat(87)}`);
+    if (!series?.length) {
+        ctx.log(`  ${chalk.dim('No timeseries data.')}`);
+        ctx.log('');
+        return;
+    }
+    for (const point of series) {
+        ctx.log(`  ${(point.ts || '').padEnd(22)}` +
+            `${String(point.sent).padEnd(7)}` +
+            `${String(point.delivered).padEnd(11)}` +
+            `${String(point.opened).padEnd(8)}` +
+            `${String(point.clicked).padEnd(9)}` +
+            `${fmtRate(point.openRate).padEnd(10)}` +
+            `${fmtRate(point.clickRate).padEnd(10)}` +
+            `${fmtRate(point.bounceRate)}`);
+    }
+    ctx.log('');
+}

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

@@ -0,0 +1,3 @@
+import type { ReportCtx, ReportResponse, SummaryResponse } from './types.js';
+export declare function renderSummary(ctx: ReportCtx, data: SummaryResponse): void;
+export declare function renderReport(ctx: ReportCtx, data: ReportResponse, mode: string): void;

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

@@ -0,0 +1,56 @@
+import chalk from 'chalk';
+import { renderEntries } from './output-entries.js';
+import { renderTimeseries } from './output-timeseries.js';
+function fmtRate(n) {
+    return (n * 100).toFixed(1) + '%';
+}
+function statsColumns(s) {
+    return [
+        String(s.sent).padEnd(7),
+        String(s.delivered).padEnd(11),
+        String(s.opened).padEnd(8),
+        String(s.clicked).padEnd(9),
+        String(s.bounced).padEnd(9),
+        fmtRate(s.openRate).padEnd(10),
+        fmtRate(s.clickRate).padEnd(10),
+        fmtRate(s.bounceRate),
+    ].join('');
+}
+function renderGroupedTable(ctx, data) {
+    ctx.log(`\n  ${'Key'.padEnd(20)}${'Sent'.padEnd(7)}${'Delivered'.padEnd(11)}` +
+        `${'Opened'.padEnd(8)}${'Clicked'.padEnd(9)}${'Bounced'.padEnd(9)}` +
+        `${'OpenRate'.padEnd(10)}${'ClickRate'.padEnd(10)}BounceRate`);
+    ctx.log(`  ${'─'.repeat(93)}`);
+    for (const g of data.groups) {
+        const key = g.key.slice(0, 19).padEnd(20);
+        ctx.log(`  ${key}${statsColumns(g)}`);
+    }
+    ctx.log(`  ${'─'.repeat(93)}`);
+    ctx.log(`  ${chalk.bold('TOTAL'.padEnd(20))}${statsColumns(data.totals)}`);
+}
+function renderTotalsOnly(ctx, data) {
+    const t = data.totals;
+    ctx.log(`\n  Sent: ${t.sent}   Delivered: ${t.delivered}   Opened: ${t.opened}` +
+        `   Clicked: ${t.clicked}   Bounced: ${t.bounced}`);
+    ctx.log(`  Open rate: ${fmtRate(t.openRate)}   Click rate: ${fmtRate(t.clickRate)}` +
+        `   Bounce rate: ${fmtRate(t.bounceRate)}`);
+}
+export function renderSummary(ctx, data) {
+    const { from, to } = data.timeRange;
+    ctx.log(`\n  ${chalk.dim(`${from.slice(0, 10)} → ${to.slice(0, 10)}`)}`);
+    if (data.groups.length > 0) {
+        renderGroupedTable(ctx, data);
+    }
+    else {
+        renderTotalsOnly(ctx, data);
+    }
+    ctx.log('');
+}
+export function renderReport(ctx, data, mode) {
+    if (mode === 'entries')
+        renderEntries(ctx, data);
+    else if (mode === 'timeseries')
+        renderTimeseries(ctx, data);
+    else
+        renderSummary(ctx, data);
+}

package/dist/lib/commands/report/payload.d.ts

@@ -0,0 +1,2 @@
+import type { ReportFlags, ReportPayload } from './types.js';
+export declare function buildReportPayload(flags: ReportFlags, onError: (m: string) => never): ReportPayload;

package/dist/lib/commands/report/payload.js

@@ -0,0 +1,49 @@
+import { REPORTS } from '../../messages.js';
+function buildTimeRange(flags) {
+    if (flags.preset)
+        return { preset: flags.preset };
+    if (flags.from && flags.to)
+        return { from: flags.from, to: flags.to };
+    return undefined;
+}
+function buildFilters(flags) {
+    const f = {};
+    if (flags.sequence?.length)
+        f.sequenceIds = flags.sequence;
+    if (flags['email-id']?.length)
+        f.emailIds = flags['email-id'];
+    if (flags.contact?.length)
+        f.contactEmails = flags.contact;
+    if (flags.event?.length)
+        f.events = flags.event;
+    return Object.keys(f).length > 0 ? f : undefined;
+}
+function validateFilterSizes(flags, onError) {
+    const arrays = [
+        flags.sequence,
+        flags['email-id'],
+        flags.contact,
+        flags.event,
+    ];
+    if (arrays.some((a) => a && a.length > 100))
+        onError(REPORTS.TOO_MANY_ITEMS);
+}
+export function buildReportPayload(flags, onError) {
+    validateFilterSizes(flags, onError);
+    const timeRange = buildTimeRange(flags);
+    if (!timeRange)
+        onError(REPORTS.TIME_RANGE_REQUIRED);
+    const payload = {
+        groupBy: flags['group-by'],
+        output: flags.output,
+        timeRange,
+    };
+    const filters = buildFilters(flags);
+    if (filters)
+        payload.filters = filters;
+    if (flags.output === 'entries') {
+        payload.page = flags.page;
+        payload.limit = flags.limit;
+    }
+    return payload;
+}

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

@@ -0,0 +1,2 @@
+import type { ReportFlags } from './types.js';
+export declare function promptReportFlags(flags: ReportFlags): Promise<ReportFlags>;

package/dist/lib/commands/report/prompt.js

@@ -0,0 +1,82 @@
+import { input, select } from '@inquirer/prompts';
+const PRESET_CHOICES = [
+    { name: 'Today', value: 'today' },
+    { name: 'Yesterday', value: 'yesterday' },
+    { name: 'Last 7 days', value: 'last7d' },
+    { name: 'Last 30 days', value: 'last30d' },
+    { name: 'Last 90 days', value: 'last90d' },
+    { name: 'This month', value: 'thisMonth' },
+    { name: 'Last month', value: 'lastMonth' },
+];
+const OUTPUT_CHOICES = [
+    { name: 'Summary — grouped aggregates', value: 'summary' },
+    { name: 'Entries — paginated event log', value: 'entries' },
+    { name: 'Timeseries — bucketed over time', value: 'timeseries' },
+];
+const GROUP_BY_CHOICES = [
+    { name: 'None (totals only)', value: 'none' },
+    { name: 'Email template', value: 'emailId' },
+    { name: 'Sequence ID', value: 'sequenceId' },
+    { name: 'Day', value: 'day' },
+    { name: 'Hour', value: 'hour' },
+    { name: 'Contact', value: 'contact' },
+    { name: 'Status', value: 'status' },
+];
+function isValidIsoDate(value) {
+    if (!value?.trim())
+        return 'Date is required';
+    if (Number.isNaN(new Date(value).getTime()))
+        return 'Enter a valid date in YYYY-MM-DD format';
+    return true;
+}
+async function promptTimeRange() {
+    const usePreset = await select({
+        choices: [
+            { name: 'Use a preset  (today, last7d, last30d…)', value: true },
+            { name: 'Enter a custom date range', value: false },
+        ],
+        message: 'Time range:',
+    });
+    if (usePreset) {
+        const preset = await select({
+            choices: PRESET_CHOICES,
+            message: 'Preset:',
+        });
+        return { preset };
+    }
+    const from = await input({
+        message: 'Start date (YYYY-MM-DD):',
+        validate: isValidIsoDate,
+    });
+    const to = await input({
+        message: 'End date, exclusive (YYYY-MM-DD):',
+        validate(v) {
+            const check = isValidIsoDate(v);
+            if (check !== true)
+                return check;
+            if (new Date(v) <= new Date(from))
+                return 'End date must be after start date';
+            return true;
+        },
+    });
+    return { from, to };
+}
+export async function promptReportFlags(flags) {
+    const hasTimeRange = Boolean(flags.preset || (flags.from && flags.to));
+    if (hasTimeRange)
+        return flags;
+    const timeRange = await promptTimeRange();
+    const output = await select({
+        choices: OUTPUT_CHOICES,
+        default: flags.output,
+        message: 'Output mode:',
+    });
+    const groupBy = output === 'summary'
+        ? await select({
+            choices: GROUP_BY_CHOICES,
+            default: flags['group-by'],
+            message: 'Group by:',
+        })
+        : 'none';
+    return { ...flags, ...timeRange, 'group-by': groupBy, output };
+}

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

@@ -0,0 +1,97 @@
+import type { ApiResponse } from '../../api-client.js';
+export interface ReportFilters {
+    contactEmails?: string[];
+    emailIds?: string[];
+    events?: string[];
+    sequenceIds?: string[];
+}
+export type ReportTimeRange = {
+    from: string;
+    to: string;
+} | {
+    preset: string;
+};
+export interface ReportPayload {
+    filters?: ReportFilters;
+    groupBy: string;
+    limit?: number;
+    output: string;
+    page?: number;
+    timeRange?: ReportTimeRange;
+}
+export interface ReportGroup {
+    bounceRate: number;
+    bounced: number;
+    clickRate: number;
+    clicked: number;
+    complained: number;
+    delivered: number;
+    key: string;
+    openRate: number;
+    opened: number;
+    sent: number;
+    skipped: number;
+    unsubscribed: number;
+}
+export type ReportTotals = Omit<ReportGroup, 'key'>;
+export interface SummaryResponse {
+    groupBy: string;
+    groups: ReportGroup[];
+    timeRange: {
+        from: string;
+        to: string;
+    };
+    totals: ReportTotals;
+}
+export interface EntryRecord {
+    contact: string;
+    emailId: string;
+    reason?: null | string;
+    sequenceId: string;
+    status: string;
+    timestamp: string;
+}
+export interface EntriesResponse {
+    entries: EntryRecord[];
+    limit: number;
+    page: number;
+    timeRange: {
+        from: string;
+        to: string;
+    };
+    total: number;
+}
+export type TimeseriesPoint = ReportTotals & {
+    ts: string;
+};
+export interface TimeseriesResponse {
+    bucket: string;
+    series: TimeseriesPoint[];
+    timeRange: {
+        from: string;
+        to: string;
+    };
+}
+export type ReportResponse = EntriesResponse | SummaryResponse | TimeseriesResponse;
+export type ReportFlags = {
+    contact?: string[];
+    'email-id'?: string[];
+    event?: string[];
+    from?: string;
+    'group-by': string;
+    limit: number;
+    output: string;
+    page: number;
+    preset?: string;
+    sequence?: string[];
+    to?: string;
+};
+export type ReportCtx = {
+    log(msg?: string): void;
+    onApiError(resp: {
+        error?: string;
+        status: number;
+    }): never;
+    post<T = Record<string, unknown>>(path: string, body?: unknown): Promise<ApiResponse<T>>;
+    spinner<T>(text: string, json: boolean, work: () => Promise<T>): Promise<T>;
+};

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

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

package/dist/lib/config.d.ts

@@ -28,6 +28,8 @@ export declare function saveConfig(config: MailmodoConfig): Promise<void>;
 export declare function clearConfig(): Promise<void>;
 /**
  * Returns the absolute path to the Mailmodo config directory (~/.mailmodo).
+ * Honors MAILMODO_CONFIG_DIR env var when set (used in tests to redirect away
+ * from the user's real config).
  *
  * @returns {string} The config directory path.
  */

package/dist/lib/config.js

@@ -2,8 +2,12 @@ import { existsSync } from 'node:fs';
 import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-const CONFIG_DIR = join(homedir(), '.mailmodo');
-const CONFIG_FILE = join(CONFIG_DIR, 'config');
+function configDir() {
+    return process.env.MAILMODO_CONFIG_DIR ?? join(homedir(), '.mailmodo');
+}
+function configFile() {
+    return join(configDir(), 'config');
+}
 /**
  * Loads the Mailmodo CLI configuration from ~/.mailmodo/config.
  * The config file stores the API key and account metadata as JSON.
@@ -13,10 +17,11 @@ const CONFIG_FILE = join(CONFIG_DIR, 'config');
  *   or null if the config file does not exist or is corrupted.
  */
 export async function loadConfig() {
-    if (!existsSync(CONFIG_FILE))
+    const file = configFile();
+    if (!existsSync(file))
         return null;
     try {
-        const content = await readFile(CONFIG_FILE, 'utf8');
+        const content = await readFile(file, 'utf8');
         return JSON.parse(content);
     }
     catch {
@@ -32,20 +37,22 @@ export async function loadConfig() {
  *   at minimum an apiKey. Optional fields: email, totalFreeRemaining.
  */
 export async function saveConfig(config) {
-    if (!existsSync(CONFIG_DIR)) {
-        await mkdir(CONFIG_DIR, { recursive: true });
+    const dir = configDir();
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
     }
-    await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
+    await writeFile(configFile(), JSON.stringify(config, null, 2));
 }
 /**
  * Deletes the saved CLI config file (~/.mailmodo/config), removing the stored API key.
  * No-op if the file does not exist.
  */
 export async function clearConfig() {
-    if (!existsSync(CONFIG_FILE))
+    const file = configFile();
+    if (!existsSync(file))
         return;
     try {
-        await unlink(CONFIG_FILE);
+        await unlink(file);
     }
     catch {
         // Ignore missing file or permission errors; caller can treat as best-effort sign-out.
@@ -53,9 +60,11 @@ export async function clearConfig() {
 }
 /**
  * Returns the absolute path to the Mailmodo config directory (~/.mailmodo).
+ * Honors MAILMODO_CONFIG_DIR env var when set (used in tests to redirect away
+ * from the user's real config).
  *
  * @returns {string} The config directory path.
  */
 export function getConfigDir() {
-    return CONFIG_DIR;
+    return configDir();
 }

package/dist/lib/constants.d.ts

@@ -4,11 +4,12 @@
  * when this is true so end users never see internal request metadata.
  */
 export declare const IS_DEV_MODE: boolean;
-export declare const API_BASE_URL = "https://app-vertex-debug.azurewebsites.net";
+export declare const API_BASE_URL: string;
 export declare const API_ENDPOINTS: Readonly<{
     ANALYTICS: "/analytics";
     ANALYZE: "/analyze";
     ASSETS_LOGO: "/assets/logo";
+    ASSETS_TEMPLATES: "/assets/templates";
     ASSETS_YAML: "/assets/yaml";
     AUTH_VALIDATE: "/auth/validate";
     BILLING_CAP: "/billing/cap";
@@ -25,12 +26,13 @@ export declare const API_ENDPOINTS: Readonly<{
     GENERATE: "/email/generate";
     LOGS: "/logs";
     PREVIEW: "/preview";
+    REPORTS: "/reports";
     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";
+export declare const LOGIN_URL: string;
 export declare const PREVIEW_PORT = 3421;
 export declare const DEFAULT_BRAND_COLOR = "#1A56DB";
 export declare const TEMPLATES_DIR = "mailmodo";