imsg-mcp 1.3.2 → 1.5.0

package/dist/{shutdown-pPAPSnk3.js → shutdown-Vh0gjb6m.js}

@@ -1,9 +1,9 @@
-import { existsSync, readdirSync, readFileSync, appendFileSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, appendFileSync, mkdirSync, writeFileSync, unlinkSync, statSync, rmSync, copyFileSync } from "node:fs";
 import os, { homedir, freemem, tmpdir } from "node:os";
 import Database from "better-sqlite3";
 import { execFile } from "node:child_process";
 import { randomUUID, randomBytes, createHash } from "node:crypto";
-import { join, sep, dirname, resolve } from "node:path";
+import { join, sep, dirname, resolve, basename } from "node:path";
 import { promisify } from "node:util";
 function resolveEnvPath(value, fallback) {
   if (!value) return fallback;
@@ -56,10 +56,14 @@ function getContactsDbPaths() {
 function getSlugsDbPath() {
   return resolveEnvPath(process.env.VITE_SLUGS_DB_PATH, join(homedir(), ".imsg-mcp", "slugs.db"));
 }
+function getHumansDirPath() {
+  return resolveEnvPath(process.env.VITE_HUMANS_DIR, join(homedir(), ".agents", "humans"));
+}
 const config = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   getContactsDbPaths,
   getEnv,
+  getHumansDirPath,
   getImsgDbPath,
   getSlugsDbPath,
   isAiEnv
@@ -502,10 +506,30 @@ async function sendMessageReliable(recipient, message, preferredService) {
     }
   }
 }
+const ATTACHMENT_STAGING_DIR = join(homedir(), "Library", "Messages", "imsg-mcp-staging");
+const STAGING_SWEEP_AGE_MS = 60 * 60 * 1e3;
+function stageAttachmentForSend(filepath, stagingDir = ATTACHMENT_STAGING_DIR) {
+  try {
+    mkdirSync(stagingDir, { recursive: true });
+    for (const entry of readdirSync(stagingDir)) {
+      const p = join(stagingDir, entry);
+      try {
+        if (Date.now() - statSync(p).mtimeMs > STAGING_SWEEP_AGE_MS) rmSync(p, { force: true });
+      } catch {
+      }
+    }
+    const staged = join(stagingDir, `${randomBytes(4).toString("hex")}-${basename(filepath)}`);
+    copyFileSync(filepath, staged);
+    return staged;
+  } catch {
+    return filepath;
+  }
+}
 async function sendAttachment(recipient, filepath, preferredService) {
   if (MOCK) return mockSend(`[attachment:${filepath}]`, { chatIdentifier: recipient });
+  const stagedPath = stageAttachmentForSend(filepath);
   const escapedRecipient = appleScriptEscape(recipient);
-  const escapedPath = appleScriptEscape(filepath);
+  const escapedPath = appleScriptEscape(stagedPath);
   const script = buildParticipantSendScript({
     order: sendServiceOrder(recipient, preferredService),
     escapedRecipient,
@@ -731,6 +755,362 @@ function generateThreadSlug(input) {
   if (!namePart) namePart = "unknown";
   return `${namePart}~${svc}~${hash}`;
 }
+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 computeRelationshipLeaderboard(messages) {
+  const byChat = /* @__PURE__ */ new Map();
+  for (const m of messages) {
+    if (m.isReaction) continue;
+    if (!m.chatId || isGroupChatIdentifier(m.chatId)) continue;
+    let acc = byChat.get(m.chatId);
+    if (!acc) {
+      acc = { contact: null, handle: m.chatId, sent: 0, received: 0, lastMs: 0 };
+      byChat.set(m.chatId, acc);
+    }
+    if (m.isFromMe) {
+      acc.sent++;
+    } else {
+      acc.received++;
+      if (!acc.contact && m.displayName) acc.contact = m.displayName;
+      if (m.handle && m.handle !== "unknown") acc.handle = m.handle;
+    }
+    if (m.date.getTime() > acc.lastMs) acc.lastMs = m.date.getTime();
+  }
+  const byContact = /* @__PURE__ */ new Map();
+  for (const acc of byChat.values()) {
+    const key = acc.contact ?? acc.handle;
+    if (!key || key === "unknown") continue;
+    const merged = byContact.get(key);
+    if (merged) {
+      merged.sent += acc.sent;
+      merged.received += acc.received;
+      merged.lastMs = Math.max(merged.lastMs, acc.lastMs);
+    } else {
+      byContact.set(key, { ...acc });
+    }
+  }
+  const now = Date.now();
+  const leaderboard = [];
+  for (const [contact, acc] of byContact) {
+    const total = acc.sent + acc.received;
+    if (total < 3) continue;
+    const reciprocity = Math.min(acc.sent, acc.received) / Math.max(Math.max(acc.sent, acc.received), 1);
+    const daysSinceLast = Math.max(0, (now - acc.lastMs) / 864e5);
+    const score = Math.log2(1 + total) * (0.4 + 0.6 * reciprocity) * Math.exp(-daysSinceLast / 45);
+    leaderboard.push({
+      contact,
+      handle: acc.handle,
+      total,
+      sent: acc.sent,
+      received: acc.received,
+      reciprocity: Math.round(reciprocity * 100) / 100,
+      daysSinceLast: Math.round(daysSinceLast * 10) / 10,
+      score
+    });
+  }
+  leaderboard.sort((a, b) => b.score - a.score);
+  for (const row of leaderboard) row.score = Math.round(row.score * 1e6) / 1e6;
+  return { leaderboard: leaderboard.slice(0, 50) };
+}
+const IMPLEMENTED_TYPES = [
+  "messaging_streaks",
+  "double_texts",
+  "response_time_stats",
+  "daily_heatmap",
+  "tapback_summary",
+  "year_in_review_wrapped",
+  "relationship_leaderboard"
+];
+const ANALYTIC_INFO = {
+  messaging_streaks: {
+    label: "Messaging Streaks",
+    description: "Longest and current daily-message streaks per contact",
+    defaultWindowDays: 365
+  },
+  double_texts: {
+    label: "Double Texts",
+    description: "Consecutive messages sent without a reply",
+    defaultWindowDays: 90
+  },
+  response_time_stats: {
+    label: "Response Times",
+    description: "Reply latency per contact (median, p95, mean)",
+    defaultWindowDays: 90
+  },
+  daily_heatmap: {
+    label: "Daily Heatmap",
+    description: "7×24 grid of activity by weekday × hour",
+    defaultWindowDays: 90
+  },
+  tapback_summary: {
+    label: "Tapback Summary",
+    description: "Tapback reactions sent per contact",
+    defaultWindowDays: 365
+  },
+  year_in_review_wrapped: {
+    label: "Year in Review (Wrapped)",
+    description: "Wrapped summary: top contacts, peak day, totals (pinned to 365d)",
+    defaultWindowDays: 365
+  },
+  relationship_leaderboard: {
+    label: "Relationship Leaderboard",
+    description: "Top relationships by volume × reciprocity × recency",
+    defaultWindowDays: 1825
+  }
+};
+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) };
+    case "relationship_leaderboard":
+      return { type, data: computeRelationshipLeaderboard(messages) };
+  }
+}
 const registry = /* @__PURE__ */ new Set();
 let shuttingDown = false;
 let watchdogTimer = null;
