imessage-mcp-server 1.0.0 → 2.0.0

package/src/bridge/mcp-client.js

@@ -0,0 +1,100 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { LOG } from "../shared/utils.js";
+
+export class McpClientManager {
+  constructor(mcpServersConfig = {}) {
+    this.config = mcpServersConfig;
+    this.clients = new Map(); // serverId -> { client, transport, tools }
+  }
+
+  async connectAll() {
+    const entries = Object.entries(this.config);
+    if (entries.length === 0) {
+      LOG.info("No MCP servers configured");
+      return;
+    }
+
+    await Promise.all(
+      entries.map(([serverId, serverConfig]) =>
+        this.connectServer(serverId, serverConfig)
+      )
+    );
+  }
+
+  async connectServer(serverId, serverConfig) {
+    try {
+      const transport = new StdioClientTransport({
+        command: serverConfig.command,
+        args: serverConfig.args || [],
+        env: { ...process.env, ...(serverConfig.env || {}) },
+      });
+
+      const client = new Client(
+        {
+          name: "imessage-bridge",
+          version: "2.0.0",
+        },
+        {
+          capabilities: {},
+        }
+      );
+
+      await client.connect(transport);
+      const toolsResult = await client.listTools();
+      const tools = toolsResult.tools || [];
+
+      this.clients.set(serverId, { client, transport, tools });
+      LOG.info(`MCP server connected`, { serverId, tools: tools.length });
+    } catch (err) {
+      LOG.error(`Failed to connect MCP server ${serverId}`, {
+        error: err.message,
+      });
+    }
+  }
+
+  getAllTools() {
+    const all = [];
+    for (const [serverId, { tools }] of this.clients) {
+      for (const t of tools) {
+        all.push({
+          ...t,
+          serverId,
+        });
+      }
+    }
+    return all;
+  }
+
+  async callTool(name, input) {
+    for (const [serverId, { client, tools }] of this.clients) {
+      const found = tools.find((t) => t.name === name);
+      if (found) {
+        LOG.info(`Calling MCP tool`, { serverId, name });
+        const result = await client.callTool({ name, arguments: input });
+        return this.extractToolResult(result);
+      }
+    }
+    throw new Error(`Tool ${name} not found in any connected MCP server`);
+  }
+
+  extractToolResult(result) {
+    if (!result || !result.content) return "";
+    return result.content
+      .map((c) => {
+        if (c.type === "text") return c.text;
+        if (c.type === "image") return "[image]";
+        return JSON.stringify(c);
+      })
+      .join("\n");
+  }
+
+  async close() {
+    await Promise.all(
+      Array.from(this.clients.values()).map(({ client }) =
+        client.close().catch(() => {})
+      )
+    );
+    this.clients.clear();
+  }
+}

package/src/cli.js

