imessage-mcp-server 1.0.0 → 2.0.0

package/package.json

@@ -1,34 +1,42 @@
 {
   "name": "imessage-mcp-server",
-  "version": "1.0.0",
-  "description": "MCP server for reading and sending iMessages on macOS",
+  "version": "2.0.0",
+  "description": "MCP server and AI bridge for iMessage on macOS",
   "type": "module",
-  "main": "index.js",
   "bin": {
-    "imessage-mcp-server": "./index.js"
+    "imessage-mcp-server": "./bin/imessage-mcp-server"
   },
   "publishConfig": {
     "access": "public"
   },
   "files": [
-    "index.js",
+    "bin/",
+    "src/",
+    "scripts/",
     "README.md",
+    "README.zh.md",
     "LICENSE"
   ],
   "preferUnplugged": true,
   "scripts": {
-    "start": "node index.js",
+    "start": "node bin/imessage-mcp-server --server",
+    "bridge": "node bin/imessage-mcp-server --bridge",
     "test": "echo \"No tests yet\" && exit 0"
   },
   "keywords": [
     "imessage",
+    "imessage-mcp",
+    "imessage-mcp-server",
     "mcp",
     "mcp-server",
     "model-context-protocol",
     "macos",
     "messages",
     "icloud",
-    "apple"
+    "apple",
+    "ai",
+    "bridge",
+    "agent"
   ],
   "author": "tinyxia",
   "license": "MIT",
@@ -44,7 +52,9 @@
     "url": "https://github.com/tinyxia/imessage-mcp/issues"
   },
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.30.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "better-sqlite3": "^12.11.1"
+    "better-sqlite3": "^12.11.1",
+    "openai": "^4.0.0"
   }
 }

package/scripts/install-launchagent.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+# Install iMessage Bridge as macOS LaunchAgent (auto-start on login)
+#
+# Usage:
+#   install-launchagent.sh [load|unload|status] [config-path]
+
+set -e
+
+PLIST="com.inddaily.imessage-mcp-server.bridge.plist"
+LAUNCH_AGENTS_DIR="$HOME/Library/LaunchAgents"
+DEST="$LAUNCH_AGENTS_DIR/$PLIST"
+LOG_DIR="$HOME/Library/Logs"
+CONFIG_PATH="${2:-}"
+
+# Determine how to run the bridge.
+# Prefer npx if available, otherwise fall back to node with this package path.
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PACKAGE_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+if command -v npx >/dev/null 2>&1; then
+  RUN_COMMAND="npx"
+  RUN_ARGS="-y imessage-mcp-server"
+else
+  RUN_COMMAND="node"
+  RUN_ARGS="$PACKAGE_DIR/bin/imessage-mcp-server"
+fi
+
+case "${1:-load}" in
+  load)
+    echo "📦 Installing iMessage Bridge LaunchAgent..."
+    mkdir -p "$LAUNCH_AGENTS_DIR"
+    mkdir -p "$LOG_DIR"
+
+    cat > "$DEST" <<EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.inddaily.imessage-mcp-server.bridge</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>$RUN_COMMAND</string>
+EOF
+
+    for arg in $RUN_ARGS; do
+      echo "    <string>$arg</string>" >> "$DEST"
+    done
+
+    echo "    <string>--bridge</string>" >> "$DEST"
+    if [ -n "$CONFIG_PATH" ]; then
+      echo "    <string>--config</string>" >> "$DEST"
+      echo "    <string>$CONFIG_PATH</string>" >> "$DEST"
+    fi
+
+    cat >> "$DEST" <<EOF
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>$LOG_DIR/imessage-mcp-server-bridge.log</string>
+  <key>StandardErrorPath</key>
+  <string>$LOG_DIR/imessage-mcp-server-bridge.log</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin</string>
+  </dict>
+</dict>
+</plist>
+EOF
+
+    launchctl load "$DEST" || launchctl bootstrap gui/"$(id -u)" "$DEST"
+    echo "✅ Installed and started!"
+    echo "  Log: $LOG_DIR/imessage-mcp-server-bridge.log"
+    echo "  Stop: launchctl unload $DEST"
+    ;;
+  unload)
+    echo "🗑️  Uninstalling iMessage Bridge..."
+    launchctl unload "$DEST" 2>/dev/null || true
+    rm -f "$DEST"
+    echo "✅ Uninstalled"
+    ;;
+  status)
+    if launchctl list | grep -q "com.inddaily.imessage-mcp-server.bridge"; then
+      echo "🟢 Running"
+      launchctl list | grep com.inddaily.imessage-mcp-server.bridge
+    else
+      echo "🔴 Not running"
+    fi
+    ;;
+  *)
+    echo "Usage: $0 [load|unload|status] [config-path]"
+    exit 1
+    ;;
+esac