@@ -822,53 +1202,59 @@ function isShuttingDown() {
   return shuttingDown;
 }
 export {
-  logShutdown as A,
-  stopHeapMonitor as B,
-  getLogFilePath as C,
-  getLastSendError as D,
-  looksLikeThreadSlug as E,
-  enableFileLogging as F,
-  isShuttingDown as G,
-  warn as H,
-  error as I,
-  isGroupGuid as J,
-  isGroupChatIdentifier as K,
-  generateThreadSlug as L,
-  AssociatedMessageType as M,
-  macAutoTimestampToDate as N,
-  OBJECT_REPLACEMENT_CHAR as O,
-  isReactionType as P,
-  MAC_EPOCH_OFFSET as Q,
-  NANOS_PER_SECOND as R,
-  parseAssociatedMessageGuid as S,
+  config as $,
+  info as A,
+  startHeapMonitor as B,
+  getLogs as C,
+  setLastSendError as D,
+  logShutdown as E,
+  stopHeapMonitor as F,
+  getLogFilePath as G,
+  getLastSendError as H,
+  IMPLEMENTED_TYPES as I,
+  ANALYTIC_INFO as J,
+  looksLikeThreadSlug as K,
+  enableFileLogging as L,
+  isShuttingDown as M,
+  warn as N,
+  error as O,
+  OBJECT_REPLACEMENT_CHAR as P,
+  isGroupGuid as Q,
+  isGroupChatIdentifier as R,
+  generateThreadSlug as S,
   Tables as T,
-  macTimestampToDate as U,
-  config as V,
-  getContactsDbPaths as a,
-  getSlugsDbPath as b,
+  AssociatedMessageType as U,
+  macAutoTimestampToDate as V,
+  isReactionType as W,
+  MAC_EPOCH_OFFSET as X,
+  NANOS_PER_SECOND as Y,
+  macTimestampToDate as Z,
+  parseAssociatedMessageGuid as _,
+  shutdown as a,
+  getImsgDbPath as b,
   checkLocalAccess as c,
-  appendLog as d,
-  getFileLogLines as e,
+  getContactsDbPaths as d,
+  getSlugsDbPath as e,
   formatAccessReport as f,
-  getImsgDbPath as g,
-  getLogDirectory as h,
-  checkMessagesAvailable as i,
-  sendToChat as j,
-  sendToChatId as k,
-  sendMessageReliable as l,
-  sendMessageAlt as m,
-  sendAttachment as n,
-  checkImessageAvailability as o,
+  getHumansDirPath as g,
+  appendLog as h,
+  getFileLogLines as i,
+  getLogDirectory as j,
+  checkMessagesAvailable as k,
+  sendToChat as l,
+  sendToChatId as m,
+  sendMessageReliable as n,
+  sendMessageAlt as o,
   perf as p,
-  installShutdownHandlers as q,
-  registerCleanup as r,
-  shutdown as s,
-  enableStdinEofDetection as t,
-  enableOrphanWatchdog as u,
-  logStartup as v,
-  info as w,
-  startHeapMonitor as x,
-  getLogs as y,
-  setLastSendError as z
+  sendAttachment as q,
+  checkImessageAvailability as r,
+  sanitizeSlugPart as s,
+  computeRelationshipLeaderboard as t,
+  dispatchAnalytic as u,
+  installShutdownHandlers as v,
+  registerCleanup as w,
+  enableStdinEofDetection as x,
+  enableOrphanWatchdog as y,
+  logStartup as z
 };
-//# sourceMappingURL=shutdown-pPAPSnk3.js.map
+//# sourceMappingURL=shutdown-Vh0gjb6m.js.map