opencode-feishu 0.3.6 → 0.4.0

package/dist/index.js

@@ -1,10 +1,12 @@
 import fs, { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import https, { request } from 'https';
+import { text } from 'stream/consumers';
+import { HttpsProxyAgent } from 'https-proxy-agent';
 import crypto2 from 'crypto';
 import url from 'url';
 import http from 'http';
-import https from 'https';
 import http2 from 'http2';
 import util2 from 'util';
 import zlib from 'zlib';
@@ -12,7 +14,6 @@ import stream3, { Readable } from 'stream';
 import { EventEmitter } from 'events';
 import qs from 'querystring';
 import WebSocket from 'ws';
-import { HttpsProxyAgent } from 'https-proxy-agent';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -18949,9 +18950,9 @@ var trackStream = (stream4, chunkSize, onProgress, onFinish) => {
 // node_modules/axios/lib/adapters/fetch.js
 var DEFAULT_CHUNK_SIZE = 64 * 1024;
 var { isFunction: isFunction2 } = utils_default;
-var globalFetchAPI = (({ Request, Response }) => ({
+var globalFetchAPI = (({ Request, Response: Response2 }) => ({
   Request,
-  Response
+  Response: Response2
 }))(utils_default.global);
 var {
   ReadableStream: ReadableStream2,
@@ -18968,10 +18969,10 @@ var factory = (env) => {
   env = utils_default.merge.call({
     skipUndefined: true
   }, globalFetchAPI, env);
-  const { fetch: envFetch, Request, Response } = env;
+  const { fetch: envFetch, Request, Response: Response2 } = env;
   const isFetchSupported = envFetch ? isFunction2(envFetch) : typeof fetch === "function";
   const isRequestSupported = isFunction2(Request);
-  const isResponseSupported = isFunction2(Response);
+  const isResponseSupported = isFunction2(Response2);
   if (!isFetchSupported) {
     return false;
   }
@@ -18989,7 +18990,7 @@ var factory = (env) => {
     }).headers.has("Content-Type");
     return duplexAccessed && !hasContentType;
   });
-  const supportsResponseStream = isResponseSupported && isReadableStreamSupported && test(() => utils_default.isReadableStream(new Response("").body));
+  const supportsResponseStream = isResponseSupported && isReadableStreamSupported && test(() => utils_default.isReadableStream(new Response2("").body));
   const resolvers = {
     stream: supportsResponseStream && ((res) => res.body)
   };
@@ -19100,7 +19101,7 @@ var factory = (env) => {
           responseContentLength,
           progressEventReducer(asyncDecorator(onDownloadProgress), true)
         ) || [];
-        response = new Response(
+        response = new Response2(
           trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
             flush && flush();
             unsubscribe && unsubscribe();
@@ -19138,10 +19139,10 @@ var factory = (env) => {
 var seedCache = /* @__PURE__ */ new Map();
 var getFetch = (config) => {
   let env = config && config.env || {};
-  const { fetch: fetch2, Request, Response } = env;
+  const { fetch: fetch2, Request, Response: Response2 } = env;
   const seeds = [
     Request,
-    Response,
+    Response2,
     fetch2
   ];
   let len = seeds.length, i = len, seed, target, map = seedCache;
@@ -98760,6 +98761,256 @@ function isDuplicate(messageId) {
   return false;
 }
 
+// src/feishu/resource.ts
+var MAX_RESOURCE_SIZE = 10 * 1024 * 1024;
+async function downloadMessageResource(client, messageId, fileKey, type, log) {
+  try {
+    const res = await client.im.messageResource.get({
+      path: { message_id: messageId, file_key: fileKey },
+      params: { type }
+    });
+    if (!res) {
+      log("warn", "\u8D44\u6E90\u4E0B\u8F7D\u8FD4\u56DE\u7A7A\u6570\u636E", { messageId, fileKey, type });
+      return null;
+    }
+    const stream4 = res.getReadableStream();
+    const chunks = [];
+    let totalSize = 0;
+    for await (const chunk of stream4) {
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      totalSize += buf.length;
+      if (totalSize > MAX_RESOURCE_SIZE) {
+        log("warn", "\u8D44\u6E90\u8FC7\u5927\uFF0C\u8DF3\u8FC7\u4E0B\u8F7D", { messageId, fileKey, totalSize });
+        stream4.destroy();
+        return null;
+      }
+      chunks.push(buf);
+    }
+    const buffer = Buffer.concat(chunks);
+    const headers = res.headers;
+    const contentType = headers?.["content-type"] ?? guessMimeByType(type);
+    const base64 = buffer.toString("base64");
+    const dataUrl = `data:${contentType};base64,${base64}`;
+    return { dataUrl, mime: contentType };
+  } catch (err) {
+    log("warn", "\u8D44\u6E90\u4E0B\u8F7D\u5931\u8D25", {
+      messageId,
+      fileKey,
+      type,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  }
+}
+function guessMimeByType(type) {
+  return type === "image" ? "image/png" : "application/octet-stream";
+}
+function guessMimeByFilename(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+  const map = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    bmp: "image/bmp",
+    pdf: "application/pdf",
+    doc: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xls: "application/vnd.ms-excel",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ppt: "application/vnd.ms-powerpoint",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    txt: "text/plain",
+    csv: "text/csv",
+    json: "application/json",
+    xml: "application/xml",
+    zip: "application/zip",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    ogg: "audio/ogg",
+    opus: "audio/opus",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    mov: "video/quicktime"
+  };
+  return map[ext] ?? "application/octet-stream";
+}
+
+// src/feishu/content-extractor.ts
+async function extractParts(feishuClient, messageId, messageType, rawContent, log) {
+  try {
+    switch (messageType) {
+      case "text":
+        return extractText(rawContent);
+      case "image":
+        return await extractImage(feishuClient, messageId, rawContent, log);
+      case "post":
+        return extractPost(rawContent);
+      case "file":
+        return await extractFile(feishuClient, messageId, rawContent, log);
+      case "audio":
+        return await extractAudio(feishuClient, messageId, rawContent, log);
+      case "media":
+        return extractMediaFallback();
+      case "sticker":
+        return [{ type: "text", text: "[\u8868\u60C5\u5305]" }];
+      case "interactive":
+        return extractInteractive(rawContent);
+      case "share_chat":
+        return extractShareChat(rawContent);
+      case "share_user":
+        return [{ type: "text", text: "[\u5206\u4EAB\u4E86\u4E00\u4E2A\u7528\u6237\u540D\u7247]" }];
+      case "merge_forward":
+        return [{ type: "text", text: "[\u5408\u5E76\u8F6C\u53D1\u6D88\u606F]" }];
+      default:
+        return [{ type: "text", text: `[\u4E0D\u652F\u6301\u7684\u6D88\u606F\u7C7B\u578B: ${messageType}]` }];
+    }
+  } catch (err) {
+    log("warn", "\u6D88\u606F\u5185\u5BB9\u63D0\u53D6\u5931\u8D25", {
+      messageId,
+      messageType,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return [{ type: "text", text: `[\u6D88\u606F\u5185\u5BB9\u63D0\u53D6\u5931\u8D25: ${messageType}]` }];
+  }
+}
+function describeMessageType(messageType, rawContent) {
+  switch (messageType) {
+    case "text": {
+      try {
+        const parsed = JSON.parse(rawContent);
+        return (parsed.text ?? "").trim();
+      } catch {
+        return "";
+      }
+    }
+    case "image":
+      return "[\u56FE\u7247]";
+    case "post":
+      return extractPostText(rawContent);
+    case "file": {
+      try {
+        const parsed = JSON.parse(rawContent);
+        return `[\u6587\u4EF6: ${parsed.file_name ?? "\u672A\u77E5\u6587\u4EF6"}]`;
+      } catch {
+        return "[\u6587\u4EF6]";
+      }
+    }
+    case "audio":
+      return "[\u8BED\u97F3\u6D88\u606F]";
+    case "media":
+      return "[\u89C6\u9891\u6D88\u606F]";
+    case "sticker":
+      return "[\u8868\u60C5\u5305]";
+    case "interactive":
+      return "[\u5361\u7247\u6D88\u606F]";
+    case "share_chat":
+      return "[\u7FA4\u5206\u4EAB]";
+    case "share_user":
+      return "[\u7528\u6237\u540D\u7247]";
+    case "merge_forward":
+      return "[\u5408\u5E76\u8F6C\u53D1]";
+    default:
+      return `[${messageType}]`;
+  }
+}
+function extractText(rawContent) {
+  const parsed = JSON.parse(rawContent);
+  const text2 = (parsed.text ?? "").trim();
+  if (!text2) return [];
+  return [{ type: "text", text: text2 }];
+}
+async function extractImage(client, messageId, rawContent, log) {
+  const parsed = JSON.parse(rawContent);
+  const imageKey = parsed.image_key;
+  if (!imageKey) return [{ type: "text", text: "[\u56FE\u7247: \u65E0\u6CD5\u83B7\u53D6]" }];
+  const resource = await downloadMessageResource(client, messageId, imageKey, "image", log);
+  if (!resource) return [{ type: "text", text: "[\u56FE\u7247: \u4E0B\u8F7D\u5931\u8D25]" }];
+  return [{ type: "file", mime: resource.mime, url: resource.dataUrl }];
+}
+function extractPost(rawContent) {
+  const text2 = extractPostText(rawContent);
+  if (!text2) return [];
+  return [{ type: "text", text: text2 }];
+}
+function extractPostText(rawContent) {
+  try {
+    const parsed = JSON.parse(rawContent);
+    const lines = [];
+    if (parsed.title) lines.push(parsed.title);
+    if (Array.isArray(parsed.content)) {
+      for (const paragraph of parsed.content) {
+        if (!Array.isArray(paragraph)) continue;
+        const segments = [];
+        for (const element of paragraph) {
+          if (element.tag === "text" && element.text) {
+            segments.push(element.text);
+          } else if (element.tag === "a" && element.text) {
+            segments.push(element.href ? `${element.text}(${element.href})` : element.text);
+          } else if (element.tag === "at" && element.text) {
+            segments.push(element.text);
+          } else if (element.tag === "img") {
+            segments.push("[\u56FE\u7247]");
+          }
+        }
+        if (segments.length) lines.push(segments.join(""));
+      }
+    }
+    return lines.join("\n").trim();
+  } catch {
+    return "";
+  }
+}
+async function extractFile(client, messageId, rawContent, log) {
+  const parsed = JSON.parse(rawContent);
+  const fileKey = parsed.file_key;
+  const fileName = parsed.file_name ?? "\u672A\u77E5\u6587\u4EF6";
+  if (!fileKey) return [{ type: "text", text: `[\u6587\u4EF6: ${fileName}]` }];
+  const mime = guessMimeByFilename(fileName);
+  const resource = await downloadMessageResource(client, messageId, fileKey, "file", log);
+  if (!resource) return [{ type: "text", text: `[\u6587\u4EF6\u4E0B\u8F7D\u5931\u8D25: ${fileName}]` }];
+  return [{ type: "file", mime: resource.mime || mime, url: resource.dataUrl, filename: fileName }];
+}
+async function extractAudio(client, messageId, rawContent, log) {
+  const parsed = JSON.parse(rawContent);
+  const fileKey = parsed.file_key;
+  if (!fileKey) return [{ type: "text", text: "[\u8BED\u97F3: \u65E0\u6CD5\u83B7\u53D6]" }];
+  const resource = await downloadMessageResource(client, messageId, fileKey, "file", log);
+  if (!resource) return [{ type: "text", text: "[\u8BED\u97F3: \u4E0B\u8F7D\u5931\u8D25]" }];
+  return [{ type: "file", mime: resource.mime || "audio/opus", url: resource.dataUrl }];
+}
+function extractMediaFallback() {
+  return [{ type: "text", text: "[\u89C6\u9891\u6D88\u606F]" }];
+}
+function extractInteractive(rawContent) {
+  try {
+    const parsed = JSON.parse(rawContent);
+    const texts = [];
+    if (parsed.header?.title?.content) texts.push(parsed.header.title.content);
+    if (Array.isArray(parsed.elements)) {
+      for (const el of parsed.elements) {
+        if (el.tag === "div" && el.text?.content) texts.push(el.text.content);
+        else if (el.tag === "markdown" && el.content) texts.push(el.content);
+      }
+    }
+    const text2 = texts.join("\n").trim();
+    return text2 ? [{ type: "text", text: `[\u5361\u7247\u6D88\u606F]
+${text2}` }] : [{ type: "text", text: "[\u5361\u7247\u6D88\u606F]" }];
+  } catch {
+    return [{ type: "text", text: "[\u5361\u7247\u6D88\u606F]" }];
+  }
+}
+function extractShareChat(rawContent) {
+  try {
+    const parsed = JSON.parse(rawContent);
+    return [{ type: "text", text: `[\u5206\u4EAB\u4E86\u4E00\u4E2A\u7FA4\u804A${parsed.chat_id ? `: ${parsed.chat_id}` : ""}]` }];
+  } catch {
+    return [{ type: "text", text: "[\u7FA4\u5206\u4EAB]" }];
+  }
+}
+
 // src/feishu/group-filter.ts
 function isBotMentioned(mentions, botOpenId) {
   return mentions.some((m) => m.id?.open_id === botOpenId);
@@ -98795,22 +99046,19 @@ function startFeishuGateway(options) {
         const messageId = message.message_id;
         if (isDuplicate(messageId)) return;
         const messageType = message.message_type ?? "text";
+        const rawContent = message.content ?? "";
         log("info", "\u98DE\u4E66\u6D88\u606F\u5143\u4FE1\u606F", {
           chatId,
           messageId: messageId ?? "",
           messageType,
-          hasContent: !!message.content
+          hasContent: !!rawContent
         });
-        if (messageType !== "text" || !message.content) return;
-        let text;
-        try {
-          const parsed = JSON.parse(message.content);
-          text = (parsed.text ?? "").trim();
-        } catch {
-          return;
+        if (!rawContent) return;
+        let text2 = describeMessageType(messageType, rawContent);
+        if (messageType === "text") {
+          text2 = text2.replace(/@_user_\d+\s*/g, "").trim();
         }
-        text = text.replace(/@_user_\d+\s*/g, "").trim();
-        if (!text) return;
+        if (!text2) return;
         const chatType = message.chat_type === "group" ? "group" : "p2p";
         let shouldReply = true;
         if (chatType === "group") {
@@ -98828,7 +99076,8 @@ function startFeishuGateway(options) {
           chatId: String(chatId),
           messageId: messageId ?? "",
           messageType,
-          content: text,
+          content: text2,
+          rawContent,
           chatType,
           senderId,
           rootId,
@@ -98840,7 +99089,7 @@ function startFeishuGateway(options) {
           messageId: messageId ?? "",
           chatType,
           shouldReply,
-          textPreview: text.slice(0, 80)
+          textPreview: text2.slice(0, 80)
         });
         await onMessage(ctx);
       } catch (err) {
@@ -98894,7 +99143,7 @@ function startFeishuGateway(options) {
 }
 
 // src/feishu/sender.ts
-async function sendTextMessage(client, chatId, text) {
+async function sendTextMessage(client, chatId, text2) {
   if (!chatId?.trim()) {
     return { ok: false, error: "No chat_id provided" };
   }
@@ -98904,7 +99153,7 @@ async function sendTextMessage(client, chatId, text) {
       data: {
         receive_id: chatId.trim(),
         msg_type: "text",
-        content: JSON.stringify({ text })
+        content: JSON.stringify({ text: text2 })
       }
     });
     return { ok: true, messageId: res?.data?.message_id ?? "" };
@@ -98912,13 +99161,13 @@ async function sendTextMessage(client, chatId, text) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
   }
 }
-async function updateMessage(client, messageId, text) {
+async function updateMessage(client, messageId, text2) {
   try {
     await client.im.message.update({
       path: { message_id: messageId },
       data: {
         msg_type: "text",
-        content: JSON.stringify({ text })
+        content: JSON.stringify({ text: text2 })
       }
     });
     return { ok: true, messageId };
@@ -98944,14 +99193,19 @@ async function handleEvent(event) {
       if (!sessionId) break;
       const payload = pendingBySession.get(sessionId);
       if (!payload) break;
-      const added = extractPartText(part);
-      if (added) {
-        payload.textBuffer += added;
-        try {
-          await updateMessage(payload.feishuClient, payload.placeholderId, payload.textBuffer.trim());
-        } catch {
+      const delta = event.properties.delta;
+      if (delta) {
+        payload.textBuffer += delta;
+      } else {
+        const fullText = extractPartText(part);
+        if (fullText) {
+          payload.textBuffer = fullText;
         }
       }
+      if (payload.textBuffer) {
+        const res = await updateMessage(payload.feishuClient, payload.placeholderId, payload.textBuffer.trim());
+        if (!res.ok) ;
+      }
       break;
     }
     case "session.error": {
@@ -98961,9 +99215,8 @@ async function handleEvent(event) {
       const payload = pendingBySession.get(sessionId);
       if (!payload) break;
       const errMsg = props.error?.message ?? String(props.error);
-      try {
-        await updateMessage(payload.feishuClient, payload.placeholderId, `\u274C \u4F1A\u8BDD\u9519\u8BEF: ${errMsg}`);
-      } catch {
+      const updateRes = await updateMessage(payload.feishuClient, payload.placeholderId, `\u274C \u4F1A\u8BDD\u9519\u8BEF: ${errMsg}`);
+      if (!updateRes.ok) {
         await sendTextMessage(payload.feishuClient, payload.chatId, `\u274C \u4F1A\u8BDD\u9519\u8BEF: ${errMsg}`);
       }
       break;
@@ -99015,26 +99268,21 @@ async function getOrCreateSession(client, sessionKey, directory) {
 
 // src/handler/chat.ts
 async function handleChat(ctx, deps) {
-  const { content, chatId, chatType, senderId, createTime, shouldReply } = ctx;
-  if (!content.trim()) return;
+  const { content, chatId, chatType, senderId, shouldReply, messageType, rawContent, messageId } = ctx;
+  if (!content.trim() && messageType === "text") return;
   const { config, client, feishuClient, log, directory } = deps;
   const query = directory ? { directory } : void 0;
   const sessionKey = buildSessionKey(chatType, chatType === "p2p" ? senderId : chatId);
   const session = await getOrCreateSession(client, sessionKey, directory);
-  const timeStr = createTime ? new Date(Number(createTime)).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" }) : "";
-  let promptContent = content;
-  if (chatType === "group" && senderId) {
-    promptContent = timeStr ? `[${timeStr}] [${senderId}]: ${content}` : `[${senderId}]: ${content}`;
-  } else if (timeStr) {
-    promptContent = `[${timeStr}] ${content}`;
-  }
+  const parts = await buildPromptParts(feishuClient, messageId, messageType, rawContent, content, chatType, senderId, log);
+  if (!parts.length) return;
   if (!shouldReply) {
     try {
       await client.session.prompt({
         path: { id: session.id },
         query,
         body: {
-          parts: [{ type: "text", text: promptContent }],
+          parts,
           noReply: true
         }
       });
@@ -99055,11 +99303,16 @@ async function handleChat(ctx, deps) {
     if (done) return;
     try {
       const res = await sendTextMessage(feishuClient, chatId, "\u6B63\u5728\u601D\u8003\u2026");
+      if (done) return;
       if (res.ok && res.messageId) {
         placeholderId = res.messageId;
         registerPending(session.id, { chatId, placeholderId, feishuClient });
       }
-    } catch {
+    } catch (err) {
+      log("warn", "\u53D1\u9001\u5360\u4F4D\u6D88\u606F\u5931\u8D25", {
+        chatId,
+        error: err instanceof Error ? err.message : String(err)
+      });
     }
   }, thinkingDelay) : null;
   try {
@@ -99067,7 +99320,7 @@ async function handleChat(ctx, deps) {
       path: { id: session.id },
       query,
       body: {
-        parts: [{ type: "text", text: promptContent }]
+        parts
       }
     });
     const start = Date.now();
@@ -99076,17 +99329,11 @@ async function handleChat(ctx, deps) {
     while (Date.now() - start < timeout) {
       await new Promise((r) => setTimeout(r, pollInterval));
       const { data: messages } = await client.session.messages({ path: { id: session.id }, query });
-      const text = extractLastAssistantText(messages ?? []);
-      if (text && text !== lastText) {
-        lastText = text;
+      const text2 = extractLastAssistantText(messages ?? []);
+      if (text2 && text2 !== lastText) {
+        lastText = text2;
         sameCount = 0;
-        if (placeholderId) {
-          try {
-            await updateMessage(feishuClient, placeholderId, text);
-          } catch {
-          }
-        }
-      } else if (text && text.length > 0) {
+      } else if (text2 && text2.length > 0) {
         sameCount++;
         if (sameCount >= stablePolls) break;
       }
@@ -99106,15 +99353,28 @@ async function handleChat(ctx, deps) {
     unregisterPending(session.id);
   }
 }
-async function replyOrUpdate(feishuClient, chatId, placeholderId, text) {
+async function buildPromptParts(feishuClient, messageId, messageType, rawContent, textContent, chatType, senderId, log) {
+  if (messageType === "text") {
+    let promptText = textContent;
+    if (chatType === "group" && senderId) {
+      promptText = `[${senderId}]: ${textContent}`;
+    }
+    return [{ type: "text", text: promptText }];
+  }
+  const parts = await extractParts(feishuClient, messageId, messageType, rawContent, log);
+  if (chatType === "group" && senderId && parts.length > 0) {
+    return [{ type: "text", text: `[${senderId}]:` }, ...parts];
+  }
+  return parts;
+}
+async function replyOrUpdate(feishuClient, chatId, placeholderId, text2) {
   if (placeholderId) {
-    try {
-      await updateMessage(feishuClient, placeholderId, text);
-    } catch {
-      await sendTextMessage(feishuClient, chatId, text);
+    const res = await updateMessage(feishuClient, placeholderId, text2);
+    if (!res.ok) {
+      await sendTextMessage(feishuClient, chatId, text2);
     }
   } else {
-    await sendTextMessage(feishuClient, chatId, text);
+    await sendTextMessage(feishuClient, chatId, text2);
   }
 }
 function extractLastAssistantText(messages) {
@@ -99126,7 +99386,8 @@ function extractLastAssistantText(messages) {
 // src/feishu/history.ts
 var DEFAULT_PAGE_SIZE = 50;
 async function ingestGroupHistory(feishuClient, opencodeClient, chatId, options) {
-  const { maxMessages, log } = options;
+  const { maxMessages, log, directory } = options;
+  const query = directory ? { directory } : void 0;
   log("info", "\u5F00\u59CB\u6444\u5165\u7FA4\u804A\u5386\u53F2\u4E0A\u4E0B\u6587", { chatId, maxMessages });
   const messages = await fetchRecentMessages(feishuClient, chatId, maxMessages, log);
   if (!messages.length) {
@@ -99134,10 +99395,11 @@ async function ingestGroupHistory(feishuClient, opencodeClient, chatId, options)
     return;
   }
   const sessionKey = buildSessionKey("group", chatId);
-  const session = await getOrCreateSession(opencodeClient, sessionKey);
+  const session = await getOrCreateSession(opencodeClient, sessionKey, directory);
   const contextText = formatHistoryAsContext(messages);
   await opencodeClient.session.prompt({
     path: { id: session.id },
+    query,
     body: {
       parts: [{ type: "text", text: contextText }],
       noReply: true
@@ -99163,19 +99425,15 @@ async function fetchRecentMessages(client, chatId, maxMessages, log) {
       if (!items || items.length === 0) break;
       for (const item of items) {
         if (item.deleted) continue;
-        if (item.msg_type !== "text" || !item.body?.content) continue;
-        let text;
-        try {
-          const parsed = JSON.parse(item.body.content);
-          text = (parsed.text ?? "").trim();
-        } catch {
-          continue;
-        }
-        if (!text) continue;
+        if (!item.body?.content) continue;
+        const msgType = item.msg_type ?? "text";
+        const rawContent = item.body.content;
+        const text2 = describeMessageType(msgType, rawContent);
+        if (!text2) continue;
         result.push({
           senderType: item.sender?.sender_type ?? "unknown",
           senderId: item.sender?.id ?? "",
-          content: text,
+          content: text2,
           createTime: item.create_time ?? ""
         });
         if (result.length >= maxMessages) break;
@@ -99217,7 +99475,8 @@ var DEFAULT_CONFIG = {
   maxHistoryMessages: 200,
   pollInterval: 1e3,
   stablePolls: 3,
-  dedupTtl: 10 * 60 * 1e3
+  dedupTtl: 10 * 60 * 1e3,
+  directory: ""
 };
 var FeishuPlugin = async (ctx) => {
   const { client } = ctx;
@@ -99250,6 +99509,11 @@ var FeishuPlugin = async (ctx) => {
   } catch (parseErr) {
     throw new Error(`\u98DE\u4E66\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u9519\u8BEF\uFF1A${configPath} \u5FC5\u987B\u662F\u5408\u6CD5\u7684 JSON (${parseErr})`);
   }
+  if (feishuRaw.directory !== void 0 && typeof feishuRaw.directory !== "string") {
+    throw new Error(
+      `\u98DE\u4E66\u914D\u7F6E\u9519\u8BEF\uFF1A${configPath} \u4E2D\u7684 'directory' \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`
+    );
+  }
   if (!feishuRaw.appId || !feishuRaw.appSecret) {
     throw new Error(
       `\u98DE\u4E66\u914D\u7F6E\u4E0D\u5B8C\u6574\uFF1A${configPath} \u4E2D\u5FC5\u987B\u5305\u542B appId \u548C appSecret`
@@ -99264,7 +99528,8 @@ var FeishuPlugin = async (ctx) => {
     maxHistoryMessages: feishuRaw.maxHistoryMessages ?? DEFAULT_CONFIG.maxHistoryMessages,
     pollInterval: feishuRaw.pollInterval ?? DEFAULT_CONFIG.pollInterval,
     stablePolls: feishuRaw.stablePolls ?? DEFAULT_CONFIG.stablePolls,
-    dedupTtl: feishuRaw.dedupTtl ?? DEFAULT_CONFIG.dedupTtl
+    dedupTtl: feishuRaw.dedupTtl ?? DEFAULT_CONFIG.dedupTtl,
+    directory: feishuRaw.directory ?? ctx.directory ?? DEFAULT_CONFIG.directory
   };
   initDedup(resolvedConfig.dedupTtl);
   const botOpenId = await fetchBotOpenId(resolvedConfig.appId, resolvedConfig.appSecret, log);
@@ -99278,14 +99543,15 @@ var FeishuPlugin = async (ctx) => {
         client,
         feishuClient: gateway.client,
         log,
-        directory: ctx.directory
+        directory: resolvedConfig.directory
       });
     },
     onBotAdded: (chatId) => {
       if (!gateway) return;
       ingestGroupHistory(gateway.client, client, chatId, {
         maxMessages: resolvedConfig.maxHistoryMessages,
-        log
+        log,
+        directory: resolvedConfig.directory
       }).catch((err) => {
         log("error", "\u7FA4\u804A\u5386\u53F2\u6444\u5165\u5931\u8D25", {
           chatId,
@@ -99330,8 +99596,32 @@ function resolveEnvPlaceholders(obj) {
   }
   return obj;
 }
+function proxyFetch(url2, init) {
+  const proxyUrl = process.env.HTTPS_PROXY || process.env.HTTP_PROXY || process.env.ALL_PROXY || "";
+  if (!proxyUrl) return fetch(url2, init);
+  const parsed = new URL(url2);
+  return new Promise((resolve, reject) => {
+    const req = request(
+      {
+        hostname: parsed.hostname,
+        path: parsed.pathname + parsed.search,
+        method: init?.method ?? "GET",
+        headers: init?.headers,
+        agent: new HttpsProxyAgent(proxyUrl)
+      },
+      (res) => {
+        text(res).then(
+          (body) => resolve(new Response(body, { status: res.statusCode ?? 0 }))
+        ).catch(reject);
+      }
+    );
+    req.on("error", reject);
+    if (init?.body) req.write(init.body);
+    req.end();
+  });
+}
 async function fetchBotOpenId(appId, appSecret, log) {
-  const tokenRes = await fetch("https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal", {
+  const tokenRes = await proxyFetch("https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ app_id: appId, app_secret: appSecret })
@@ -99341,7 +99631,7 @@ async function fetchBotOpenId(appId, appSecret, log) {
   if (!token) {
     throw new Error("\u83B7\u53D6 tenant_access_token \u5931\u8D25\uFF0C\u65E0\u6CD5\u542F\u52A8\u7FA4\u804A @\u63D0\u53CA\u68C0\u6D4B");
   }
-  const botRes = await fetch("https://open.feishu.cn/open-apis/bot/v3/info", {
+  const botRes = await proxyFetch("https://open.feishu.cn/open-apis/bot/v3/info", {
     method: "GET",
     headers: { Authorization: `Bearer ${token}` }
   });