package/src/bridge/daemon.js

@@ -0,0 +1,243 @@
+import fs from "fs";
+import path from "path";
+import { homedir } from "os";
+import {
+  openDb,
+  getMasterHandleId,
+  getNewMessagesForBridge,
+  sendMessage,
+} from "../shared/imessage.js";
+import { LOG, sleep } from "../shared/utils.js";
+import { LlmLoop } from "./llm-loop.js";
+
+const STATE_DIR = path.join(homedir(), ".imessage-mcp-server");
+const STATE_PATH = path.join(STATE_DIR, "bridge-state.json");
+
+export class BridgeDaemon {
+  constructor(config, mcpManager) {
+    this.config = config;
+    this.mcpManager = mcpManager;
+    this.llmLoop = new LlmLoop(config, mcpManager);
+    this.state = this.loadState();
+    this.shutdownRequested = false;
+    this.processing = false;
+
+    process.on("SIGINT", () => this.requestShutdown("SIGINT"));
+    process.on("SIGTERM", () => this.requestShutdown("SIGTERM"));
+  }
+
+  requestShutdown(signal) {
+    LOG.info(`Received ${signal}, shutting down...`);
+    this.shutdownRequested = true;
+  }
+
+  loadState() {
+    try {
+      return JSON.parse(fs.readFileSync(STATE_PATH, "utf-8"));
+    } catch {
+      return {
+        lastProcessedId: {},
+        conversations: {},
+        initialized: false,
+      };
+    }
+  }
+
+  saveState() {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+    const cleaned = { ...this.state };
+    for (const [chatId, msgs] of Object.entries(cleaned.conversations || {})) {
+      const max = 50;
+      if (msgs.length > max) {
+        cleaned.conversations[chatId] = msgs.slice(msgs.length - max);
+      }
+    }
+    fs.writeFileSync(STATE_PATH, JSON.stringify(cleaned, null, 2));
+  }
+
+  async run() {
+    LOG.info("Starting iMessage Bridge Daemon", {
+      masterHandle: this.config.masterHandle,
+      provider: this.config.provider,
+      model: this.config.model,
+    });
+
+    await this.mcpManager.connectAll();
+
+    if (!this.state.initialized) {
+      await this.initializeState();
+    }
+
+    LOG.info("Entering polling loop...");
+
+    while (!this.shutdownRequested) {
+      try {
+        await this.pollCycle();
+      } catch (err) {
+        LOG.error("Poll cycle error", { error: err.message });
+      }
+      if (!this.shutdownRequested) {
+        await sleep(this.config.pollIntervalMs);
+      }
+    }
+
+    await this.mcpManager.close();
+    LOG.info("Daemon shut down gracefully");
+  }
+
+  async initializeState() {
+    const db = openDb();
+    try {
+      const handleId = getMasterHandleId(db, this.config.masterHandle);
+      if (!handleId) {
+        LOG.error("Master handle not found in chat.db", {
+          handle: this.config.masterHandle,
+        });
+        const handles = db.prepare("SELECT id FROM handle").all();
+        LOG.info("Available handles:");
+        for (const h of handles) LOG.info(`  - ${h.id}`);
+        process.exit(1);
+      }
+
+      if (Object.keys(this.state.lastProcessedId).length === 0) {
+        const chats = db
+          .prepare(
+            `
+            SELECT DISTINCT cmj.chat_id
+            FROM message m
+            JOIN chat_message_join cmj ON cmj.message_id = m.ROWID
+            WHERE m.handle_id = ?
+          `
+          )
+          .all(handleId);
+        for (const c of chats) {
+          const lastMsg = db
+            .prepare(
+              `
+              SELECT MAX(m.ROWID) as last_id
+              FROM message m
+              JOIN chat_message_join cmj ON cmj.message_id = m.ROWID
+              WHERE m.handle_id = ? AND cmj.chat_id = ?
+            `
+            )
+            .get(handleId, c.chat_id);
+          if (lastMsg?.last_id) {
+            this.state.lastProcessedId[String(c.chat_id)] = lastMsg.last_id;
+          }
+        }
+      }
+
+      this.state.initialized = true;
+      this.saveState();
+      LOG.info("Initialized: skipping existing messages", {
+        chatsTracked: Object.keys(this.state.lastProcessedId).length,
+      });
+    } finally {
+      db.close();
+    }
+  }
+
+  async pollCycle() {
+    const db = openDb();
+    try {
+      const handleId = getMasterHandleId(db, this.config.masterHandle);
+      if (!handleId) {
+        LOG.warn("Master handle not found, skipping poll");
+        return;
+      }
+
+      const chatIds = Object.keys(this.state.lastProcessedId);
+      let newMessages = [];
+
+      if (chatIds.length === 0) {
+        // First run - discover chats
+        const chats = db
+          .prepare(
+            `
+            SELECT DISTINCT cmj.chat_id
+            FROM message m
+            JOIN chat_message_join cmj ON cmj.message_id = m.ROWID
+            WHERE m.handle_id = ?
+          `
+          )
+          .all(handleId);
+        for (const c of chats) {
+          const lastMsg = db
+            .prepare(
+              `
+              SELECT MAX(m.ROWID) as last_id
+              FROM message m
+              JOIN chat_message_join cmj ON cmj.message_id = m.ROWID
+              WHERE m.handle_id = ? AND cmj.chat_id = ?
+            `
+            )
+            .get(handleId, c.chat_id);
+          if (lastMsg?.last_id) {
+            this.state.lastProcessedId[String(c.chat_id)] = lastMsg.last_id;
+          }
+        }
+        this.saveState();
+      } else {
+        for (const chatId of chatIds) {
+          const lastId = this.state.lastProcessedId[chatId] || 0;
+          const msgs = getNewMessagesForBridge(db, handleId, lastId);
+          newMessages.push(...msgs);
+        }
+      }
+
+      if (newMessages.length > 0 && !this.processing) {
+        this.processing = true;
+        LOG.info(`Found ${newMessages.length} new message(s)`);
+
+        for (const msg of newMessages) {
+          if (this.shutdownRequested) break;
+          try {
+            await this.processMessage(msg);
+            this.saveState();
+          } catch (err) {
+            LOG.error("Error processing message", {
+              msgId: msg.ROWID,
+              error: err.message,
+            });
+          }
+        }
+
+        this.processing = false;
+      } else if (newMessages.length > 0 && this.processing) {
+        LOG.debug("Still processing previous message, skipping poll cycle");
+      }
+    } finally {
+      db.close();
+    }
+  }
+
+  async processMessage(message) {
+    const { ROWID: msgId, text: userText, chat_id: chatId } = message;
+    LOG.info(`Processing message #${msgId}`, {
+      chatId,
+      text: userText.substring(0, 100),
+    });
+
+    if (this.config.sendProcessingIndicator) {
+      await this.reply("⏳ 收到，正在处理...");
+    }
+
+    const replyFn = (text) => this.reply(text);
+    await this.llmLoop.process(userText, this.state, chatId, replyFn);
+
+    this.state.lastProcessedId[String(chatId)] = msgId;
+    LOG.info(`Message #${msgId} processed successfully`);
+  }
+
+  async reply(text) {
+    try {
+      sendMessage(this.config.masterHandle, text);
+      LOG.info("Reply sent", {
+        length: text.length,
+        preview: text.substring(0, 60),
+      });
+    } catch (err) {
+      LOG.error("Failed to send reply", { error: err.message });
+    }
+  }
+}

