imessage-mcp-server 1.0.0 → 2.0.0

package/src/safety.js

@@ -0,0 +1,58 @@
+import { LOG } from "./shared/utils.js";
+
+export function isToolAllowed(toolName, safety) {
+  if (safety.readOnly && isWriteTool(toolName)) {
+    return false;
+  }
+  if (safety.allowedTools && !safety.allowedTools.includes(toolName)) {
+    return false;
+  }
+  if (safety.blockedTools && safety.blockedTools.includes(toolName)) {
+    return false;
+  }
+  return true;
+}
+
+function isWriteTool(toolName) {
+  const writeTools = new Set([
+    "run_shell_command",
+    "shell",
+    "execute_command",
+    "write_file",
+    "edit_file",
+    "delete_file",
+  ]);
+  return writeTools.has(toolName);
+}
+
+export function isCommandBlocked(command, blockedPatterns) {
+  if (!command || !blockedPatterns || blockedPatterns.length === 0) return false;
+  for (const pattern of blockedPatterns) {
+    const regex = new RegExp(pattern, "i");
+    if (regex.test(command)) {
+      LOG.warn("Blocked command matched", { command, pattern });
+      return true;
+    }
+  }
+  return false;
+}
+
+export async function requestConfirmation(text, replyFn) {
+  try {
+    await replyFn(`⚠️ 请求确认：\n${text}\n\n回复 "确认" 以继续执行。`);
+    // In a real implementation, this would wait for the user's reply.
+    // For now, we return false to be safe; the daemon can implement polling.
+    return false;
+  } catch (err) {
+    LOG.error("Failed to send confirmation request", { error: err.message });
+    return false;
+  }
+}
+
+export function sanitizeForLogging(input) {
+  const clone = { ...input };
+  if (clone.apiKey) clone.apiKey = "***";
+  if (clone.password) clone.password = "***";
+  if (clone.token) clone.token = "***";
+  return clone;
+}

package/src/server/index.js

@@ -0,0 +1,45 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { DEFAULTS } from "../shared/constants.js";
+import { TOOLS } from "./tools.js";
+
+export async function startServer() {
+  const server = new Server(
+    {
+      name: DEFAULTS.SERVER.name,
+      version: DEFAULTS.SERVER.version,
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: Object.entries(TOOLS).map(([name, tool]) => ({
+        name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+      })),
+    };
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const tool = TOOLS[name];
+    if (!tool) {
+      throw new Error(`Unknown tool: ${name}`);
+    }
+    return tool.handler(args ?? {});
+  });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("iMessage MCP Server running on stdio");
+}

package/src/server/tools.js

@@ -0,0 +1,163 @@
+import {
+  sendMessage,
+  listConversations,
+  readConversation,
+  getNewMessages,
+} from "../shared/imessage.js";
+
+export const TOOLS = {
+  send_imessage: {
+    description: "Send an iMessage to a recipient's email or phone number",
+    inputSchema: {
+      type: "object",
+      properties: {
+        recipient: {
+          type: "string",
+          description: "Recipient iMessage account (email or phone number)",
+        },
+        text: {
+          type: "string",
+          description: "Message text to send",
+        },
+      },
+      required: ["recipient", "text"],
+    },
+    handler: (args) => {
+      const result = sendMessage(args.recipient, args.text);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+      };
+    },
+  },
+
+  list_conversations: {
+    description:
+      "List recent iMessage conversations with their latest message preview and unread count",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Max conversations to return (default 20)",
+          default: 20,
+        },
+      },
+    },
+    handler: (args) => {
+      const conversations = listConversations(args.limit ?? 20);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(conversations, null, 2),
+          },
+        ],
+      };
+    },
+  },
+
+  read_conversation: {
+    description:
+      "Read messages from a specific conversation by chat_id or handle (email/phone). Returns paginated messages.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        handle: {
+          type: "string",
+          description:
+            "Filter by handle (email or phone number of the conversation partner)",
+        },
+        chat_id: {
+          type: "number",
+          description: "Filter by chat ROWID",
+        },
+        limit: {
+          type: "number",
+          description: "Max messages to return (default 30)",
+          default: 30,
+        },
+        before_id: {
+          type: "number",
+          description:
+            "Return messages before this ROWID (for pagination/older messages)",
+        },
+        include_read: {
+          type: "boolean",
+          description: "Include already-read messages (default true)",
+          default: true,
+        },
+        unread_only: {
+          type: "boolean",
+          description: "Only return unread messages (default false)",
+          default: false,
+        },
+      },
+    },
+    handler: (args) => {
+      const result = readConversation({
+        handle: args.handle,
+        chat_id: args.chat_id,
+        limit: args.limit ?? 30,
+        before_id: args.before_id,
+        include_read: args.include_read !== false,
+        unread_only: args.unread_only === true,
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2),
+          },
+        ],
+      };
+    },
+  },
+
+  get_new_messages: {
+    description:
+      "Get recently received messages since a given timestamp. Use this to poll for new incoming iMessages.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        since: {
+          type: "string",
+          description:
+            "ISO timestamp to fetch messages from (e.g., '2026-06-28T10:00:00.000Z'). If omitted, returns last 10 messages.",
+        },
+        max_results: {
+          type: "number",
+          description: "Max messages to return (default 10)",
+          default: 10,
+        },
+        unread_only: {
+          type: "boolean",
+          description: "Only return unread messages (default false)",
+          default: false,
+        },
+      },
+    },
+    handler: (args) => {
+      const messages = getNewMessages({
+        since: args.since,
+        max_results: args.max_results ?? 10,
+        unread_only: args.unread_only === true,
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                total: messages.length,
+                has_unread: messages.some((m) => !m.is_read),
+                messages,
+              },
+              null,
+              2
+            ),
+          },
+        ],
+      };
+    },
+  },
+};

