imsg-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,3503 @@
+#!/usr/bin/env node
+import { execFile } from "node:child_process";
+import { existsSync, mkdirSync, statSync } from "node:fs";
+import { join, dirname, isAbsolute } from "node:path";
+import { promisify } from "node:util";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { c as checkLocalAccess, f as formatAccessReport, s as shutdown, g as getImsgDbPath, a as getContactsDbPaths, b as getSlugsDbPath, d as appendLog, e as getFileLogLines, h as getLogDirectory, p as perf, i as checkMessagesAvailable, j as sendToChat, k as sendToChatId, l as sendMessageReliable, m as sendMessageAlt, n as sendAttachment, o as checkImessageAvailability, q as installShutdownHandlers, r as registerCleanup, t as enableStdinEofDetection, u as enableOrphanWatchdog, v as logStartup, w as info, x as startHeapMonitor, y as getLogs, z as logShutdown, A as stopHeapMonitor, B as getLogFilePath, C as getLastSendError } from "./shutdown-B9ClCyco.js";
+import { homedir } from "node:os";
+import Database from "better-sqlite3";
+import { streamExport } from "./exportStream-BaheQ6M4.js";
+import { I as IMessageDB, h as hasNativeModule } from "./imessage-db-BVDtx0Sn.js";
+import { z } from "zod";
+import { A as APP_VERSION, a as APP_NAME } from "./meta-D3NoTAjA.js";
+import { randomUUID } from "node:crypto";
+import { parseUserDate } from "./dateParse-DJXMfq3a.js";
+import { i as installWatchdog, n as noteActivity, r as readWatchdogState } from "./watchdog-V3lgEhMp.js";
+const MS_PER_DAY = 864e5;
+function localDateKey(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function contactKey(m) {
+  return m.chatId;
+}
+function byDate(a, b) {
+  return a.date.getTime() - b.date.getTime();
+}
+function computeStreaks(messages) {
+  const byContact = /* @__PURE__ */ new Map();
+  for (const m of messages) {
+    if (m.isReaction) continue;
+    const c = contactKey(m);
+    if (!byContact.has(c)) byContact.set(c, /* @__PURE__ */ new Set());
+    byContact.get(c).add(localDateKey(m.date));
+  }
+  localDateKey(/* @__PURE__ */ new Date());
+  const results = [];
+  for (const [contact, dayset] of byContact) {
+    const days = Array.from(dayset).sort();
+    let longest = 0;
+    let longestStart = null;
+    let longestEnd = null;
+    let runLen = 0;
+    let runStart = null;
+    for (let i = 0; i < days.length; i++) {
+      if (i === 0 || new Date(days[i]).getTime() - new Date(days[i - 1]).getTime() !== MS_PER_DAY) {
+        runLen = 1;
+        runStart = days[i];
+      } else {
+        runLen++;
+      }
+      if (runLen > longest) {
+        longest = runLen;
+        longestStart = runStart;
+        longestEnd = days[i];
+      }
+    }
+    let curLen = 0;
+    const cursor = /* @__PURE__ */ new Date();
+    while (dayset.has(localDateKey(cursor))) {
+      curLen++;
+      cursor.setDate(cursor.getDate() - 1);
+    }
+    results.push({
+      contact,
+      longestStreakDays: longest,
+      longestStreakStart: longestStart,
+      longestStreakEnd: longestEnd,
+      currentStreakDays: curLen
+    });
+  }
+  results.sort((a, b) => b.longestStreakDays - a.longestStreakDays);
+  return results;
+}
+function computeDoubleTexts(messages) {
+  const byContact = /* @__PURE__ */ new Map();
+  for (const m of messages) {
+    if (m.isReaction) continue;
+    const c = contactKey(m);
+    if (!byContact.has(c)) byContact.set(c, []);
+    byContact.get(c).push(m);
+  }
+  const results = [];
+  for (const [contact, msgs] of byContact) {
+    msgs.sort(byDate);
+    let mineRun = 0;
+    let theirsRun = 0;
+    let mineDoubles = 0;
+    let theirsDoubles = 0;
+    for (const m of msgs) {
+      if (m.isFromMe) {
+        mineRun++;
+        theirsRun = 0;
+        if (mineRun >= 2) mineDoubles++;
+      } else {
+        theirsRun++;
+        mineRun = 0;
+        if (theirsRun >= 2) theirsDoubles++;
+      }
+    }
+    results.push({
+      contact,
+      doubleTextsFromMe: mineDoubles,
+      doubleTextsFromThem: theirsDoubles
+    });
+  }
+  results.sort(
+    (a, b) => b.doubleTextsFromMe + b.doubleTextsFromThem - (a.doubleTextsFromMe + a.doubleTextsFromThem)
+  );
+  return results;
+}
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.min(sorted.length - 1, Math.floor(p / 100 * sorted.length));
+  return sorted[idx] ?? 0;
+}
+function computeResponseTimes(messages) {
+  const byContact = /* @__PURE__ */ new Map();
+  for (const m of messages) {
+    if (m.isReaction) continue;
+    const c = contactKey(m);
+    if (!byContact.has(c)) byContact.set(c, []);
+    byContact.get(c).push(m);
+  }
+  const results = [];
+  for (const [contact, msgs] of byContact) {
+    msgs.sort(byDate);
+    const deltas = [];
+    for (let i = 1; i < msgs.length; i++) {
+      const prev = msgs[i - 1];
+      const curr = msgs[i];
+      if (!prev.isFromMe && curr.isFromMe) {
+        deltas.push(curr.date.getTime() - prev.date.getTime());
+      }
+    }
+    if (deltas.length === 0) continue;
+    deltas.sort((a, b) => a - b);
+    const mean = deltas.reduce((s, n) => s + n, 0) / deltas.length;
+    results.push({
+      contact,
+      count: deltas.length,
+      medianMs: percentile(deltas, 50),
+      p95Ms: percentile(deltas, 95),
+      meanMs: Math.round(mean)
+    });
+  }
+  results.sort((a, b) => a.medianMs - b.medianMs);
+  return results;
+}
+function computeHeatmap(messages) {
+  const grid = Array.from({ length: 7 }, () => Array.from({ length: 24 }, () => 0));
+  let total = 0;
+  for (const m of messages) {
+    if (m.isReaction) continue;
+    const dow = m.date.getDay();
+    const hr = m.date.getHours();
+    const dowRow = grid[dow];
+    if (dowRow && hr >= 0 && hr < 24) {
+      dowRow[hr] = (dowRow[hr] ?? 0) + 1;
+      total++;
+    }
+  }
+  return { grid, total };
+}
+function computeTapbacks(messages) {
+  const byContact = /* @__PURE__ */ new Map();
+  for (const m of messages) {
+    if (!m.isReaction || !m.reaction) continue;
+    const c = contactKey(m);
+    if (!byContact.has(c)) {
+      byContact.set(c, {
+        contact: c,
+        heart: 0,
+        thumbsUp: 0,
+        thumbsDown: 0,
+        haha: 0,
+        exclaim: 0,
+        question: 0,
+        emoji: 0,
+        total: 0
+      });
+    }
+    const r = byContact.get(c);
+    const t = (m.reaction.type || "").toLowerCase();
+    if (t.includes("heart") || t === "love") r.heart++;
+    else if (t.includes("thumb") && t.includes("up") || t === "like") r.thumbsUp++;
+    else if (t.includes("thumb") && t.includes("down") || t === "dislike") r.thumbsDown++;
+    else if (t.includes("haha") || t === "laugh") r.haha++;
+    else if (t.includes("exclaim") || t === "emphasis") r.exclaim++;
+    else if (t.includes("question")) r.question++;
+    else r.emoji++;
+    r.total++;
+  }
+  const out = Array.from(byContact.values());
+  out.sort((a, b) => b.total - a.total);
+  return out;
+}
+function computeWrapped(messages) {
+  if (messages.length === 0) {
+    return {
+      windowStart: "",
+      windowEnd: "",
+      totalSent: 0,
+      totalReceived: 0,
+      totalReactions: 0,
+      topContacts: [],
+      peakDay: null,
+      longestStreakDays: 0,
+      longestStreakContact: null
+    };
+  }
+  let sent = 0;
+  let received = 0;
+  let reactions = 0;
+  const perContact = /* @__PURE__ */ new Map();
+  const perDay = /* @__PURE__ */ new Map();
+  for (const m of messages) {
+    if (m.isReaction) {
+      reactions++;
+      continue;
+    }
+    if (m.isFromMe) sent++;
+    else received++;
+    const c = contactKey(m);
+    if (!perContact.has(c)) perContact.set(c, { sent: 0, received: 0, total: 0 });
+    const pc = perContact.get(c);
+    if (m.isFromMe) pc.sent++;
+    else pc.received++;
+    pc.total++;
+    const dk = localDateKey(m.date);
+    perDay.set(dk, (perDay.get(dk) ?? 0) + 1);
+  }
+  const topContacts = Array.from(perContact.entries()).map(([contact, v]) => ({ contact, ...v })).sort((a, b) => b.total - a.total).slice(0, 5);
+  let peakDay = null;
+  for (const [d, count] of perDay) {
+    if (!peakDay || count > peakDay.count) peakDay = { date: d, count };
+  }
+  const streaks = computeStreaks(messages);
+  const top = streaks[0];
+  return {
+    windowStart: localDateKey(messages[0].date),
+    windowEnd: localDateKey(messages[messages.length - 1].date),
+    totalSent: sent,
+    totalReceived: received,
+    totalReactions: reactions,
+    topContacts,
+    peakDay,
+    longestStreakDays: top?.longestStreakDays ?? 0,
+    longestStreakContact: top?.contact ?? null
+  };
+}
+function dispatchAnalytic(type, messages) {
+  switch (type) {
+    case "messaging_streaks":
+      return { type, data: computeStreaks(messages) };
+    case "double_texts":
+      return { type, data: computeDoubleTexts(messages) };
+    case "response_time_stats":
+      return { type, data: computeResponseTimes(messages) };
+    case "daily_heatmap":
+      return { type, data: computeHeatmap(messages) };
+    case "tapback_summary":
+      return { type, data: computeTapbacks(messages) };
+    case "year_in_review_wrapped":
+      return { type, data: computeWrapped(messages) };
+  }
+}
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+let dbPath = join(homedir(), ".imsg-mcp", "analytics-cache.db");
+let db = null;
+function open() {
+  if (db) return db;
+  const dir = dirname(dbPath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS analytics_cache (
+      type TEXT NOT NULL,
+      args_hash TEXT NOT NULL,
+      max_rowid INTEGER NOT NULL,
+      data_json TEXT NOT NULL,
+      computed_at INTEGER NOT NULL,
+      PRIMARY KEY (type, args_hash)
+    );
+  `);
+  return db;
+}
+function hashArgs(args) {
+  return JSON.stringify(args, Object.keys(args).sort());
+}
+function lookupCache(type, args, maxRowId) {
+  const conn = open();
+  const row = conn.prepare(
+    `SELECT data_json, max_rowid, computed_at FROM analytics_cache
+       WHERE type = ? AND args_hash = ?`
+  ).get(type, hashArgs(args));
+  if (!row) return null;
+  if (row.max_rowid !== maxRowId) return null;
+  if (Date.now() - row.computed_at > DEFAULT_TTL_MS) return null;
+  return { data: JSON.parse(row.data_json), computedAt: row.computed_at };
+}
+function storeCache(type, args, maxRowId, data) {
+  const conn = open();
+  conn.prepare(
+    `INSERT INTO analytics_cache (type, args_hash, max_rowid, data_json, computed_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(type, args_hash) DO UPDATE SET
+         max_rowid = excluded.max_rowid,
+         data_json = excluded.data_json,
+         computed_at = excluded.computed_at`
+  ).run(type, hashArgs(args), maxRowId, JSON.stringify(data), Date.now());
+}
+const MAX_ENTRIES = 10;
+const lru = [];
+function rememberSearch(query, matches) {
+  if (matches.length === 0) return;
+  const dupIdx = lru.findIndex((e) => e.query === query);
+  if (dupIdx >= 0) lru.splice(dupIdx, 1);
+  lru.unshift({ query, recordedAt: Date.now(), matches });
+  if (lru.length > MAX_ENTRIES) lru.length = MAX_ENTRIES;
+}
+function resolveContactSelector(selector) {
+  const m = selector.match(/^contact:(\d+)$/i);
+  if (!m?.[1]) return null;
+  const idx = Number.parseInt(m[1], 10) - 1;
+  if (idx < 0) return null;
+  for (const entry of lru) {
+    if (idx < entry.matches.length) {
+      const hit = entry.matches[idx];
+      if (hit) return hit;
+    }
+  }
+  return null;
+}
+const EMOJI_REGEX = /[\u{1F300}-\u{1FAFF}\u{2600}-\u{27BF}\u{1F1E6}-\u{1F1FF}]/gu;
+const WHITESPACE_REGEX = /\s+/g;
+function cleanText(s) {
+  return s.toLowerCase().replace(EMOJI_REGEX, " ").replace(WHITESPACE_REGEX, " ").trim();
+}
+function tokenSet(s) {
+  if (!s) return /* @__PURE__ */ new Set();
+  return new Set(s.split(" ").filter(Boolean));
+}
+function levenshtein(a, b, maxLen = 200) {
+  if (a === b) return 0;
+  const aLen = Math.min(a.length, maxLen);
+  const bLen = Math.min(b.length, maxLen);
+  if (aLen === 0) return bLen;
+  if (bLen === 0) return aLen;
+  let prev = new Array(bLen + 1);
+  let curr = new Array(bLen + 1);
+  for (let j = 0; j <= bLen; j++) prev[j] = j;
+  for (let i = 1; i <= aLen; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= bLen; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      const del = (prev[j] ?? 0) + 1;
+      const ins = (curr[j - 1] ?? 0) + 1;
+      const sub = (prev[j - 1] ?? 0) + cost;
+      curr[j] = Math.min(del, ins, sub);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[bLen] ?? Math.max(aLen, bLen);
+}
+function levenshteinRatio(a, b) {
+  if (a === b) return 1;
+  const aLen = Math.min(a.length, 200);
+  const bLen = Math.min(b.length, 200);
+  const maxLen = Math.max(aLen, bLen);
+  if (maxLen === 0) return 1;
+  return 1 - levenshtein(a, b) / maxLen;
+}
+function fuzzyScore(query, candidate) {
+  const q = cleanText(query);
+  const c = cleanText(candidate);
+  if (!q || !c) return 0;
+  if (c.includes(q)) return 0.95;
+  if (q.includes(c)) return 0.9;
+  const qTokens = tokenSet(q);
+  const cTokens = tokenSet(c);
+  let intersection = 0;
+  for (const tok of qTokens) {
+    if (cTokens.has(tok)) intersection++;
+  }
+  const dice = 2 * intersection / (qTokens.size + cTokens.size || 1);
+  let bestTokenLev = 0;
+  if (qTokens.size === 1) {
+    for (const tok of cTokens) {
+      const r = levenshteinRatio(q, tok);
+      if (r > bestTokenLev) bestTokenLev = r;
+    }
+  }
+  const levRatio = Math.max(levenshteinRatio(q, c), bestTokenLev);
+  const blend = qTokens.size <= 1 ? 0.1 * dice + 0.9 * levRatio : 0.7 * dice + 0.3 * levRatio;
+  return Math.max(0, Math.min(1, blend));
+}
+function rankFuzzy(query, candidates, getText, minScore = 0.6) {
+  const out = [];
+  for (const c of candidates) {
+    const score = fuzzyScore(query, getText(c));
+    if (score >= minScore) out.push({ item: c, score });
+  }
+  out.sort((a, b) => b.score - a.score);
+  return out;
+}
+const ignoreOverride = /* @__PURE__ */ Symbol("Let zodToJsonSchema decide on which parser to use");
+const defaultOptions = {
+  name: void 0,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  allowedAdditionalProperties: true,
+  rejectedAdditionalProperties: false,
+  definitionPath: "definitions",
+  target: "jsonSchema7",
+  strictUnions: false,
+  definitions: {},
+  errorMessages: false,
+  markdownDescription: false,
+  patternStrategy: "escape",
+  applyRegexFlags: false,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref",
+  openAiAnyTypeName: "OpenAiAnyType"
+};
+const getDefaultOptions = (options) => ({
+  ...defaultOptions,
+  ...options
+});
+const getRefs = (options) => {
+  const _options = getDefaultOptions(options);
+  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+  return {
+    ..._options,
+    flags: { hasReferencedOpenAiAnyType: false },
+    currentPath,
+    propertyPath: void 0,
+    seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
+      def._def,
+      {
+        def: def._def,
+        path: [..._options.basePath, _options.definitionPath, name],
+        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+        jsonSchema: void 0
+      }
+    ]))
+  };
+};
+function addErrorMessage(res, key, errorMessage, refs) {
+  if (!refs?.errorMessages)
+    return;
+  if (errorMessage) {
+    res.errorMessage = {
+      ...res.errorMessage,
+      [key]: errorMessage
+    };
+  }
+}
+function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+  res[key] = value;
+  addErrorMessage(res, key, errorMessage, refs);
+}
+const getRelativePath = (pathA, pathB) => {
+  let i = 0;
+  for (; i < pathA.length && i < pathB.length; i++) {
+    if (pathA[i] !== pathB[i])
+      break;
+  }
+  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
+};
+var ZodFirstPartyTypeKind;
+(function(ZodFirstPartyTypeKind2) {
+  ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
+  ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
+  ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
+  ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
+  ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
+  ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
+  ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
+  ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
+  ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
+  ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
+  ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
+  ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
+  ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
+  ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
+  ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
+  ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
+  ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
+  ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
+  ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
+  ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
+  ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
+  ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
+  ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
+  ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
+  ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
+  ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
+  ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
+  ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
+  ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
+  ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
+  ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
+  ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
+  ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
+  ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
+  ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
+  ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
+})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+function parseAnyDef(refs) {
+  if (refs.target !== "openAi") {
+    return {};
+  }
+  const anyDefinitionPath = [
+    ...refs.basePath,
+    refs.definitionPath,
+    refs.openAiAnyTypeName
+  ];
+  refs.flags.hasReferencedOpenAiAnyType = true;
+  return {
+    $ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
+  };
+}
+function parseArrayDef(def, refs) {
+  const res = {
+    type: "array"
+  };
+  if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
+    res.items = parseDef(def.type._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "items"]
+    });
+  }
+  if (def.minLength) {
+    setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
+  }
+  if (def.maxLength) {
+    setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+  }
+  if (def.exactLength) {
+    setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+    setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+  }
+  return res;
+}
+function parseBigintDef(def, refs) {
+  const res = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+function parseBooleanDef() {
+  return {
+    type: "boolean"
+  };
+}
+function parseBrandedDef(_def, refs) {
+  return parseDef(_def.type._def, refs);
+}
+const parseCatchDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+function parseDateDef(def, refs, overrideDateStrategy) {
+  const strategy = overrideDateStrategy ?? refs.dateStrategy;
+  if (Array.isArray(strategy)) {
+    return {
+      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
+    };
+  }
+  switch (strategy) {
+    case "string":
+    case "format:date-time":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "format:date":
+      return {
+        type: "string",
+        format: "date"
+      };
+    case "integer":
+      return integerDateParser(def, refs);
+  }
+}
+const integerDateParser = (def, refs) => {
+  const res = {
+    type: "integer",
+    format: "unix-time"
+  };
+  if (refs.target === "openApi3") {
+    return res;
+  }
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        setResponseValueAndErrors(
+          res,
+          "minimum",
+          check.value,
+          // This is in milliseconds
+          check.message,
+          refs
+        );
+        break;
+      case "max":
+        setResponseValueAndErrors(
+          res,
+          "maximum",
+          check.value,
+          // This is in milliseconds
+          check.message,
+          refs
+        );
+        break;
+    }
+  }
+  return res;
+};
+function parseDefaultDef(_def, refs) {
+  return {
+    ...parseDef(_def.innerType._def, refs),
+    default: _def.defaultValue()
+  };
+}
+function parseEffectsDef(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef(refs);
+}
+function parseEnumDef(def) {
+  return {
+    type: "string",
+    enum: Array.from(def.values)
+  };
+}
+const isJsonSchema7AllOfType = (type) => {
+  if ("type" in type && type.type === "string")
+    return false;
+  return "allOf" in type;
+};
+function parseIntersectionDef(def, refs) {
+  const allOf = [
+    parseDef(def.left._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "0"]
+    }),
+    parseDef(def.right._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "1"]
+    })
+  ].filter((x) => !!x);
+  let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
+  const mergedAllOf = [];
+  allOf.forEach((schema) => {
+    if (isJsonSchema7AllOfType(schema)) {
+      mergedAllOf.push(...schema.allOf);
+      if (schema.unevaluatedProperties === void 0) {
+        unevaluatedProperties = void 0;
+      }
+    } else {
+      let nestedSchema = schema;
+      if ("additionalProperties" in schema && schema.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema;
+        nestedSchema = rest;
+      } else {
+        unevaluatedProperties = void 0;
+      }
+      mergedAllOf.push(nestedSchema);
+    }
+  });
+  return mergedAllOf.length ? {
+    allOf: mergedAllOf,
+    ...unevaluatedProperties
+  } : void 0;
+}
+function parseLiteralDef(def, refs) {
+  const parsedType = typeof def.value;
+  if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
+    return {
+      type: Array.isArray(def.value) ? "array" : "object"
+    };
+  }
+  if (refs.target === "openApi3") {
+    return {
+      type: parsedType === "bigint" ? "integer" : parsedType,
+      enum: [def.value]
+    };
+  }
+  return {
+    type: parsedType === "bigint" ? "integer" : parsedType,
+    const: def.value
+  };
+}
+let emojiRegex = void 0;
+const zodPatterns = {
+  /**
+   * `c` was changed to `[cC]` to replicate /i flag
+   */
+  cuid: /^[cC][^\s-]{8,}$/,
+  cuid2: /^[0-9a-z]+$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  /**
+   * `a-z` was added to replicate /i flag
+   */
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  /**
+   * Constructed a valid Unicode RegExp
+   *
+   * Lazily instantiate since this type of regex isn't supported
+   * in all envs (e.g. React Native).
+   *
+   * See:
+   * https://github.com/colinhacks/zod/issues/2433
+   * Fix in Zod:
+   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+   */
+  emoji: () => {
+    if (emojiRegex === void 0) {
+      emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
+    }
+    return emojiRegex;
+  },
+  /**
+   * Unused
+   */
+  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+  /**
+   * Unused
+   */
+  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+  /**
+   * Unused
+   */
+  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+  nanoid: /^[a-zA-Z0-9_-]{21}$/,
+  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+};
+function parseStringDef(def, refs) {
+  const res = {
+    type: "string"
+  };
+  if (def.checks) {
+    for (const check of def.checks) {
+      switch (check.kind) {
+        case "min":
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+          break;
+        case "max":
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+          break;
+        case "email":
+          switch (refs.emailStrategy) {
+            case "format:email":
+              addFormat(res, "email", check.message, refs);
+              break;
+            case "format:idn-email":
+              addFormat(res, "idn-email", check.message, refs);
+              break;
+            case "pattern:zod":
+              addPattern(res, zodPatterns.email, check.message, refs);
+              break;
+          }
+          break;
+        case "url":
+          addFormat(res, "uri", check.message, refs);
+          break;
+        case "uuid":
+          addFormat(res, "uuid", check.message, refs);
+          break;
+        case "regex":
+          addPattern(res, check.regex, check.message, refs);
+          break;
+        case "cuid":
+          addPattern(res, zodPatterns.cuid, check.message, refs);
+          break;
+        case "cuid2":
+          addPattern(res, zodPatterns.cuid2, check.message, refs);
+          break;
+        case "startsWith":
+          addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
+          break;
+        case "endsWith":
+          addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
+          break;
+        case "datetime":
+          addFormat(res, "date-time", check.message, refs);
+          break;
+        case "date":
+          addFormat(res, "date", check.message, refs);
+          break;
+        case "time":
+          addFormat(res, "time", check.message, refs);
+          break;
+        case "duration":
+          addFormat(res, "duration", check.message, refs);
+          break;
+        case "length":
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+          break;
+        case "includes": {
+          addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
+          break;
+        }
+        case "ip": {
+          if (check.version !== "v6") {
+            addFormat(res, "ipv4", check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addFormat(res, "ipv6", check.message, refs);
+          }
+          break;
+        }
+        case "base64url":
+          addPattern(res, zodPatterns.base64url, check.message, refs);
+          break;
+        case "jwt":
+          addPattern(res, zodPatterns.jwt, check.message, refs);
+          break;
+        case "cidr": {
+          if (check.version !== "v6") {
+            addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
+          }
+          break;
+        }
+        case "emoji":
+          addPattern(res, zodPatterns.emoji(), check.message, refs);
+          break;
+        case "ulid": {
+          addPattern(res, zodPatterns.ulid, check.message, refs);
+          break;
+        }
+        case "base64": {
+          switch (refs.base64Strategy) {
+            case "format:binary": {
+              addFormat(res, "binary", check.message, refs);
+              break;
+            }
+            case "contentEncoding:base64": {
+              setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
+              break;
+            }
+            case "pattern:zod": {
+              addPattern(res, zodPatterns.base64, check.message, refs);
+              break;
+            }
+          }
+          break;
+        }
+        case "nanoid": {
+          addPattern(res, zodPatterns.nanoid, check.message, refs);
+        }
+      }
+    }
+  }
+  return res;
+}
+function escapeLiteralCheckValue(literal, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
+}
+const ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+function escapeNonAlphaNumeric(source) {
+  let result = "";
+  for (let i = 0; i < source.length; i++) {
+    if (!ALPHA_NUMERIC.has(source[i])) {
+      result += "\\";
+    }
+    result += source[i];
+  }
+  return result;
+}
+function addFormat(schema, value, message, refs) {
+  if (schema.format || schema.anyOf?.some((x) => x.format)) {
+    if (!schema.anyOf) {
+      schema.anyOf = [];
+    }
+    if (schema.format) {
+      schema.anyOf.push({
+        format: schema.format,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { format: schema.errorMessage.format }
+        }
+      });
+      delete schema.format;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.format;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.anyOf.push({
+      format: value,
+      ...message && refs.errorMessages && { errorMessage: { format: message } }
+    });
+  } else {
+    setResponseValueAndErrors(schema, "format", value, message, refs);
+  }
+}
+function addPattern(schema, regex, message, refs) {
+  if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
+    if (!schema.allOf) {
+      schema.allOf = [];
+    }
+    if (schema.pattern) {
+      schema.allOf.push({
+        pattern: schema.pattern,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { pattern: schema.errorMessage.pattern }
+        }
+      });
+      delete schema.pattern;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.pattern;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.allOf.push({
+      pattern: stringifyRegExpWithFlags(regex, refs),
+      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
+    });
+  } else {
+    setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
+  }
+}
+function stringifyRegExpWithFlags(regex, refs) {
+  if (!refs.applyRegexFlags || !regex.flags) {
+    return regex.source;
+  }
+  const flags = {
+    i: regex.flags.includes("i"),
+    m: regex.flags.includes("m"),
+    s: regex.flags.includes("s")
+    // `.` matches newlines
+  };
+  const source = flags.i ? regex.source.toLowerCase() : regex.source;
+  let pattern = "";
+  let isEscaped = false;
+  let inCharGroup = false;
+  let inCharRange = false;
+  for (let i = 0; i < source.length; i++) {
+    if (isEscaped) {
+      pattern += source[i];
+      isEscaped = false;
+      continue;
+    }
+    if (flags.i) {
+      if (inCharGroup) {
+        if (source[i].match(/[a-z]/)) {
+          if (inCharRange) {
+            pattern += source[i];
+            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
+            inCharRange = false;
+          } else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
+            pattern += source[i];
+            inCharRange = true;
+          } else {
+            pattern += `${source[i]}${source[i].toUpperCase()}`;
+          }
+          continue;
+        }
+      } else if (source[i].match(/[a-z]/)) {
+        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
+        continue;
+      }
+    }
+    if (flags.m) {
+      if (source[i] === "^") {
+        pattern += `(^|(?<=[\r
+]))`;
+        continue;
+      } else if (source[i] === "$") {
+        pattern += `($|(?=[\r
+]))`;
+        continue;
+      }
+    }
+    if (flags.s && source[i] === ".") {
+      pattern += inCharGroup ? `${source[i]}\r
+` : `[${source[i]}\r
+]`;
+      continue;
+    }
+    pattern += source[i];
+    if (source[i] === "\\") {
+      isEscaped = true;
+    } else if (inCharGroup && source[i] === "]") {
+      inCharGroup = false;
+    } else if (!inCharGroup && source[i] === "[") {
+      inCharGroup = true;
+    }
+  }
+  try {
+    new RegExp(pattern);
+  } catch {
+    console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
+    return regex.source;
+  }
+  return pattern;
+}
+function parseRecordDef(def, refs) {
+  if (refs.target === "openAi") {
+    console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
+  }
+  if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      type: "object",
+      required: def.keyType._def.values,
+      properties: def.keyType._def.values.reduce((acc, key) => ({
+        ...acc,
+        [key]: parseDef(def.valueType._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, "properties", key]
+        }) ?? parseAnyDef(refs)
+      }), {}),
+      additionalProperties: refs.rejectedAdditionalProperties
+    };
+  }
+  const schema = {
+    type: "object",
+    additionalProperties: parseDef(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    }) ?? refs.allowedAdditionalProperties
+  };
+  if (refs.target === "openApi3") {
+    return schema;
+  }
+  if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
+    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      ...schema,
+      propertyNames: {
+        enum: def.keyType._def.values
+      }
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
+    const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  }
+  return schema;
+}
+function parseMapDef(def, refs) {
+  if (refs.mapStrategy === "record") {
+    return parseRecordDef(def, refs);
+  }
+  const keys = parseDef(def.keyType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "0"]
+  }) || parseAnyDef(refs);
+  const values = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "1"]
+  }) || parseAnyDef(refs);
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+function parseNativeEnumDef(def) {
+  const object = def.values;
+  const actualKeys = Object.keys(def.values).filter((key) => {
+    return typeof object[object[key]] !== "number";
+  });
+  const actualValues = actualKeys.map((key) => object[key]);
+  const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
+  return {
+    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
+    enum: actualValues
+  };
+}
+function parseNeverDef(refs) {
+  return refs.target === "openAi" ? void 0 : {
+    not: parseAnyDef({
+      ...refs,
+      currentPath: [...refs.currentPath, "not"]
+    })
+  };
+}
+function parseNullDef(refs) {
+  return refs.target === "openApi3" ? {
+    enum: ["null"],
+    nullable: true
+  } : {
+    type: "null"
+  };
+}
+const primitiveMappings = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "integer",
+  ZodBoolean: "boolean",
+  ZodNull: "null"
+};
+function parseUnionDef(def, refs) {
+  if (refs.target === "openApi3")
+    return asAnyOf(def, refs);
+  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+  if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
+    const types = options.reduce((types2, x) => {
+      const type = primitiveMappings[x._def.typeName];
+      return type && !types2.includes(type) ? [...types2, type] : types2;
+    }, []);
+    return {
+      type: types.length > 1 ? types : types[0]
+    };
+  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+    const types = options.reduce((acc, x) => {
+      const type = typeof x._def.value;
+      switch (type) {
+        case "string":
+        case "number":
+        case "boolean":
+          return [...acc, type];
+        case "bigint":
+          return [...acc, "integer"];
+        case "object":
+          if (x._def.value === null)
+            return [...acc, "null"];
+        case "symbol":
+        case "undefined":
+        case "function":
+        default:
+          return acc;
+      }
+    }, []);
+    if (types.length === options.length) {
+      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+      return {
+        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+        enum: options.reduce((acc, x) => {
+          return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+        }, [])
+      };
+    }
+  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
+    return {
+      type: "string",
+      enum: options.reduce((acc, x) => [
+        ...acc,
+        ...x._def.values.filter((x2) => !acc.includes(x2))
+      ], [])
+    };
+  }
+  return asAnyOf(def, refs);
+}
+const asAnyOf = (def, refs) => {
+  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", `${i}`]
+  })).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
+  return anyOf.length ? { anyOf } : void 0;
+};
+function parseNullableDef(def, refs) {
+  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
+    if (refs.target === "openApi3") {
+      return {
+        type: primitiveMappings[def.innerType._def.typeName],
+        nullable: true
+      };
+    }
+    return {
+      type: [
+        primitiveMappings[def.innerType._def.typeName],
+        "null"
+      ]
+    };
+  }
+  if (refs.target === "openApi3") {
+    const base2 = parseDef(def.innerType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath]
+    });
+    if (base2 && "$ref" in base2)
+      return { allOf: [base2], nullable: true };
+    return base2 && { ...base2, nullable: true };
+  }
+  const base = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "0"]
+  });
+  return base && { anyOf: [base, { type: "null" }] };
+}
+function parseNumberDef(def, refs) {
+  const res = {
+    type: "number"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "int":
+        res.type = "integer";
+        addErrorMessage(res, "type", check.message, refs);
+        break;
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+function parseObjectDef(def, refs) {
+  const forceOptionalIntoNullable = refs.target === "openAi";
+  const result = {
+    type: "object",
+    properties: {}
+  };
+  const required = [];
+  const shape = def.shape();
+  for (const propName in shape) {
+    let propDef = shape[propName];
+    if (propDef === void 0 || propDef._def === void 0) {
+      continue;
+    }
+    let propOptional = safeIsOptional(propDef);
+    if (propOptional && forceOptionalIntoNullable) {
+      if (propDef._def.typeName === "ZodOptional") {
+        propDef = propDef._def.innerType;
+      }
+      if (!propDef.isNullable()) {
+        propDef = propDef.nullable();
+      }
+      propOptional = false;
+    }
+    const parsedDef = parseDef(propDef._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "properties", propName],
+      propertyPath: [...refs.currentPath, "properties", propName]
+    });
+    if (parsedDef === void 0) {
+      continue;
+    }
+    result.properties[propName] = parsedDef;
+    if (!propOptional) {
+      required.push(propName);
+    }
+  }
+  if (required.length) {
+    result.required = required;
+  }
+  const additionalProperties = decideAdditionalProperties(def, refs);
+  if (additionalProperties !== void 0) {
+    result.additionalProperties = additionalProperties;
+  }
+  return result;
+}
+function decideAdditionalProperties(def, refs) {
+  if (def.catchall._def.typeName !== "ZodNever") {
+    return parseDef(def.catchall._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    });
+  }
+  switch (def.unknownKeys) {
+    case "passthrough":
+      return refs.allowedAdditionalProperties;
+    case "strict":
+      return refs.rejectedAdditionalProperties;
+    case "strip":
+      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
+  }
+}
+function safeIsOptional(schema) {
+  try {
+    return schema.isOptional();
+  } catch {
+    return true;
+  }
+}
+const parseOptionalDef = (def, refs) => {
+  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
+    return parseDef(def.innerType._def, refs);
+  }
+  const innerSchema = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "1"]
+  });
+  return innerSchema ? {
+    anyOf: [
+      {
+        not: parseAnyDef(refs)
+      },
+      innerSchema
+    ]
+  } : parseAnyDef(refs);
+};
+const parsePipelineDef = (def, refs) => {
+  if (refs.pipeStrategy === "input") {
+    return parseDef(def.in._def, refs);
+  } else if (refs.pipeStrategy === "output") {
+    return parseDef(def.out._def, refs);
+  }
+  const a = parseDef(def.in._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", "0"]
+  });
+  const b = parseDef(def.out._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
+  });
+  return {
+    allOf: [a, b].filter((x) => x !== void 0)
+  };
+};
+function parsePromiseDef(def, refs) {
+  return parseDef(def.type._def, refs);
+}
+function parseSetDef(def, refs) {
+  const items = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items"]
+  });
+  const schema = {
+    type: "array",
+    uniqueItems: true,
+    items
+  };
+  if (def.minSize) {
+    setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
+  }
+  if (def.maxSize) {
+    setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
+  }
+  return schema;
+}
+function parseTupleDef(def, refs) {
+  if (def.rest) {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      items: def.items.map((x, i) => parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i}`]
+      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
+      additionalItems: parseDef(def.rest._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "additionalItems"]
+      })
+    };
+  } else {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      maxItems: def.items.length,
+      items: def.items.map((x, i) => parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i}`]
+      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
+    };
+  }
+}
+function parseUndefinedDef(refs) {
+  return {
+    not: parseAnyDef(refs)
+  };
+}
+function parseUnknownDef(refs) {
+  return parseAnyDef(refs);
+}
+const parseReadonlyDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+const selectParser = (def, typeName, refs) => {
+  switch (typeName) {
+    case ZodFirstPartyTypeKind.ZodString:
+      return parseStringDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodNumber:
+      return parseNumberDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodObject:
+      return parseObjectDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodBigInt:
+      return parseBigintDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodBoolean:
+      return parseBooleanDef();
+    case ZodFirstPartyTypeKind.ZodDate:
+      return parseDateDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodUndefined:
+      return parseUndefinedDef(refs);
+    case ZodFirstPartyTypeKind.ZodNull:
+      return parseNullDef(refs);
+    case ZodFirstPartyTypeKind.ZodArray:
+      return parseArrayDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodUnion:
+    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+      return parseUnionDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodIntersection:
+      return parseIntersectionDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodTuple:
+      return parseTupleDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodRecord:
+      return parseRecordDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodLiteral:
+      return parseLiteralDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodEnum:
+      return parseEnumDef(def);
+    case ZodFirstPartyTypeKind.ZodNativeEnum:
+      return parseNativeEnumDef(def);
+    case ZodFirstPartyTypeKind.ZodNullable:
+      return parseNullableDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodOptional:
+      return parseOptionalDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodMap:
+      return parseMapDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodSet:
+      return parseSetDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodLazy:
+      return () => def.getter()._def;
+    case ZodFirstPartyTypeKind.ZodPromise:
+      return parsePromiseDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodNaN:
+    case ZodFirstPartyTypeKind.ZodNever:
+      return parseNeverDef(refs);
+    case ZodFirstPartyTypeKind.ZodEffects:
+      return parseEffectsDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodAny:
+      return parseAnyDef(refs);
+    case ZodFirstPartyTypeKind.ZodUnknown:
+      return parseUnknownDef(refs);
+    case ZodFirstPartyTypeKind.ZodDefault:
+      return parseDefaultDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodBranded:
+      return parseBrandedDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodReadonly:
+      return parseReadonlyDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodCatch:
+      return parseCatchDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodPipeline:
+      return parsePipelineDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodFunction:
+    case ZodFirstPartyTypeKind.ZodVoid:
+    case ZodFirstPartyTypeKind.ZodSymbol:
+      return void 0;
+    default:
+      return /* @__PURE__ */ ((_) => void 0)();
+  }
+};
+function parseDef(def, refs, forceResolution = false) {
+  const seenItem = refs.seen.get(def);
+  if (refs.override) {
+    const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
+    if (overrideResult !== ignoreOverride) {
+      return overrideResult;
+    }
+  }
+  if (seenItem && !forceResolution) {
+    const seenSchema = get$ref(seenItem, refs);
+    if (seenSchema !== void 0) {
+      return seenSchema;
+    }
+  }
+  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
+  refs.seen.set(def, newItem);
+  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
+  const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  if (jsonSchema) {
+    addMeta(def, refs, jsonSchema);
+  }
+  if (refs.postProcess) {
+    const postProcessResult = refs.postProcess(jsonSchema, def, refs);
+    newItem.jsonSchema = jsonSchema;
+    return postProcessResult;
+  }
+  newItem.jsonSchema = jsonSchema;
+  return jsonSchema;
+}
+const get$ref = (item, refs) => {
+  switch (refs.$refStrategy) {
+    case "root":
+      return { $ref: item.path.join("/") };
+    case "relative":
+      return { $ref: getRelativePath(refs.currentPath, item.path) };
+    case "none":
+    case "seen": {
+      if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
+        console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
+        return parseAnyDef(refs);
+      }
+      return refs.$refStrategy === "seen" ? parseAnyDef(refs) : void 0;
+    }
+  }
+};
+const addMeta = (def, refs, jsonSchema) => {
+  if (def.description) {
+    jsonSchema.description = def.description;
+    if (refs.markdownDescription) {
+      jsonSchema.markdownDescription = def.description;
+    }
+  }
+  return jsonSchema;
+};
+const zodToJsonSchema = (schema, options) => {
+  const refs = getRefs(options);
+  let definitions = void 0;
+  const main = parseDef(
+    schema._def,
+    refs,
+    false
+  ) ?? parseAnyDef(refs);
+  if (refs.flags.hasReferencedOpenAiAnyType) {
+    if (!definitions) {
+      definitions = {};
+    }
+    if (!definitions[refs.openAiAnyTypeName]) {
+      definitions[refs.openAiAnyTypeName] = {
+        // Skipping "object" as no properties can be defined and additionalProperties must be "false"
+        type: ["string", "number", "integer", "boolean", "array", "null"],
+        items: {
+          $ref: refs.$refStrategy === "relative" ? "1" : [
+            ...refs.basePath,
+            refs.definitionPath,
+            refs.openAiAnyTypeName
+          ].join("/")
+        }
+      };
+    }
+  }
+  const combined = definitions ? {
+    ...main,
+    [refs.definitionPath]: definitions
+  } : main;
+  if (refs.target === "jsonSchema7") {
+    combined.$schema = "http://json-schema.org/draft-07/schema#";
+  } else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
+    combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+  }
+  if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) {
+    console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
+  }
+  return combined;
+};
+const UNLIMITED = Number.MAX_SAFE_INTEGER;
+const DEFAULT_TOOL_TIMEOUT_MS = 3e4;
+const nonEmptyString = (description) => z.string().trim().min(1).describe(description);
+const ReactionSchema = z.object({
+  type: z.string(),
+  emoji: z.string().optional(),
+  fromHandle: z.string(),
+  isRemoval: z.boolean(),
+  targetMessageGuid: z.string(),
+  targetMessagePart: z.number().int()
+});
+const ReplyContextSchema = z.object({
+  replyToGuid: z.string(),
+  replyToText: z.string().nullable().optional()
+});
+const AttachmentSchema = z.object({
+  filename: z.string(),
+  mimeType: z.string().nullable(),
+  transferName: z.string().nullable(),
+  totalBytes: z.number().int()
+});
+const MessageSchema = z.object({
+  id: z.number().int(),
+  guid: z.string(),
+  text: z.string().nullable(),
+  handle: z.string(),
+  displayName: z.string().optional(),
+  isFromMe: z.boolean(),
+  date: z.string(),
+  dateRead: z.string().nullable(),
+  dateDelivered: z.string().nullable(),
+  isRead: z.boolean(),
+  isDelivered: z.boolean(),
+  chatId: z.string(),
+  service: z.enum(["iMessage", "SMS"]),
+  isReaction: z.boolean(),
+  reaction: ReactionSchema.optional(),
+  isReply: z.boolean(),
+  replyTo: ReplyContextSchema.optional(),
+  reactions: z.array(ReactionSchema).optional(),
+  richContentType: z.string().optional(),
+  richContentSummary: z.string().optional(),
+  isEdited: z.boolean(),
+  isRetracted: z.boolean(),
+  hasAttachments: z.boolean(),
+  attachments: z.array(AttachmentSchema).optional()
+});
+const ConversationSchema = z.object({
+  chatId: z.string(),
+  chatIdentifier: z.string(),
+  displayName: z.string().nullable(),
+  rawIdentifier: z.string(),
+  participants: z.array(z.string()),
+  lastMessageDate: z.string().nullable(),
+  lastMessageSnippet: z.string().nullable(),
+  unreadCount: z.number().int(),
+  threadSlug: z.string(),
+  isGroupChat: z.boolean(),
+  serviceType: z.enum(["iMessage", "SMS"])
+});
+const GetMessagesSchema = z.object({
+  limit: z.number().int().min(0).default(20).describe(
+    "Number of messages to retrieve. 0 = unlimited (bounded by tool safety limits). Default 20."
+  ),
+  chatIdentifier: nonEmptyString("Phone number, email, or chat ID to filter by").optional(),
+  threadSlug: nonEmptyString("Thread slug from list_conversations").optional(),
+  beforeMessageId: z.number().int().positive().optional().describe("Pagination cursor. Pass `oldestMessageId` from a previous response.")
+});
+const GetMessagesOutputSchema = z.object({
+  messages: z.array(MessageSchema),
+  count: z.number().int(),
+  hasMore: z.boolean(),
+  oldestMessageId: z.number().int().optional()
+});
+const ExportMessagesSchema = z.object({
+  chatIdentifier: nonEmptyString("Phone number, email, or chat ID").optional(),
+  threadSlug: nonEmptyString("Thread slug from list_conversations").optional(),
+  format: z.enum(["markdown", "csv", "json", "ndjson"]).default("markdown"),
+  outputPath: nonEmptyString(
+    "Absolute path. Parent directory must exist; file will be created/overwritten."
+  ),
+  since: nonEmptyString("Earliest date, ISO or relative like '1 year ago'").optional(),
+  until: nonEmptyString("Latest date, ISO or relative like 'yesterday'").optional(),
+  pageSize: z.number().int().min(100).max(5e3).default(1e3)
+});
+const ExportMessagesOutputSchema = z.object({
+  count: z.number().int(),
+  sizeBytes: z.number().int(),
+  savedTo: z.string(),
+  format: z.string(),
+  oldest: z.string().nullable(),
+  newest: z.string().nullable(),
+  durationMs: z.number()
+});
+const GetUnreadMessagesSchema = z.object({
+  limit: z.number().int().min(0).optional().describe("Max unread messages. 0 = unlimited. Default 100.")
+});
+const GetUnreadMessagesOutputSchema = z.object({
+  messages: z.array(MessageSchema),
+  count: z.number().int(),
+  hasMore: z.boolean(),
+  nextOffset: z.number().int().nullable()
+});
+const SendMessageSchema = z.object({
+  recipient: nonEmptyString("Phone number or email address to send to").optional(),
+  threadSlug: nonEmptyString("Thread slug from list_conversations").optional(),
+  message: nonEmptyString("Message text to send"),
+  attachments: z.array(nonEmptyString("Absolute file path to attach")).optional().describe(
+    "Absolute file paths to attach. Each is sent in a follow-up AppleScript call after the text. Use sparingly — large files may be silently rate-limited by Messages.app."
+  )
+});
+const SendMessageOutputSchema = z.object({
+  success: z.boolean(),
+  target: z.string().optional(),
+  error: z.string().optional(),
+  timestamp: z.string().nullable().optional(),
+  threadSlug: z.string().optional(),
+  lastMessageId: z.number().int().optional(),
+  attachments: z.array(
+    z.object({
+      path: z.string(),
+      success: z.boolean(),
+      error: z.string().optional()
+    })
+  ).optional()
+});
+const WaitForReplySchema = z.object({
+  chatIdentifier: nonEmptyString("Phone number, email, or chat ID to monitor").optional(),
+  threadSlug: nonEmptyString("Thread slug from list_conversations to monitor").optional(),
+  timeoutSeconds: z.number().min(10).max(3600).default(300),
+  pollIntervalSeconds: z.number().min(5).max(60).default(10),
+  afterMessageId: z.number().int().positive().optional()
+});
+const WaitForReplyOutputSchema = z.object({
+  received: z.boolean().optional(),
+  messages: z.array(MessageSchema).optional(),
+  count: z.number().int().optional(),
+  timedOut: z.boolean().optional(),
+  timeoutSeconds: z.number().optional(),
+  threadSlug: z.string().optional(),
+  chatIdentifier: z.string().optional(),
+  cancelled: z.boolean().optional(),
+  elapsedSeconds: z.number().optional()
+});
+const ListConversationsSchema = z.object({
+  limit: z.number().int().min(0).default(20)
+});
+const ListConversationsOutputSchema = z.object({
+  conversations: z.array(ConversationSchema),
+  count: z.number().int(),
+  hasMore: z.boolean(),
+  nextOffset: z.number().int().nullable()
+});
+const SearchMessagesSchema = z.object({
+  query: nonEmptyString("Search query"),
+  limit: z.number().int().min(0).default(20),
+  mode: z.enum(["literal", "fuzzy"]).default("fuzzy").describe(
+    "Search mode. 'literal' = SQL LIKE substring match. 'fuzzy' = token-based scoring with typo tolerance; ranks by WRatio-style score."
+  ),
+  minScore: z.number().min(0).max(1).default(0.6).describe(
+    "Fuzzy mode: minimum normalized score (0-1) for a match to be returned. Ignored in literal mode."
+  )
+});
+const SearchMessagesOutputSchema = z.object({
+  query: z.string().optional(),
+  mode: z.enum(["literal", "fuzzy"]).optional(),
+  messages: z.array(MessageSchema),
+  count: z.number().int(),
+  hasMore: z.boolean(),
+  nextOffset: z.number().int().nullable(),
+  softCapWarning: z.string().optional()
+});
+const GetLogsSchema = z.object({
+  tail: z.number().int().min(1).max(500).optional(),
+  source: z.enum(["memory", "file", "all"]).optional()
+});
+const GetLogsOutputSchema = z.object({
+  source: z.string(),
+  tail: z.number().int(),
+  sections: z.array(z.string())
+});
+z.object({});
+const RunBuildOutputSchema = z.object({
+  ok: z.boolean(),
+  stdout: z.string(),
+  stderr: z.string()
+});
+z.object({});
+const RequestRestartOutputSchema = z.object({
+  restartRequested: z.boolean()
+});
+z.object({});
+const HealthCheckOutputSchema = z.object({
+  status: z.string(),
+  issues: z.array(z.string()),
+  uptimeMs: z.number(),
+  idleMs: z.number(),
+  pid: z.number(),
+  node: z.string(),
+  heapMb: z.number(),
+  rssMb: z.number(),
+  eventLoopP99Ms: z.number(),
+  eventLoopMaxMs: z.number(),
+  toolCallCount: z.number(),
+  recentErrorCount: z.number(),
+  engine: z.string()
+});
+z.object({});
+const GetLastSendErrorOutputSchema = z.object({
+  lastSendError: z.object({
+    message: z.string(),
+    timestamp: z.string(),
+    stderr: z.string().optional(),
+    stdout: z.string().optional(),
+    code: z.number().optional()
+  }).nullable()
+});
+const ContactSchema = z.object({
+  id: z.number().int(),
+  displayName: z.string(),
+  firstName: z.string().nullable(),
+  lastName: z.string().nullable(),
+  middleName: z.string().nullable(),
+  nickname: z.string().nullable(),
+  organization: z.string().nullable(),
+  phoneNumbers: z.array(z.string()),
+  emails: z.array(z.string())
+});
+const ListContactsSchema = z.object({
+  limit: z.number().int().min(0).default(20).describe("Max contacts. 0 = unlimited (bounded by safety cap)."),
+  offset: z.number().int().min(0).default(0).describe("Offset for pagination.")
+});
+const ListContactsOutputSchema = z.object({
+  contacts: z.array(ContactSchema),
+  count: z.number().int(),
+  hasMore: z.boolean(),
+  totalCount: z.number().int()
+});
+const SearchContactsSchema = z.object({
+  query: nonEmptyString("Substring to match against name, phone, or email."),
+  limit: z.number().int().min(0).default(20).describe("Max results. 0 = unlimited.")
+});
+const SearchContactsOutputSchema = z.object({
+  query: z.string(),
+  contacts: z.array(ContactSchema),
+  count: z.number().int()
+});
+const GetContactSchema = z.object({
+  handle: z.string().optional().describe("Phone number or email to look up."),
+  id: z.number().int().optional().describe("Numeric contact id.")
+}).refine((v) => v.handle !== void 0 || v.id !== void 0, {
+  message: "Provide either `handle` or `id`."
+});
+const GetContactOutputSchema = z.object({
+  contact: ContactSchema.nullable()
+});
+const ResolveHandleSchema = z.object({
+  handle: nonEmptyString("Phone number or email to resolve to a contact name.")
+});
+const ResolveHandleOutputSchema = z.object({
+  handle: z.string(),
+  displayName: z.string(),
+  contactId: z.number().int().nullable(),
+  label: z.string().nullable(),
+  resolved: z.boolean()
+});
+const CheckImessageAvailabilitySchema = z.object({
+  handle: nonEmptyString("Phone number or email to preflight-check for reachability.")
+});
+const CheckImessageAvailabilityOutputSchema = z.object({
+  handle: z.string(),
+  service: z.enum(["iMessage", "SMS", "unknown"]),
+  reachable: z.boolean(),
+  hint: z.string().optional()
+});
+const AttachmentRecordSchema = z.object({
+  rowId: z.number().int(),
+  filename: z.string(),
+  mimeType: z.string().nullable(),
+  transferName: z.string().nullable(),
+  totalBytes: z.number().int(),
+  createdDate: z.string(),
+  chatId: z.string()
+});
+const SearchAttachmentsSchema = z.object({
+  mimePrefix: z.string().optional().describe("Filter by MIME type prefix, e.g. 'image/', 'video/', 'application/pdf'."),
+  chatIdentifier: z.string().optional().describe("Restrict to a single chat (use chat_identifier from list_conversations)."),
+  since: z.string().optional().describe("ISO date or relative ('1 week ago'). Lower bound on attachment creation."),
+  until: z.string().optional().describe("ISO date or relative. Upper bound on creation."),
+  limit: z.number().int().min(0).default(20).describe("Max results. 0 = unlimited (capped at 1000).")
+});
+const SearchAttachmentsOutputSchema = z.object({
+  attachments: z.array(AttachmentRecordSchema),
+  count: z.number().int()
+});
+const ChatAnalyticsSchema = z.object({
+  type: z.enum([
+    "messaging_streaks",
+    "double_texts",
+    "response_time_stats",
+    "daily_heatmap",
+    "tapback_summary",
+    "year_in_review_wrapped"
+  ]).describe(
+    "Which analytic to compute. Six priority types are implemented; 20 more are reserved for future versions and return a structured 'not_yet_implemented' error."
+  ),
+  windowDays: z.number().int().min(1).max(3650).default(90).describe("Days of history to analyze. Defaults to 90; year_in_review pin to 365 internally.")
+});
+const ChatAnalyticsOutputSchema = z.object({
+  type: z.string(),
+  windowDays: z.number().int(),
+  computedAtIso: z.string(),
+  fromCache: z.boolean(),
+  data: z.unknown()
+});
+const GetAttachmentSchema = z.object({
+  rowId: z.number().int().describe("Attachment ROWID (from search_attachments)."),
+  inlineMaxBytes: z.number().int().default(5e6).describe("If file is ≤ this size, return base64 content inline; otherwise return path only.")
+});
+const GetAttachmentOutputSchema = z.object({
+  rowId: z.number().int(),
+  filename: z.string(),
+  resolvedPath: z.string(),
+  mimeType: z.string().nullable(),
+  totalBytes: z.number().int(),
+  inline: z.boolean(),
+  base64: z.string().optional(),
+  converted: z.string().optional().describe("Set when source was HEIC and we converted to PNG.")
+});
+const noArgsSchema = { type: "object", properties: {} };
+const annotations = {
+  read: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  status: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  send: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  export: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false
+  },
+  build: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  }
+};
+const TOOL_TIMEOUTS_MS = {
+  wait_for_reply: 0,
+  run_build: 12e4,
+  search_messages: 6e4,
+  get_messages: 6e4,
+  list_conversations: 6e4,
+  get_unread_messages: 6e4,
+  send_message: 6e4,
+  health_check: 5e3,
+  export_messages: 6e5,
+  get_logs: 1e4,
+  get_last_send_error: 5e3,
+  request_restart: 5e3,
+  list_contacts: 1e4,
+  search_contacts: 1e4,
+  get_contact: 5e3,
+  resolve_handle: 5e3,
+  check_imessage_availability: 1e4,
+  search_attachments: 3e4,
+  get_attachment: 3e4,
+  chat_analytics: 6e4
+};
+function resolveLimit(limit, defaultValue = 20) {
+  if (limit === void 0) return defaultValue;
+  if (limit === 0) return UNLIMITED;
+  return limit;
+}
+const TOOLS = [
+  {
+    name: "get_messages",
+    description: "Get recent iMessages. Optionally filter by conversation. Response footer includes oldestMessageId for beforeMessageId pagination; use export_messages for very large histories.",
+    annotations: annotations.read,
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", default: 20, description: "Number of messages. 0 = unlimited." },
+        chatIdentifier: { type: "string", description: "Phone number, email, or chat ID" },
+        threadSlug: { type: "string", description: "Thread slug from list_conversations" },
+        beforeMessageId: {
+          type: "number",
+          description: "Fetch messages older than this message id"
+        }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(GetMessagesOutputSchema)
+  },
+  {
+    name: "export_messages",
+    description: "Stream-export a conversation to markdown, csv, json, or ndjson without loading all history into memory.",
+    annotations: annotations.export,
+    inputSchema: {
+      type: "object",
+      required: ["outputPath"],
+      properties: {
+        chatIdentifier: { type: "string", description: "Phone number, email, or chat ID" },
+        threadSlug: { type: "string", description: "Thread slug from list_conversations" },
+        format: {
+          type: "string",
+          enum: ["markdown", "csv", "json", "ndjson"],
+          default: "markdown"
+        },
+        outputPath: {
+          type: "string",
+          description: "Absolute output path. Existing files are overwritten."
+        },
+        since: { type: "string", description: "Earliest date, ISO or relative" },
+        until: { type: "string", description: "Latest date, ISO or relative" },
+        pageSize: { type: "number", default: 1e3, description: "Internal page size, 100-5000" }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(ExportMessagesOutputSchema)
+  },
+  {
+    name: "get_unread_messages",
+    description: "Get unread iMessages across all conversations, newest first.",
+    annotations: annotations.read,
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Max unread messages. 0 = unlimited. Default 100." }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(GetUnreadMessagesOutputSchema)
+  },
+  {
+    name: "send_message",
+    description: "Send an iMessage or SMS. Use recipient for 1-on-1 or threadSlug for existing threads, including groups. Optional `attachments` is an array of absolute file paths sent as follow-up messages (1-on-1 only — Messages.app does not reliably accept file sends to group chats).",
+    annotations: annotations.send,
+    inputSchema: {
+      type: "object",
+      required: ["message"],
+      properties: {
+        recipient: { type: "string", description: "Phone number or email" },
+        threadSlug: { type: "string", description: "Thread slug from list_conversations" },
+        message: { type: "string", description: "Message text to send" },
+        attachments: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional absolute file paths to send after the text. 1-on-1 only."
+        }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(SendMessageOutputSchema)
+  },
+  {
+    name: "wait_for_reply",
+    description: "Wait for a new incoming message in a conversation until timeout or client cancellation.",
+    annotations: annotations.read,
+    inputSchema: {
+      type: "object",
+      properties: {
+        chatIdentifier: { type: "string", description: "Phone number, email, or chat ID" },
+        threadSlug: { type: "string", description: "Thread slug from list_conversations" },
+        timeoutSeconds: {
+          type: "number",
+          default: 300,
+          description: "Timeout in seconds, 10-3600"
+        },
+        pollIntervalSeconds: {
+          type: "number",
+          default: 10,
+          description: "Polling interval in seconds, 5-60"
+        },
+        afterMessageId: { type: "number", description: "Only return messages after this id" }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(WaitForReplyOutputSchema)
+  },
+  {
+    name: "list_conversations",
+    description: "List recent conversations with thread slugs, snippets, unread counts, participants, and service metadata.",
+    annotations: annotations.read,
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          default: 20,
+          description: "Number of conversations. 0 = unlimited."
+        }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(ListConversationsOutputSchema)
+  },
+  {
+    name: "search_messages",
+    description: "Search message text across all conversations.",
+    annotations: annotations.read,
+    inputSchema: {
+      type: "object",
+      required: ["query"],
+      properties: {
+        query: { type: "string", description: "Search query" },
+        limit: { type: "number", default: 20, description: "Number of results. 0 = unlimited." }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(SearchMessagesOutputSchema)
+  },
+  {
+    name: "get_logs",
+    description: "Return debug logs from memory, file, or both.",
+    annotations: annotations.status,
+    inputSchema: {
+      type: "object",
+      properties: {
+        tail: { type: "number", description: "Return last N lines. Default 50." },
+        source: { type: "string", enum: ["memory", "file", "all"], description: "Log source" }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(GetLogsOutputSchema)
+  },
+  {
+    name: "get_last_send_error",
+    description: "Return details for the last send_message failure.",
+    annotations: annotations.status,
+    inputSchema: noArgsSchema,
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(GetLastSendErrorOutputSchema)
+  },
+  {
+    name: "run_build",
+    description: "Run pnpm build in the project directory and return stdout/stderr.",
+    annotations: annotations.build,
+    inputSchema: noArgsSchema,
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(RunBuildOutputSchema)
+  },
+  {
+    name: "request_restart",
+    description: "Exit the MCP server process so the client can restart it and load new code.",
+    annotations: annotations.build,
+    inputSchema: noArgsSchema,
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(RequestRestartOutputSchema)
+  },
+  {
+    name: "health_check",
+    description: "Return in-memory MCP vital signs without touching SQLite.",
+    annotations: annotations.status,
+    inputSchema: noArgsSchema,
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(HealthCheckOutputSchema)
+  },
+  {
+    name: "list_contacts",
+    description: "List loaded contacts (from macOS Address Book + iCloud sources), sorted by name. Use search_contacts for substring matching.",
+    annotations: annotations.read,
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", default: 20, description: "Max contacts. 0 = unlimited." },
+        offset: { type: "number", default: 0, description: "Offset for pagination." }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(ListContactsOutputSchema)
+  },
+  {
+    name: "search_contacts",
+    description: "Substring-match contacts by display name, phone number, or email.",
+    annotations: annotations.read,
+    inputSchema: {
+      type: "object",
+      required: ["query"],
+      properties: {
+        query: { type: "string", description: "Substring (case-insensitive for name/email)." },
+        limit: { type: "number", default: 20, description: "Max results. 0 = unlimited." }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(SearchContactsOutputSchema)
+  },
+  {
+    name: "get_contact",
+    description: "Fetch a single contact by handle (phone/email) or by numeric id. Returns null if not found.",
+    annotations: annotations.read,
+    inputSchema: {
+      type: "object",
+      properties: {
+        handle: { type: "string", description: "Phone number or email to look up." },
+        id: { type: "number", description: "Numeric contact id." }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(GetContactOutputSchema)
+  },
+  {
+    name: "resolve_handle",
+    description: "Resolve a phone number or email to its contact display name. Pass-through if unknown.",
+    annotations: annotations.read,
+    inputSchema: {
+      type: "object",
+      required: ["handle"],
+      properties: {
+        handle: { type: "string", description: "Phone number or email." }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(ResolveHandleOutputSchema)
+  },
+  {
+    name: "check_imessage_availability",
+    description: "Preflight check: is this handle reachable via iMessage or SMS? Call BEFORE send_message to avoid wasted send attempts to unreachable recipients. Returns the best-guess service plus a human-readable hint when unreachable.",
+    annotations: annotations.status,
+    inputSchema: {
+      type: "object",
+      required: ["handle"],
+      properties: {
+        handle: {
+          type: "string",
+          description: "Phone number (E.164 preferred) or email to preflight."
+        }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(CheckImessageAvailabilityOutputSchema)
+  },
+  {
+    name: "search_attachments",
+    description: "Search attachments (images, videos, files) by MIME type prefix, date range, and/or chat. Returns metadata only — use get_attachment to fetch bytes. Excludes stickers and Apple plugin payloads.",
+    annotations: annotations.read,
+    inputSchema: {
+      type: "object",
+      properties: {
+        mimePrefix: { type: "string", description: "e.g. 'image/', 'video/', 'application/pdf'." },
+        chatIdentifier: { type: "string", description: "Restrict to one chat." },
+        since: { type: "string", description: "ISO date or relative ('1 week ago')." },
+        until: { type: "string", description: "ISO date or relative." },
+        limit: {
+          type: "number",
+          default: 20,
+          description: "Max results. 0 = unlimited (cap 1000)."
+        }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(SearchAttachmentsOutputSchema)
+  },
+  {
+    name: "get_attachment",
+    description: "Fetch an attachment by ROWID (from search_attachments). Returns base64 inline if ≤ inlineMaxBytes (default 5MB); otherwise returns the resolved path only. HEIC images are auto-converted to PNG via macOS sips.",
+    annotations: annotations.read,
+    inputSchema: {
+      type: "object",
+      required: ["rowId"],
+      properties: {
+        rowId: { type: "number", description: "Attachment ROWID from search_attachments." },
+        inlineMaxBytes: { type: "number", default: 5e6, description: "Inline byte cap." }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(GetAttachmentOutputSchema)
+  },
+  {
+    name: "chat_analytics",
+    description: "Compute analytics over your chat history. Pick a `type`: messaging_streaks, double_texts, response_time_stats, daily_heatmap, tapback_summary, or year_in_review_wrapped. Results are cached at ~/.imsg-mcp/analytics-cache.db keyed on (type, args, MAX(message.rowid)) so subsequent calls without new messages hit cache. 20 additional analytic types are reserved for future versions.",
+    annotations: annotations.read,
+    inputSchema: {
+      type: "object",
+      required: ["type"],
+      properties: {
+        type: {
+          type: "string",
+          enum: [
+            "messaging_streaks",
+            "double_texts",
+            "response_time_stats",
+            "daily_heatmap",
+            "tapback_summary",
+            "year_in_review_wrapped"
+          ]
+        },
+        windowDays: {
+          type: "number",
+          default: 90,
+          description: "Days of history to scan (1-3650). year_in_review pins to 365."
+        }
+      }
+    },
+    // @ts-expect-error
+    outputSchema: zodToJsonSchema(ChatAnalyticsOutputSchema)
+  }
+];
+const DEV_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "health_check",
+  "get_logs",
+  "get_last_send_error",
+  "run_build",
+  "request_restart"
+]);
+function isDevMode() {
+  return process.env.IMSG_DEV === "1";
+}
+function getActiveTools() {
+  if (isDevMode()) return TOOLS;
+  return TOOLS.filter((t) => !DEV_TOOL_NAMES.has(t.name));
+}
+const INSTRUCTIONS_UUID = randomUUID();
+function wrapUntrusted(text) {
+  if (text == null || text === "") return "";
+  const neutralized = text.replace(/<\/untrusted>/gi, "&lt;/untrusted&gt;").replace(new RegExp(`<\\/instructions uuid="${INSTRUCTIONS_UUID}">`, "gi"), "").replace(/<\/instructions>/gi, "&lt;/instructions&gt;");
+  return `<untrusted>${neutralized}</untrusted>`;
+}
+const ANSI_REGEX = new RegExp(
+  [
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"
+  ].join("|"),
+  "g"
+);
+const CONTROL_CHAR_REGEX = /[\x00-\x08\x0B\x0C\x0E-\x1F]/g;
+function sanitizeUserText(text, maxLength = 4096) {
+  if (text == null) return null;
+  let sanitized = text.replace(ANSI_REGEX, "");
+  sanitized = sanitized.replace(CONTROL_CHAR_REGEX, "�");
+  if (sanitized.length > maxLength) {
+    sanitized = `${sanitized.slice(0, maxLength - 1)}…`;
+  }
+  return sanitized;
+}
+const execFileAsync = promisify(execFile);
+class ToolTimeoutError extends Error {
+  constructor(toolName, timeoutMs) {
+    super(
+      `Tool '${toolName}' timed out after ${timeoutMs}ms. The MCP server has unblocked; the underlying query may still be running in the background.`
+    );
+    this.toolName = toolName;
+    this.timeoutMs = timeoutMs;
+    this.name = "ToolTimeoutError";
+  }
+}
+function withTimeout(toolName, fn) {
+  const ms = TOOL_TIMEOUTS_MS[toolName] ?? DEFAULT_TOOL_TIMEOUT_MS;
+  if (ms <= 0) return fn();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new ToolTimeoutError(toolName, ms)), ms);
+    timer.unref();
+    fn().then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+function round1(n) {
+  return Math.round(n * 10) / 10;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const sec = Math.floor(ms / 1e3);
+  if (sec < 60) return `${sec}s`;
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}m ${sec % 60}s`;
+  const hr = Math.floor(min / 60);
+  return `${hr}h ${min % 60}m`;
+}
+function relativeDate(d) {
+  const now = /* @__PURE__ */ new Date();
+  const time = d.toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit", hour12: true });
+  const sameDay = d.getFullYear() === now.getFullYear() && d.getMonth() === now.getMonth() && d.getDate() === now.getDate();
+  if (sameDay) return `Today ${time}`;
+  const yesterday = new Date(now);
+  yesterday.setDate(now.getDate() - 1);
+  if (d.getFullYear() === yesterday.getFullYear() && d.getMonth() === yesterday.getMonth() && d.getDate() === yesterday.getDate()) {
+    return `Yesterday ${time}`;
+  }
+  return `${d.getMonth() + 1}/${d.getDate()} ${time}`;
+}
+function formatMessage(msg, conversationLabel) {
+  const direction = msg.isFromMe ? "→" : "←";
+  const dateStr = relativeDate(msg.date);
+  const svcTag = msg.service === "SMS" ? " [SMS]" : "";
+  let sender;
+  if (msg.isFromMe) {
+    sender = "me";
+  } else if (msg.displayName && msg.displayName !== msg.handle) {
+    sender = `${msg.displayName} (${msg.handle})`;
+  } else {
+    sender = msg.handle;
+  }
+  let status = "";
+  if (!msg.isFromMe && !msg.isRead) {
+    status = " [UNREAD]";
+  } else if (msg.isFromMe) {
+    if (msg.dateRead) {
+      status = ` [Read ${msg.dateRead.toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit", hour12: true })}]`;
+    } else if (msg.isDelivered) {
+      status = " [Delivered]";
+    }
+  }
+  const convCtx = conversationLabel ? ` {${conversationLabel}}` : "";
+  const rawText = sanitizeUserText(msg.text);
+  const text = rawText ? wrapUntrusted(rawText) : "(no text)";
+  return `[${dateStr}] ${direction} ${sender}${svcTag}: ${text}${status}${convCtx}`;
+}
+function messageToStructured(msg) {
+  return {
+    ...msg,
+    text: sanitizeUserText(msg.text),
+    date: msg.date.toISOString(),
+    dateRead: msg.dateRead?.toISOString() ?? null,
+    dateDelivered: msg.dateDelivered?.toISOString() ?? null
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function toolText(text, structuredContent) {
+  return {
+    content: [{ type: "text", text }],
+    ...structuredContent ? { structuredContent } : {}
+  };
+}
+function toolError(text, _structuredContent) {
+  return {
+    ...toolText(text),
+    isError: true
+  };
+}
+function validateExportOutputPath(outputPath) {
+  if (!isAbsolute(outputPath)) {
+    return "outputPath must be an absolute path.";
+  }
+  const parent = dirname(outputPath);
+  if (!existsSync(parent)) {
+    return `Parent directory does not exist: ${parent}`;
+  }
+  const parentStat = statSync(parent);
+  if (!parentStat.isDirectory()) {
+    return `Parent path is not a directory: ${parent}`;
+  }
+  if (existsSync(outputPath) && statSync(outputPath).isDirectory()) {
+    return `outputPath points to a directory, not a file: ${outputPath}`;
+  }
+  return null;
+}
+function engineLabel() {
+  return hasNativeModule() ? "Rust parser + TS DB" : "TS";
+}
+class IMessageMCPServer {
+  server;
+  db;
+  // Activity tracking — surfaced via health_check and watchdog
+  toolCallCount = 0;
+  recentErrorCount = 0;
+  lastActivityTs = Date.now();
+  constructor() {
+    this.server = new Server(
+      {
+        name: APP_NAME,
+        version: APP_VERSION
+      },
+      {
+        capabilities: {
+          tools: {},
+          resources: { subscribe: false, listChanged: false }
+        }
+      }
+    );
+    this.db = new IMessageDB(getImsgDbPath(), getContactsDbPaths(), getSlugsDbPath());
+    this.setupHandlers();
+  }
+  setupHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: getActiveTools()
+    }));
+    this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+      const { name, arguments: args } = request.params;
+      this.lastActivityTs = Date.now();
+      this.toolCallCount++;
+      noteActivity();
+      const signal = extra?.signal;
+      const startedAt = performance.now();
+      const stampMeta = (result) => {
+        const duration_ms = Math.round((performance.now() - startedAt) * 10) / 10;
+        return { ...result, _meta: { engine: engineLabel(), duration_ms } };
+      };
+      try {
+        return stampMeta(await withTimeout(name, () => this.dispatchTool(name, args, signal)));
+      } catch (error) {
+        const isTimeout = error instanceof ToolTimeoutError;
+        appendLog(isTimeout ? "warn" : "error", isTimeout ? "Tool timed out" : "Tool error", {
+          tool: name,
+          error: error.message || String(error)
+        });
+        if (!isTimeout) this.recentErrorCount++;
+        return stampMeta(
+          toolError(`Error: ${error.message || String(error)}`, {
+            error: error.message || String(error)
+          })
+        );
+      } finally {
+        this.db.scheduleBackgroundRefresh();
+      }
+    });
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+      resources: []
+    }));
+    this.server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({
+      resourceTemplates: [
+        {
+          uriTemplate: "messages://recent/{hours}",
+          name: "Recent messages (last N hours)",
+          description: "Read all messages across every chat from the last {hours} hours.",
+          mimeType: "application/json"
+        },
+        {
+          uriTemplate: "messages://contact/{handle}/{hours}",
+          name: "Messages with a contact (last N hours)",
+          description: "Read messages from the chat containing {handle} (phone/email) in the last {hours} hours.",
+          mimeType: "application/json"
+        },
+        {
+          uriTemplate: "contacts://",
+          name: "All loaded contacts",
+          description: "Read all contacts from the macOS Address Book sources.",
+          mimeType: "application/json"
+        }
+      ]
+    }));
+    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const { uri } = request.params;
+      try {
+        const result = await this.readResource(uri);
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: "application/json",
+              text: JSON.stringify(result)
+            }
+          ]
+        };
+      } catch (e) {
+        throw new Error(`Resource ${uri} failed: ${e.message ?? e}`);
+      }
+    });
+  }
+  async readResource(uri) {
+    let m = uri.match(/^messages:\/\/recent\/(\d+)$/);
+    if (m?.[1]) {
+      const hours = Number(m[1]);
+      const cutoffMs = Date.now() - hours * 3600 * 1e3;
+      const msgs = await this.db.getRecentMessages(500);
+      return {
+        windowHours: hours,
+        messages: msgs.filter((mm) => mm.date.getTime() >= cutoffMs).map(messageToStructured)
+      };
+    }
+    m = uri.match(/^messages:\/\/contact\/([^/]+)\/(\d+)$/);
+    if (m?.[1] && m?.[2]) {
+      const handle = decodeURIComponent(m[1]);
+      const hours = Number(m[2]);
+      const cutoffMs = Date.now() - hours * 3600 * 1e3;
+      const chat = await this.db.findChatByHandle(handle);
+      if (!chat) return { handle, windowHours: hours, messages: [] };
+      const msgs = await this.db.getMessagesForChat(chat.chatIdentifier, 500);
+      return {
+        handle,
+        chatId: chat.chatIdentifier,
+        windowHours: hours,
+        messages: msgs.filter((mm) => mm.date.getTime() >= cutoffMs).map(messageToStructured)
+      };
+    }
+    if (uri === "contacts://") {
+      const all = this.db.contacts.listContacts(0, 1e4);
+      return { count: all.contacts.length, contacts: all.contacts };
+    }
+    throw new Error(`Unknown resource URI: ${uri}`);
+  }
+  async dispatchTool(name, args, signal) {
+    if (DEV_TOOL_NAMES.has(name) && !isDevMode()) {
+      throw new Error(`Unknown tool: ${name}`);
+    }
+    switch (name) {
+      case "get_messages":
+        return await this.handleGetMessages(args);
+      case "get_unread_messages":
+        return await this.handleGetUnreadMessages(args);
+      case "send_message":
+        return await this.handleSendMessage(args);
+      case "wait_for_reply":
+        return await this.handleWaitForReply(args, signal);
+      case "list_conversations":
+        return await this.handleListConversations(args);
+      case "search_messages":
+        return await this.handleSearchMessages(args);
+      case "get_logs":
+        return await this.handleGetLogs(args);
+      case "get_last_send_error":
+        return await this.handleGetLastSendError();
+      case "run_build":
+        return await this.handleRunBuild();
+      case "request_restart":
+        return await this.handleRequestRestart();
+      case "health_check":
+        return await this.handleHealthCheck();
+      case "export_messages":
+        return await this.handleExportMessages(args, signal);
+      case "list_contacts":
+        return await this.handleListContacts(args);
+      case "search_contacts":
+        return await this.handleSearchContacts(args);
+      case "get_contact":
+        return await this.handleGetContact(args);
+      case "resolve_handle":
+        return await this.handleResolveHandle(args);
+      case "check_imessage_availability":
+        return await this.handleCheckImessageAvailability(args);
+      case "search_attachments":
+        return await this.handleSearchAttachments(args);
+      case "get_attachment":
+        return await this.handleGetAttachment(args);
+      case "chat_analytics":
+        return await this.handleChatAnalytics(args);
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  }
+  async handleGetLogs(args) {
+    const { tail, source } = GetLogsSchema.parse(args ?? {});
+    const n = tail ?? 50;
+    const sections = [];
+    if (source !== "file") {
+      const memLines = getLogs(n);
+      sections.push(
+        `## In-Memory Logs (${memLines.length} lines)
+${memLines.length === 0 ? "No log lines yet." : memLines.join("\n")}`
+      );
+    }
+    if (source === "file" || source === "all") {
+      const fileLines = getFileLogLines(n);
+      const logPath = getLogFilePath() ?? getLogDirectory();
+      sections.push(
+        `## File Logs (${logPath})
+${fileLines.length === 0 ? "No file log entries." : fileLines.join("\n")}`
+      );
+    }
+    if (source !== "file" && source !== "all") {
+      const logPath = getLogFilePath() ?? getLogDirectory();
+      sections.push(`
+📁 Full NDJSON logs: ${logPath}`);
+    }
+    return toolText(sections.join("\n\n"), { source: source ?? "memory", tail: n, sections });
+  }
+  async handleGetLastSendError() {
+    const err = getLastSendError();
+    if (!err) {
+      return toolText(
+        "No send failure recorded. Last send either succeeded or occurred before this server run.",
+        {
+          lastSendError: null
+        }
+      );
+    }
+    const text = [
+      "Last send_message failure:",
+      `  message: ${err.message}`,
+      `  timestamp: ${err.timestamp}`,
+      err.stderr != null ? `  stderr: ${err.stderr}` : "",
+      err.stdout != null ? `  stdout: ${err.stdout}` : "",
+      err.code != null ? `  code: ${err.code}` : ""
+    ].filter(Boolean).join("\n");
+    return toolText(text, { lastSendError: err });
+  }
+  async handleRunBuild() {
+    try {
+      const { stdout, stderr } = await execFileAsync("pnpm", ["build"], {
+        encoding: "utf8",
+        maxBuffer: 2 * 1024 * 1024,
+        cwd: process.cwd()
+      });
+      return toolText(
+        `Build succeeded.
+
+stdout:
+${stdout}${stderr ? `
+
+stderr:
+${stderr}` : ""}`,
+        {
+          ok: true,
+          stdout,
+          stderr
+        }
+      );
+    } catch (error) {
+      const stderr = error.stderr?.toString?.() ?? error.message ?? "";
+      const stdout = error.stdout?.toString?.() ?? "";
+      appendLog("error", "run_build failed", { stderr, stdout });
+      return toolError(`Build failed.
+
+stdout:
+${stdout}
+
+stderr:
+${stderr}`);
+    }
+  }
+  async handleRequestRestart() {
+    const msg = "Restart requested. Please restart the MCP server in your client (e.g. Cursor) to load new code.";
+    setImmediate(() => shutdown(0));
+    return toolText(msg, { restartRequested: true });
+  }
+  /**
+   * Returns vital signs in a fixed text format. Designed to never touch the
+   * DB so it returns instantly even when SQL is blocked — that's the whole
+   * point: this tool verifies "the MCP is alive even though queries are slow".
+   */
+  async handleHealthCheck() {
+    const wd = readWatchdogState();
+    const uptimeMs = Date.now() - wd.startedAt;
+    const idleMs = Date.now() - this.lastActivityTs;
+    let status = "healthy";
+    const issues = [];
+    if (wd.eventLoopP99Ms > 500) {
+      status = "degraded";
+      issues.push(`event-loop lag p99 ${wd.eventLoopP99Ms.toFixed(0)}ms`);
+    }
+    if (wd.eventLoopP99Ms > 5e3) {
+      status = "unhealthy";
+    }
+    if (wd.rssMb > 800) {
+      status = status === "healthy" ? "degraded" : status;
+      issues.push(`RSS ${wd.rssMb}MB`);
+    }
+    if (this.recentErrorCount > 5) {
+      status = status === "healthy" ? "degraded" : status;
+      issues.push(`${this.recentErrorCount} recent errors`);
+    }
+    const lines = [
+      `Status: ${status}`,
+      issues.length ? `Issues: ${issues.join("; ")}` : "",
+      "",
+      `Uptime: ${formatDuration(uptimeMs)}`,
+      `Last activity: ${formatDuration(idleMs)} ago`,
+      `PID: ${process.pid}`,
+      `Node: ${process.version}`,
+      "",
+      `Heap: ${wd.heapMb || round1(process.memoryUsage().heapUsed / 1024 / 1024)}MB`,
+      `RSS: ${wd.rssMb || round1(process.memoryUsage().rss / 1024 / 1024)}MB`,
+      `Event-loop p99: ${wd.eventLoopP99Ms.toFixed(1)}ms`,
+      `Event-loop max: ${wd.eventLoopMaxMs.toFixed(1)}ms`,
+      "",
+      `Total tool calls: ${this.toolCallCount}`,
+      `Recent errors: ${this.recentErrorCount}`,
+      `Engine: ${engineLabel()}`
+    ].filter((l) => l !== null);
+    return toolText(lines.join("\n"), {
+      status,
+      issues,
+      uptimeMs,
+      idleMs,
+      pid: process.pid,
+      node: process.version,
+      heapMb: wd.heapMb || round1(process.memoryUsage().heapUsed / 1024 / 1024),
+      rssMb: wd.rssMb || round1(process.memoryUsage().rss / 1024 / 1024),
+      eventLoopP99Ms: wd.eventLoopP99Ms,
+      eventLoopMaxMs: wd.eventLoopMaxMs,
+      toolCallCount: this.toolCallCount,
+      recentErrorCount: this.recentErrorCount,
+      engine: engineLabel()
+    });
+  }
+  async handleGetMessages(args) {
+    const span = perf("tool:get_messages");
+    const parsed = GetMessagesSchema.parse(args);
+    const { chatIdentifier, threadSlug, beforeMessageId } = parsed;
+    const HARD_PAGE_CAP = 5e3;
+    const requested = resolveLimit(parsed.limit);
+    const limit = Math.min(requested, HARD_PAGE_CAP);
+    const wasCapped = requested > HARD_PAGE_CAP;
+    let messages;
+    let threadHeader = "";
+    if (chatIdentifier || threadSlug) {
+      let targetIdentifier = chatIdentifier;
+      if (threadSlug) {
+        const slugRecord = this.db.getSlugRecord(threadSlug);
+        if (!slugRecord) {
+          return toolError(`Unknown thread slug: ${threadSlug}`);
+        }
+        targetIdentifier = slugRecord.chatIdentifier;
+      }
+      messages = await this.db.getMessagesForChat(targetIdentifier, limit, { beforeMessageId });
+      const conv = await this.db.findChatByHandle(targetIdentifier);
+      if (conv) {
+        const name = conv.displayName || conv.rawIdentifier;
+        const ident = conv.displayName ? ` (${conv.rawIdentifier})` : "";
+        const kind = conv.isGroupChat ? "Group" : "1-on-1";
+        threadHeader = `Thread: ${conv.threadSlug} | ${name}${ident} | ${conv.serviceType} | ${kind}
+
+`;
+      }
+    } else {
+      messages = await this.db.getRecentMessages(limit);
+    }
+    const durMs = span.end({ limit, returned: messages.length });
+    if (messages.length === 0) {
+      return toolText(`${threadHeader}No messages found.`, {
+        messages: [],
+        count: 0,
+        hasMore: false
+      });
+    }
+    const formatted = messages.map((m) => formatMessage(m)).join("\n");
+    const oldestId = Math.min(...messages.map((m) => m.id));
+    const hasMore = messages.length === limit;
+    const paginationLine = chatIdentifier || threadSlug ? `
+_Pagination: oldestMessageId=${oldestId}, hasMore=${hasMore}${wasCapped ? ` (capped at ${HARD_PAGE_CAP} per call — use beforeMessageId or export_messages)` : ""}_` : "";
+    const perfLine = `
+_Engine: TS | Query: ${durMs.toFixed(0)}ms | Messages: ${messages.length}_`;
+    return toolText(
+      `${threadHeader}Found ${messages.length} message(s):
+
+${formatted}${paginationLine}${perfLine}`,
+      {
+        messages: messages.map(messageToStructured),
+        count: messages.length,
+        hasMore,
+        oldestMessageId: chatIdentifier || threadSlug ? oldestId : void 0
+      }
+    );
+  }
+  async handleExportMessages(args, signal) {
+    const span = perf("tool:export_messages");
+    const parsed = ExportMessagesSchema.parse(args);
+    const { format, outputPath, since, until, pageSize } = parsed;
+    let chatIdentifier = parsed.chatIdentifier;
+    if (parsed.threadSlug) {
+      const slugRecord = this.db.getSlugRecord(parsed.threadSlug);
+      if (!slugRecord) {
+        return toolError(`Unknown thread slug: ${parsed.threadSlug}`, {
+          threadSlug: parsed.threadSlug
+        });
+      }
+      chatIdentifier = slugRecord.chatIdentifier;
+    }
+    if (!chatIdentifier) {
+      return toolError("chatIdentifier or threadSlug required");
+    }
+    const pathError = validateExportOutputPath(outputPath);
+    if (pathError) {
+      return toolError(pathError);
+    }
+    const sinceDate = since ? parseUserDate(since) : null;
+    const untilDate = until ? parseUserDate(until) : null;
+    if (since && !sinceDate) {
+      return toolError(`Could not parse 'since': ${since}`);
+    }
+    if (until && !untilDate) {
+      return toolError(`Could not parse 'until': ${until}`);
+    }
+    const result = await streamExport({
+      db: this.db,
+      chatIdentifier,
+      format,
+      outputPath,
+      since: sinceDate,
+      until: untilDate,
+      pageSize,
+      signal
+    });
+    const durMs = span.end({ format, count: result.count, sizeBytes: result.sizeBytes });
+    return toolText(
+      [
+        `Exported ${result.count} message(s) to ${result.savedTo}`,
+        `Format: ${format}`,
+        `Range: ${result.oldest?.toISOString() ?? "(none)"} → ${result.newest?.toISOString() ?? "(none)"}`,
+        `Size: ${(result.sizeBytes / 1024).toFixed(1)} KB`,
+        `_Took ${durMs.toFixed(0)}ms_`
+      ].join("\n"),
+      {
+        ...result,
+        format,
+        oldest: result.oldest?.toISOString() ?? null,
+        newest: result.newest?.toISOString() ?? null,
+        durationMs: durMs
+      }
+    );
+  }
+  async handleGetUnreadMessages(args) {
+    const { limit } = GetUnreadMessagesSchema.parse(args ?? {});
+    const resolvedLimit = resolveLimit(limit, 100);
+    const messages = await this.db.getUnreadMessages(resolvedLimit + 1);
+    const hasMore = messages.length > resolvedLimit;
+    const results = messages.slice(0, resolvedLimit);
+    if (results.length === 0) {
+      return toolText("No unread messages.", {
+        messages: [],
+        count: 0,
+        hasMore: false,
+        nextOffset: null
+      });
+    }
+    const formatted = results.map((msg) => {
+      const slug = this.db.getSlugForChatIdentifier(msg.chatId);
+      const label = slug ?? msg.chatId;
+      return formatMessage(msg, label);
+    }).join("\n");
+    return toolText(`Found ${results.length} unread message(s):
+
+${formatted}`, {
+      messages: results.map(messageToStructured),
+      count: results.length,
+      hasMore,
+      nextOffset: null
+    });
+  }
+  async handleSendMessage(args) {
+    const { recipient, threadSlug, message, attachments } = SendMessageSchema.parse(args);
+    if (!recipient && !threadSlug) {
+      return toolError("Either recipient or threadSlug is required.");
+    }
+    if (attachments?.length) {
+      for (const p of attachments) {
+        if (!isAbsolute(p)) {
+          return toolError(`Attachment path must be absolute: ${p}`);
+        }
+        if (!existsSync(p)) {
+          return toolError(`Attachment file not found: ${p}`);
+        }
+      }
+    }
+    const available = await checkMessagesAvailable();
+    if (!available) {
+      return toolError("Messages.app is not running or accessible.");
+    }
+    let result;
+    let resolvedTarget = recipient ?? threadSlug ?? "";
+    if (threadSlug) {
+      const slugRecord = this.db.getSlugRecord(threadSlug);
+      if (!slugRecord) {
+        return toolError(
+          `Unknown thread slug: ${threadSlug}. Use list_conversations to see available slugs.`
+        );
+      }
+      if (slugRecord.isGroup) {
+        if (slugRecord.displayName && !slugRecord.displayName.startsWith("chat")) {
+          result = await sendToChat(slugRecord.displayName, message);
+        } else {
+          result = await sendToChatId(slugRecord.chatGuid, message);
+        }
+      } else {
+        result = await sendMessageReliable(slugRecord.chatIdentifier, message);
+        if (!result.success) {
+          result = await sendMessageAlt(slugRecord.chatIdentifier, message);
+        }
+      }
+      resolvedTarget = slugRecord.displayName || slugRecord.chatIdentifier;
+    } else {
+      result = await sendMessageReliable(recipient, message);
+      if (!result.success) {
+        result = await sendMessageAlt(recipient, message);
+      }
+    }
+    if (result.success) {
+      const attachmentResults = [];
+      if (attachments?.length) {
+        const targetHandle = threadSlug ? this.db.getSlugRecord(threadSlug)?.chatIdentifier : recipient;
+        const isGroupTarget = threadSlug ? Boolean(this.db.getSlugRecord(threadSlug)?.isGroup) : false;
+        if (isGroupTarget) {
+          for (const p of attachments) {
+            attachmentResults.push({
+              path: p,
+              success: false,
+              error: "Attachment send to group chats not supported (Messages.app limitation)."
+            });
+          }
+        } else if (targetHandle) {
+          for (const p of attachments) {
+            const r = await sendAttachment(targetHandle, p);
+            attachmentResults.push({
+              path: p,
+              success: r.success,
+              error: r.error
+            });
+          }
+        }
+      }
+      const chat = await this.db.findChatByHandle(
+        threadSlug ? this.db.getSlugRecord(threadSlug)?.chatIdentifier ?? "" : recipient
+      );
+      let lastMessageId;
+      if (chat) {
+        const lastMsg = await this.db.getLastMessage(chat.chatIdentifier);
+        lastMessageId = lastMsg?.id;
+      }
+      const attSummary = attachmentResults.length > 0 ? `
+Attachments: ${attachmentResults.filter((a) => a.success).length}/${attachmentResults.length} delivered` : "";
+      return toolText(
+        `Message sent to ${resolvedTarget} at ${result.timestamp?.toLocaleString()}${chat ? `
+Thread: ${chat.threadSlug}` : ""}${lastMessageId ? `
+Last message ID: ${lastMessageId} (use with wait_for_reply)` : ""}${attSummary}`,
+        {
+          success: true,
+          target: resolvedTarget,
+          timestamp: result.timestamp?.toISOString() ?? null,
+          threadSlug: chat?.threadSlug,
+          lastMessageId,
+          attachments: attachmentResults.length > 0 ? attachmentResults : void 0
+        }
+      );
+    } else {
+      appendLog("error", "send_message failed", { recipient: resolvedTarget, error: result.error });
+      return toolError(
+        `Failed to send message: ${result.error}. Use get_last_send_error for details.`,
+        {
+          error: result.error
+        }
+      );
+    }
+  }
+  async handleWaitForReply(args, signal) {
+    const { chatIdentifier, threadSlug, timeoutSeconds, pollIntervalSeconds, afterMessageId } = WaitForReplySchema.parse(args);
+    if (!chatIdentifier && !threadSlug) {
+      return toolError("Either chatIdentifier or threadSlug is required.");
+    }
+    const timeoutMs = timeoutSeconds * 1e3;
+    const pollIntervalMs = pollIntervalSeconds * 1e3;
+    const startTime = Date.now();
+    let chat;
+    if (threadSlug) {
+      const slugRecord = this.db.getSlugRecord(threadSlug);
+      if (!slugRecord) {
+        return toolError(`Unknown thread slug: ${threadSlug}`);
+      }
+      chat = await this.db.findChatByHandle(slugRecord.chatIdentifier);
+    } else {
+      chat = await this.db.findChatByHandle(chatIdentifier);
+    }
+    if (!chat) {
+      return toolError(`Could not find conversation for: ${threadSlug || chatIdentifier}`);
+    }
+    let lastKnownId = afterMessageId;
+    if (!lastKnownId) {
+      const lastMsg = await this.db.getLastMessage(chat.chatIdentifier);
+      lastKnownId = lastMsg?.id || 0;
+    }
+    while (Date.now() - startTime < timeoutMs) {
+      if (signal?.aborted) {
+        return toolError(
+          `Cancelled by client after ${Math.round((Date.now() - startTime) / 1e3)}s`
+        );
+      }
+      const newMessages = await this.db.getMessagesAfter(chat.chatIdentifier, lastKnownId);
+      if (newMessages.length > 0) {
+        const formatted = newMessages.map((m) => formatMessage(m)).join("\n");
+        return toolText(`Received ${newMessages.length} new message(s):
+
+${formatted}`, {
+          received: true,
+          messages: newMessages.map(messageToStructured),
+          count: newMessages.length
+        });
+      }
+      await sleep(pollIntervalMs);
+    }
+    return toolText(
+      `Timeout reached (${timeoutSeconds}s) - no new messages received in conversation with ${threadSlug || chatIdentifier}`,
+      {
+        received: false,
+        timedOut: true,
+        timeoutSeconds,
+        threadSlug,
+        chatIdentifier: chat.chatIdentifier
+      }
+    );
+  }
+  async handleListConversations(args) {
+    const { limit } = ListConversationsSchema.parse(args);
+    const resolvedLimit = resolveLimit(limit);
+    const limited = await this.db.listConversations(resolvedLimit + 1);
+    const hasMore = limited.length > resolvedLimit;
+    const results = limited.slice(0, resolvedLimit);
+    if (results.length === 0) {
+      return toolText("No conversations found.", {
+        conversations: [],
+        count: 0,
+        hasMore: false,
+        nextOffset: null
+      });
+    }
+    const formatted = results.map((conv) => {
+      const slug = conv.threadSlug ?? conv.chatIdentifier;
+      let name = conv.displayName || conv.chatIdentifier;
+      if (conv.isGroupChat && !conv.displayName) {
+        const resolved = this.db.resolveParticipantNames(conv.participants);
+        const names = resolved.filter((n, i) => n !== conv.participants[i]);
+        if (names.length > 0) {
+          name = names.length <= 3 ? names.join(", ") : `${names.slice(0, 3).join(", ")} +${names.length - 3}`;
+        }
+      }
+      const ident = conv.displayName && conv.displayName !== conv.rawIdentifier ? ` (${conv.rawIdentifier})` : "";
+      const svc = conv.serviceType === "SMS" ? " [SMS]" : "";
+      const group = conv.isGroupChat ? " [Group]" : "";
+      const lastDate = conv.lastMessageDate ? ` - ${relativeDate(conv.lastMessageDate)}` : "";
+      let snippetText = conv.lastMessageSnippet;
+      if (snippetText) {
+        snippetText = sanitizeUserText(snippetText);
+      }
+      const snippet = snippetText ? ` - "${wrapUntrusted(snippetText.length > 50 ? `${snippetText.slice(0, 47)}...` : snippetText)}"` : "";
+      const unread = conv.unreadCount > 0 ? ` [${conv.unreadCount} unread]` : "";
+      return `• [${slug}] ${name}${ident}${svc}${group}${lastDate}${snippet}${unread}`;
+    }).join("\n");
+    return toolText(`Found ${results.length} conversation(s):
+
+${formatted}`, {
+      conversations: results.map((conversation) => ({
+        ...conversation,
+        lastMessageDate: conversation.lastMessageDate?.toISOString() ?? null,
+        lastMessageSnippet: sanitizeUserText(conversation.lastMessageSnippet)
+      })),
+      count: results.length,
+      hasMore,
+      nextOffset: null
+    });
+  }
+  async handleSearchMessages(args) {
+    const { query, limit, mode, minScore } = SearchMessagesSchema.parse(args);
+    const resolvedLimit = resolveLimit(limit);
+    const SOFT_CAP = 1e4;
+    let messages;
+    let softCapWarning;
+    if (mode === "fuzzy") {
+      const candidates = await this.db.searchMessages(query, SOFT_CAP);
+      const ranked = rankFuzzy(query, candidates, (m) => m.text ?? "", minScore);
+      messages = ranked.slice(0, resolvedLimit + 1).map((r) => r.item);
+      if (candidates.length >= SOFT_CAP) {
+        softCapWarning = `Candidate pool capped at ${SOFT_CAP} pre-scoring. Tighten the query for more reliable ranking.`;
+      }
+    } else {
+      messages = await this.db.searchMessages(query, resolvedLimit + 1);
+    }
+    const hasMore = messages.length > resolvedLimit;
+    const results = messages.slice(0, resolvedLimit);
+    if (results.length === 0) {
+      return toolText(`No messages found matching "${query}".`, {
+        query,
+        mode,
+        messages: [],
+        count: 0,
+        hasMore: false,
+        nextOffset: null,
+        softCapWarning
+      });
+    }
+    const formatted = results.map((msg) => {
+      const slug = this.db.getSlugForChatIdentifier(msg.chatId);
+      const label = slug ?? msg.chatId;
+      return formatMessage(msg, label);
+    }).join("\n");
+    return toolText(`Found ${results.length} message(s) matching "${query}":
+
+${formatted}`, {
+      query,
+      mode,
+      messages: results.map(messageToStructured),
+      count: results.length,
+      hasMore,
+      nextOffset: null,
+      softCapWarning
+    });
+  }
+  // ── Contact tools ──────────────────────────────────────────────────────
+  async handleListContacts(args) {
+    const { limit, offset } = ListContactsSchema.parse(args);
+    const resolvedLimit = resolveLimit(limit);
+    const SAFETY_CAP = 5e3;
+    const effectiveLimit = Math.min(resolvedLimit, SAFETY_CAP);
+    const { contacts, total } = this.db.contacts.listContacts(offset, effectiveLimit);
+    const hasMore = offset + contacts.length < total;
+    if (contacts.length === 0) {
+      return toolText(`No contacts found${offset > 0 ? ` (offset ${offset})` : ""}.`, {
+        contacts: [],
+        count: 0,
+        hasMore: false,
+        totalCount: total
+      });
+    }
+    const formatted = contacts.map((c) => {
+      const phones = c.phoneNumbers.length > 0 ? ` 📱 ${c.phoneNumbers.join(", ")}` : "";
+      const emails = c.emails.length > 0 ? ` ✉ ${c.emails.join(", ")}` : "";
+      return `• ${sanitizeUserText(c.displayName)}${phones}${emails}`;
+    }).join("\n");
+    return toolText(`Showing ${contacts.length} of ${total} contact(s):
+
+${formatted}`, {
+      contacts,
+      count: contacts.length,
+      hasMore,
+      totalCount: total
+    });
+  }
+  async handleSearchContacts(args) {
+    const { query, limit } = SearchContactsSchema.parse(args);
+    const resolvedLimit = resolveLimit(limit);
+    const all = this.db.contacts.searchContacts(query);
+    const results = resolvedLimit === Number.MAX_SAFE_INTEGER ? all : all.slice(0, resolvedLimit);
+    if (results.length === 0) {
+      return toolText(`No contacts match "${query}".`, {
+        query,
+        contacts: [],
+        count: 0
+      });
+    }
+    rememberSearch(
+      query,
+      results.map((c) => ({
+        handle: c.phoneNumbers[0] ?? c.emails[0] ?? c.displayName,
+        displayName: c.displayName
+      }))
+    );
+    const formatted = results.map((c, i) => {
+      const phones = c.phoneNumbers.length > 0 ? ` 📱 ${c.phoneNumbers.join(", ")}` : "";
+      const emails = c.emails.length > 0 ? ` ✉ ${c.emails.join(", ")}` : "";
+      return `[contact:${i + 1}] ${sanitizeUserText(c.displayName)}${phones}${emails}`;
+    }).join("\n");
+    const hint = results.length > 1 ? `
+
+Re-select by index in any contact-accepting tool: handle: "contact:1" … "contact:${results.length}".` : "";
+    return toolText(
+      `Found ${results.length} contact(s) matching "${query}":
+
+${formatted}${hint}`,
+      {
+        query,
+        contacts: results,
+        count: results.length
+      }
+    );
+  }
+  async handleGetContact(args) {
+    const { handle, id } = GetContactSchema.parse(args);
+    let contact = null;
+    if (handle !== void 0) {
+      const selectorHit = resolveContactSelector(handle);
+      const effectiveHandle = selectorHit?.handle ?? handle;
+      const lookup = this.db.contacts.lookupContact(effectiveHandle);
+      contact = lookup ? this.db.contacts.getContact(lookup.contactId) : null;
+    } else if (id !== void 0) {
+      contact = this.db.contacts.getContact(id);
+    }
+    if (!contact) {
+      return toolText("Contact not found.", { contact: null });
+    }
+    const phones = contact.phoneNumbers.length > 0 ? `
+Phones: ${contact.phoneNumbers.join(", ")}` : "";
+    const emails = contact.emails.length > 0 ? `
+Emails: ${contact.emails.join(", ")}` : "";
+    const org = contact.organization ? `
+Organization: ${contact.organization}` : "";
+    return toolText(
+      `${sanitizeUserText(contact.displayName)} (id ${contact.id})${phones}${emails}${org}`,
+      { contact }
+    );
+  }
+  async handleResolveHandle(args) {
+    const { handle } = ResolveHandleSchema.parse(args);
+    const selectorHit = resolveContactSelector(handle);
+    const effectiveHandle = selectorHit?.handle ?? handle;
+    const lookup = this.db.contacts.lookupContact(effectiveHandle);
+    if (lookup) {
+      return toolText(`${handle} → ${sanitizeUserText(lookup.displayName)}`, {
+        handle,
+        displayName: lookup.displayName,
+        contactId: lookup.contactId,
+        label: lookup.label ?? null,
+        resolved: true
+      });
+    }
+    return toolText(`No contact for ${handle}.`, {
+      handle,
+      displayName: handle,
+      contactId: null,
+      label: null,
+      resolved: false
+    });
+  }
+  async handleCheckImessageAvailability(args) {
+    const { handle } = CheckImessageAvailabilitySchema.parse(args);
+    const selectorHit = resolveContactSelector(handle);
+    const effectiveHandle = selectorHit?.handle ?? handle;
+    const result = await checkImessageAvailability(effectiveHandle);
+    const text = result.reachable ? `${handle} reachable via ${result.service}.` : `${handle} not reachable. ${result.hint ?? ""}`.trim();
+    return toolText(text, {
+      handle,
+      service: result.service,
+      reachable: result.reachable,
+      hint: result.hint
+    });
+  }
+  async handleSearchAttachments(args) {
+    const { mimePrefix, chatIdentifier, since, until, limit } = SearchAttachmentsSchema.parse(args);
+    const sinceMs = since ? parseUserDate(since)?.getTime() : void 0;
+    const untilMs = until ? parseUserDate(until)?.getTime() : void 0;
+    const resolvedLimit = resolveLimit(limit);
+    const opts = {
+      limit: resolvedLimit
+    };
+    if (mimePrefix !== void 0) opts.mimePrefix = mimePrefix;
+    if (chatIdentifier !== void 0) opts.chatIdentifier = chatIdentifier;
+    if (sinceMs !== void 0) opts.sinceMs = sinceMs;
+    if (untilMs !== void 0) opts.untilMs = untilMs;
+    const results = this.db.searchAttachments(opts);
+    const formatted = results.map(
+      (a) => `[${a.rowId}] ${a.mimeType ?? "?"} · ${a.totalBytes}B · ${a.createdDate.toISOString().slice(0, 10)} · ${a.transferName ?? a.filename}`
+    ).join("\n");
+    return toolText(`Found ${results.length} attachment(s):
+
+${formatted}`, {
+      attachments: results.map((a) => ({
+        rowId: a.rowId,
+        filename: a.filename,
+        mimeType: a.mimeType,
+        transferName: a.transferName,
+        totalBytes: a.totalBytes,
+        createdDate: a.createdDate.toISOString(),
+        chatId: a.chatId
+      })),
+      count: results.length
+    });
+  }
+  async handleGetAttachment(args) {
+    const { readFileSync } = await import("node:fs");
+    const { rowId, inlineMaxBytes } = GetAttachmentSchema.parse(args);
+    const rec = this.db.getAttachmentByRowId(rowId);
+    if (!rec) return toolError(`Attachment ROWID ${rowId} not found.`);
+    const resolvedPath = rec.filename.replace(/^~/, process.env.HOME ?? "~");
+    if (!existsSync(resolvedPath)) {
+      return toolError(`Attachment file does not exist: ${resolvedPath}`);
+    }
+    const stat = statSync(resolvedPath);
+    const sizeBytes = stat.size;
+    const isHeic = (rec.mimeType ?? "").toLowerCase().includes("heic") || resolvedPath.toLowerCase().endsWith(".heic");
+    const inline = sizeBytes <= inlineMaxBytes;
+    let base64;
+    let convertedNote;
+    let finalMime = rec.mimeType;
+    let finalPath = resolvedPath;
+    if (inline) {
+      if (isHeic) {
+        try {
+          const { execFileSync } = await import("node:child_process");
+          const { tmpdir } = await import("node:os");
+          const { join: pjoin } = await import("node:path");
+          const out = pjoin(tmpdir(), `imsg-att-${rowId}.png`);
+          execFileSync("sips", ["-s", "format", "png", resolvedPath, "--out", out], {
+            stdio: "ignore"
+          });
+          finalPath = out;
+          finalMime = "image/png";
+          convertedNote = "HEIC → PNG via sips";
+          base64 = readFileSync(out).toString("base64");
+        } catch (e) {
+          return toolError(`HEIC→PNG conversion failed: ${e.message ?? e}`);
+        }
+      } else {
+        base64 = readFileSync(resolvedPath).toString("base64");
+      }
+    }
+    return toolText(
+      inline ? `Attachment ${rowId} (${sizeBytes}B, ${finalMime ?? "?"}) returned inline.` : `Attachment ${rowId} too large to inline (${sizeBytes}B > ${inlineMaxBytes}B). Use path: ${resolvedPath}`,
+      {
+        rowId,
+        filename: rec.filename,
+        resolvedPath: finalPath,
+        mimeType: finalMime,
+        totalBytes: sizeBytes,
+        inline,
+        base64,
+        converted: convertedNote
+      }
+    );
+  }
+  async handleChatAnalytics(args) {
+    const { type, windowDays } = ChatAnalyticsSchema.parse(args);
+    const effectiveDays = type === "year_in_review_wrapped" ? 365 : windowDays;
+    const cutoffMs = Date.now() - effectiveDays * 864e5;
+    const maxRowId = this.db.getMaxMessageRowId();
+    const cacheArgs = { type, windowDays: effectiveDays };
+    const hit = lookupCache(type, cacheArgs, maxRowId);
+    if (hit) {
+      return toolText(`Cached ${type} (computed at ${new Date(hit.computedAt).toISOString()}).`, {
+        type,
+        windowDays: effectiveDays,
+        computedAtIso: new Date(hit.computedAt).toISOString(),
+        fromCache: true,
+        data: hit.data
+      });
+    }
+    const messages = await this.db.getMessagesInWindow(cutoffMs);
+    const result = dispatchAnalytic(type, messages);
+    const computedAtIso = (/* @__PURE__ */ new Date()).toISOString();
+    storeCache(type, cacheArgs, maxRowId, result.data);
+    return toolText(
+      `Computed ${type} over ${messages.length} messages in the last ${effectiveDays}d.`,
+      {
+        type,
+        windowDays: effectiveDays,
+        computedAtIso,
+        fromCache: false,
+        data: result.data
+      }
+    );
+  }
+  async run() {
+    installShutdownHandlers();
+    registerCleanup(() => logShutdown("normal"));
+    registerCleanup(() => stopHeapMonitor());
+    registerCleanup(() => this.db.close());
+    enableStdinEofDetection();
+    enableOrphanWatchdog();
+    installWatchdog();
+    logStartup("mcp-server");
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    info("iMessage MCP Server running on stdio");
+    startHeapMonitor();
+    console.error(`iMessage MCP Server running on stdio (logs: ${getLogDirectory()})`);
+  }
+}
+async function runMcpServer() {
+  try {
+    const server = new IMessageMCPServer();
+    await server.run();
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    const report = await checkLocalAccess();
+    console.error("");
+    console.error(formatAccessReport(report));
+    await shutdown(1);
+  }
+}
+export {
+  IMessageMCPServer,
+  runMcpServer
+};
+//# sourceMappingURL=index.js.map