claude-codex-wechat 0.1.29 → 0.1.31

package/dist/mcp/mediaServer.js

@@ -0,0 +1,91 @@
+import { createRequire as __cjsCreateRequire } from 'node:module'; const require = __cjsCreateRequire(import.meta.url);
+
+// src/mcp/mediaServer.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+var BRIDGE_API_URL = process.env.BRIDGE_API_URL || "http://localhost:8787";
+var server = new McpServer({
+  name: "wechat-media",
+  version: "1.0.0"
+});
+async function sendMedia(kind, filePath, fileName) {
+  const response = await fetch(`${BRIDGE_API_URL}/api/channel/send-media`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ kind, filePath, fileName })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`\u53D1\u9001\u5931\u8D25 (HTTP ${response.status}): ${text}`);
+  }
+  const result = await response.json();
+  if (!result.ok) {
+    throw new Error(`\u53D1\u9001\u5931\u8D25: ${result.error ?? "\u672A\u77E5\u9519\u8BEF"}`);
+  }
+  return "\u53D1\u9001\u6210\u529F";
+}
+server.tool(
+  "send_image",
+  "\u53D1\u9001\u56FE\u7247\u6587\u4EF6\u5230\u5F53\u524D\u5FAE\u4FE1\u5BF9\u8BDD\u3002\u4F20\u5165\u56FE\u7247\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84\u3002",
+  { filePath: z.string().describe("\u56FE\u7247\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84\uFF0C\u5982 /path/to/image.png") },
+  async ({ filePath }) => {
+    try {
+      const msg = await sendMedia("image", filePath);
+      return { content: [{ type: "text", text: msg }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: e.message }], isError: true };
+    }
+  }
+);
+server.tool(
+  "send_video",
+  "\u53D1\u9001\u89C6\u9891\u6587\u4EF6\u5230\u5F53\u524D\u5FAE\u4FE1\u5BF9\u8BDD\u3002\u4F20\u5165\u89C6\u9891\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84\u3002",
+  { filePath: z.string().describe("\u89C6\u9891\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84\uFF0C\u5982 /path/to/video.mp4") },
+  async ({ filePath }) => {
+    try {
+      const msg = await sendMedia("video", filePath);
+      return { content: [{ type: "text", text: msg }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: e.message }], isError: true };
+    }
+  }
+);
+server.tool(
+  "send_audio",
+  "\u53D1\u9001\u97F3\u9891\u6587\u4EF6\u5230\u5F53\u524D\u5FAE\u4FE1\u5BF9\u8BDD\u3002\u4F20\u5165\u97F3\u9891\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84\u3002\u97F3\u9891\u6587\u4EF6\u4EE5\u6587\u4EF6\u9644\u4EF6\u5F62\u5F0F\u53D1\u9001\uFF0C\u7528\u6237\u53EF\u70B9\u51FB\u64AD\u653E\u3002",
+  { filePath: z.string().describe("\u97F3\u9891\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84\uFF0C\u5982 /path/to/audio.mp3") },
+  async ({ filePath }) => {
+    try {
+      const fileName = filePath.split("/").pop() || "audio.mp3";
+      const msg = await sendMedia("file", filePath, fileName);
+      return { content: [{ type: "text", text: msg }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: e.message }], isError: true };
+    }
+  }
+);
+server.tool(
+  "send_file",
+  "\u53D1\u9001\u6587\u4EF6\u5230\u5F53\u524D\u5FAE\u4FE1\u5BF9\u8BDD\u3002\u4F20\u5165\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84\u548C\u53EF\u9009\u7684\u663E\u793A\u6587\u4EF6\u540D\u3002",
+  {
+    filePath: z.string().describe("\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84\uFF0C\u5982 /path/to/document.pdf"),
+    fileName: z.string().optional().describe("\u663E\u793A\u7ED9\u7528\u6237\u7684\u6587\u4EF6\u540D\uFF08\u53EF\u9009\uFF0C\u9ED8\u8BA4\u4F7F\u7528\u539F\u6587\u4EF6\u540D\uFF09")
+  },
+  async ({ filePath, fileName }) => {
+    try {
+      const msg = await sendMedia("file", filePath, fileName);
+      return { content: [{ type: "text", text: msg }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: e.message }], isError: true };
+    }
+  }
+);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  console.error("[wechat-media-mcp] fatal:", err);
+  process.exit(1);
+});

package/dist/server/cli.js

