@seqyuan/annodex 0.1.72 → 0.1.74

package/bin/annodex-im-gateway.js

@@ -6,7 +6,12 @@ const http = require("http");
 const https = require("https");
 const os = require("os");
 const path = require("path");
+const crypto = require("crypto");
 const WebSocket = require("ws");
+const imMedia = require("../lib/im-media.js");
+
+const UPLOAD_CHUNK_SIZE = 512 * 1024;
+const REQUEST_TIMEOUT_MS = 30_000;
 
 const REVISION_DIGITS = ["\u200b", "\u200c", "\u200d", "\u2060", "\ufeff"];
 const REVISION_SUFFIX_PATTERN = /[\u200b\u200c\u200d\u2060\ufeff]+$/u;
@@ -340,6 +345,7 @@ class WeComWsClient {
     this.ws = null;
     this.heartbeatTimer = null;
     this.pendingAcks = new Map();
+    this.pendingResponses = new Map();
     this.authenticated = createDeferred();
   }
 
@@ -408,6 +414,90 @@ class WeComWsClient {
     }).catch(() => undefined);
   }
 
+  async sendRequest(cmd, body, timeoutMs = REQUEST_TIMEOUT_MS, reqId = `${cmd}_${crypto.randomUUID()}`) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingResponses.delete(reqId);
+        reject(new Error(`wecom request timeout for ${cmd}`));
+      }, timeoutMs);
+      this.pendingResponses.set(reqId, { resolve, reject, timeout });
+      void this.sendFrame({ cmd, headers: { req_id: reqId }, body }).catch((error) => {
+        clearTimeout(timeout);
+        this.pendingResponses.delete(reqId);
+        reject(error);
+      });
+    });
+  }
+
+  raiseForWeComError(frame, context) {
+    if ((frame.errcode ?? 0) === 0) return;
+    const error = new Error(frame.errmsg || `wecom ${context} failed (${frame.errcode})`);
+    error.errcode = frame.errcode;
+    error.errmsg = frame.errmsg;
+    throw error;
+  }
+
+  async uploadMediaFile(filePath, options = {}) {
+    const data = fs.readFileSync(filePath);
+    const fileName = (options.fileName || path.basename(filePath) || "file").trim();
+    const mediaType = (options.mediaType || "file").trim();
+    const totalSize = data.length;
+    const totalChunks = Math.ceil(totalSize / UPLOAD_CHUNK_SIZE);
+    if (totalChunks > 100) {
+      throw new Error(`File too large for WeCom upload (${totalChunks} chunks)`);
+    }
+
+    const initResponse = await this.sendRequest("aibot_upload_media_init", {
+      type: mediaType,
+      filename: fileName,
+      total_size: totalSize,
+      total_chunks: totalChunks,
+      md5: crypto.createHash("md5").update(data).digest("hex"),
+    });
+    this.raiseForWeComError(initResponse, "media upload init");
+
+    const initBody = asRecord(initResponse.body);
+    const uploadId = resolveOptionalString(initBody?.upload_id);
+    if (!uploadId) throw new Error("media upload init failed: missing upload_id");
+
+    for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex += 1) {
+      const start = chunkIndex * UPLOAD_CHUNK_SIZE;
+      const chunk = data.subarray(start, start + UPLOAD_CHUNK_SIZE);
+      const chunkResponse = await this.sendRequest("aibot_upload_media_chunk", {
+        upload_id: uploadId,
+        chunk_index: chunkIndex,
+        base64_data: chunk.toString("base64"),
+      });
+      this.raiseForWeComError(chunkResponse, `media upload chunk ${chunkIndex}`);
+    }
+
+    const finishResponse = await this.sendRequest("aibot_upload_media_finish", { upload_id: uploadId });
+    this.raiseForWeComError(finishResponse, "media upload finish");
+
+    const finishBody = asRecord(finishResponse.body);
+    const mediaId = resolveOptionalString(finishBody?.media_id);
+    if (!mediaId) throw new Error("media upload finish failed: missing media_id");
+
+    return {
+      mediaId,
+      mediaType: resolveOptionalString(finishBody?.type) || mediaType,
+      fileName,
+    };
+  }
+
+  async replyMediaMessage(reqId, mediaType, mediaId) {
+    const response = await this.sendRequest(
+      "aibot_respond_msg",
+      {
+        msgtype: mediaType,
+        [mediaType]: { media_id: mediaId },
+      },
+      REQUEST_TIMEOUT_MS,
+      reqId,
+    );
+    this.raiseForWeComError(response, "send reply media");
+  }
+
   async disconnect() {
     this.stopHeartbeat();
     this.rejectPendingAcks(new Error("wecom websocket disconnected"));
@@ -424,6 +514,23 @@ class WeComWsClient {
     const frame = JSON.parse(frameText);
     const reqId = frame.headers?.req_id?.trim();
 
+    if (reqId && this.pendingResponses.has(reqId)) {
+      const pending = this.pendingResponses.get(reqId);
+      if (pending) {
+        this.pendingResponses.delete(reqId);
+        clearTimeout(pending.timeout);
+        if ((frame.errcode ?? 0) !== 0) {
+          pending.reject(Object.assign(new Error(frame.errmsg || "wecom request failed"), {
+            errcode: frame.errcode,
+            errmsg: frame.errmsg,
+          }));
+        } else {
+          pending.resolve(frame);
+        }
+      }
+      return;
+    }
+
     if (reqId && this.pendingAcks.has(reqId)) {
       const pending = this.pendingAcks.get(reqId);
       if (pending) {
@@ -485,6 +592,11 @@ class WeComWsClient {
       clearTimeout(pending.timeout);
       pending.reject(error);
     }
+    for (const [reqId, pending] of this.pendingResponses) {
+      this.pendingResponses.delete(reqId);
+      clearTimeout(pending.timeout);
+      pending.reject(error);
+    }
   }
 }
 
@@ -575,6 +687,7 @@ class ProjectWeComBridge {
     this.client = null;
     this.stopped = false;
     this.reconnectTimer = null;
+    this.mediaUploadDisabled = false;
   }
 
   async start() {
@@ -620,6 +733,53 @@ class ProjectWeComBridge {
     this.client = null;
   }
 
+  async deliverMedia(reqId, mediaPaths) {
+    const fallbacks = [];
+    if (!mediaPaths.length || !this.client) return fallbacks;
+
+    for (const rawPath of mediaPaths) {
+      const resolved = imMedia.resolveMediaPath(rawPath, this.project.cwd);
+      if (!resolved.ok) {
+        console.error(`[im] skip media ${rawPath}: ${resolved.error}`);
+        continue;
+      }
+
+      if (this.mediaUploadDisabled) {
+        fallbacks.push(imMedia.formatMediaUploadFallback(resolved.path, "企业微信机器人未开通图片/文件上传权限"));
+        continue;
+      }
+
+      const mediaType = imMedia.detectWeComMediaType(resolved.path, resolved.size);
+      try {
+        const upload = await this.client.uploadMediaFile(resolved.path, { mediaType });
+        await this.client.replyMediaMessage(reqId, upload.mediaType, upload.mediaId);
+        console.error(`[im] delivered media ${resolved.path} as ${upload.mediaType}`);
+      } catch (error) {
+        const errcode = error && typeof error === "object" ? error.errcode : undefined;
+        const errmsg = error && typeof error === "object" ? error.errmsg : undefined;
+        if (imMedia.isWeComMediaPermissionError(errcode, errmsg || String(error))) {
+          this.mediaUploadDisabled = true;
+          console.error(`[im] media upload disabled for ${this.project.cwd}: ${errmsg || String(error)}`);
+          fallbacks.push(imMedia.formatMediaUploadFallback(
+            resolved.path,
+            "企业微信机器人未开通图片/文件上传权限",
+          ));
+        } else {
+          console.error(`[im] media delivery failed for ${resolved.path}: ${String(error)}`);
+          fallbacks.push(imMedia.formatMediaUploadFallback(resolved.path, String(error)));
+        }
+      }
+    }
+
+    return fallbacks;
+  }
+
+  async sendFallbackText(reqId, text) {
+    if (!text.trim() || !this.client) return;
+    const streamId = `${reqId}-fallback-${Date.now()}`;
+    await this.client.replyStream(reqId, streamId, text, true);
+  }
+
   async handleFrame(frame) {
     const inbound = extractWeComInboundMessage(frame);
     if (!inbound) return;
@@ -629,6 +789,7 @@ class ProjectWeComBridge {
     const startedAt = Date.now();
     let refreshTimer = null;
     let toolsRunning = false;
+    let lastCleanedText = "";
 
     try {
       await reply.beginProcessing();
@@ -650,7 +811,9 @@ class ProjectWeComBridge {
         },
         onDelta: (text) => {
           toolsRunning = false;
-          reply.schedulePush(text);
+          const cleaned = imMedia.cleanImReplyText(text).cleaned;
+          lastCleanedText = cleaned;
+          reply.schedulePush(cleaned);
         },
       });
 
@@ -658,10 +821,17 @@ class ProjectWeComBridge {
         console.error(`[im] turn failed for ${this.project.cwd} user ${inbound.userId}: ${result.reply || "unknown error"}`);
       }
 
-      const text = typeof result.reply === "string" && result.reply.trim()
+      const rawReply = typeof result.reply === "string" && result.reply.trim()
         ? result.reply.trim()
         : "No reply from annodex.";
-      await reply.finish(text);
+      const { cleaned, mediaPaths } = imMedia.cleanImReplyText(rawReply);
+      const finishText = cleaned || lastCleanedText || "No reply from annodex.";
+      await reply.finish(finishText);
+
+      const fallbacks = await this.deliverMedia(inbound.reqId, mediaPaths);
+      if (fallbacks.length) {
+        await this.sendFallbackText(inbound.reqId, fallbacks.join("\n\n"));
+      }
     } catch (error) {
       console.error(`[im] turn request failed for ${this.project.cwd} user ${inbound.userId}: ${String(error)}`);
       await reply.fail(`annodex IM error: ${String(error)}`);

package/lib/im-media.js

@@ -0,0 +1,171 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const MEDIA_DELIVERY_EXTS = [
+  "png", "jpg", "jpeg", "gif", "webp", "bmp", "svg",
+  "pdf", "csv", "tsv", "txt", "md", "json", "yaml", "yml",
+  "html", "htm", "xml",
+  "xlsx", "xls", "docx", "doc", "pptx", "ppt",
+  "zip", "tar", "gz", "tgz", "7z",
+  "mp4", "mov", "webm", "mp3", "wav", "ogg", "amr",
+].join("|");
+
+const MEDIA_TAG_RE = /\bMEDIA:\s*(`[^`\n]+`|"[^"\n]+"|'[^'\n]+'|(?:~\/|\/|[A-Za-z]:[/\\])[^\s"'`,;:)\]}]+)/gi;
+
+const SHOW_WIDGET_FENCE_RE = /```\s*show-widget[\s\S]*?```/gi;
+const SHOW_WIDGET_PARTIAL_RE = /```\s*show-widget[\s\S]*$/;
+
+const IMAGE_EXTS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg"]);
+const VIDEO_EXTS = new Set([".mp4", ".mov", ".webm", ".avi", ".mkv"]);
+const AUDIO_EXTS = new Set([".mp3", ".wav", ".ogg", ".amr"]);
+
+const ABSOLUTE_MAX_BYTES = 20 * 1024 * 1024;
+const IMAGE_MAX_BYTES = 10 * 1024 * 1024;
+
+const WECOM_MEDIA_PERMISSION_ERRCODES = new Set([48002, 60020, 81013]);
+
+function collapseBlankLines(text) {
+  return text.replace(/\n{3,}/g, "\n\n").trim();
+}
+
+function stripShowWidgetFences(text) {
+  let cleaned = text.replace(SHOW_WIDGET_FENCE_RE, "");
+  cleaned = cleaned.replace(SHOW_WIDGET_PARTIAL_RE, "");
+  return cleaned;
+}
+
+function normalizeMediaTagPath(rawPath) {
+  let value = String(rawPath || "").trim();
+  if (!value) return "";
+  if (value.length >= 2 && value[0] === value[value.length - 1] && "`\"'".includes(value[0])) {
+    value = value.slice(1, -1).trim();
+  }
+  return value.replace(/^[`"'\\]+|[`"'\\.,;:)\]}]+$/g, "").trim();
+}
+
+function extractMediaFromText(text) {
+  const media = [];
+  const seen = new Set();
+  let cleaned = text;
+
+  for (const match of text.matchAll(MEDIA_TAG_RE)) {
+    const rawPath = normalizeMediaTagPath(match[1] || "");
+    if (!rawPath || seen.has(rawPath)) continue;
+    if (!hasDeliverableExtension(rawPath)) continue;
+    seen.add(rawPath);
+    media.push(rawPath);
+  }
+
+  cleaned = cleaned.replace(MEDIA_TAG_RE, "");
+  cleaned = collapseBlankLines(cleaned);
+  return { mediaPaths: media, cleaned };
+}
+
+function hasDeliverableExtension(filePath) {
+  const ext = path.extname(filePath).slice(1).toLowerCase();
+  if (!ext) return false;
+  return MEDIA_DELIVERY_EXTS.split("|").includes(ext);
+}
+
+function resolveMediaPath(rawPath, cwd) {
+  const trimmed = String(rawPath || "").trim();
+  if (!trimmed) {
+    return { ok: false, error: "empty path" };
+  }
+
+  let resolved;
+  try {
+    if (trimmed.startsWith("~")) {
+      resolved = path.resolve(trimmed.replace(/^~(?=$|[/\\])/, os.homedir()));
+    } else if (path.isAbsolute(trimmed)) {
+      resolved = path.resolve(trimmed);
+    } else if (cwd) {
+      resolved = path.resolve(cwd, trimmed);
+    } else {
+      return { ok: false, error: "relative path requires cwd" };
+    }
+  } catch (error) {
+    return { ok: false, error: String(error) };
+  }
+
+  let stat;
+  try {
+    stat = fs.statSync(resolved);
+  } catch {
+    return { ok: false, error: `file not found: ${resolved}` };
+  }
+  if (!stat.isFile()) {
+    return { ok: false, error: `not a file: ${resolved}` };
+  }
+  if (stat.size > ABSOLUTE_MAX_BYTES) {
+    return { ok: false, error: `file exceeds 20MB WeCom limit: ${resolved}` };
+  }
+
+  return { ok: true, path: resolved, size: stat.size };
+}
+
+function detectWeComMediaType(filePath, sizeBytes) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (IMAGE_EXTS.has(ext)) {
+    if (sizeBytes > IMAGE_MAX_BYTES) return "file";
+    return "image";
+  }
+  if (VIDEO_EXTS.has(ext)) return "video";
+  if (AUDIO_EXTS.has(ext)) return "voice";
+  return "file";
+}
+
+function cleanImReplyText(text) {
+  let cleaned = stripShowWidgetFences(String(text || ""));
+  const extracted = extractMediaFromText(cleaned);
+  cleaned = extracted.cleaned;
+  if (stripShowWidgetFences(String(text || "")).includes("show-widget") && !cleaned) {
+    cleaned = "(visual diagram — see attachment below if available)";
+  }
+  return { cleaned, mediaPaths: extracted.mediaPaths };
+}
+
+function isWeComMediaPermissionError(errcode, errmsg) {
+  if (WECOM_MEDIA_PERMISSION_ERRCODES.has(Number(errcode))) return true;
+  const msg = String(errmsg || "").toLowerCase();
+  return (
+    msg.includes("permission")
+    || msg.includes("privilege")
+    || msg.includes("auth")
+    || msg.includes("权限")
+    || msg.includes("上传")
+    || msg.includes("upload")
+  );
+}
+
+function formatMediaUploadFallback(filePath, reason) {
+  const label = reason || "企业微信机器人可能未开通图片/文件上传权限";
+  return `附件未能上传（${label}）。文件路径：\`${filePath}\``;
+}
+
+function buildImMediaGuidance() {
+  return [
+    "WeCom IM cannot render show-widget, HTML, or interactive charts in chat.",
+    "For diagrams, charts, or exports: save PNG/PDF (or other files) under the project directory, then include one line per file:",
+    "MEDIA:/absolute/path/to/file.png",
+    "Always mention the saved file path in plain text as well — some enterprises disable bot file/image upload.",
+    "Do not use show-widget fences in IM replies.",
+  ].join("\n");
+}
+
+module.exports = {
+  ABSOLUTE_MAX_BYTES,
+  IMAGE_MAX_BYTES,
+  cleanImReplyText,
+  collapseBlankLines,
+  detectWeComMediaType,
+  extractMediaFromText,
+  formatMediaUploadFallback,
+  isWeComMediaPermissionError,
+  resolveMediaPath,
+  stripShowWidgetFences,
+  buildImMediaGuidance,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seqyuan/annodex",
-  "version": "0.1.72",
+  "version": "0.1.74",
   "description": "AI-native bioinformatics workspace by Annoroad",
   "license": "MIT",
   "bin": {
@@ -23,6 +23,7 @@
     "lib/macos-codex-security.js",
     "lib/default-SOUL.md",
     "lib/default-HARNESS.md",
+    "lib/im-media.js",
     "public",
     "next.config.ts",
     "package.json"