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

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

@@ -0,0 +1,28 @@
+import type { ApiResponse } from '../../api-client.js';
+export interface EmailMetric {
+    click: string;
+    conv: string;
+    emailId: string;
+    open: string;
+    sent: number;
+}
+export interface AnalyticsResponse {
+    emails: EmailMetric[];
+    monthlySent: number;
+    quota: {
+        blockSize: number;
+        blocksUsed: number;
+        currentBlockEmailsRemaining: number;
+        freeRemaining: number;
+        plan: string;
+    };
+}
+export type StatusCtx = {
+    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/status/types.js

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

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";
@@ -30,7 +31,7 @@ export declare const API_ENDPOINTS: Readonly<{
     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";

package/dist/lib/constants.js

@@ -1,13 +1,12 @@
 /** Set by `bin/dev.js` when running the CLI locally (tsx bootstrap). */
 const DEV_API_BASE_URL = 'https://app-vertex-debug.azurewebsites.net';
+const PRODUCTION_API_BASE_URL = 'https://api.mailmodo.dev';
 /**
  * True when the CLI is running in a dev/debug context. Verbose request
  * diagnostics (URL, status, response body, error code) are only surfaced
  * when this is true so end users never see internal request metadata.
  */
 export const IS_DEV_MODE = Boolean(process.env.MAILMODO_DEV_TSX || process.env.MAILMODO_DEBUG);
-// const PRODUCTION_API_BASE_URL = 'https://api.mailmodo.com';
-const PRODUCTION_API_BASE_URL = 'https://app-vertex-debug.azurewebsites.net';
 export const API_BASE_URL = process.env.MAILMODO_DEV_TSX
     ? DEV_API_BASE_URL
     : PRODUCTION_API_BASE_URL;
@@ -15,6 +14,7 @@ export const API_ENDPOINTS = Object.freeze({
     ANALYTICS: '/analytics',
     ANALYZE: '/analyze',
     ASSETS_LOGO: '/assets/logo',
+    ASSETS_TEMPLATES: '/assets/templates',
     ASSETS_YAML: '/assets/yaml',
     AUTH_VALIDATE: '/auth/validate',
     BILLING_CAP: '/billing/cap',
@@ -36,9 +36,8 @@ export const API_ENDPOINTS = Object.freeze({
     SEQUENCES_SDK: '/sequences/sdk',
     SEQUENCES_VALIDATE: '/sequences/validate',
 });
-const DEV_LOGIN_URL = 'https://app-vertex-debug.azurewebsites.net/signup.html';
-// const PRODUCTION_LOGIN_URL = 'https://mailmodo.com/cli';
-const PRODUCTION_LOGIN_URL = 'https://app-vertex-debug.azurewebsites.net/signup.html';
+const DEV_LOGIN_URL = 'https://app-vertex-debug.azurewebsites.net/signup';
+const PRODUCTION_LOGIN_URL = 'https://app.mailmodo.dev/signup';
 export const LOGIN_URL = process.env.MAILMODO_DEV_TSX
     ? DEV_LOGIN_URL
     : PRODUCTION_LOGIN_URL;

package/dist/lib/messages.d.ts

@@ -13,6 +13,16 @@ export declare const PROMPTS: {
     readonly REPLY_TO: "Reply-to address (optional, press Enter to use sender email):";
     readonly SENDER_EMAIL: "Sender email address:";
 };
+export declare const BLANK_DIR: {
+    readonly CHOICE_FRESH: "Start fresh — new emails will be generated (your domain, sender, and address settings will be kept)";
+    readonly CHOICE_RESTORE: "Restore project files from server";
+    readonly CHOICE_RESTORE_INIT: "Restore existing project files from server";
+    readonly CHOICE_SKIP: "Skip — I'll navigate to my project directory manually";
+    readonly PROMPT: "No mailmodo.yaml or templates found in this directory.";
+    readonly PROMPT_INIT: "A project was found on the server. What would you like to do?";
+    readonly RESTORED_INIT: `Project restored from server. Run ${string} to re-deploy, or ${string} to review your emails.`;
+    readonly SKIP_HINT: `Navigate to your project directory and run your command there, or run ${string} to start a new project here.`;
+};
 export declare const MISSING_TEMPLATES: {
     readonly ABORT_HINT: `Restore the missing files from version control, then run ${string} again.`;
     readonly CHOICE_ABORT: "Abort (restore from version control)";
@@ -63,6 +73,7 @@ export declare const DEPLOY: {
     readonly SDK_ONBOARDING_HEADER: string;
     readonly SUCCESS: `${string} Emails are live.`;
 };
+export declare function restoredFromServerHint(ids: string[]): string;
 export declare function pauseSuccess(sequenceId: string): string;
 export declare function pauseAlready(sequenceId: string): string;
 export declare function resumeSuccess(sequenceId: string): string;

package/dist/lib/messages.js

@@ -14,6 +14,16 @@ export const PROMPTS = {
     REPLY_TO: 'Reply-to address (optional, press Enter to use sender email):',
     SENDER_EMAIL: 'Sender email address:',
 };
+export const BLANK_DIR = {
+    CHOICE_FRESH: 'Start fresh — new emails will be generated (your domain, sender, and address settings will be kept)',
+    CHOICE_RESTORE: 'Restore project files from server',
+    CHOICE_RESTORE_INIT: 'Restore existing project files from server',
+    CHOICE_SKIP: "Skip — I'll navigate to my project directory manually",
+    PROMPT: 'No mailmodo.yaml or templates found in this directory.',
+    PROMPT_INIT: 'A project was found on the server. What would you like to do?',
+    RESTORED_INIT: `Project restored from server. Run ${chalk.cyan('mailmodo deploy')} to re-deploy, or ${chalk.cyan('mailmodo emails')} to review your emails.`,
+    SKIP_HINT: `Navigate to your project directory and run your command there, or run ${chalk.cyan('mailmodo init')} to start a new project here.`,
+};
 export const MISSING_TEMPLATES = {
     ABORT_HINT: `Restore the missing files from version control, then run ${chalk.cyan('mailmodo deploy')} again.`,
     CHOICE_ABORT: 'Abort (restore from version control)',
@@ -63,6 +73,27 @@ export const DEPLOY = {
     SDK_ONBOARDING_HEADER: chalk.bold('ADD THIS TO YOUR APP (one-time only):'),
     SUCCESS: `${chalk.green('Deployed.')} Emails are live.`,
 };
+export function restoredFromServerHint(ids) {
+    if (ids.length === 1) {
+        const [id] = ids;
+        return (`Template ${chalk.cyan(id)} was not found locally and has been refreshed from the server.\n` +
+            `  Review it with ${chalk.cyan(`mailmodo preview ${id}`)}, then run ${chalk.cyan('mailmodo deploy')} again.`);
+    }
+    const header = 'Template ID';
+    const colWidth = Math.max(header.length, ...ids.map((id) => id.length));
+    const pad = (s) => s.padEnd(colWidth);
+    const hr = '─'.repeat(colWidth + 2);
+    const table = [
+        `  ┌${hr}┐`,
+        `  │ ${chalk.bold(pad(header))} │`,
+        `  ├${hr}┤`,
+        ...ids.map((id) => `  │ ${chalk.cyan(pad(id))} │`),
+        `  └${hr}┘`,
+    ].join('\n');
+    return (`${ids.length} templates were not found locally and have been refreshed from the server:\n\n` +
+        `${table}\n\n` +
+        `  Review each with ${chalk.cyan('mailmodo preview <id>')}, then run ${chalk.cyan('mailmodo deploy')} again.`);
+}
 export function pauseSuccess(sequenceId) {
     return `Sequence ${chalk.cyan(sequenceId)} paused. Run ${chalk.cyan(`mailmodo deploy --resume ${sequenceId}`)} to resume.`;
 }

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

@@ -1,5 +1,19 @@
 import { type MailmodoYaml } from '../yaml-config.js';
-import type { DeployFlags } from '../deploy/types.js';
+import type { DeployFlags } from '../commands/deploy/types.js';
 import type { RegenCtx } from './types.js';
+/**
+ * Returns the IDs of emails whose template file does not exist on disk.
+ * Resolves the correct filename for each email by accounting for per-email
+ * and project-level style settings (branded vs. plain).
+ */
 export declare function getMissingTemplateIds(yamlConfig: MailmodoYaml): string[];
-export declare function handleMissingTemplates(ctx: RegenCtx, yamlConfig: MailmodoYaml, missingIds: string[], flags: DeployFlags): Promise<boolean>;
+/**
+ * Handles the case where one or more template files are missing before a
+ * command can proceed. First attempts a silent server restore for all missing
+ * IDs; if the server has backups for all of them the command continues without
+ * any user interaction. Only falls through to an interactive prompt (or an
+ * immediate error in --json / --yes mode) for files the server also does not have.
+ * Returns true if the situation was resolved (restored or regenerated), false
+ * if the user chose to abort.
+ */
+export declare function handleMissingTemplates(ctx: RegenCtx, yamlConfig: MailmodoYaml, missingIds: string[], flags: DeployFlags): Promise<'regenerated' | 'restored' | false>;

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

@@ -2,44 +2,56 @@ import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { select } from '@inquirer/prompts';
 import chalk from 'chalk';
-import { API_ENDPOINTS, TEMPLATES_DIR } from '../constants.js';
+import { TEMPLATES_DIR } from '../constants.js';
 import { MISSING_TEMPLATES } from '../messages.js';
-import { getTemplateFilename, saveTemplate, } from '../yaml-config.js';
-import { buildRegeneratePayload } from '../deploy/payload.js';
+import { getTemplateFilename } from '../yaml-config.js';
+import { regenerateMissingTemplates } from './regenerate.js';
+/**
+ * Returns the IDs of emails whose template file does not exist on disk.
+ * Resolves the correct filename for each email by accounting for per-email
+ * and project-level style settings (branded vs. plain).
+ */
 export function getMissingTemplateIds(yamlConfig) {
     return yamlConfig.emails
         .filter((e) => !existsSync(join(process.cwd(), TEMPLATES_DIR, getTemplateFilename(e.id, e.style, yamlConfig.project?.emailStyle))))
         .map((e) => e.id);
 }
-async function regenerateMissingTemplates(ctx, yamlConfig, missingIds, flags) {
-    const response = await ctx.spinner(`  ${MISSING_TEMPLATES.REGENERATE_SPINNER}`, flags.json, () => ctx.post(API_ENDPOINTS.GENERATE, buildRegeneratePayload(yamlConfig, missingIds)));
-    if (!response.ok)
-        ctx.onApiError(response);
-    const saves = [];
-    for (const email of response.data?.emails ?? []) {
-        if (!/^[\w-]+$/.test(email.id))
-            continue;
-        if (email.html)
-            saves.push(saveTemplate(`${email.id}.html`, email.html));
-        if (email.plainHtml)
-            saves.push(saveTemplate(`${email.id}_plain.html`, email.plainHtml));
-    }
-    await Promise.all(saves);
-    await ctx.syncYaml();
+/**
+ * Attempts to restore each missing template from the server without showing
+ * any prompt or message to the user. Returns the IDs that could not be
+ * restored — either because the server has no backup or a network error occurred.
+ */
+async function silentlyRestoreFromServer(ctx, missingIds) {
+    const results = await Promise.all(missingIds.map((id) => ctx.fetchTemplate(id)));
+    // Keep only the IDs where the server fetch returned false (not restored)
+    return missingIds.filter((_, i) => !results[i]);
 }
+/**
+ * Handles the case where one or more template files are missing before a
+ * command can proceed. First attempts a silent server restore for all missing
+ * IDs; if the server has backups for all of them the command continues without
+ * any user interaction. Only falls through to an interactive prompt (or an
+ * immediate error in --json / --yes mode) for files the server also does not have.
+ * Returns true if the situation was resolved (restored or regenerated), false
+ * if the user chose to abort.
+ */
 export async function handleMissingTemplates(ctx, yamlConfig, missingIds, flags) {
+    // Try to silently recover from server before interrupting the user
+    const stillMissing = await silentlyRestoreFromServer(ctx, missingIds);
+    if (stillMissing.length === 0)
+        return 'restored';
     if (flags.json) {
         ctx.log(JSON.stringify({
             error: 'missing_templates',
             message: MISSING_TEMPLATES.YES_ERROR,
-            missingTemplates: missingIds.map((id) => `${id}.html`),
+            missingTemplates: stillMissing.map((id) => `${id}.html`),
         }, null, 2));
         ctx.exit(1);
     }
     if (flags.yes)
         ctx.error(MISSING_TEMPLATES.YES_ERROR);
     ctx.log(`\n  ${MISSING_TEMPLATES.HEADER}`);
-    for (const id of missingIds)
+    for (const id of stillMissing)
         ctx.log(`  ${chalk.red('✗')} mailmodo/${id}.html`);
     ctx.log(`\n  ${MISSING_TEMPLATES.REGENERATE_NOTE}\n`);
     const action = await select({
@@ -56,6 +68,6 @@ export async function handleMissingTemplates(ctx, yamlConfig, missingIds, flags)
         ctx.log(`\n  ${MISSING_TEMPLATES.ABORT_HINT}\n`);
         return false;
     }
-    await regenerateMissingTemplates(ctx, yamlConfig, missingIds, flags);
-    return true;
+    await regenerateMissingTemplates(ctx, yamlConfig, stillMissing, flags);
+    return 'regenerated';
 }

package/dist/lib/templates/regenerate.d.ts

@@ -0,0 +1,10 @@
+import { type MailmodoYaml } from '../yaml-config.js';
+import type { DeployFlags } from '../commands/deploy/types.js';
+import type { RegenCtx } from './types.js';
+/**
+ * Calls POST /email/generate with the missing email IDs, writes the returned
+ * HTML files to disk, then syncs both the YAML and all templates to the server.
+ * Called when the user chooses "Re-generate via AI" from the missing-template
+ * prompt, or when no server backup exists to restore from.
+ */
+export declare function regenerateMissingTemplates(ctx: RegenCtx, yamlConfig: MailmodoYaml, missingIds: string[], flags: DeployFlags): Promise<void>;

package/dist/lib/templates/regenerate.js

@@ -0,0 +1,29 @@
+import { API_ENDPOINTS } from '../constants.js';
+import { saveTemplate } from '../yaml-config.js';
+import { buildRegeneratePayload } from '../commands/deploy/payload.js';
+import { MISSING_TEMPLATES } from '../messages.js';
+/**
+ * Calls POST /email/generate with the missing email IDs, writes the returned
+ * HTML files to disk, then syncs both the YAML and all templates to the server.
+ * Called when the user chooses "Re-generate via AI" from the missing-template
+ * prompt, or when no server backup exists to restore from.
+ */
+export async function regenerateMissingTemplates(ctx, yamlConfig, missingIds, flags) {
+    const response = await ctx.spinner(`  ${MISSING_TEMPLATES.REGENERATE_SPINNER}`, flags.json, () => ctx.post(API_ENDPOINTS.GENERATE, buildRegeneratePayload(yamlConfig, missingIds)));
+    if (!response.ok)
+        ctx.onApiError(response);
+    const saves = [];
+    for (const email of response.data?.emails ?? []) {
+        // Guard against path traversal: only allow alphanumeric, dash, and underscore IDs
+        if (!/^[\w-]+$/.test(email.id))
+            continue;
+        if (email.html)
+            saves.push(saveTemplate(`${email.id}.html`, email.html));
+        if (email.plainHtml)
+            saves.push(saveTemplate(`${email.id}_plain.html`, email.plainHtml));
+    }
+    await Promise.all(saves);
+    await ctx.syncYaml();
+    // Back up the freshly generated templates so the server reflects the new state
+    await ctx.syncTemplates(yamlConfig);
+}

package/dist/lib/templates/sync.d.ts

@@ -0,0 +1,33 @@
+import type { ApiClient } from '../api-client.js';
+import { type MailmodoYaml } from '../yaml-config.js';
+/**
+ * Bulk-uploads all template HTML files referenced in the YAML to the server
+ * as a backup. Only files present on disk are sent; any extra files in the
+ * mailmodo/ folder that are not listed in the YAML are intentionally skipped.
+ * All files are read in parallel before building the multipart payload.
+ */
+export declare function syncTemplatesToServer(client: ApiClient, yaml: MailmodoYaml): Promise<void>;
+/**
+ * Uploads a single template's HTML files to the server for incremental sync.
+ * Used by the edit command after a change so only the modified template is
+ * re-uploaded instead of the full set. The branded HTML (`html` field) is
+ * required by the API; the plain variant (`plainHtml`) is uploaded only if
+ * its file exists on disk.
+ */
+export declare function syncTemplateToServer(client: ApiClient, emailId: string): Promise<void>;
+/**
+ * Downloads all backed-up templates from the server and writes them to the
+ * local mailmodo/ folder. Only templates whose emailId appears in the YAML
+ * are written to disk — extra templates stored on the server (e.g. from a
+ * previous project state) are intentionally ignored to keep the local folder
+ * in sync with the current YAML.
+ * Returns true if at least one file was written, false otherwise.
+ */
+export declare function fetchTemplatesFromServer(client: ApiClient, yaml: MailmodoYaml): Promise<boolean>;
+/**
+ * Downloads a single backed-up template from the server by emailId and writes
+ * it to the local mailmodo/ folder. Returns true if the template was found and
+ * written successfully, false if it has not been backed up or on any error.
+ * The plain HTML variant is only written if the server returned a non-empty value.
+ */
+export declare function fetchTemplateFromServer(client: ApiClient, emailId: string): Promise<boolean>;

package/dist/lib/templates/sync.js

@@ -0,0 +1,106 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { API_ENDPOINTS, TEMPLATES_DIR } from '../constants.js';
+import { saveTemplate } from '../yaml-config.js';
+/**
+ * Bulk-uploads all template HTML files referenced in the YAML to the server
+ * as a backup. Only files present on disk are sent; any extra files in the
+ * mailmodo/ folder that are not listed in the YAML are intentionally skipped.
+ * All files are read in parallel before building the multipart payload.
+ */
+export async function syncTemplatesToServer(client, yaml) {
+    // Collect filenames for both branded and plain variants, filtered to those that exist on disk
+    const filenames = yaml.emails
+        .flatMap((email) => [`${email.id}.html`, `${email.id}_plain.html`])
+        .filter((f) => existsSync(join(process.cwd(), TEMPLATES_DIR, f)));
+    if (filenames.length === 0)
+        return;
+    // Read all files in parallel to avoid sequential await-in-loop
+    const files = await Promise.all(filenames.map(async (f) => ({
+        content: await readFile(join(process.cwd(), TEMPLATES_DIR, f), 'utf8'),
+        name: f,
+    })));
+    // API expects multipart fields keyed by the template filename (e.g. abc123.html)
+    const formData = new FormData();
+    for (const { name, content } of files) {
+        formData.append(name, new Blob([content], { type: 'text/html' }), name);
+    }
+    await client.postFormData(API_ENDPOINTS.ASSETS_TEMPLATES, formData);
+}
+/**
+ * Uploads a single template's HTML files to the server for incremental sync.
+ * Used by the edit command after a change so only the modified template is
+ * re-uploaded instead of the full set. The branded HTML (`html` field) is
+ * required by the API; the plain variant (`plainHtml`) is uploaded only if
+ * its file exists on disk.
+ */
+export async function syncTemplateToServer(client, emailId) {
+    const htmlPath = join(process.cwd(), TEMPLATES_DIR, `${emailId}.html`);
+    // API requires the branded HTML field; skip entirely if the file is absent
+    if (!existsSync(htmlPath))
+        return;
+    const formData = new FormData();
+    const html = await readFile(htmlPath, 'utf8');
+    formData.append('html', new Blob([html], { type: 'text/html' }), `${emailId}.html`);
+    const plainPath = join(process.cwd(), TEMPLATES_DIR, `${emailId}_plain.html`);
+    if (existsSync(plainPath)) {
+        const plainHtml = await readFile(plainPath, 'utf8');
+        formData.append('plainHtml', new Blob([plainHtml], { type: 'text/html' }), `${emailId}_plain.html`);
+    }
+    await client.postFormData(`${API_ENDPOINTS.ASSETS_TEMPLATES}/${emailId}`, formData);
+}
+/**
+ * Downloads all backed-up templates from the server and writes them to the
+ * local mailmodo/ folder. Only templates whose emailId appears in the YAML
+ * are written to disk — extra templates stored on the server (e.g. from a
+ * previous project state) are intentionally ignored to keep the local folder
+ * in sync with the current YAML.
+ * Returns true if at least one file was written, false otherwise.
+ */
+export async function fetchTemplatesFromServer(client, yaml) {
+    try {
+        const resp = await client.get(API_ENDPOINTS.ASSETS_TEMPLATES);
+        if (!resp.ok || !resp.data?.templates?.length)
+            return false;
+        // Build a set of valid IDs from the YAML to filter out stale server entries
+        const validIds = new Set(yaml.emails.map((e) => e.id));
+        const saves = [];
+        for (const t of resp.data.templates) {
+            if (!validIds.has(t.emailId))
+                continue;
+            // The API returns an empty string when a variant was never stored; skip those
+            if (t.html)
+                saves.push(saveTemplate(`${t.emailId}.html`, t.html));
+            if (t.plainHtml)
+                saves.push(saveTemplate(`${t.emailId}_plain.html`, t.plainHtml));
+        }
+        await Promise.all(saves);
+        return saves.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Downloads a single backed-up template from the server by emailId and writes
+ * it to the local mailmodo/ folder. Returns true if the template was found and
+ * written successfully, false if it has not been backed up or on any error.
+ * The plain HTML variant is only written if the server returned a non-empty value.
+ */
+export async function fetchTemplateFromServer(client, emailId) {
+    try {
+        const resp = await client.get(`${API_ENDPOINTS.ASSETS_TEMPLATES}/${emailId}`);
+        // A missing or empty html field means the template was never backed up
+        if (!resp.ok || !resp.data?.html)
+            return false;
+        await saveTemplate(`${emailId}.html`, resp.data.html);
+        // plainHtml is empty string when no plain variant is stored; skip in that case
+        if (resp.data.plainHtml)
+            await saveTemplate(`${emailId}_plain.html`, resp.data.plainHtml);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/templates/types.d.ts

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

package/dist/lib/yaml-config.d.ts

@@ -44,6 +44,7 @@ export interface MailmodoYaml {
  *   formatted Error with the line number if the file contains invalid YAML syntax.
  */
 export declare function loadYaml(cwd?: string): Promise<MailmodoYaml | null>;
+export declare function parseYamlText(text: string): MailmodoYaml | null;
 /**
  * Serializes and writes the mailmodo.yaml configuration to disk.
  *

package/dist/lib/yaml-config.js

@@ -25,6 +25,14 @@ export async function loadYaml(cwd) {
         throw new Error(yamlParseError(error.message));
     }
 }
+export function parseYamlText(text) {
+    try {
+        return load(text);
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Serializes and writes the mailmodo.yaml configuration to disk.
  *