@@ -2,17 +2,18 @@
 import { createRequire as __cjsCreateRequire } from 'node:module'; const require = __cjsCreateRequire(import.meta.url);
 
 // src/cli.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "node:fs";
 import { dirname as dirname9, join as join14 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/daemon/bootstrap.ts
 import { networkInterfaces } from "node:os";
 
 // src/daemon/server.ts
-import { mkdtempSync } from "node:fs";
+import { mkdtempSync, existsSync as existsSync9, writeFileSync as writeFileSync2 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { dirname as dirname7, join as join11 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import Fastify from "fastify";
 
 // src/channels/platforms.ts
@@ -1866,6 +1867,105 @@ var WeixinDirectApiClient = class {
       throw new Error(`weixin_send_typing_failed:${payload.ret ?? -1}:${payload.errmsg ?? "unknown_error"}`);
     }
   }
+  /** Request a CDN upload URL from the iLink platform. */
+  async getUploadUrl(input) {
+    const response = await this.fetchImpl(`${this.baseUrl}/ilink/bot/getuploadurl`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        AuthorizationType: "ilink_bot_token",
+        Authorization: `Bearer ${this.botToken}`,
+        "X-WECHAT-UIN": this.wechatUin
+      },
+      body: JSON.stringify({
+        filekey: input.filekey,
+        media_type: input.mediaType,
+        to_user_id: input.toUserId,
+        rawsize: input.rawsize,
+        rawfilemd5: input.rawfilemd5,
+        filesize: input.filesize,
+        no_need_thumb: input.noNeedThumb ?? true,
+        aeskey: input.aeskey,
+        ...input.contextToken ? { context_token: input.contextToken } : {},
+        base_info: { channel_version: this.channelVersion }
+      })
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(`weixin_get_upload_url_failed:http_${response.status}:${text.slice(0, 200)}`);
+    }
+    const payload = await response.json();
+    if ((payload.errcode ?? 0) !== 0 || (payload.ret ?? 0) !== 0) {
+      throw new Error(`weixin_get_upload_url_failed:${payload.errcode ?? payload.ret ?? -1}:${payload.errmsg ?? "unknown_error"}`);
+    }
+    if (!payload.upload_param && !payload.upload_full_url) {
+      throw new Error("weixin_get_upload_url_failed:no_upload_param");
+    }
+    return {
+      uploadParam: payload.upload_param ?? "",
+      uploadFullUrl: payload.upload_full_url
+    };
+  }
+  /**
+   * Send a media message (image/voice/file/video) to a user.
+   * The media must already be uploaded to CDN; pass the resulting CDNMedia reference.
+   */
+  async sendMediaMessage(input) {
+    const item = this.buildMediaItem(input);
+    const response = await this.fetchImpl(`${this.baseUrl}/ilink/bot/sendmessage`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        AuthorizationType: "ilink_bot_token",
+        Authorization: `Bearer ${this.botToken}`,
+        "X-WECHAT-UIN": this.wechatUin
+      },
+      body: JSON.stringify({
+        msg: {
+          from_user_id: "",
+          to_user_id: input.toUserId,
+          client_id: randomUUID(),
+          message_type: 2,
+          message_state: 2,
+          item_list: [item],
+          context_token: input.contextToken
+        },
+        base_info: { channel_version: this.channelVersion }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`weixin_send_media_failed:${response.status}`);
+    }
+    const payload = await response.json();
+    if ((payload.errcode ?? 0) !== 0 || (payload.ret ?? 0) !== 0) {
+      throw new Error(`weixin_send_media_failed:${payload.errcode ?? payload.ret ?? -1}:${payload.errmsg ?? "unknown_error"}`);
+    }
+  }
+  buildMediaItem(input) {
+    const aesKeyBase64 = Buffer.from(input.aesKeyHex).toString("base64");
+    const cdnMedia = {
+      encrypt_query_param: input.downloadParam,
+      aes_key: aesKeyBase64,
+      encrypt_type: 1
+    };
+    switch (input.itemType) {
+      case 2:
+        return { type: 2, image_item: { media: cdnMedia, mid_size: input.ciphertextSize } };
+      case 3:
+        return { type: 3, voice_item: {
+          media: cdnMedia,
+          ...input.voiceInfo ? {
+            encode_type: input.voiceInfo.encodeType,
+            playtime: input.voiceInfo.playtime,
+            ...input.voiceInfo.sampleRate ? { sample_rate: input.voiceInfo.sampleRate } : {}
+          } : {}
+        } };
+      case 4:
+        return { type: 4, file_item: { media: cdnMedia, file_name: input.fileName ?? "file", len: String(input.rawSize) } };
+      case 5:
+        return { type: 5, video_item: { media: cdnMedia, video_size: input.ciphertextSize } };
+    }
+  }
 };
 
 // src/channels/weixin-direct/adapter.ts
@@ -2021,18 +2121,49 @@ var WeixinDirectAdapter = class _WeixinDirectAdapter {
     if (this.options.stateStore && !this.options.stateStore.canSend(message.chatId)) {
       throw new Error(`weixin_push_quota_exceeded:${message.chatId}`);
     }
-    const chunks = chunkText(message.text ?? "", MAX_TEXT_LENGTH);
-    const chunkDelayMs = this.options.chunkDelayMs ?? DEFAULT_CHUNK_DELAY_MS;
-    for (let i = 0; i < chunks.length; i += 1) {
-      if (i > 0 && chunkDelayMs > 0) await delay2(chunkDelayMs);
-      await this.options.api.sendTextMessage({
-        toUserId: message.chatId,
-        text: chunks[i],
-        contextToken
-      });
+    const mediaKinds = /* @__PURE__ */ new Set(["image", "video", "audio", "file"]);
+    if (mediaKinds.has(message.kind)) {
+      await this.sendMediaMessage(message, contextToken);
+    } else {
+      const chunks = chunkText(message.text ?? "", MAX_TEXT_LENGTH);
+      const chunkDelayMs = this.options.chunkDelayMs ?? DEFAULT_CHUNK_DELAY_MS;
+      for (let i = 0; i < chunks.length; i += 1) {
+        if (i > 0 && chunkDelayMs > 0) await delay2(chunkDelayMs);
+        await this.options.api.sendTextMessage({
+          toUserId: message.chatId,
+          text: chunks[i],
+          contextToken
+        });
+      }
     }
     this.options.stateStore?.recordSent(message.chatId);
   }
+  async sendMediaMessage(message, contextToken) {
+    const uploader = this.options.mediaUploader;
+    const api = this.options.api;
+    if (!uploader || !api.sendMediaMessage) {
+      throw new Error("weixin_media_upload_unavailable");
+    }
+    if (!message.filePath) {
+      throw new Error("weixin_media_no_file_path");
+    }
+    const result = await uploader.upload(message.filePath, { contextToken, mediaType: mediaKindToMediaType(message.kind), toUserId: message.chatId });
+    if (!result.ok) {
+      throw new Error(`weixin_media_upload_failed:${result.reason}`);
+    }
+    const itemType = mediaKindToItemType(message.kind);
+    await api.sendMediaMessage({
+      toUserId: message.chatId,
+      contextToken,
+      itemType,
+      downloadParam: result.downloadParam,
+      aesKeyHex: result.aesKeyHex,
+      rawSize: result.rawSize,
+      ciphertextSize: result.ciphertextSize,
+      fileName: message.fileName,
+      ...result.voiceInfo ? { voiceInfo: result.voiceInfo } : {}
+    });
+  }
   async setTyping(chatId, active) {
     await this.typing?.set(chatId, active);
   }
@@ -2193,13 +2324,41 @@ function chunkText(text, limit) {
   }
   return chunks.length > 0 ? chunks : [""];
 }
