@aidalinfo/email-mcp 0.1.1 → 0.2.0

package/dist/redact.js

@@ -0,0 +1,23 @@
+/**
+ * Central redaction for everything that leaves the process as text (tool errors, audit lines,
+ * HTTP error bodies): registered secrets, auth headers and client keys, whatever their source.
+ */
+export class Redactor {
+    secrets = new Set();
+    /** Registers a secret value; values under 8 characters are ignored (too likely to hit plain text). */
+    add(secret) {
+        if (secret && secret.length >= 8)
+            this.secrets.add(secret);
+    }
+    apply(text) {
+        let t = text;
+        for (const s of this.secrets)
+            t = t.split(s).join("[REDACTED]");
+        return t
+            .replace(/(x-auth-token["']?\s*[:=]\s*["']?)[^"'\s,}]+/gi, "$1[REDACTED]")
+            .replace(/(authorization["']?\s*[:=]\s*["']?)(?:(bearer|basic)\s+)?[^"'\s,}]+/gi, (_, h, scheme) => `${h}${scheme ? `${scheme} ` : ""}[REDACTED]`)
+            .replace(/\bemk_[A-Za-z0-9_-]{16,}/g, "[REDACTED]");
+    }
+}
+/** Process-wide instance: the entry point registers the secrets it loads. */
+export const redactor = new Redactor();

package/dist/tem-client.js

@@ -73,4 +73,9 @@ export class TemClient {
     async getEmail(id) {
         return this.call("GET", `${this.base}/emails/${encodeURIComponent(id)}`, "get email");
     }
+    async listBlocklists(domainId, email) {
+        const qs = new URLSearchParams({ domain_id: domainId, email, page_size: "20" });
+        const res = await this.call("GET", `${this.base}/blocklists?${qs}`, "list TEM blocklists");
+        return (res.blocklists ?? []).filter((b) => b.domain_id === domainId && b.email.toLowerCase() === email);
+    }
 }

package/dist/templates.js