@@ -0,0 +1,125 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+import { parseArgs } from "./config.js";
+import { startServer } from "./server/index.js";
+import { startBridge } from "./bridge/index.js";
+import { LOG } from "./shared/utils.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_PATH = path.join(__dirname, "..", "package.json");
+const INSTALL_SCRIPT = path.join(__dirname, "..", "scripts", "install-launchagent.sh");
+
+function showHelp() {
+  console.log(`
+imessage-mcp-server — MCP server and AI bridge for iMessage on macOS
+
+Usage:
+  npx imessage-mcp-server --server              Start the MCP server (stdio)
+  npx imessage-mcp-server --bridge --config ... Start the bridge daemon
+  npx imessage-mcp-server --help                Show this help
+  npx imessage-mcp-server --version             Show version
+
+MCP Server mode:
+  --server                                      Start as MCP Server
+
+Bridge mode:
+  --bridge                                      Start as AI bridge daemon
+  --config <path>                               Path to bridge-config.json
+  --foreground                                  Run in foreground (don't daemonize)
+  --test-config                                 Validate config and MCP connections
+  --install-service                             Install as macOS LaunchAgent
+  --uninstall                                   Uninstall LaunchAgent
+  --status                                      Check LaunchAgent status
+
+Bridge options (override config file):
+  --master-handle <handle>                      Your iMessage handle
+  --provider <anthropic|openai>                 LLM provider
+  --api-key <key>                               API key
+  --base-url <url>                              Custom API base URL
+  --model <model>                               Model name
+
+Environment variables:
+  IMESSAGE_DB_PATH                              Path to chat.db
+  ANTHROPIC_API_KEY / OPENAI_API_KEY            API keys
+`);
+}
+
+function showVersion() {
+  const pkg = JSON.parse(fs.readFileSync(PKG_PATH, "utf-8"));
+  console.log(pkg.version);
+}
+
+function runInstallScript(action, configPath) {
+  if (!fs.existsSync(INSTALL_SCRIPT)) {
+    console.error("Install script not found:", INSTALL_SCRIPT);
+    process.exit(1);
+  }
+  const parts = [INSTALL_SCRIPT, action];
+  if (configPath) parts.push(configPath);
+  const quoted = parts.map((p) => `"${p.replace(/"/g, '\\"')}"`).join(" ");
+  execSync(`bash ${quoted}`, { stdio: "inherit" });
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+
+  if (args.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  if (args.version) {
+    showVersion();
+    process.exit(0);
+  }
+
+  // Platform check
+  if (process.platform !== "darwin") {
+    console.error(
+      "❌ iMessage MCP only supports macOS (detected: " + process.platform + ")"
+    );
+    process.exit(1);
+  }
+
+  // osascript check
+  try {
+    execSync("which osascript", { encoding: "utf-8", stdio: "pipe" });
+  } catch {
+    console.error("❌ osascript not found. This tool requires macOS.");
+    process.exit(1);
+  }
+
+  // Default to help when no arguments provided
+  if (!args.mode && argv.length === 0) {
+    showHelp();
+    process.exit(0);
+  }
+
+  try {
+    if (args.mode === "server") {
+      await startServer();
+    } else if (args.mode === "bridge") {
+      if (args.installService) {
+        runInstallScript("load", args.configPath);
+        return;
+      }
+      if (args.uninstall) {
+        runInstallScript("unload", args.configPath);
+        return;
+      }
+      if (args.status) {
+        runInstallScript("status", args.configPath);
+        return;
+      }
+      await startBridge(args);
+    } else {
+      console.error("Unknown mode. Use --server or --bridge.");
+      process.exit(1);
+    }
+  } catch (err) {
+    LOG.error("Fatal error", { error: err.message, stack: err.stack });
+    process.exit(1);
+  }
+}

package/src/config.js

@@ -0,0 +1,236 @@
+import fs from "fs";
+import path from "path";
+import { homedir, hostname } from "os";
+import { DEFAULTS } from "./shared/constants.js";
+
+function resolveEnvRefs(value) {
+  if (typeof value !== "string") return value;
+  return value.replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name] || "");
+}
+
+function deepResolveEnv(obj) {
+  if (typeof obj === "string") return resolveEnvRefs(obj);
+  if (Array.isArray(obj)) return obj.map(deepResolveEnv);
+  if (obj && typeof obj === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      out[k] = deepResolveEnv(v);
+    }
+    return out;
+  }
+  return obj;
+}
+
+export function parseArgs(argv) {
+  const args = {
+    mode: null, // 'server' | 'bridge'
+    configPath: null,
+    foreground: false,
+    testConfig: false,
+    installService: false,
+    uninstall: false,
+    status: false,
+    help: false,
+    version: false,
+    masterHandle: null,
+    provider: null,
+    apiKey: null,
+    baseUrl: null,
+    model: null,
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--server":
+        args.mode = "server";
+        break;
+      case "--bridge":
+        args.mode = "bridge";
+        break;
+      case "--config":
+        args.configPath = argv[++i];
+        break;
+      case "--foreground":
+        args.foreground = true;
+        break;
+      case "--test-config":
+        args.testConfig = true;
+        break;
+      case "--install-service":
+        args.installService = true;
+        break;
+      case "--uninstall":
+        args.uninstall = true;
+        break;
+      case "--status":
+        args.status = true;
+        break;
+      case "--help":
+      case "-h":
+        args.help = true;
+        break;
+      case "--version":
+      case "-v":
+        args.version = true;
+        break;
+      case "--master-handle":
+        args.masterHandle = argv[++i];
+        break;
+      case "--provider":
+        args.provider = argv[++i];
+        break;
+      case "--api-key":
+        args.apiKey = argv[++i];
+        break;
+      case "--base-url":
+        args.baseUrl = argv[++i];
+        break;
+      case "--model":
+        args.model = argv[++i];
+        break;
+    }
+  }
+
+  return args;
+}
+
+export function loadConfigFile(configPath) {
+  if (!configPath) return {};
+  const resolved = path.resolve(configPath);
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`Config file not found: ${resolved}`);
+  }
+  const raw = JSON.parse(fs.readFileSync(resolved, "utf-8"));
+  return deepResolveEnv(raw);
+}
+
+export function buildBridgeConfig(args) {
+  const fileConfig = loadConfigFile(args.configPath) || {};
+
+  // Try reading Claude Code settings for env fallbacks
+  let claudeEnv = {};
+  let claudeModel = null;
+  try {
+    const settingsPath = path.join(homedir(), ".claude/settings.json");
+    if (fs.existsSync(settingsPath)) {
+      const raw = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+      claudeEnv = raw.env || {};
+      claudeModel = raw.model || null;
+    }
+  } catch {
+    // ignore
+  }
+
+  const cfg = {
+    masterHandle:
+      args.masterHandle ||
+      fileConfig.masterHandle ||
+      process.env.IMESSAGE_MASTER_HANDLE,
+    provider:
+      args.provider ||
+      fileConfig.provider ||
+      process.env.IMESSAGE_PROVIDER ||
+      "anthropic",
+    apiKey:
+      args.apiKey ||
+      fileConfig.apiKey ||
+      process.env.ANTHROPIC_API_KEY ||
+      process.env.ANTHROPIC_AUTH_TOKEN ||
+      process.env.OPENAI_API_KEY ||
+      claudeEnv.ANTHROPIC_AUTH_TOKEN ||
+      claudeEnv.ANTHROPIC_API_KEY ||
+      claudeEnv.OPENAI_API_KEY,
+    baseUrl:
+      args.baseUrl ||
+      fileConfig.baseUrl ||
+      process.env.ANTHROPIC_BASE_URL ||
+      process.env.OPENAI_BASE_URL ||
+      claudeEnv.ANTHROPIC_BASE_URL ||
+      claudeEnv.OPENAI_BASE_URL,
+    model:
+      args.model ||
+      fileConfig.model ||
+      process.env.ANTHROPIC_MODEL ||
+      process.env.OPENAI_MODEL ||
+      claudeEnv.ANTHROPIC_MODEL ||
+      claudeEnv.ANTHROPIC_DEFAULT_SONNET_MODEL ||
+      claudeEnv.ANTHROPIC_DEFAULT_OPUS_MODEL ||
+      claudeEnv.ANTHROPIC_DEFAULT_HAIKU_MODEL ||
+      claudeModel || "claude-3-5-sonnet-20241022",
+    maxTokens:
+      fileConfig.maxTokens ||
+      parseInt(process.env.IMESSAGE_MAX_TOKENS, 10) ||
+      DEFAULTS.BRIDGE.maxTokens,
+    pollIntervalMs:
+      fileConfig.pollIntervalMs ||
+      parseInt(process.env.IMESSAGE_POLL_INTERVAL_MS, 10) ||
+      DEFAULTS.BRIDGE.pollIntervalMs,
+    maxHistoryPerConversation:
+      fileConfig.maxHistoryPerConversation ||
+      DEFAULTS.BRIDGE.maxHistoryPerConversation,
+    maxToolIterations:
+      fileConfig.maxToolIterations || DEFAULTS.BRIDGE.maxToolIterations,
+    sendProcessingIndicator:
+      fileConfig.sendProcessingIndicator !== undefined
+        ? fileConfig.sendProcessingIndicator
+        : DEFAULTS.BRIDGE.sendProcessingIndicator,
+    systemPrompt:
+      fileConfig.systemPrompt || buildDefaultSystemPrompt(fileConfig.projectDir || homedir()),
+    mcpServers: fileConfig.mcpServers || {},
+    safety: {
+      requireConfirmation: false,
+      allowedTools: null,
+      blockedTools: [],
+      blockedCommands: ["rm -rf /", "sudo"],
+      readOnly: false,
+      ...fileConfig.safety,
+    },
+  };
+
+  if (fileConfig.thinking) {
+    cfg.thinking = fileConfig.thinking;
+  }
+
+  return cfg;
+}
+
+function buildDefaultSystemPrompt(projectDir) {
+  const project = projectDir || "/Users/USER/Documents/project";
+  return `你是运行在用户 Mac 电脑上的 AI 助手，通过 iMessage 与用户沟通。
+
+## 核心能力
+- 执行 Shell 命令来管理项目、查询系统状态、运行脚本等
+- 读取和浏览文件系统中的文件
+- 智能回答问题、提供技术建议和编程帮助
+- 使用中文与用户交流
+
+## 重要规则
+- 保持回复简洁、有用。iMessage 有长度限制，长回复请分成多条发送。
+- 如果用户的请求涉及项目代码，先用工具了解项目结构再回答。
+- 对于不确定的内容，诚实告知用户，不要编造信息。
+- 执行有风险的操作前（如删除文件、修改配置），先提醒用户。
+- 工具箱中的 \`send_long_reply\` 用于发送超过一条 iMessage 的长回复，自动分多条发送。
+
+## 运行环境
+- 主机名: ${hostname()}
+- 用户目录: ${homedir()}
+- 当前项目目录: ${project}
+`;
+}
+
+export function validateBridgeConfig(cfg) {
+  if (!cfg.masterHandle) {
+    throw new Error(
+      "masterHandle is required. Set it via --master-handle, config file, or IMESSAGE_MASTER_HANDLE env."
+    );
+  }
+  if (!cfg.apiKey) {
+    throw new Error(
+      "apiKey is required. Set it via --api-key, config file, or ANTHROPIC_API_KEY/OPENAI_API_KEY env."
+    );
+  }
+  if (!cfg.model) {
+    throw new Error("model is required.");
+  }
+}