package/src/shared/constants.js

@@ -0,0 +1,30 @@
+import { homedir } from "os";
+import { resolve } from "path";
+
+// Apple Cocoa epoch: 2001-01-01 00:00:00 UTC
+export const COCOA_EPOCH_OFFSET_S = 978_307_200;
+
+// Default iMessage SQLite database path
+export const DEFAULT_DB_PATH = resolve(
+  homedir(),
+  "Library/Messages/chat.db"
+);
+
+// Runtime path override via environment
+export const DB_PATH = resolve(
+  process.env.IMESSAGE_DB_PATH || DEFAULT_DB_PATH
+);
+
+export const DEFAULTS = {
+  SERVER: {
+    name: "imessage-mcp",
+    version: "2.0.0",
+  },
+  BRIDGE: {
+    pollIntervalMs: 3000,
+    maxHistoryPerConversation: 20,
+    maxToolIterations: 10,
+    maxTokens: 4096,
+    sendProcessingIndicator: true,
+  },
+};

package/src/shared/imessage.js

@@ -0,0 +1,277 @@
+import Database from "better-sqlite3";
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { COCOA_EPOCH_OFFSET_S, DB_PATH } from "./constants.js";
+import { cocoaDateToISO } from "./utils.js";
+
+export function validateDbPath() {
+  if (!existsSync(DB_PATH)) {
+    console.error("❌ iMessage database not found at: " + DB_PATH);
+    console.error("   Make sure you are signed into iMessage on this Mac.");
+    console.error(
+      "   If the database is elsewhere, set IMESSAGE_DB_PATH to its location."
+    );
+    process.exit(1);
+  }
+}
+
+export function openDb(options = {}) {
+  validateDbPath();
+  const db = new Database(DB_PATH, {
+    readonly: options.readonly !== false,
+    fileMustExist: true,
+  });
+  db.pragma("journal_mode = WAL");
+  if (options.queryOnly) {
+    db.pragma("query_only = true");
+  }
+  return db;
+}
+
+export function sendMessage(recipient, text) {
+  const escaped = text.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+  const script = `tell application "Messages" to send "${escaped}" to buddy "${recipient}"`;
+  execSync(`osascript -e '${script}'`, {
+    encoding: "utf-8",
+    timeout: 15_000,
+  });
+  return { success: true, recipient, text };
+}
+
+export function listConversations(limit = 20) {
+  const db = openDb();
+  const rows = db
+    .prepare(
+      `
+      SELECT
+        c.ROWID AS chat_id,
+        c.display_name,
+        c.chat_identifier,
+        c.service_name,
+        h.id AS handle_id_str,
+        m.ROWID AS last_msg_id,
+        m.text AS last_msg_text,
+        m.date AS last_msg_date,
+        m.is_from_me AS last_msg_from_me,
+        (SELECT COUNT(*) FROM message
+         WHERE handle_id = h.ROWID
+           AND is_read = 0 AND is_from_me = 0
+           AND is_finished = 1
+        ) AS unread_count
+      FROM chat c
+      JOIN chat_handle_join chj ON chj.chat_id = c.ROWID
+      JOIN handle h ON h.ROWID = chj.handle_id
+      LEFT JOIN (
+        SELECT cmj.chat_id, MAX(m.ROWID) AS max_msg_id
+        FROM chat_message_join cmj
+        JOIN message m ON m.ROWID = cmj.message_id
+        GROUP BY cmj.chat_id
+      ) latest ON latest.chat_id = c.ROWID
+      LEFT JOIN message m ON m.ROWID = latest.max_msg_id
+      ORDER BY COALESCE(m.date, 0) DESC
+      LIMIT ?
+    `
+    )
+    .all(Math.min(limit, 100));
+  db.close();
+
+  return rows.map((r) => ({
+    chat_id: r.chat_id,
+    display_name: r.display_name || r.chat_identifier || r.handle_id_str,
+    handle: r.handle_id_str,
+    service: r.service_name,
+    unread_count: r.unread_count || 0,
+    last_message: r.last_msg_text
+      ? {
+          text: r.last_msg_text.substring(0, 200),
+          date: cocoaDateToISO(r.last_msg_date),
+          is_from_me: !!r.last_msg_from_me,
+        }
+      : null,
+  }));
+}
+
+export function readConversation({
+  handle,
+  chat_id,
+  limit = 30,
+  before_id,
+  include_read = true,
+  unread_only = false,
+}) {
+  const db = openDb();
+  let where = "WHERE 1=1";
+  const params = [];
+
+  if (handle) {
+    where += " AND h.id = ?";
+    params.push(handle);
+  }
+  if (chat_id) {
+    where += " AND cmj.chat_id = ?";
+    params.push(chat_id);
+  }
+  if (before_id) {
+    where += " AND m.ROWID < ?";
+    params.push(before_id);
+  }
+  if (unread_only) {
+    where += " AND m.is_read = 0 AND m.is_from_me = 0 AND m.is_finished = 1";
+  } else if (!include_read) {
+    where += " AND m.is_read = 0 AND m.is_from_me = 0";
+  }
+
+  const rows = db
+    .prepare(
+      `
+      SELECT
+        m.ROWID,
+        m.text,
+        m.is_from_me,
+        m.is_read,
+        m.is_delivered,
+        m.date,
+        m.service,
+        m.date_read,
+        m.date_delivered,
+        h.id AS handle_id_str,
+        c.ROWID AS chat_id,
+        COALESCE(c.display_name, c.chat_identifier) AS chat_name
+      FROM message m
+      JOIN chat_message_join cmj ON cmj.message_id = m.ROWID
+      JOIN chat c ON c.ROWID = cmj.chat_id
+      LEFT JOIN handle h ON h.ROWID = m.handle_id
+      ${where}
+      ORDER BY m.date DESC
+      LIMIT ?
+    `
+    )
+    .all(...params, Math.min(limit, 200));
+  db.close();
+
+  const messages = rows
+    .map((r) => ({
+      id: r.ROWID,
+      chat_id: r.chat_id,
+      chat_name: r.chat_name,
+      text: r.text,
+      from_me: !!r.is_from_me,
+      from: r.is_from_me ? "me" : r.handle_id_str,
+      is_read: !!r.is_read,
+      is_delivered: !!r.is_delivered,
+      service: r.service,
+      date: cocoaDateToISO(r.date),
+      date_read: cocoaDateToISO(r.date_read),
+      date_delivered: cocoaDateToISO(r.date_delivered),
+    }))
+    .reverse();
+
+  return {
+    chat_id: rows[0]?.chat_id ?? null,
+    chat_name: rows[0]?.chat_name ?? null,
+    total: messages.length,
+    messages,
+  };
+}
+
+export function getNewMessages({ since, max_results = 10, unread_only = false }) {
+  const db = openDb();
+  let where = "WHERE m.is_from_me = 0 AND m.is_finished = 1";
+
+  if (since) {
+    const d = new Date(since);
+    if (!isNaN(d.getTime())) {
+      const cocoaNs = (d.getTime() / 1000 - COCOA_EPOCH_OFFSET_S) * 1_000_000_000;
+      where += ` AND m.date > ${Math.floor(cocoaNs)}`;
+    }
+  }
+
+  if (unread_only) {
+    where += " AND m.is_read = 0";
+  }
+
+  const rows = db
+    .prepare(
+      `
+      SELECT
+        m.ROWID,
+        m.text,
+        m.is_from_me,
+        m.is_read,
+        m.is_delivered,
+        m.date,
+        m.service,
+        h.id AS handle_id_str,
+        c.ROWID AS chat_id,
+        COALESCE(c.display_name, c.chat_identifier) AS chat_name
+      FROM message m
+      JOIN chat_message_join cmj ON cmj.message_id = m.ROWID
+      JOIN chat c ON c.ROWID = cmj.chat_id
+      LEFT JOIN handle h ON h.ROWID = m.handle_id
+      ${where}
+      ORDER BY m.date DESC
+      LIMIT ?
+    `
+    )
+    .all(Math.min(max_results, 100));
+  db.close();
+
+  return rows.map((r) => ({
+    id: r.ROWID,
+    chat_id: r.chat_id,
+    chat_name: r.chat_name,
+    text: r.text,
+    from: r.handle_id_str,
+    is_read: !!r.is_read,
+    is_delivered: !!r.is_delivered,
+    service: r.service,
+    date: cocoaDateToISO(r.date),
+  }));
+}
+
+// ─── Bridge-specific helpers ────────────────────────────────────────────────
+
+export function getMasterHandleId(db, masterHandle) {
+  const row = db.prepare("SELECT ROWID FROM handle WHERE id = ?").get(masterHandle);
+  return row?.ROWID;
+}
+
+export function getLatestMessageId(db) {
+  const row = db.prepare("SELECT MAX(ROWID) as max_id FROM message").get();
+  return row?.max_id || 0;
+}
+
+export function getChatName(db, chatId) {
+  const row = db
+    .prepare(
+      `
+      SELECT COALESCE(c.display_name, c.chat_identifier, h.id) AS name
+      FROM chat c
+      LEFT JOIN chat_handle_join chj ON chj.chat_id = c.ROWID
+      LEFT JOIN handle h ON h.ROWID = chj.handle_id
+      WHERE c.ROWID = ?
+      LIMIT 1
+    `
+    )
+    .get(chatId);
+  return row?.name || `chat_${chatId}`;
+}
+
+export function getNewMessagesForBridge(db, handleId, lastId) {
+  return db
+    .prepare(
+      `
+      SELECT m.ROWID, m.text, m.date, cmj.chat_id
+      FROM message m
+      JOIN chat_message_join cmj ON cmj.message_id = m.ROWID
+      WHERE m.is_from_me = 0
+        AND m.handle_id = ?
+        AND m.ROWID > ?
+        AND m.is_finished = 1
+        AND m.text IS NOT NULL
+        AND m.text != ''
+      ORDER BY m.ROWID ASC
+    `
+    )
+    .all(handleId, lastId || 0);
+}

