@agenticmail/core 0.7.6 → 0.9.0

package/dist/index.js

@@ -1087,14 +1087,14 @@ var StalwartAdmin = class {
     if (!isValidDomain(domain)) {
       throw new Error(`Invalid domain format: "${domain}"`);
     }
-    const { readFileSync: readFileSync5, writeFileSync: writeFileSync6 } = await import("fs");
-    const { homedir: homedir9 } = await import("os");
-    const { join: join10 } = await import("path");
-    const configPath = join10(homedir9(), ".agenticmail", "stalwart.toml");
+    const { readFileSync: readFileSync7, writeFileSync: writeFileSync8 } = await import("fs");
+    const { homedir: homedir11 } = await import("os");
+    const { join: join12 } = await import("path");
+    const configPath = join12(homedir11(), ".agenticmail", "stalwart.toml");
     try {
-      let config = readFileSync5(configPath, "utf-8");
+      let config = readFileSync7(configPath, "utf-8");
       config = config.replace(/^hostname\s*=\s*"[^"]*"/m, `hostname = "${escapeTomlString(domain)}"`);
-      writeFileSync6(configPath, config);
+      writeFileSync8(configPath, config);
       console.log(`[Stalwart] Updated hostname to "${domain}" in stalwart.toml`);
     } catch (err) {
       throw new Error(`Failed to set config server.hostname=${domain}`);
@@ -1103,15 +1103,15 @@ var StalwartAdmin = class {
   // --- DKIM ---
   /** Path to the host-side stalwart.toml (mounted read-only into container) */
   get configPath() {
-    const { homedir: homedir9 } = __require("os");
-    const { join: join10 } = __require("path");
-    return join10(homedir9(), ".agenticmail", "stalwart.toml");
+    const { homedir: homedir11 } = __require("os");
+    const { join: join12 } = __require("path");
+    return join12(homedir11(), ".agenticmail", "stalwart.toml");
   }
   /** Path to host-side DKIM key directory */
   get dkimDir() {
-    const { homedir: homedir9 } = __require("os");
-    const { join: join10 } = __require("path");
-    return join10(homedir9(), ".agenticmail");
+    const { homedir: homedir11 } = __require("os");
+    const { join: join12 } = __require("path");
+    return join12(homedir11(), ".agenticmail");
   }
   /**
    * Create/reuse a DKIM signing key for a domain.
@@ -1212,12 +1212,12 @@ var StalwartAdmin = class {
    * This bypasses the need for a PTR record on the sending IP.
    */
   async configureOutboundRelay(config) {
-    const { readFileSync: readFileSync5, writeFileSync: writeFileSync6 } = await import("fs");
-    const { homedir: homedir9 } = await import("os");
-    const { join: join10 } = await import("path");
+    const { readFileSync: readFileSync7, writeFileSync: writeFileSync8 } = await import("fs");
+    const { homedir: homedir11 } = await import("os");
+    const { join: join12 } = await import("path");
     const routeName = config.routeName ?? "gmail";
-    const tomlPath = join10(homedir9(), ".agenticmail", "stalwart.toml");
-    let toml = readFileSync5(tomlPath, "utf-8");
+    const tomlPath = join12(homedir11(), ".agenticmail", "stalwart.toml");
+    let toml = readFileSync7(tomlPath, "utf-8");
     toml = toml.replace(/\n\[queue\.route\.gmail\][\s\S]*?(?=\n\[|$)/, "");
     toml = toml.replace(/\n\[queue\.strategy\][\s\S]*?(?=\n\[|$)/, "");
     const safeRouteName = routeName.replace(/[^a-zA-Z0-9_-]/g, "");
@@ -1237,7 +1237,7 @@ auth.secret = "${escapeTomlString(config.password)}"
 route = [ { if = "is_local_domain('', rcpt_domain)", then = "'local'" },
            { else = "'${safeRouteName}'" } ]
 `;
-    writeFileSync6(tomlPath, toml, "utf-8");
+    writeFileSync8(tomlPath, toml, "utf-8");
     await this.restartContainer();
   }
 };
@@ -5105,12 +5105,12 @@ var GatewayManager = class {
       zone = await this.cfClient.createZone(domain);
     }
     const existingRecords = await this.cfClient.listDnsRecords(zone.id);
-    const { homedir: homedir9 } = await import("os");
-    const backupDir = join4(homedir9(), ".agenticmail");
+    const { homedir: homedir11 } = await import("os");
+    const backupDir = join4(homedir11(), ".agenticmail");
     const backupPath = join4(backupDir, `dns-backup-${domain}-${Date.now()}.json`);
-    const { writeFileSync: writeFileSync6, mkdirSync: mkdirSync7 } = await import("fs");
-    mkdirSync7(backupDir, { recursive: true });
-    writeFileSync6(backupPath, JSON.stringify({
+    const { writeFileSync: writeFileSync8, mkdirSync: mkdirSync9 } = await import("fs");
+    mkdirSync9(backupDir, { recursive: true });
+    writeFileSync8(backupPath, JSON.stringify({
       domain,
       zoneId: zone.id,
       backedUpAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -7292,10 +7292,301 @@ secret = "${password}"
     return existsSync7(configPath);
   }
 };
+
+// src/threading/thread-id.ts
+import { createHash as createHash2 } from "crypto";
+function stripReplyPrefixes(subject) {
+  let s = subject;
+  for (; ; ) {
+    const next = s.replace(/^\s*(?:re|fwd?|fw)\s*(?:\[\d+\])?\s*:\s*/i, "");
+    if (next === s) break;
+    s = next;
+  }
+  return s;
+}
+function stripCoordinationMarkers(subject) {
+  return subject.replace(/\[\s*(?:final|done|closed|wrap)\s*\]/gi, " ");
+}
+function normalizeSubject(subject) {
+  if (!subject) return "(no subject)";
+  let s = stripReplyPrefixes(subject);
+  s = stripCoordinationMarkers(s);
+  s = s.replace(/\s+/g, " ").trim().toLowerCase();
+  return s || "(no subject)";
+}
+function normalizeAddress(addr) {
+  if (!addr) return "(unknown)";
+  const m = addr.match(/<([^>]+)>/);
+  const raw = m ? m[1] : addr;
+  return raw.trim().toLowerCase();
+}
+function threadIdFor(input) {
+  const subject = normalizeSubject(input.subject);
+  return createHash2("sha256").update(subject).digest("base64url").slice(0, 16);
+}
+
+// src/threading/thread-cache.ts
+import {
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync5,
+  writeFileSync as writeFileSync6,
+  readdirSync,
+  statSync,
+  rmSync,
+  renameSync
+} from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join10 } from "path";
+var CACHE_DIR_DEFAULT = join10(homedir9(), ".agenticmail", "thread-cache");
+var DEFAULT_K_MESSAGES = 10;
+var DEFAULT_LRU_CAP = 5e3;
+var PREVIEW_MAX_CHARS = 240;
+var ThreadCache = class {
+  dir;
+  k;
+  lruCap;
+  constructor(opts = {}) {
+    this.dir = opts.cacheDir ?? CACHE_DIR_DEFAULT;
+    this.k = opts.k ?? DEFAULT_K_MESSAGES;
+    this.lruCap = opts.lruCap ?? DEFAULT_LRU_CAP;
+    try {
+      mkdirSync7(this.dir, { recursive: true });
+    } catch {
+    }
+  }
+  pathFor(threadId) {
+    return join10(this.dir, `${threadId}.json`);
+  }
+  read(threadId) {
+    const p = this.pathFor(threadId);
+    if (!existsSync8(p)) return null;
+    try {
+      const raw = readFileSync5(p, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      try {
+        rmSync(p, { force: true });
+      } catch {
+      }
+      return null;
+    }
+  }
+  /**
+   * Append a message to the thread's cache, pruning to the K
+   * newest entries. Creates the cache entry on first write.
+   *
+   * `rootFromAddr` is the sender of the ROOT message on the
+   * thread; on a brand-new thread this is just `env.fromAddr`,
+   * on a reply it's read off the existing cache entry (callers
+   * should pass the existing entry's rootFromAddr when known).
+   */
+  pushMessage(threadId, env, meta) {
+    const existing = this.read(threadId);
+    const entry = existing ? {
+      ...existing,
+      // We re-affirm subject + rootFromAddr to existing values —
+      // the first-seen values win. Reply messages carry the
+      // replier's `from`, not the original sender's, so we'd
+      // corrupt the thread root if we overwrote here.
+      subject: existing.subject,
+      rootFromAddr: existing.rootFromAddr,
+      lastUpdated: Date.now(),
+      messages: dedupAndCap([env, ...existing.messages], this.k)
+    } : {
+      threadId,
+      subject: meta.subject,
+      rootFromAddr: meta.rootFromAddr,
+      lastUpdated: Date.now(),
+      messages: [env]
+    };
+    this.writeAtomic(threadId, entry);
+    this.maybeEvict();
+    return entry;
+  }
+  /** Permanently remove a thread's cache (called on [FINAL] / [DONE] / [CLOSED] / [WRAP]). */
+  delete(threadId) {
+    try {
+      rmSync(this.pathFor(threadId), { force: true });
+    } catch {
+    }
+  }
+  /**
+   * Render the cache as a compact text block for the wake prompt.
+   * One line per message, newest first. Empty string when the
+   * cache is empty — caller decides whether to suppress the
+   * header in that case.
+   */
+  renderForPrompt(entry) {
+    if (!entry || entry.messages.length === 0) return "";
+    return entry.messages.map((m) => {
+      const preview = m.preview.replace(/\s+/g, " ").slice(0, PREVIEW_MAX_CHARS);
+      return `- UID ${m.uid} \xB7 ${m.from} \xB7 ${m.date} \xB7 "${m.subject}" \xB7 ${preview}`;
+    }).join("\n");
+  }
+  writeAtomic(threadId, entry) {
+    const p = this.pathFor(threadId);
+    const tmp = `${p}.tmp`;
+    writeFileSync6(tmp, JSON.stringify(entry), "utf-8");
+    renameSync(tmp, p);
+  }
+  /**
+   * Best-effort LRU eviction. Runs at most every 256 writes (we
+   * don't track a precise counter — `Math.random()` sampling keeps
+   * the write path cheap). When the directory has more files than
+   * `lruCap`, sort by mtime ascending and delete the oldest 10%.
+   */
+  maybeEvict() {
+    if (Math.random() > 1 / 256) return;
+    let files;
+    try {
+      files = readdirSync(this.dir).filter((f) => f.endsWith(".json"));
+    } catch {
+      return;
+    }
+    if (files.length <= this.lruCap) return;
+    const stats = files.map((f) => {
+      const p = join10(this.dir, f);
+      try {
+        return { p, mtime: statSync(p).mtimeMs };
+      } catch {
+        return { p, mtime: 0 };
+      }
+    });
+    stats.sort((a, b) => a.mtime - b.mtime);
+    const dropCount = Math.max(1, Math.floor(this.lruCap * 0.1));
+    for (let i = 0; i < dropCount; i++) {
+      try {
+        rmSync(stats[i].p, { force: true });
+      } catch {
+      }
+    }
+  }
+};
+function dedupAndCap(messages, k) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const m of messages) {
+    if (seen.has(m.uid)) continue;
+    seen.add(m.uid);
+    out.push(m);
+    if (out.length >= k) break;
+  }
+  return out;
+}
+
+// src/threading/agent-memory.ts
+import {
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync6,
+  writeFileSync as writeFileSync7,
+  rmSync as rmSync2,
+  renameSync as renameSync2
+} from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join11 } from "path";
+var MEMORY_DIR_DEFAULT = join11(homedir10(), ".agenticmail", "agent-memory");
+var AgentMemoryStore = class {
+  dir;
+  constructor(opts = {}) {
+    this.dir = opts.memoryDir ?? MEMORY_DIR_DEFAULT;
+    try {
+      mkdirSync8(this.dir, { recursive: true });
+    } catch {
+    }
+  }
+  dirFor(agentId) {
+    return join11(this.dir, sanitizeId(agentId));
+  }
+  pathFor(agentId, threadId) {
+    return join11(this.dirFor(agentId), `${sanitizeId(threadId)}.md`);
+  }
+  read(agentId, threadId) {
+    const p = this.pathFor(agentId, threadId);
+    if (!existsSync9(p)) return null;
+    try {
+      const raw = readFileSync6(p, "utf-8");
+      const parsed = parse(raw);
+      return { ...parsed, raw };
+    } catch {
+      return null;
+    }
+  }
+  write(agentId, threadId, fields) {
+    const agentDir = this.dirFor(agentId);
+    try {
+      mkdirSync8(agentDir, { recursive: true });
+    } catch {
+    }
+    const body = render({ ...fields, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    const p = this.pathFor(agentId, threadId);
+    const tmp = `${p}.tmp`;
+    writeFileSync7(tmp, body, "utf-8");
+    renameSync2(tmp, p);
+  }
+  delete(agentId, threadId) {
+    try {
+      rmSync2(this.pathFor(agentId, threadId), { force: true });
+    } catch {
+    }
+  }
+  /** Render an agent's memory for injection into a wake prompt.
+   *  Returns the raw markdown if present; empty string when there's
+   *  no prior memory (the caller decides whether to suppress the
+   *  whole "Your own memory" block). */
+  renderForPrompt(memory) {
+    if (!memory) return "";
+    return memory.raw;
+  }
+};
+function sanitizeId(id) {
+  return id.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function render(fields) {
+  const fm = ["---"];
+  fm.push(`updated_at: ${fields.updatedAt}`);
+  if (typeof fields.lastUid === "number") fm.push(`last_uid: ${fields.lastUid}`);
+  fm.push("---", "");
+  const sections = [];
+  if (fields.summary && fields.summary.trim()) {
+    sections.push(fields.summary.trim());
+  }
+  if (fields.commitments && fields.commitments.length > 0) {
+    sections.push(`### Commitments
+${fields.commitments.map((c) => `- ${c}`).join("\n")}`);
+  }
+  if (fields.openQuestions && fields.openQuestions.length > 0) {
+    sections.push(`### Open
+${fields.openQuestions.map((q) => `- ${q}`).join("\n")}`);
+  }
+  if (fields.lastAction && fields.lastAction.trim()) {
+    sections.push(`### Last action
+${fields.lastAction.trim()}`);
+  }
+  return fm.join("\n") + sections.join("\n\n") + "\n";
+}
+function parse(raw) {
+  const out = {};
+  const m = raw.match(/^---\n([\s\S]*?)\n---\n/);
+  if (m) {
+    for (const line of m[1].split("\n")) {
+      const kv = line.match(/^(\w+):\s*(.*)$/);
+      if (!kv) continue;
+      if (kv[1] === "updated_at") out.updatedAt = kv[2].trim();
+      else if (kv[1] === "last_uid") {
+        const n = parseInt(kv[2], 10);
+        if (!isNaN(n)) out.lastUid = n;
+      }
+    }
+  }
+  return out;
+}
 export {
   AGENT_ROLES,
   AccountManager,
   AgentDeletionService,
+  AgentMemoryStore,
   AgenticMailClient,
   CloudflareClient,
   DEFAULT_AGENT_NAME,
@@ -7319,6 +7610,7 @@ export {
   SmsManager,
   SmsPoller,
   StalwartAdmin,
+  ThreadCache,
   TunnelManager,
   WARNING_THRESHOLD,
   buildInboundSecurityAdvisory,
@@ -7333,7 +7625,9 @@ export {
   getDatabase,
   isInternalEmail,
   isValidPhoneNumber,
+  normalizeAddress,
   normalizePhoneNumber,
+  normalizeSubject,
   parseEmail,
   parseGoogleVoiceSms,
   recordToolCall,
@@ -7343,5 +7637,6 @@ export {
   scanOutboundEmail,
   scoreEmail,
   setTelemetryVersion,
-  startRelayBridge
+  startRelayBridge,
+  threadIdFor
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenticmail/core",
-  "version": "0.7.6",
+  "version": "0.9.0",
   "description": "Core SDK for AgenticMail — email, SMS, and phone number access for AI agents",
   "type": "module",
   "main": "dist/index.js",