package/src/providers/anthropic.js

@@ -0,0 +1,80 @@
+import { Anthropic } from "@anthropic-ai/sdk";
+import { BaseProvider, mcpToAnthropicTools } from "./base.js";
+
+export class AnthropicProvider extends BaseProvider {
+  constructor(config) {
+    super(config);
+    this.client = new Anthropic({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl,
+      maxRetries: 3,
+    });
+  }
+
+  normalizeMessages(messages) {
+    // Anthropic requires alternating user/assistant roles.
+    // We collapse consecutive same-role blocks.
+    const normalized = [];
+    for (const m of messages) {
+      if (normalized.length === 0) {
+        normalized.push({ ...m });
+        continue;
+      }
+      const last = normalized[normalized.length - 1];
+      if (last.role === m.role) {
+        // Merge content arrays
+        last.content = last.content.concat(m.content);
+      } else {
+        normalized.push({ ...m });
+      }
+    }
+    return normalized;
+  }
+
+  async chat(messages, tools) {
+    const requestPayload = {
+      model: this.config.model,
+      max_tokens: this.config.maxTokens || 4096,
+      system: this.config.systemPrompt || undefined,
+      messages: this.normalizeMessages(messages),
+    };
+
+    if (tools.length > 0) {
+      requestPayload.tools = mcpToAnthropicTools(tools);
+    }
+
+    if (this.config.thinking?.enabled) {
+      requestPayload.thinking = {
+        type: "enabled",
+        budget_tokens: this.config.thinking.budgetTokens || 1024,
+      };
+    }
+
+    const response = await this.client.messages.create(requestPayload);
+
+    const result = {
+      text: "",
+      thinking: [],
+      toolCalls: [],
+    };
+
+    for (const block of response.content) {
+      if (block.type === "text") {
+        result.text = block.text;
+      } else if (block.type === "thinking") {
+        result.thinking.push({
+          thinking: block.thinking || "",
+          signature: block.signature,
+        });
+      } else if (block.type === "tool_use") {
+        result.toolCalls.push({
+          id: block.id,
+          name: block.name,
+          input: block.input || {},
+        });
+      }
+    }
+
+    return result;
+  }
+}