package/src/shared/utils.js

@@ -0,0 +1,54 @@
+import { COCOA_EPOCH_OFFSET_S } from "./constants.js";
+
+export function cocoaDateToISO(cocoaNs) {
+  if (!cocoaNs || cocoaNs <= 0) return null;
+  const unixMs = (cocoaNs / 1_000_000_000 + COCOA_EPOCH_OFFSET_S) * 1000;
+  return new Date(unixMs).toISOString();
+}
+
+export function isoToCocoaNs(isoString) {
+  const d = new Date(isoString);
+  if (isNaN(d.getTime())) return null;
+  return Math.floor((d.getTime() / 1000 - COCOA_EPOCH_OFFSET_S) * 1_000_000_000);
+}
+
+export function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function log(level, msg, data = null) {
+  const ts = new Date().toISOString();
+  const line = data
+    ? `[${ts}] [${level}] ${msg} ${JSON.stringify(data)}`
+    : `[${ts}] [${level}] ${msg}`;
+  console.error(line);
+}
+
+export const LOG = {
+  info: (m, d) => log("INFO", m, d),
+  warn: (m, d) => log("WARN", m, d),
+  error: (m, d) => log("ERROR", m, d),
+  debug: (m, d) => log("DEBUG", m, d),
+};
+
+export function truncate(str, maxLen = 5000, suffix = "\n\n... (truncated)") {
+  if (!str || str.length <= maxLen) return str;
+  return str.substring(0, maxLen) + suffix;
+}
+
+export function splitLongReply(text, maxPartLen = 300) {
+  if (text.length <= maxPartLen) return [text];
+  const sentences = text.split(/(?<=[。！？\n])/);
+  const parts = [];
+  let current = "";
+  for (const s of sentences) {
+    if (current.length + s.length > maxPartLen && current.length > 0) {
+      parts.push(current.trim());
+      current = s;
+    } else {
+      current += s;
+    }
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts.length ? parts : [text.substring(0, maxPartLen)];
+}