package/src/bridge/index.js

@@ -0,0 +1,31 @@
+import { validateBridgeConfig, buildBridgeConfig } from "../config.js";
+import { McpClientManager } from "./mcp-client.js";
+import { BridgeDaemon } from "./daemon.js";
+import { LOG } from "../shared/utils.js";
+
+export async function startBridge(args) {
+  const config = buildBridgeConfig(args);
+  validateBridgeConfig(config);
+
+  const mcpManager = new McpClientManager(config.mcpServers);
+  const daemon = new BridgeDaemon(config, mcpManager);
+
+  if (args.testConfig) {
+    LOG.info("Testing bridge configuration...");
+    await mcpManager.connectAll();
+    const tools = mcpManager.getAllTools();
+    LOG.info("Configuration valid", {
+      provider: config.provider,
+      model: config.model,
+      mcpServers: Object.keys(config.mcpServers).length,
+      toolsAvailable: tools.length,
+    });
+    for (const t of tools) {
+      LOG.info(`  - ${t.name} (${t.serverId})`);
+    }
+    await mcpManager.close();
+    return;
+  }
+
+  await daemon.run();
+}

package/src/bridge/llm-loop.js

@@ -0,0 +1,232 @@
+import { sendMessage } from "../shared/imessage.js";
+import { LOG, sleep, splitLongReply } from "../shared/utils.js";
+import { isToolAllowed, isCommandBlocked } from "../safety.js";
+import { createProvider } from "../providers/index.js";
+
+export class LlmLoop {
+  constructor(config, mcpManager) {
+    this.config = config;
+    this.mcpManager = mcpManager;
+    this.provider = createProvider(config);
+  }
+
+  async process(userText, state, chatId, replyFn) {
+    const chatHistory = state.conversations[chatId] || [];
+    const apiMessages = [
+      ...chatHistory.slice(-(this.config.maxHistoryPerConversation || 20) * 2),
+      { role: "user", content: userText },
+    ];
+
+    const allMcpTools = this.mcpManager.getAllTools();
+    const localTools = this.getLocalTools();
+    const availableTools = [...allMcpTools, ...localTools]
+      .filter((t) => isToolAllowed(t.name, this.config.safety))
+      .map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema,
+      }));
+
+    let currentMessages = [...apiMessages];
+    let maxIterations = this.config.maxToolIterations || 10;
+    let finalText = "";
+    let usedLongReply = false;
+
+    try {
+      while (maxIterations-- > 0) {
+        LOG.debug("Calling LLM", {
+          messagesCount: currentMessages.length,
+          toolsCount: availableTools.length,
+          iterationsLeft: maxIterations,
+        });
+
+        const result = await this.provider.chat(currentMessages, availableTools);
+
+        const assistantContent = [];
+        for (const block of this.normalizeResultBlocks(result)) {
+          if (block.type === "text") {
+            finalText = block.text;
+            assistantContent.push(block);
+          } else if (block.type === "thinking") {
+            assistantContent.push(block);
+          } else if (block.type === "tool_use") {
+            assistantContent.push(block);
+          }
+        }
+
+        if (assistantContent.length > 0) {
+          currentMessages.push({ role: "assistant", content: assistantContent });
+        }
+
+        if (result.toolCalls.length === 0) break;
+
+        for (const toolCall of result.toolCalls) {
+          const toolResult = await this.executeTool(toolCall, replyFn);
+
+          currentMessages.push({
+            role: "user",
+            content: [
+              {
+                type: "tool_result",
+                tool_use_id: toolCall.id,
+                content:
+                  typeof toolResult === "string"
+                    ? toolResult
+                    : JSON.stringify(toolResult),
+              },
+            ],
+          });
+
+          if (toolCall.name === "send_long_reply") {
+            usedLongReply = true;
+          }
+        }
+      }
+    } catch (err) {
+      LOG.error("LLM error", { error: err.message, status: err.status });
+      const errorMsg =
+        err.status === 401
+          ? "❌ API 认证失败，请检查 API Key 配置"
+          : err.status === 429
+          ? "❌ API 速率限制，请稍后再试"
+          : `❌ 处理出错: ${err.message}`;
+      await replyFn(errorMsg);
+      return;
+    }
+
+    // Send final response
+    if (finalText && !usedLongReply) {
+      await this.sendReply(finalText, replyFn);
+    }
+
+    // Update conversation history
+    state.conversations[chatId] = [
+      ...(state.conversations[chatId] || []).slice(
+        -(this.config.maxHistoryPerConversation || 20) * 2
+      ),
+      { role: "user", content: userText },
+    ];
+    if (finalText) {
+      state.conversations[chatId].push({
+        role: "assistant",
+        content: finalText,
+      });
+    }
+  }
+
+  normalizeResultBlocks(result) {
+    const blocks = [];
+    if (result.text) {
+      blocks.push({ type: "text", text: result.text });
+    }
+    for (const t of result.thinking || []) {
+      blocks.push({
+        type: "thinking",
+        thinking: t.thinking || "",
+        signature: t.signature,
+      });
+    }
+    for (const tc of result.toolCalls || []) {
+      blocks.push({
+        type: "tool_use",
+        id: tc.id,
+        name: tc.name,
+        input: tc.input || {},
+      });
+    }
+    return blocks;
+  }
+
+  getLocalTools() {
+    return [
+      {
+        name: "send_imessage",
+        description:
+          "Send an iMessage to a specified recipient. Use only when explicitly asked.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            recipient: {
+              type: "string",
+              description: "Email or phone number of the recipient",
+            },
+            text: { type: "string", description: "Message text to send" },
+          },
+          required: ["recipient", "text"],
+        },
+        local: true,
+      },
+      {
+        name: "send_long_reply",
+        description:
+          "Send a long reply that exceeds a single iMessage by splitting it into multiple messages. Call this instead of producing text when the response is long.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            parts: {
+              type: "array",
+              items: { type: "string" },
+              description: "Array of message parts, each ≤ 1000 characters",
+            },
+          },
+          required: ["parts"],
+        },
+        local: true,
+      },
+    ];
+  }
+
+  async executeTool(toolCall, replyFn) {
+    LOG.info(`Tool call`, { name: toolCall.name, input: toolCall.input });
+
+    if (!isToolAllowed(toolCall.name, this.config.safety)) {
+      return `工具 ${toolCall.name} 被安全策略禁止`;
+    }
+
+    const command = toolCall.input?.command || toolCall.input?.cmd || toolCall.input?.shell;
+    if (typeof command === "string" && isCommandBlocked(command, this.config.safety.blockedCommands)) {
+      return `命令被安全策略禁止: ${command}`;
+    }
+
+    try {
+      switch (toolCall.name) {
+        case "send_imessage": {
+          const { recipient, text } = toolCall.input || {};
+          if (!recipient || !text) return "缺少 recipient 或 text";
+          sendMessage(recipient, text);
+          return `已发送消息给 ${recipient}`;
+        }
+
+        case "send_long_reply": {
+          const parts = toolCall.input?.parts || [];
+          for (const part of parts) {
+            await replyFn(part);
+            if (parts.length > 1) await sleep(1000);
+          }
+          return `已发送 ${parts.length} 条消息`;
+        }
+
+        default:
+          return await this.mcpManager.callTool(toolCall.name, toolCall.input);
+      }
+    } catch (err) {
+      LOG.error(`Tool execution failed`, {
+        name: toolCall.name,
+        error: err.message,
+      });
+      return `工具执行出错: ${err.message}`;
+    }
+  }
+
+  async sendReply(text, replyFn) {
+    if (text.length > 300) {
+      const parts = splitLongReply(text, 300);
+      for (const part of parts) {
+        await replyFn(part);
+        if (parts.length > 1) await sleep(500);
+      }
+    } else {
+      await replyFn(text);
+    }
+  }
+}