@@ -0,0 +1,118 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { EmailError } from "./errors.js";
+export const TEMPLATE_NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+const VARIABLE_RE = /^[a-z][a-z0-9_]{0,39}$/;
+const PLACEHOLDER_RE = /\{\{\s*([a-z][a-z0-9_]{0,39})\s*\}\}/g;
+export const DEFAULT_VARIABLE_LENGTH = 1_000;
+export const HARD_VARIABLE_LENGTH = 10_000;
+const escapeHtml = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+function parseTemplate(raw, file) {
+    const t = raw;
+    const fail = (m) => {
+        throw new Error(`template ${file}: ${m}`);
+    };
+    if (!t || typeof t !== "object")
+        fail("not a JSON object");
+    if (typeof t.name !== "string" || !TEMPLATE_NAME_RE.test(t.name))
+        fail("name must match [a-z0-9-], 64 characters max");
+    if (!Number.isInteger(t.version) || t.version < 1)
+        fail("version must be a positive integer");
+    for (const k of ["subject", "text"])
+        if (typeof t[k] !== "string" || !t[k].trim())
+            fail(`${k} is required`);
+    if (t.html !== undefined && (typeof t.html !== "string" || !t.html.trim()))
+        fail("html must be a non-empty string when present");
+    if (/[\u0000-\u001f\u007f]/.test(t.subject))
+        fail("subject must not contain line breaks or control characters");
+    const variables = {};
+    for (const [name, spec] of Object.entries((t.variables ?? {}))) {
+        if (!VARIABLE_RE.test(name))
+            fail(`variable "${name}" must match [a-z][a-z0-9_]*`);
+        const maxLength = spec?.maxLength ?? DEFAULT_VARIABLE_LENGTH;
+        if (!Number.isInteger(maxLength) || maxLength < 1 || maxLength > HARD_VARIABLE_LENGTH)
+            fail(`variable "${name}": maxLength must be 1..${HARD_VARIABLE_LENGTH}`);
+        variables[name] = { required: spec?.required !== false, maxLength: maxLength, description: typeof spec?.description === "string" ? spec.description : undefined };
+    }
+    for (const k of ["subject", "text", "html"]) {
+        for (const m of (t[k] ?? "").matchAll(PLACEHOLDER_RE)) {
+            if (!Object.hasOwn(variables, m[1]))
+                fail(`${k} uses {{${m[1]}}}, which is not declared in variables`);
+        }
+    }
+    if (t.clients !== undefined && (!Array.isArray(t.clients) || t.clients.some((c) => typeof c !== "string")))
+        fail("clients must be a list of client ids");
+    return {
+        name: t.name,
+        version: t.version,
+        description: typeof t.description === "string" ? t.description : undefined,
+        subject: t.subject,
+        text: t.text,
+        html: t.html,
+        variables,
+        clients: t.clients,
+    };
+}
+/**
+ * Versioned templates for recurring sends, loaded once at startup from EMAIL_TEMPLATES_DIR
+ * (one JSON file per name and version). A send names the exact version: changing a template means
+ * adding a new version, never editing the content a routine was approved with.
+ */
+export class TemplateCatalog {
+    dir;
+    byKey = new Map();
+    constructor(dir) {
+        this.dir = dir;
+        if (!dir)
+            return;
+        for (const f of readdirSync(dir).filter((n) => n.endsWith(".json")).sort()) {
+            let raw;
+            try {
+                raw = JSON.parse(readFileSync(join(dir, f), "utf-8"));
+            }
+            catch (err) {
+                throw new Error(`template ${f}: invalid JSON (${err instanceof Error ? err.message : String(err)})`);
+            }
+            const t = parseTemplate(raw, f);
+            const key = `${t.name}@${t.version}`;
+            if (this.byKey.has(key))
+                throw new Error(`template ${f}: ${key} is defined twice`);
+            this.byKey.set(key, t);
+        }
+    }
+    get configured() {
+        return !!this.dir;
+    }
+    list(clientId) {
+        return [...this.byKey.values()].filter((t) => !t.clients || t.clients.includes(clientId));
+    }
+    /** Renders a template for a client. Variables are escaped in the HTML body and refused with control characters in the subject. */
+    render(clientId, name, version, vars) {
+        if (!this.configured)
+            throw new EmailError("capability_unavailable", "capability_unavailable: no template directory is configured (EMAIL_TEMPLATES_DIR)");
+        const t = this.byKey.get(`${name}@${version}`);
+        if (!t || (t.clients && !t.clients.includes(clientId)))
+            throw new EmailError("not_found", `not_found: template ${name}@${version} does not exist for this client — see email_templates`);
+        for (const k of Object.keys(vars)) {
+            if (!Object.hasOwn(t.variables, k))
+                throw new EmailError("invalid_request", `invalid_request: template ${name}@${version} has no variable "${k.slice(0, 40)}"`);
+        }
+        for (const [k, spec] of Object.entries(t.variables)) {
+            const v = Object.hasOwn(vars, k) ? vars[k] : undefined;
+            if (v === undefined || v === "") {
+                if (spec.required)
+                    throw new EmailError("invalid_request", `invalid_request: variable "${k}" is required by ${name}@${version}`);
+                continue;
+            }
+            if (v.length > spec.maxLength)
+                throw new EmailError("invalid_request", `invalid_request: variable "${k}" is longer than ${spec.maxLength} characters`);
+        }
+        const fill = (s, esc) => s.replace(PLACEHOLDER_RE, (_, k) => esc(Object.hasOwn(vars, k) ? vars[k] : ""));
+        const subject = fill(t.subject, (v) => {
+            if (/[\u0000-\u001f\u007f]/.test(v))
+                throw new EmailError("invalid_request", "invalid_request: a variable used in the subject contains a line break or a control character");
+            return v;
+        });
+        return { subject, text: fill(t.text, (v) => v), html: t.html === undefined ? undefined : fill(t.html, escapeHtml) };
+    }
+}