imsg-mcp 1.0.0

package/dist/shutdown-B9ClCyco.js

@@ -0,0 +1,775 @@
+import { existsSync, readdirSync, appendFileSync, mkdirSync, writeFileSync, unlinkSync } 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 } from "node:crypto";
+import { join, sep, dirname, resolve } from "node:path";
+import { promisify } from "node:util";
+function resolveEnvPath(value, fallback) {
+  if (!value) return fallback;
+  if (value.startsWith("~/") || value === "~") {
+    return join(homedir(), value.slice(2));
+  }
+  return resolve(process.cwd(), value);
+}
+function getEnv() {
+  return process.env.VITE_ENV ?? "development";
+}
+function isAiEnv() {
+  return getEnv() === "ai";
+}
+function getImsgDbPath() {
+  return resolveEnvPath(
+    process.env.VITE_IMSG_DB_PATH,
+    join(homedir(), "Library", "Messages", "chat.db")
+  );
+}
+function getContactsDbPaths() {
+  const main = process.env.VITE_CONTACTS_DB_PATH ?? join(homedir(), "Library", "Application Support", "AddressBook", "AddressBook-v22.abcddb");
+  const mainResolved = resolveEnvPath(main, "");
+  const paths = /* @__PURE__ */ new Set([mainResolved]);
+  const sourcesSegment = `${sep}Sources${sep}`;
+  const sourcesIndex = mainResolved.indexOf(sourcesSegment);
+  const addressBookDir = sourcesIndex >= 0 ? mainResolved.slice(0, sourcesIndex) : dirname(mainResolved);
+  const addSourceDb = (path) => {
+    if (existsSync(path)) {
+      paths.add(path);
+    }
+  };
+  const uuid = process.env.VITE_ADDRESS_BOOK_UUID;
+  if (uuid) {
+    addSourceDb(join(addressBookDir, "Sources", uuid, "AddressBook-v22.abcddb"));
+  }
+  const sourcesDir = join(addressBookDir, "Sources");
+  if (existsSync(sourcesDir)) {
+    try {
+      const entries = readdirSync(sourcesDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        addSourceDb(join(sourcesDir, entry.name, "AddressBook-v22.abcddb"));
+      }
+    } catch {
+    }
+  }
+  return [...paths];
+}
+function getSlugsDbPath() {
+  return resolveEnvPath(process.env.VITE_SLUGS_DB_PATH, join(homedir(), ".imsg-mcp", "slugs.db"));
+}
+const config = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getContactsDbPaths,
+  getEnv,
+  getImsgDbPath,
+  getSlugsDbPath,
+  isAiEnv
+}, Symbol.toStringTag, { value: "Module" }));
+const MAX_LOG_LINES = 500;
+const MAX_FILE_BYTES = 10 * 1024 * 1024;
+function isFileLoggingEnabled() {
+  return process.env.IMSG_DEV === "1";
+}
+function isVerboseLogging() {
+  return process.env.IMSG_LOG_VERBOSE === "1";
+}
+const memoryLines = [];
+let logFilePath = null;
+let logFileBytes = 0;
+let lastSendError = null;
+function getLogDir() {
+  return join(tmpdir(), "imsg-mcp");
+}
+function ensureLogFile() {
+  if (logFilePath && logFileBytes < MAX_FILE_BYTES) return logFilePath;
+  try {
+    const dir = getLogDir();
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const date = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    logFilePath = join(dir, `imsg-mcp-${process.pid}-${date}.ndjson`);
+    logFileBytes = 0;
+    return logFilePath;
+  } catch {
+    return null;
+  }
+}
+function writeToFile(json) {
+  if (!isFileLoggingEnabled()) return;
+  const path = ensureLogFile();
+  if (!path) return;
+  try {
+    const line = `${json}
+`;
+    appendFileSync(path, line);
+    logFileBytes += line.length;
+  } catch {
+  }
+}
+function heapMB() {
+  return Math.round(process.memoryUsage().heapUsed / 1024 / 1024 * 10) / 10;
+}
+function formatMemoryLine(entry) {
+  let line = `${entry.ts} [${entry.level}] ${entry.msg}`;
+  if (entry.dur_ms != null) line += ` (${entry.dur_ms.toFixed(1)}ms)`;
+  if (entry.data != null) line += ` ${JSON.stringify(entry.data)}`;
+  return line;
+}
+function emit(entry) {
+  const line = formatMemoryLine(entry);
+  memoryLines.push(line);
+  if (memoryLines.length > MAX_LOG_LINES) {
+    memoryLines.splice(0, memoryLines.length - MAX_LOG_LINES);
+  }
+  writeToFile(JSON.stringify(entry));
+}
+function info(msg, data) {
+  emit({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "info", msg, mem_mb: heapMB(), data });
+}
+function warn(msg, data) {
+  emit({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "warn", msg, mem_mb: heapMB(), data });
+}
+function error(msg, data) {
+  emit({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "error", msg, mem_mb: heapMB(), data });
+}
+function perf(msg) {
+  const startTime = performance.now();
+  const startHeap = heapMB();
+  return {
+    end(data) {
+      const dur_ms = performance.now() - startTime;
+      const endHeap = heapMB();
+      emit({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "perf",
+        msg,
+        dur_ms,
+        mem_mb: endHeap,
+        mem_delta_mb: Math.round((endHeap - startHeap) * 10) / 10,
+        data
+      });
+      return dur_ms;
+    }
+  };
+}
+function appendLog(level, message, data) {
+  const entry = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    msg: message,
+    mem_mb: heapMB(),
+    data: data != null ? typeof data === "object" ? data : { value: data } : void 0
+  };
+  emit(entry);
+}
+function getLogs(tail) {
+  if (tail != null && tail > 0) return memoryLines.slice(-tail);
+  return [...memoryLines];
+}
+function setLastSendError(details) {
+  lastSendError = { ...details, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+  error("send_message failed", details);
+}
+function getLastSendError() {
+  return lastSendError ? { ...lastSendError } : null;
+}
+function getLogFilePath() {
+  return logFilePath;
+}
+function getLogDirectory() {
+  return getLogDir();
+}
+function logStartup(entrypoint) {
+  info("startup", { pid: process.pid, ppid: process.ppid, entrypoint, node: process.version });
+}
+function logShutdown(reason) {
+  info("shutdown", { pid: process.pid, reason, uptime_s: Math.round(process.uptime()) });
+}
+function getFileLogLines(tail = 50) {
+  try {
+    const { readdirSync: readdirSync2, readFileSync } = require("node:fs");
+    const dir = getLogDir();
+    const files = readdirSync2(dir).filter((f) => f.endsWith(".ndjson")).sort().reverse();
+    if (files.length === 0) return [];
+    const content = readFileSync(join(dir, files[0]), "utf8");
+    const lines = content.trim().split("\n").filter(Boolean);
+    return tail > 0 ? lines.slice(-tail) : lines;
+  } catch {
+    return [];
+  }
+}
+const HEAP_WARN_MB = 150;
+let heapMonitorTimer = null;
+function startHeapMonitor() {
+  if (!isFileLoggingEnabled()) return;
+  if (heapMonitorTimer) return;
+  const intervalMs = isVerboseLogging() ? 1e4 : 6e4;
+  heapMonitorTimer = setInterval(() => {
+    const heap = heapMB();
+    const { rss } = process.memoryUsage();
+    const rssMb = Math.round(rss / 1024 / 1024 * 10) / 10;
+    if (heap > HEAP_WARN_MB) {
+      warn("heap exceeds threshold", { heap_mb: heap, rss_mb: rssMb, threshold_mb: HEAP_WARN_MB });
+    }
+    const freeMb = Math.round(freemem() / 1024 / 1024);
+    emit({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level: "info",
+      msg: "heartbeat",
+      mem_mb: heap,
+      data: {
+        rss_mb: rssMb,
+        uptime_s: Math.round(process.uptime()),
+        system_free_mb: freeMb || void 0
+      }
+    });
+  }, intervalMs);
+  heapMonitorTimer.unref();
+}
+function stopHeapMonitor() {
+  if (heapMonitorTimer) {
+    clearInterval(heapMonitorTimer);
+    heapMonitorTimer = null;
+  }
+}
+const MAC_EPOCH_OFFSET = 978307200;
+const NANOS_PER_SECOND = 1e9;
+const Tables = {
+  MESSAGE: "message",
+  HANDLE: "handle",
+  CHAT: "chat",
+  CHAT_MESSAGE_JOIN: "chat_message_join",
+  CHAT_HANDLE_JOIN: "chat_handle_join",
+  ATTACHMENT: "attachment",
+  MESSAGE_ATTACHMENT_JOIN: "message_attachment_join"
+};
+const AssociatedMessageType = {
+  NORMAL: 0
+};
+const ASSOCIATED_MESSAGE_GUID_REGEX = /^p:(\d+)\/(.+)$/;
+const OBJECT_REPLACEMENT_CHAR = "";
+function macTimestampToDate(timestamp) {
+  if (timestamp == null || timestamp === 0) return null;
+  const unixSeconds = timestamp / NANOS_PER_SECOND + MAC_EPOCH_OFFSET;
+  return new Date(unixSeconds * 1e3);
+}
+function parseAssociatedMessageGuid(guid) {
+  if (!guid) return null;
+  const match = guid.match(ASSOCIATED_MESSAGE_GUID_REGEX);
+  if (match) {
+    return { partIndex: parseInt(match[1], 10), targetGuid: match[2] };
+  }
+  return null;
+}
+function isReactionType(associatedMessageType) {
+  return associatedMessageType >= 1e3 && associatedMessageType !== 0;
+}
+function dateToMacTimestamp(date) {
+  return Math.floor((date.getTime() / 1e3 - MAC_EPOCH_OFFSET) * NANOS_PER_SECOND);
+}
+function resolveChat(db, opts) {
+  let chatRow;
+  if (opts.chatGuid) {
+    chatRow = db.prepare("SELECT ROWID, chat_identifier FROM chat WHERE guid = ?").get(opts.chatGuid);
+  }
+  if (!chatRow && opts.chatIdentifier) {
+    chatRow = db.prepare("SELECT ROWID, chat_identifier FROM chat WHERE chat_identifier = ?").get(opts.chatIdentifier);
+  }
+  if (!chatRow) return null;
+  const handle = db.prepare("SELECT ROWID FROM handle WHERE id = ?").get(chatRow.chat_identifier);
+  const handleId = handle?.ROWID ?? 0;
+  return { chatRowId: chatRow.ROWID, handleId };
+}
+function insertSentMessage(dbPath, target, text) {
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  try {
+    const resolved = resolveChat(db, target);
+    if (!resolved) {
+      console.warn("[mock-send] Could not resolve chat for", target);
+      return null;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const macDate = dateToMacTimestamp(now);
+    const guid = `mock:${randomUUID()}`;
+    const insert = db.prepare(`
+      INSERT INTO message (guid, text, handle_id, date, is_from_me, associated_message_type, is_read, is_delivered, service)
+      VALUES (?, ?, ?, ?, 1, 0, 1, 1, 'iMessage')
+    `);
+    const result = insert.run(guid, text, resolved.handleId, macDate);
+    const messageRowId = Number(result.lastInsertRowid);
+    db.prepare(
+      "INSERT INTO chat_message_join (chat_id, message_id, message_date) VALUES (?, ?, ?)"
+    ).run(resolved.chatRowId, messageRowId, macDate);
+    return messageRowId;
+  } finally {
+    db.close();
+  }
+}
+const execFileAsync = promisify(execFile);
+function isPhoneLike(handle) {
+  return /^\+?[\d\s\-()]+$/.test(handle.trim());
+}
+const MOCK = isAiEnv() || process.env.VITEST === "true";
+function mockSend(text, target) {
+  if (process.env.VITEST !== "true") {
+    try {
+      insertSentMessage(getImsgDbPath(), target, text);
+    } catch (err) {
+      console.warn("[mock-send] DB insert failed (non-fatal):", err);
+    }
+  }
+  return { success: true, timestamp: /* @__PURE__ */ new Date() };
+}
+async function runAppleScript(script, captureErrorForSend = false) {
+  try {
+    const { stdout, stderr } = await execFileAsync("osascript", ["-e", script], {
+      timeout: 3e4
+    });
+    if (stderr?.trim()) {
+      console.error("[osascript] stderr:", stderr);
+    }
+    return stdout.trim();
+  } catch (error2) {
+    if (captureErrorForSend) {
+      setLastSendError({
+        message: error2.message || String(error2),
+        stderr: error2.stderr ?? void 0,
+        stdout: error2.stdout ?? void 0,
+        code: error2.code ?? void 0
+      });
+    }
+    if (error2.code === "ENOENT") {
+      throw new Error("osascript not found. This tool requires macOS.");
+    }
+    if (error2.stderr) {
+      throw new Error(`AppleScript error: ${error2.stderr}`);
+    }
+    throw error2;
+  }
+}
+function appleScriptEscape(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+async function sendMessageAlt(recipient, message) {
+  if (MOCK) return mockSend(message, { chatIdentifier: recipient });
+  const escapedRecipient = appleScriptEscape(recipient);
+  const escapedMessage = appleScriptEscape(message);
+  const script = `
+    tell application "Messages"
+      send "${escapedMessage}" to buddy "${escapedRecipient}" of (service 1 whose service type is iMessage)
+    end tell
+  `;
+  try {
+    await runAppleScript(script, true);
+    return { success: true, timestamp: /* @__PURE__ */ new Date() };
+  } catch (_error) {
+    return sendSMS(recipient, message);
+  }
+}
+async function sendSMS(phoneNumber, message) {
+  if (MOCK) return mockSend(message, { chatIdentifier: phoneNumber });
+  const escapedPhone = appleScriptEscape(phoneNumber);
+  const escapedMessage = appleScriptEscape(message);
+  const script = `
+    tell application "Messages"
+      send "${escapedMessage}" to buddy "${escapedPhone}" of (service 1 whose service type is SMS)
+    end tell
+  `;
+  try {
+    await runAppleScript(script, true);
+    return { success: true, timestamp: /* @__PURE__ */ new Date() };
+  } catch (error2) {
+    return { success: false, error: error2.message || String(error2) };
+  }
+}
+async function sendToChat(chatName, message) {
+  if (MOCK) return mockSend(message, { chatIdentifier: chatName });
+  const escapedName = appleScriptEscape(chatName);
+  const escapedMessage = appleScriptEscape(message);
+  const script = `
+    tell application "Messages"
+      send "${escapedMessage}" to chat "${escapedName}"
+    end tell
+  `;
+  try {
+    await runAppleScript(script, true);
+    return { success: true, timestamp: /* @__PURE__ */ new Date() };
+  } catch (error2) {
+    return { success: false, error: error2.message || String(error2) };
+  }
+}
+async function sendToChatId(chatId, message) {
+  if (MOCK) return mockSend(message, { chatGuid: chatId });
+  const escapedId = appleScriptEscape(chatId);
+  const escapedMessage = appleScriptEscape(message);
+  const script = `
+    tell application "Messages"
+      send "${escapedMessage}" to text chat id "${escapedId}"
+    end tell
+  `;
+  try {
+    await runAppleScript(script, true);
+    return { success: true, timestamp: /* @__PURE__ */ new Date() };
+  } catch (error2) {
+    return { success: false, error: error2.message || String(error2) };
+  }
+}
+async function checkMessagesAvailable() {
+  if (MOCK) return true;
+  const script = `
+    tell application "System Events"
+      return exists application process "Messages"
+    end tell
+  `;
+  try {
+    const result = await runAppleScript(script);
+    return result === "true";
+  } catch {
+    return false;
+  }
+}
+async function sendMessageReliable(recipient, message) {
+  if (MOCK) return mockSend(message, { chatIdentifier: recipient });
+  const tmpFile = join(tmpdir(), `imsg-send-${randomBytes(8).toString("hex")}.txt`);
+  try {
+    writeFileSync(tmpFile, message, { encoding: "utf8" });
+  } catch (error2) {
+    return { success: false, error: `Failed to stage send payload: ${error2.message ?? error2}` };
+  }
+  const escapedRecipient = appleScriptEscape(recipient);
+  const escapedPath = appleScriptEscape(tmpFile);
+  const phoneFallback = isPhoneLike(recipient);
+  const script = phoneFallback ? `
+      tell application "Messages"
+        set msgBody to read (POSIX file "${escapedPath}") as «class utf8»
+        try
+          set iSvc to 1st account whose service type = iMessage
+          send msgBody to participant "${escapedRecipient}" of iSvc
+          return "iMessage"
+        on error
+          set sSvc to 1st account whose service type = SMS
+          send msgBody to participant "${escapedRecipient}" of sSvc
+          return "SMS"
+        end try
+      end tell
+    ` : `
+      tell application "Messages"
+        set msgBody to read (POSIX file "${escapedPath}") as «class utf8»
+        set iSvc to 1st account whose service type = iMessage
+        send msgBody to participant "${escapedRecipient}" of iSvc
+        return "iMessage"
+      end tell
+    `;
+  try {
+    const service = await runAppleScript(script, true);
+    return {
+      success: true,
+      timestamp: /* @__PURE__ */ new Date(),
+      service: service === "SMS" || service === "iMessage" ? service : void 0
+    };
+  } catch (error2) {
+    return { success: false, error: error2.message || String(error2) };
+  } finally {
+    try {
+      unlinkSync(tmpFile);
+    } catch {
+    }
+  }
+}
+async function sendAttachment(recipient, filepath) {
+  if (MOCK) return mockSend(`[attachment:${filepath}]`, { chatIdentifier: recipient });
+  const escapedRecipient = appleScriptEscape(recipient);
+  const escapedPath = appleScriptEscape(filepath);
+  const phoneFallback = isPhoneLike(recipient);
+  const script = phoneFallback ? `
+      tell application "Messages"
+        try
+          set iSvc to 1st account whose service type = iMessage
+          send (POSIX file "${escapedPath}") to participant "${escapedRecipient}" of iSvc
+          return "iMessage"
+        on error
+          set sSvc to 1st account whose service type = SMS
+          send (POSIX file "${escapedPath}") to participant "${escapedRecipient}" of sSvc
+          return "SMS"
+        end try
+      end tell
+    ` : `
+      tell application "Messages"
+        set iSvc to 1st account whose service type = iMessage
+        send (POSIX file "${escapedPath}") to participant "${escapedRecipient}" of iSvc
+        return "iMessage"
+      end tell
+    `;
+  try {
+    const service = await runAppleScript(script, true);
+    return {
+      success: true,
+      timestamp: /* @__PURE__ */ new Date(),
+      service: service === "SMS" || service === "iMessage" ? service : void 0
+    };
+  } catch (error2) {
+    return { success: false, error: error2.message || String(error2) };
+  }
+}
+async function checkImessageAvailability(handle) {
+  if (MOCK) {
+    return { service: "iMessage", reachable: true };
+  }
+  const escaped = appleScriptEscape(handle);
+  const script = `
+    tell application "Messages"
+      try
+        set b to buddy "${escaped}" of (1st account whose service type is iMessage)
+        return "iMessage"
+      on error
+        try
+          set b to buddy "${escaped}" of (1st account whose service type is SMS)
+          return "SMS"
+        on error
+          return "unknown"
+        end try
+      end try
+    end tell
+  `;
+  try {
+    const result = await runAppleScript(script);
+    if (result === "iMessage" || result === "SMS") {
+      return { service: result, reachable: true };
+    }
+    return {
+      service: "unknown",
+      reachable: false,
+      hint: isPhoneLike(handle) ? "Handle not found in iMessage or SMS buddies. Verify the number format (try '+1...' for US) and that the recipient has at least one of iMessage or SMS reachable." : "Handle not found in iMessage buddies. For email addresses, the recipient must have iMessage active on that address."
+    };
+  } catch (error2) {
+    return {
+      service: "unknown",
+      reachable: false,
+      hint: `Availability check failed: ${error2.message ?? error2}. Most common cause: Messages.app Automation permission is not granted to this terminal/IDE.`
+    };
+  }
+}
+function inspectSqlite(path) {
+  const db = new Database(path, { readonly: true, fileMustExist: true });
+  try {
+    db.pragma("schema_version");
+    return null;
+  } finally {
+    db.close();
+  }
+}
+function classifyDbError(error2) {
+  const message = error2 instanceof Error ? error2.message : String(error2);
+  if (/operation not permitted/i.test(message) || /authorization denied/i.test(message)) {
+    return [
+      "Full Disk Access is missing for the app running this command.",
+      "Grant Full Disk Access to Terminal, iTerm2, Warp, VS Code, Cursor, or whichever app is launching imsg-mcp, then fully restart that app.",
+      "Open System Settings -> Privacy & Security -> Full Disk Access."
+    ].join(" ");
+  }
+  if (/unable to open database file/i.test(message) || /no such file/i.test(message)) {
+    return "Database file was not found at the configured path.";
+  }
+  return message;
+}
+function iconFor(status) {
+  if (status === "ok") return "OK";
+  if (status === "warn") return "WARN";
+  return "ERR";
+}
+async function checkLocalAccess() {
+  const items = [];
+  items.push({
+    key: "platform",
+    label: "Platform",
+    status: process.platform === "darwin" ? "ok" : "error",
+    detail: process.platform === "darwin" ? `Running on macOS ${os.release()}` : `Running on ${process.platform}; live iMessage access only works on macOS.`
+  });
+  const imsgDbPath = getImsgDbPath();
+  if (!existsSync(imsgDbPath)) {
+    items.push({
+      key: "messages-db",
+      label: "Messages DB",
+      status: "error",
+      detail: `Missing ${imsgDbPath}`
+    });
+  } else {
+    try {
+      const error2 = inspectSqlite(imsgDbPath);
+      items.push({
+        key: "messages-db",
+        label: "Messages DB",
+        status: error2 ? "error" : "ok",
+        detail: error2 ? classifyDbError(error2) : `Readable at ${imsgDbPath}`
+      });
+    } catch (error2) {
+      items.push({
+        key: "messages-db",
+        label: "Messages DB",
+        status: "error",
+        detail: classifyDbError(error2)
+      });
+    }
+  }
+  const contactPaths = getContactsDbPaths() ?? [];
+  const existingContactPaths = contactPaths.filter((path) => existsSync(path));
+  if (existingContactPaths.length === 0) {
+    items.push({
+      key: "contacts-db",
+      label: "Contacts DB",
+      status: "warn",
+      detail: "No readable Address Book database was found. Message reads still work, but names may stay as raw phone numbers or emails."
+    });
+  } else {
+    const failures = [];
+    for (const path of existingContactPaths) {
+      try {
+        inspectSqlite(path);
+      } catch (error2) {
+        failures.push(`${path}: ${classifyDbError(error2)}`);
+      }
+    }
+    items.push({
+      key: "contacts-db",
+      label: "Contacts DB",
+      status: failures.length === 0 ? "ok" : "warn",
+      detail: failures.length === 0 ? `Readable at ${existingContactPaths.join(", ")}` : `Some contact databases are unreadable. ${failures.join(" ")}`
+    });
+  }
+  const messagesRunning = await checkMessagesAvailable().catch(() => false);
+  items.push({
+    key: "messages-app",
+    label: "Messages.app",
+    status: messagesRunning ? "ok" : "warn",
+    detail: messagesRunning ? "Messages.app is running." : "Messages.app is not running. Reading still works, but sending requires Messages.app to be open."
+  });
+  return {
+    ok: items.every((item) => item.status !== "error"),
+    items
+  };
+}
+function formatAccessReport(report) {
+  const lines = ["imsg-mcp doctor", ""];
+  for (const item of report.items) {
+    lines.push(`${iconFor(item.status)}  ${item.label}`);
+    lines.push(`    ${item.detail}`);
+  }
+  lines.push("");
+  lines.push(
+    report.ok ? "Environment looks ready for local message reads." : "Fix the ERR items above, then rerun `imsg doctor`."
+  );
+  return lines.join("\n");
+}
+const registry = /* @__PURE__ */ new Set();
+let shuttingDown = false;
+let watchdogTimer = null;
+function registerCleanup(fn) {
+  registry.add(fn);
+}
+async function shutdown(exitCode = 0) {
+  if (shuttingDown) {
+    setTimeout(() => process.exit(exitCode), 3e3).unref();
+    return new Promise(() => {
+    });
+  }
+  shuttingDown = true;
+  if (watchdogTimer) {
+    clearInterval(watchdogTimer);
+    watchdogTimer = null;
+  }
+  for (const fn of registry) {
+    try {
+      await fn();
+    } catch {
+    }
+  }
+  registry.clear();
+  process.exit(exitCode);
+}
+function syncCleanup() {
+  for (const fn of registry) {
+    try {
+      const result = fn();
+      if (result && typeof result.catch === "function") {
+        result.catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+}
+function installShutdownHandlers() {
+  const onSignal = (signal) => {
+    try {
+      appendLog("info", "signal_received", { signal });
+    } catch {
+    }
+    shutdown(signal === "SIGINT" ? 130 : 0);
+  };
+  for (const sig of ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"]) {
+    process.on(sig, () => onSignal(sig));
+  }
+  process.on("exit", syncCleanup);
+}
+function enableStdinEofDetection() {
+  process.stdin.on("end", () => {
+    if (!shuttingDown) shutdown(0);
+  });
+  process.stdin.resume();
+}
+function enableOrphanWatchdog(intervalMs = 5e3) {
+  if (watchdogTimer) return;
+  const parentPid = process.ppid;
+  watchdogTimer = setInterval(() => {
+    if (process.ppid === 1 || process.ppid !== parentPid) {
+      shutdown(0);
+    }
+  }, intervalMs);
+  watchdogTimer.unref();
+}
+function isShuttingDown() {
+  return shuttingDown;
+}
+export {
+  stopHeapMonitor as A,
+  getLogFilePath as B,
+  getLastSendError as C,
+  isShuttingDown as D,
+  warn as E,
+  error as F,
+  AssociatedMessageType as G,
+  macTimestampToDate as H,
+  isReactionType as I,
+  parseAssociatedMessageGuid as J,
+  config as K,
+  MAC_EPOCH_OFFSET as M,
+  NANOS_PER_SECOND as N,
+  OBJECT_REPLACEMENT_CHAR as O,
+  Tables as T,
+  getContactsDbPaths as a,
+  getSlugsDbPath as b,
+  checkLocalAccess as c,
+  appendLog as d,
+  getFileLogLines 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,
+  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,
+  logShutdown as z
+};
+//# sourceMappingURL=shutdown-B9ClCyco.js.map