package/src/providers/base.js

@@ -0,0 +1,37 @@
+export function mcpToAnthropicTools(mcpTools) {
+  return mcpTools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.inputSchema || { type: "object", properties: {} },
+  }));
+}
+
+export function mcpToOpenAITools(mcpTools) {
+  return mcpTools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.inputSchema || { type: "object", properties: {} },
+    },
+  }));
+}
+
+export function openAIToolCallToMcp(toolCall) {
+  return {
+    id: toolCall.id,
+    name: toolCall.function.name,
+    input: JSON.parse(toolCall.function.arguments || "{}"),
+  };
+}
+
+export class BaseProvider {
+  constructor(config) {
+    this.config = config;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async chat(messages, tools) {
+    throw new Error("Not implemented");
+  }
+}

package/src/providers/index.js

@@ -0,0 +1,19 @@
+import { AnthropicProvider } from "./anthropic.js";
+import { OpenAIProvider } from "./openai.js";
+
+export function createProvider(config) {
+  const provider = config.provider || "anthropic";
+  switch (provider.toLowerCase()) {
+    case "anthropic":
+    case "claude":
+      return new AnthropicProvider(config);
+    case "openai":
+    case "deepseek":
+    case "kimi":
+      return new OpenAIProvider(config);
+    default:
+      throw new Error(`Unsupported provider: ${provider}`);
+  }
+}
+
+export { AnthropicProvider, OpenAIProvider };

package/src/providers/openai.js

@@ -0,0 +1,104 @@
+import OpenAI from "openai";
+import { BaseProvider, mcpToOpenAITools, openAIToolCallToMcp } from "./base.js";
+
+export class OpenAIProvider extends BaseProvider {
+  constructor(config) {
+    super(config);
+    this.client = new OpenAI({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl,
+      maxRetries: 3,
+    });
+  }
+
+  normalizeMessages(messages) {
+    // OpenAI expects messages array with system/user/assistant/tool roles.
+    // For tool results, Anthropic-style tool_result blocks must be converted.
+    const normalized = [];
+    for (const m of messages) {
+      if (typeof m.content === "string") {
+        normalized.push({ role: m.role, content: m.content });
+        continue;
+      }
+
+      // content is array of blocks
+      const textBlocks = [];
+      const toolCalls = [];
+      const toolResults = [];
+
+      for (const block of m.content) {
+        if (block.type === "text") {
+          textBlocks.push(block.text);
+        } else if (block.type === "tool_use") {
+          toolCalls.push({
+            id: block.id,
+            type: "function",
+            function: {
+              name: block.name,
+              arguments: JSON.stringify(block.input || {}),
+            },
+          });
+        } else if (block.type === "tool_result") {
+          toolResults.push({
+            role: "tool",
+            tool_call_id: block.tool_use_id,
+            content:
+              typeof block.content === "string"
+                ? block.content
+                : JSON.stringify(block.content),
+          });
+        } else if (block.type === "thinking") {
+          // OpenAI-compatible endpoints usually ignore thinking blocks;
+          // include as text if the model supports it.
+          textBlocks.push(`[thinking] ${block.thinking || ""}`);
+        }
+      }
+
+      if (toolCalls.length > 0) {
+        normalized.push({
+          role: m.role,
+          tool_calls: toolCalls,
+          content: textBlocks.length > 0 ? textBlocks.join("\n") : null,
+        });
+      } else if (textBlocks.length > 0) {
+        normalized.push({ role: m.role, content: textBlocks.join("\n") });
+      }
+      for (const tr of toolResults) {
+        normalized.push(tr);
+      }
+    }
+    return normalized;
+  }
+
+  async chat(messages, tools) {
+    const normalizedMessages = this.normalizeMessages(messages);
+    if (this.config.systemPrompt) {
+      normalizedMessages.unshift({
+        role: "system",
+        content: this.config.systemPrompt,
+      });
+    }
+
+    const requestPayload = {
+      model: this.config.model,
+      max_tokens: this.config.maxTokens || 4096,
+      messages: normalizedMessages,
+    };
+
+    if (tools.length > 0) {
+      requestPayload.tools = mcpToOpenAITools(tools);
+      requestPayload.tool_choice = "auto";
+    }
+
+    const response = await this.client.chat.completions.create(requestPayload);
+    const choice = response.choices[0];
+
+    const result = {
+      text: choice.message.content || "",
+      thinking: [],
+      toolCalls: (choice.message.tool_calls || []).map(openAIToolCallToMcp),
+    };
+
+    return result;
+  }
+}