+function mediaKindToItemType(kind) {
+  switch (kind) {
+    case "image":
+      return 2;
+    case "audio":
+      return 3;
+    case "file":
+      return 4;
+    case "video":
+      return 5;
+    default:
+      throw new Error(`weixin_unknown_media_kind:${kind}`);
+  }
+}
+function mediaKindToMediaType(kind) {
+  switch (kind) {
+    case "image":
+      return 1;
+    case "video":
+      return 2;
+    case "file":
+      return 3;
+    case "audio":
+      return 4;
+    default:
+      return 3;
+  }
+}
 
 // src/channels/weixin-direct/mediaDownloader.ts
 import { mkdirSync as mkdirSync2, writeFileSync } from "node:fs";
 import { dirname as dirname5 } from "node:path";
 
 // src/channels/weixin-direct/mediaCrypto.ts
-import { createDecipheriv } from "node:crypto";
+import { createCipheriv, createDecipheriv, randomBytes as randomBytes3 } from "node:crypto";
 function decodeAesKey(encoded) {
   if (/^[0-9a-fA-F]{32}$/.test(encoded)) {
     return Buffer.from(encoded, "hex");
@@ -2223,6 +2382,19 @@ function decryptAesEcb(ciphertext, key) {
   const decipher = createDecipheriv("aes-128-ecb", key, null);
   return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
 }
+function encryptAesEcb(plaintext, key) {
+  if (key.length !== 16) {
+    throw new Error(`weixin_media_aes_key_size:${key.length}`);
+  }
+  const cipher = createCipheriv("aes-128-ecb", key, null);
+  return Buffer.concat([cipher.update(plaintext), cipher.final()]);
+}
+function generateAesKey() {
+  return randomBytes3(16);
+}
+function encodeAesKeyHex(key) {
+  return key.toString("hex");
+}
 
 // src/channels/weixin-direct/mediaDownloader.ts
 var CDN_BASE_URL = "https://novac2c.cdn.weixin.qq.com/c2c";
@@ -2265,6 +2437,143 @@ var WeixinMediaDownloader = class {
   }
 };
 
+// src/channels/weixin-direct/mediaUploader.ts
+import { createHash, randomBytes as randomBytes4 } from "node:crypto";
+import { readFileSync as readFileSync4 } from "node:fs";
+
+// src/channels/weixin-direct/voiceInfo.ts
+function encodeTypeFromExt(ext) {
+  switch (ext.toLowerCase()) {
+    case ".mp3":
+      return 7;
+    case ".amr":
+      return 5;
+    case ".silk":
+    case ".slk":
+      return 6;
+    case ".wav":
+    case ".pcm":
+      return 1;
+    case ".ogg":
+    case ".opus":
+      return 8;
+    case ".spx":
+      return 4;
+    default:
+      return 7;
+  }
+}
+function estimatePlaytime(buf, ext) {
+  switch (ext.toLowerCase()) {
+    case ".wav": {
+      if (buf.length < 44) return 1e3;
+      const byteRate = buf.readUInt32LE(28);
+      if (byteRate === 0) return 1e3;
+      const dataSize = buf.length - 44;
+      return Math.round(dataSize / byteRate * 1e3);
+    }
+    case ".mp3": {
+      return Math.round(buf.length * 8 / 128e3 * 1e3);
+    }
+    case ".amr": {
+      const frames = Math.floor((buf.length - 6) / 32);
+      return frames * 20;
+    }
+    default:
+      return Math.round(buf.length * 8 / 16e3 * 1e3);
+  }
+}
+function detectVoiceInfo(buf, fileName) {
+  const ext = fileName.includes(".") ? "." + fileName.split(".").pop() : ".mp3";
+  return {
+    encodeType: encodeTypeFromExt(ext),
+    playtime: estimatePlaytime(buf, ext),
+    sampleRate: ext === ".wav" && buf.length >= 28 ? buf.readUInt32LE(24) : void 0
+  };
+}
+
+// src/channels/weixin-direct/mediaUploader.ts
+var CDN_UPLOAD_BASE_URL = "https://novac2c.cdn.weixin.qq.com/c2c";
+var WeixinMediaUploader = class {
+  cdnBaseUrl;
+  fetchImpl;
+  getUploadUrl;
+  constructor(options) {
+    this.cdnBaseUrl = (options.cdnBaseUrl ?? CDN_UPLOAD_BASE_URL).replace(/\/+$/, "");
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.getUploadUrl = options.getUploadUrl;
+  }
+  async upload(filePath, options) {
+    let plaintext;
+    try {
+      plaintext = readFileSync4(filePath);
+    } catch {
+      return { ok: false, reason: "read_failed" };
+    }
+    const rawsize = plaintext.length;
+    const rawfilemd5 = createHash("md5").update(plaintext).digest("hex");
+    const key = generateAesKey();
+    const aeskeyHex = encodeAesKeyHex(key);
+    let ciphertext;
+    try {
+      ciphertext = encryptAesEcb(plaintext, key);
+    } catch {
+      return { ok: false, reason: "encrypt_failed" };
+    }
+    const filesize = ciphertext.length;
+    const filekey = randomBytes4(16).toString("hex");
+    let uploadParam;
+    let uploadFullUrl;
+    try {
+      const result = await this.getUploadUrl({
+        filekey,
+        rawsize,
+        rawfilemd5,
+        filesize,
+        aeskey: aeskeyHex,
+        noNeedThumb: true,
+        ...options?.contextToken ? { contextToken: options.contextToken } : {},
+        ...options?.mediaType != null ? { mediaType: options.mediaType } : {},
+        ...options?.toUserId ? { toUserId: options.toUserId } : {}
+      });
+      uploadParam = result.uploadParam;
+      uploadFullUrl = result.uploadFullUrl;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : "";
+      return { ok: false, reason: msg || "get_upload_url_failed" };
+    }
+    const uploadUrl = uploadFullUrl || `${this.cdnBaseUrl}/upload?encrypted_query_param=${encodeURIComponent(uploadParam)}&filekey=${encodeURIComponent(filekey)}`;
+    let response;
+    try {
+      response = await this.fetchImpl(uploadUrl, {
+        method: "POST",
+        headers: { "content-type": "application/octet-stream" },
+        body: new Uint8Array(ciphertext),
+        signal: AbortSignal.timeout(12e4)
+      });
+    } catch {
+      return { ok: false, reason: "upload_failed" };
+    }
+    if (!response.ok) {
+      return { ok: false, reason: `upload_http_${response.status}` };
+    }
+    const encryptedParam = response.headers.get("x-encrypted-param") ?? "";
+    if (!encryptedParam) {
+      return { ok: false, reason: "no_encrypted_param_in_response" };
+    }
+    const isAudio = options?.mediaType === 4;
+    const voiceInfo = isAudio ? detectVoiceInfo(plaintext, filePath) : void 0;
+    return {
+      ok: true,
+      downloadParam: encryptedParam,
+      aesKeyHex: aeskeyHex,
+      rawSize: rawsize,
+      ciphertextSize: filesize,
+      ...voiceInfo ? { voiceInfo } : {}
+    };
+  }
+};
+
 // src/channels/weixin-direct/managedAdapter.ts
 var ManagedWeixinDirectAdapter = class {
   id = "weixin-managed";
@@ -2342,13 +2651,18 @@ function createWeixinAdapter(config, stateStore, mediaDir) {
   if (config?.enabled !== true) return null;
   if (!config.baseUrl || !config.token) return null;
   const wechatUin = buildTransientWeixinUin();
+  const apiClient = new WeixinDirectApiClient({
+    baseUrl: config.baseUrl,
+    botToken: config.token,
+    wechatUin
+  });
+  const mediaUploader = new WeixinMediaUploader({
+    getUploadUrl: (input) => apiClient.getUploadUrl(input)
+  });
   return new WeixinDirectAdapter({
-    api: new WeixinDirectApiClient({
-      baseUrl: config.baseUrl,
-      botToken: config.token,
-      wechatUin
-    }),
+    api: apiClient,
     stateStore,
+    mediaUploader,
     ...mediaDir ? { mediaDownloader: new WeixinMediaDownloader(), mediaDir } : {}
   });
 }
@@ -2387,7 +2701,7 @@ var WeixinOutboundGate = class _WeixinOutboundGate {
     const buffered = this.pendingLast.get(chatId);
     if (buffered) {
       this.pendingLast.delete(chatId);
-      await this.options.send(chatId, { kind: buffered.kind, text: buffered.text + CONTINUATION_HINT });
+      await this.options.send(chatId, appendHintIfText(buffered));
       this.hintedReplies.set(chatId, Date.now());
       store.enqueueOutbound(chatId, message);
       return;
@@ -2428,7 +2742,7 @@ var WeixinOutboundGate = class _WeixinOutboundGate {
       const isLastSlot = quota.remaining === 1;
       const hasMore = pending.length > 1;
       if (isLastSlot && hasMore) {
-        await this.options.send(chatId, { kind: next.kind, text: next.text + CONTINUATION_HINT });
+        await this.options.send(chatId, appendHintIfText(next));
         this.hintedReplies.set(chatId, Date.now());
         store.shiftOutbound(chatId);
         break;
@@ -2439,6 +2753,11 @@ var WeixinOutboundGate = class _WeixinOutboundGate {
     if (!store.hasPendingOutbound(chatId)) this.hintedReplies.delete(chatId);
   }
 };
+var MEDIA_KINDS = /* @__PURE__ */ new Set(["image", "video", "audio", "file"]);
+function appendHintIfText(item) {
+  if (MEDIA_KINDS.has(item.kind)) return item;
+  return { ...item, text: item.text + CONTINUATION_HINT };
+}
 
 // src/providers/claude-code/claudeStreamingRunner.ts
 import { spawn as spawn3 } from "node:child_process";
@@ -2636,10 +2955,12 @@ var ClaudeStreamingRunner = class {
   command;
   spawner;
   capabilityProbe;
+  mcpConfigPath;
   constructor(input = {}) {
     this.command = input.command ?? "claude";
     this.spawner = input.spawner ?? defaultClaudeStreamSpawner;
     this.capabilityProbe = input.capabilityProbe ?? probeAppendSystemPromptSupport;
+    this.mcpConfigPath = input.mcpConfigPath;
   }
   async startSession(input) {
     const resumeId = input.options?.providerSessionId;
@@ -2749,12 +3070,12 @@ var ClaudeStreamingRunner = class {
   }
   ensureHandle(session) {
     if (session.handle) return session.handle;
-    const args = buildStreamingArgs(session);
+    const args = buildStreamingArgs(session, this.mcpConfigPath);
     session.handle = this.spawner({ command: this.command, args, cwd: session.cwd });
     return session.handle;
   }
 };
-function buildStreamingArgs(session) {
+function buildStreamingArgs(session, mcpConfigPath) {
   const args = [
     "-p",
     "--input-format",
@@ -2765,7 +3086,8 @@ function buildStreamingArgs(session) {
     "--verbose",
     "--dangerously-skip-permissions",
     ...session.supportsAppendSystemPrompt ? ["--append-system-prompt", BRIDGE_APPEND_SYSTEM_PROMPT] : [],
-    "--replay-user-messages"
+    "--replay-user-messages",
+    ...mcpConfigPath ? ["--mcp-config", mcpConfigPath] : []
   ];
   if (session.resumeId) {
     args.push("--resume", session.resumeId);
@@ -2909,7 +3231,7 @@ var CodexAppServerClient = class {
   buffer = "";
   constructor(input) {
     const command = input.command ?? "codex";
-    this.child = spawn4(command, ["app-server", "--listen", "stdio://"], {
+    this.child = spawn4(command, ["app-server", "--listen", "stdio://", ...input.mcpServerConfigs ?? []], {
       cwd: input.cwd,
       stdio: ["pipe", "pipe", "pipe"],
       shell: useShellForCli()
@@ -3080,8 +3402,10 @@ var CodexInteractiveRunner = class {
   sessions = /* @__PURE__ */ new Map();
   command;
   syncThreadForResume;
+  mcpServerConfigs;
   constructor(input = {}) {
     this.command = input.command;
+    this.mcpServerConfigs = input.mcpServerConfigs;
     this.syncThreadForResume = input.syncThreadForResume ?? syncCodexThreadForResume;
   }
   async startSession(input) {
@@ -3204,7 +3528,8 @@ var CodexInteractiveRunner = class {
     if (session.client) return session.client;
     const client = new CodexAppServerClient({
       command: this.command,
-      cwd: session.cwd
+      cwd: session.cwd,
+      ...this.mcpServerConfigs?.length ? { mcpServerConfigs: this.mcpServerConfigs } : {}
     });
     await client.initialize();
     client.onNotification("item/agentMessage/delta", (params) => {
@@ -3310,8 +3635,8 @@ var CodexProvider = class {
 // src/providers/defaultProviders.ts
 function createDefaultProviders(input = {}) {
   return [
-    new ClaudeCodeProvider({ runner: new ClaudeStreamingRunner({ command: input.claudeCommand }) }),
-    new CodexProvider({ runner: new CodexInteractiveRunner({ command: input.codexCommand }) })
+    new ClaudeCodeProvider({ runner: new ClaudeStreamingRunner({ command: input.claudeCommand, mcpConfigPath: input.mcpConfigPath }) }),
+    new CodexProvider({ runner: new CodexInteractiveRunner({ command: input.codexCommand, mcpServerConfigs: input.codexMcpServerConfigs }) })
   ];
 }
 
@@ -3502,7 +3827,7 @@ function buildBridgeCommandHelpMarkdown(input) {
 }
 
 // src/session/currentConversationStore.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
 import { nanoid as nanoid2 } from "nanoid";
 var CurrentConversationStore = class {
   constructor(configPath, defaults) {
@@ -3562,7 +3887,7 @@ var CurrentConversationStore = class {
   }
   readState() {
     if (!existsSync6(this.configPath)) return {};
-    const raw = JSON.parse(readFileSync4(this.configPath, "utf8"));
+    const raw = JSON.parse(readFileSync5(this.configPath, "utf8"));
     return raw && typeof raw === "object" ? raw : {};
   }
   writeCurrent(record) {
@@ -3633,7 +3958,12 @@ var MessageRouter = class _MessageRouter {
    */
   async sendToChat(message) {
     if (this.options.outboundGate) {
-      await this.options.outboundGate.deliver(message.chatId, { kind: message.kind, text: message.text });
+      await this.options.outboundGate.deliver(message.chatId, {
+        kind: message.kind,
+        text: message.text,
+        ...message.filePath ? { filePath: message.filePath } : {},
+        ...message.fileName ? { fileName: message.fileName } : {}
+      });
     } else {
       await this.options.channel.sendMessage(message);
     }
@@ -4121,7 +4451,7 @@ function composeInboundText(content) {
 }
 
 // src/storage/lastProviderSessionStore.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
 var LastProviderSessionStore = class {
   constructor(configPath) {
     this.configPath = configPath;
@@ -4148,7 +4478,7 @@ var LastProviderSessionStore = class {
   }
   readState() {
     if (!existsSync7(this.configPath)) return {};
-    const raw = JSON.parse(readFileSync5(this.configPath, "utf8"));
+    const raw = JSON.parse(readFileSync6(this.configPath, "utf8"));
     return raw && typeof raw === "object" ? raw : {};
   }
   writeState(state) {
@@ -4158,7 +4488,7 @@ var LastProviderSessionStore = class {
 };
 
 // src/storage/runtimeUserStore.ts
-import { readFileSync as readFileSync6, existsSync as existsSync8 } from "node:fs";
+import { readFileSync as readFileSync7, existsSync as existsSync8 } from "node:fs";
 import { nanoid as nanoid3 } from "nanoid";
 var RuntimeUserStore = class {
   constructor(configPath) {
@@ -4219,7 +4549,7 @@ var RuntimeUserStore = class {
   }
   readState() {
     if (!existsSync8(this.configPath)) return {};
-    const raw = JSON.parse(readFileSync6(this.configPath, "utf8"));
+    const raw = JSON.parse(readFileSync7(this.configPath, "utf8"));
     return raw && typeof raw === "object" ? raw : {};
   }
   writeState(state) {
@@ -4551,13 +4881,13 @@ var RelayTunnelRouter = class {
 };
 
 // src/shared/version.ts
-import { readFileSync as readFileSync7 } from "node:fs";
+import { readFileSync as readFileSync8 } from "node:fs";
 import { dirname as dirname6, join as join10 } from "node:path";
 import { fileURLToPath } from "node:url";
 function readClientVersion() {
   try {
     const here2 = dirname6(fileURLToPath(import.meta.url));
-    const pkg = JSON.parse(readFileSync7(join10(here2, "..", "..", "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync8(join10(here2, "..", "..", "package.json"), "utf8"));
     return typeof pkg.version === "string" && pkg.version ? pkg.version : "0.0.0";
   } catch {
     return "0.0.0";
@@ -4612,9 +4942,37 @@ function createDaemonServer(options = {}) {
   const activeUserStore = options.activeUserStore ?? new RuntimeUserStore(configPath);
   const lastProviderSessions = new LastProviderSessionStore(configPath);
   const sessionBindingMatch = /* @__PURE__ */ new Map();
+  const bridgePort = process.env.BRIDGE_PORT ?? "8787";
+  const mcpConfigPath = join11(dirname7(configPath), "mcp-media.json");
+  const serverDir = dirname7(fileURLToPath2(import.meta.url));
+  const mcpMediaServerTs = join11(serverDir, "..", "mcp", "mediaServer.ts");
+  const mcpMediaServerJs = join11(serverDir, "..", "mcp", "mediaServer.js");
+  const useTs = existsSync9(mcpMediaServerTs) && !existsSync9(mcpMediaServerJs);
+  const mcpCommand = useTs ? "tsx" : "node";
+  const mcpArgs = [useTs ? mcpMediaServerTs : mcpMediaServerJs];
+  writeFileSync2(mcpConfigPath, JSON.stringify({
+    mcpServers: {
+      "wechat-media": {
+        command: mcpCommand,
+        args: mcpArgs,
+        env: { BRIDGE_API_URL: `http://localhost:${bridgePort}` }
+      }
+    }
+  }, null, 2) + "\n");
+  const codexMcpScript = useTs ? mcpMediaServerTs : mcpMediaServerJs;
+  const codexMcpServerConfigs = [
+    "-c",
+    `mcp_servers.wechat-media.command="${mcpCommand}"`,
+    "-c",
+    `mcp_servers.wechat-media.args=["${codexMcpScript}"]`,
+    "-c",
+    `mcp_servers.wechat-media.env.BRIDGE_API_URL="http://localhost:${bridgePort}"`
+  ];
   const providerAdapters = options.providers ?? createDefaultProviders({
     claudeCommand: options.providerCommands?.claude?.command,
-    codexCommand: options.providerCommands?.codex?.command
+    codexCommand: options.providerCommands?.codex?.command,
+    mcpConfigPath,
+    codexMcpServerConfigs
   });
   let currentConversation = conversation.getCurrent();
   if (currentConversation) {
@@ -4639,7 +4997,13 @@ function createDaemonServer(options = {}) {
   const weixinOutboundGate = managedWechatChannel && weixinStateStore ? new WeixinOutboundGate({
     store: weixinStateStore,
     send: async (chatId, msg) => {
-      await managedWechatChannel.sendMessage({ chatId, kind: msg.kind, text: msg.text });
+      await managedWechatChannel.sendMessage({
+        chatId,
+        kind: msg.kind,
+        text: msg.text,
+        ...msg.filePath ? { filePath: msg.filePath } : {},
+        ...msg.fileName ? { fileName: msg.fileName } : {}
+      });
     }
   }) : void 0;
   const tunnelProvider = options.tunnelProvider ?? new RelayTunnelRouter({
@@ -4785,6 +5149,36 @@ function createDaemonServer(options = {}) {
     request.raw.on("error", cleanup);
     return reply.hijack();
   });
+  app.post("/api/channel/send-media", async (request, reply) => {
+    const { kind, filePath, fileName, chatId } = request.body ?? {};
+    if (!filePath || typeof filePath !== "string") {
+      return reply.code(400).send({ ok: false, error: "filePath is required" });
+    }
+    const validKinds = ["image", "video", "audio", "file"];
+    if (!kind || !validKinds.includes(kind)) {
+      return reply.code(400).send({ ok: false, error: `kind must be one of: ${validKinds.join(", ")}` });
+    }
+    if (!channel) {
+      return reply.code(503).send({ ok: false, error: "channel not available" });
+    }
+    const targetChatId = chatId || activeUserStore.getActiveUser()?.platformUserId;
+    if (!targetChatId) {
+      return reply.code(400).send({ ok: false, error: "no active chat target; provide chatId or ensure an active user exists" });
+    }
+    try {
+      await channel.sendMessage({
+        chatId: targetChatId,
+        kind,
+        text: "",
+        filePath,
+        ...fileName ? { fileName } : {}
+      });
+      return { ok: true };
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return reply.code(500).send({ ok: false, error: msg });
+    }
+  });
   app.addHook("onReady", async () => {
     await channel?.start({ background: true });
   });
@@ -4924,7 +5318,7 @@ async function resolveProviderCommands(providers) {
 }
 
 // src/daemon/staticFrontend.ts
-import { readFileSync as readFileSync8 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
 import { join as join12 } from "node:path";
 import fastifyStatic from "@fastify/static";
 function attachStaticFrontend(webRoot2) {
@@ -4933,7 +5327,7 @@ function attachStaticFrontend(webRoot2) {
       root: webRoot2,
       wildcard: false
     });
-    const indexHtml = readFileSync8(join12(webRoot2, "index.html"), "utf8");
+    const indexHtml = readFileSync9(join12(webRoot2, "index.html"), "utf8");
     app.setNotFoundHandler((request, reply) => {
       if (request.url.startsWith("/api")) {
         reply.code(404).send({ error: "not_found" });
@@ -4945,7 +5339,7 @@ function attachStaticFrontend(webRoot2) {
 }
 
 // src/daemon/service.ts
-import { existsSync as existsSync9, statSync, openSync as openSync2, closeSync as closeSync2, watchFile } from "node:fs";
+import { existsSync as existsSync10, statSync, openSync as openSync2, closeSync as closeSync2, watchFile } from "node:fs";
 import { mkdir as mkdir4, readFile as readFile6, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
 import { dirname as dirname8, join as join13 } from "node:path";
@@ -4999,13 +5393,13 @@ async function startService(context) {
 async function stopService(context) {
   if (process.platform === "darwin") {
     const spec = buildLaunchdSpec(context);
-    if (!existsSync9(spec.plistPath)) return await readServiceStatus(context);
+    if (!existsSync10(spec.plistPath)) return await readServiceStatus(context);
     await runLaunchctl(["bootout", `gui/${process.getuid?.() ?? 0}`, spec.plistPath]).catch(() => void 0);
     return await readServiceStatus(context);
   }
   if (process.platform === "linux") {
     const spec = buildSystemdUserSpec(context);
-    if (!existsSync9(spec.unitPath)) return await readServiceStatus(context);
+    if (!existsSync10(spec.unitPath)) return await readServiceStatus(context);
     await runSystemctl(["--user", "stop", spec.unitName]).catch(() => void 0);
     return await readServiceStatus(context);
   }
@@ -5023,7 +5417,7 @@ async function stopService(context) {
 async function uninstallService(context) {
   if (process.platform === "darwin") {
     const spec = buildLaunchdSpec(context);
-    if (existsSync9(spec.plistPath)) {
+    if (existsSync10(spec.plistPath)) {
       await runLaunchctl(["bootout", `gui/${process.getuid?.() ?? 0}`, spec.plistPath]).catch(() => void 0);
       await rm2(spec.plistPath, { force: true });
     }
@@ -5031,7 +5425,7 @@ async function uninstallService(context) {
   }
   if (process.platform === "linux") {
     const spec = buildSystemdUserSpec(context);
-    if (existsSync9(spec.unitPath)) {
+    if (existsSync10(spec.unitPath)) {
       await runSystemctl(["--user", "disable", "--now", spec.unitName]).catch(() => void 0);
       await rm2(spec.unitPath, { force: true });
       await runSystemctl(["--user", "daemon-reload"]).catch(() => void 0);
@@ -5081,7 +5475,7 @@ async function tailServiceLogs(context) {
 async function readServiceStatus(context) {
   if (process.platform === "darwin") {
     const spec = buildLaunchdSpec(context);
-    const installed = existsSync9(spec.plistPath);
+    const installed = existsSync10(spec.plistPath);
     const running = installed ? await runLaunchctl(["print", `gui/${process.getuid?.() ?? 0}/${spec.label}`]).then(() => true, () => false) : false;
     return {
       manager: "launchd",
@@ -5095,7 +5489,7 @@ async function readServiceStatus(context) {
   }
   if (process.platform === "linux") {
     const spec = buildSystemdUserSpec(context);
-    const installed = existsSync9(spec.unitPath);
+    const installed = existsSync10(spec.unitPath);
     const running = installed ? await runSystemctl(["--user", "is-active", "--quiet", spec.unitName]).then(() => true, () => false) : false;
     return {
       manager: "systemd-user",
@@ -5280,7 +5674,7 @@ function isProcessAlive(pid) {
   }
 }
 async function readPidFile(pidPath) {
-  if (!existsSync9(pidPath)) return null;
+  if (!existsSync10(pidPath)) return null;
   try {
     const raw = (await readFile6(pidPath, "utf8")).trim();
     const pid = Number.parseInt(raw, 10);
@@ -5331,12 +5725,12 @@ async function spawnDetachedDaemon(spec) {
   }
 }
 async function tailFile(path, lines) {
-  if (!existsSync9(path)) return "";
+  if (!existsSync10(path)) return "";
   const content = await readFile6(path, "utf8");
   return content.split(/\r?\n/).slice(-lines).join("\n").trim();
 }
 async function tailFiles(paths) {
-  const existing = paths.filter((path) => existsSync9(path));
+  const existing = paths.filter((path) => existsSync10(path));
   for (const path of existing) {
     const tail = await tailFile(path, 200);
     if (tail) process.stdout.write(`[${path}]
@@ -5387,7 +5781,7 @@ function fileSizeHint(path) {
 }
 
 // src/cli.ts
-var here = dirname9(fileURLToPath2(import.meta.url));
+var here = dirname9(fileURLToPath3(import.meta.url));
 var webRoot = join14(here, "..", "web");
 async function main() {
   const command = process.argv[2];
@@ -5437,7 +5831,7 @@ async function main() {
   }
 }
 async function cmdStart() {
-  if (!existsSync10(webRoot)) {
+  if (!existsSync11(webRoot)) {
     console.error(`\u627E\u4E0D\u5230\u524D\u7AEF\u6784\u5EFA\u4EA7\u7269: ${webRoot}`);
     console.error("\u8BF7\u91CD\u65B0\u5B89\u88C5\u5B8C\u6574\u7684 npm \u5305\u3002");
     process.exitCode = 1;
@@ -5468,7 +5862,7 @@ async function cmdTail() {
   await tailServiceLogs(createServiceContext());
 }
 async function cmdDaemon() {
-  if (!existsSync10(webRoot)) {
+  if (!existsSync11(webRoot)) {
     console.error(`\u627E\u4E0D\u5230\u524D\u7AEF\u6784\u5EFA\u4EA7\u7269: ${webRoot}`);
     process.exitCode = 1;
     return;
@@ -5481,13 +5875,13 @@ async function cmdDaemon() {
 async function cmdDoctor() {
   const configPath = process.env.BRIDGE_CONFIG ?? defaultConfigPath();
   console.log("claude-codex-wechat doctor\n");
-  report("\u914D\u7F6E\u6587\u4EF6", existsSync10(configPath) ? configPath : `\u7F3A\u5931 (${configPath})\uFF0C\u9996\u6B21 start \u65F6\u81EA\u52A8\u521B\u5EFA`);
-  report("\u524D\u7AEF\u4EA7\u7269", existsSync10(webRoot) ? webRoot : `\u7F3A\u5931 (${webRoot})`);
+  report("\u914D\u7F6E\u6587\u4EF6", existsSync11(configPath) ? configPath : `\u7F3A\u5931 (${configPath})\uFF0C\u9996\u6B21 start \u65F6\u81EA\u52A8\u521B\u5EFA`);
+  report("\u524D\u7AEF\u4EA7\u7269", existsSync11(webRoot) ? webRoot : `\u7F3A\u5931 (${webRoot})`);
   const claude = await findExecutable("claude");
   report("claude \u53EF\u6267\u884C", claude ?? "\u672A\u627E\u5230\uFF0C\u9700\u5148\u5B89\u88C5\u5E76\u767B\u5F55 Claude Code");
   const codex = await findExecutable("codex");
   report("codex \u53EF\u6267\u884C", codex ?? "\u672A\u627E\u5230\uFF08\u4EC5\u4F7F\u7528 Claude \u65F6\u53EF\u5FFD\u7565\uFF09");
-  if (existsSync10(configPath)) {
+  if (existsSync11(configPath)) {
     const config = loadBridgeConfig(configPath);
     const wechat = config.wechat;
     report("\u5FAE\u4FE1\u542F\u7528", wechat?.enabled ? "\u662F" : "\u5426");
@@ -5498,7 +5892,7 @@ async function cmdDoctor() {
 }
 function printUpdateHint() {
   const configPath = process.env.BRIDGE_CONFIG ?? defaultConfigPath();
-  if (!existsSync10(configPath)) return;
+  if (!existsSync11(configPath)) return;
   let update;
   try {
     update = loadBridgeConfig(configPath).update;
@@ -5514,12 +5908,12 @@ function printUpdateHint() {
 }
 function cmdPrintConfig() {
   const configPath = process.env.BRIDGE_CONFIG ?? defaultConfigPath();
-  if (!existsSync10(configPath)) {
+  if (!existsSync11(configPath)) {
     console.error(`\u914D\u7F6E\u4E0D\u5B58\u5728: ${configPath}\uFF08\u9996\u6B21 start \u540E\u81EA\u52A8\u751F\u6210\uFF09`);
     process.exitCode = 1;
     return;
   }
-  console.log(readFileSync9(configPath, "utf8"));
+  console.log(readFileSync10(configPath, "utf8"));
 }
 async function cmdUninstall() {
   const status = await uninstallService(createServiceContext());
@@ -5527,7 +5921,7 @@ async function cmdUninstall() {
 }
 function createServiceContext() {
   return {
-    cliEntrypointPath: fileURLToPath2(import.meta.url),
+    cliEntrypointPath: fileURLToPath3(import.meta.url),
     nodePath: process.execPath,
     configPath: process.env.BRIDGE_CONFIG ?? defaultConfigPath(),
     port: Number(process.env.BRIDGE_PORT ?? 8787)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-codex-wechat",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "private": false,
   "type": "module",
   "packageManager": "pnpm@11.5.0",
@@ -39,10 +39,12 @@
   },
   "dependencies": {
     "@fastify/static": "^9.1.3",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "latest",
     "fastify": "latest",
     "lucide-react": "^1.22.0",
-    "nanoid": "latest"
+    "nanoid": "latest",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@fastify/middie": "^9.3.2",