omp-wechat 1.5.0 → 1.6.0

package/README.md

@@ -32,6 +32,9 @@ For boot-time persistence, install a launchd/systemd service via `/wechat instal
 - **Failover**: 30s timer takes over automatically if the lock holder crashes
 - **Bidirectional**: receive and reply to WeChat text messages
 - **Image recognition**: inbound images are downloaded from WeChat CDN, AES-decrypted, and passed to the vision model
+- **Inbound file content**: text files (`.txt/.md/.csv/.json/.py/…`) sent by the user are downloaded, decrypted, and their content is handed to the AI; binary files arrive as metadata placeholders
+- **Markdown stripping**: AI replies are stripped of markdown formatting before delivery — WeChat renders plain text only
+- **File delivery**: AI-generated files (documents, images, PDFs, spreadsheets, code…) written to a per-chat outbox directory are automatically uploaded to the WeChat CDN (AES-128-ECB encrypted) and sent back to the user as file/image messages
 - **Per-chat sessions**: each WeChat chat gets an independent AI session (concurrent, isolated)
 - **LRU pool**: caps memory usage by evicting least-recently-used sessions (default: 50)
 - **Typing indicator**: native WeChat "Typing..." shown during AI processing
@@ -110,11 +113,39 @@ systemPrompt: |
 | `model` | OMP default | Default model: role alias (`@smol`, `@slow`) or `provider/id` |
 | `cwd` | `process.cwd()` | Working directory for AI sessions — determines which project context (CLAUDE.md, .omp/) the agent loads |
 | `systemPrompt` | Built-in | System prompt for WeChat chat sessions |
+| `outboxDir` | `~/.omp-wechat/outbox` | Base directory for per-chat outboxes (see File Delivery below) |
+| `maxFileSizeMb` | `100` | Max file size delivered via WeChat, in MB |
+| `sendFiles` | `true` | Set to `false` to disable file delivery entirely |
 
 > **Model and tools are managed by OMP/Pi.** `createAgentSession()` automatically calls `discoverAuthStorage()`, reusing your existing `omp login` / `pi login` OAuth, `~/.omp/agent/agent.db` API keys, or `models.yml` config. This project never touches API keys.
 >
 > **Image recognition** requires a vision model role configured in OMP (e.g. `omp model role vision xfyun/xopkimik25`). If no vision role is set, inbound images are skipped — only the text placeholder is sent to the AI.
 
+## File Delivery
+
+Ask the AI to generate a file (report, PDF, spreadsheet, image, code, …) — the finished artifact is sent back to you as a WeChat file or image message automatically.
+
+### How it works
+
+1. Every chat gets a private **outbox directory**: `~/.omp-wechat/outbox/<wxid>/`
+2. The session's system prompt teaches the AI to write final deliverables there (and only there)
+3. When the AI finishes a turn, the plugin diffs the outbox and uploads every new/changed file:
+   - `getuploadurl` → CDN upload (AES-128-ECB encrypted) → `sendmessage` as a file item
+   - Images (`.png/.jpg/.jpeg/.gif/.webp/.bmp`) are auto-routed to image messages; everything else goes as a file
+4. Delivered files are removed from the outbox; failed or oversized files stay on disk and a text notice is sent instead
+
+### Example
+
+> **You**: Please generate a weekly report as a PDF
+> **AI**: *(writes `weekly-report.pdf` to the outbox)* Done — the report is attached.
+> **You** (WeChat): receives the text reply **plus** the `weekly-report.pdf` file
+
+### Limitations
+
+- Files are sent via `sendmessage` using the latest inbound `context_token`, same as text replies — an expired token (long-running task, restart) may fail delivery until you message again
+- Files larger than `maxFileSizeMb` are skipped with a text notice
+- Only files in the per-chat outbox are ever sent — the AI cannot exfiltrate arbitrary paths
+
 ## Slash Commands
 
 | Command | Description |
@@ -174,9 +205,11 @@ OMP-Wechat/
 │   ├── ilink/
 │   │   ├── types.ts          # iLink Bot API type definitions
 │   │   ├── client.ts         # iLink API client (poll/send/typing)
+│   │   ├── upload.ts         # Outbound media: CDN upload + file/image send
+│   │   ├── cdn.ts            # CDN media download/upload + AES-128-ECB crypto
 │   │   └── login.ts          # QR code login flow
 │   ├── engine/
-│   │   ├── session.ts        # AI session creation + reply subscription
+│   │   ├── session.ts        # AI session creation + reply/outbox subscription
 │   │   └── pool.ts           # Session pool (LRU eviction, concurrency)
 │   ├── access/
 │   │   └── control.ts        # Access control (pairing/allowlist/disabled)
@@ -191,15 +224,17 @@ OMP-Wechat/
 
 ## Limitations
 
-- **Reply-only**: iLink requires `context_token` from an inbound message; you cannot initiate conversations
+- **Reply-only**: iLink requires `context_token` from an inbound message; you cannot initiate conversations (applies to text and file replies alike)
 - **1:1 only**: iLink Bot API does not support group chats
 - **Single instance**: iLink allows only one bot connection per account
-- **Media**: inbound images are downloaded from WeChat CDN, AES-decrypted, and passed to the vision model (if `modelRoles.vision` is configured); voice/video remain as placeholders
+- **Media**: inbound images and text files are fully processed (vision model / content extraction); voice (unless the server provides transcription) and video remain as placeholders
 
 ## Roadmap
 
 - [x] **Phase 2a**: Inbound image support (CDN download + AES decrypt + vision model)
 - [ ] **Phase 2b**: Voice transcription / video support
+- [x] **Phase 2c**: Outbound file delivery — AI-generated files sent back via WeChat (CDN upload + file/image messages)
+- [x] **Phase 2d**: Inbound file content extraction + markdown stripping for replies
 - [x] **Phase 3**: Persistent sessions — `SessionManager.continueRecent()` per chat, context survives restarts
 - [x] **Phase 4**: Per-chat model selection — `/model` `/models` chat commands for manual switching
 - [ ] **Phase 5**: Fine-grained permissions (per-user tool restrictions, bash approval via WeChat)

package/dist/index.js

@@ -1326,6 +1326,13 @@ function saveSyncBuf(buf) {
   mkdirSync2(STATE_DIR, { recursive: true });
   writeFileSync(SYNC_BUF_FILE, buf);
 }
+function formatSize(bytes) {
+  if (bytes < 1024)
+    return `${bytes}B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
 function extractInboundText(msg, includeImagePlaceholder = true) {
   const items = msg.item_list ?? [];
   const parts = [];
@@ -1343,7 +1350,11 @@ function extractInboundText(msg, includeImagePlaceholder = true) {
         parts.push(item.voice_item?.text ?? "(voice)");
         break;
       case 4:
-        parts.push(`(file: ${item.file_item?.file_name ?? "unknown"})`);
+        {
+          const name = item.file_item?.file_name ?? "unknown";
+          const len = parseInt(item.file_item?.len ?? "", 10);
+          parts.push(`(file: ${name}${Number.isFinite(len) && len > 0 ? ", " + formatSize(len) : ""})`);
+        }
         break;
       case 5:
         parts.push("(video)");
@@ -1572,7 +1583,9 @@ async function pollQrStatus(qrcode, baseUrl) {
 }
 
 // src/bridge.ts
-import { randomBytes as randomBytes3 } from "crypto";
+import { randomBytes as randomBytes5 } from "crypto";
+import { rmSync as rmSync2 } from "fs";
+import { basename as basename3, extname as extname2 } from "path";
 
 // src/config.ts
 import { homedir as homedir4 } from "os";
@@ -1607,6 +1620,15 @@ function loadConfig() {
         config.cwd = expandTilde(parsed.cwd);
       if (parsed.systemPrompt)
         config.systemPrompt = parsed.systemPrompt;
+      if (parsed.outboxDir)
+        config.outboxDir = expandTilde(parsed.outboxDir);
+      if (parsed.maxFileSizeMb) {
+        const mb = parseInt(parsed.maxFileSizeMb, 10);
+        if (Number.isFinite(mb) && mb > 0)
+          config.maxFileSizeMb = mb;
+      }
+      if (parsed.sendFiles === "false")
+        config.sendFiles = false;
     }
   } catch (err) {
     logger.warn("Failed to load config.yml, using defaults", err);
@@ -1742,7 +1764,7 @@ function isDuplicate(key) {
 }
 
 // src/ilink/cdn.ts
-import { createDecipheriv } from "crypto";
+import { createCipheriv, createDecipheriv, randomBytes as randomBytes3 } from "crypto";
 var CDN_BASE_URL = "https://novac2c.cdn.weixin.qq.com/c2c";
 function parseAesKey(aeskeyHex, aesKeyBase64) {
   if (aeskeyHex && /^[0-9a-fA-F]{32}$/.test(aeskeyHex)) {
@@ -1762,6 +1784,13 @@ function decryptAesEcb(ciphertext, key) {
   const decipher = createDecipheriv("aes-128-ecb", key, null);
   return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
 }
+function encryptAesEcb(plaintext, key) {
+  const cipher = createCipheriv("aes-128-ecb", key, null);
+  return Buffer.concat([cipher.update(plaintext), cipher.final()]);
+}
+function generateAesKey() {
+  return randomBytes3(16);
+}
 function buildCdnUrl(encryptQueryParam, fullUrl) {
   if (fullUrl)
     return fullUrl;
@@ -1796,13 +1825,185 @@ async function downloadAndDecrypt(encryptQueryParam, fullUrl, aeskeyHex, aesKeyB
   }
 }
 
+// src/ilink/upload.ts
+import { createHash, randomBytes as randomBytes4 } from "crypto";
+import { readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import { basename as basename2, extname } from "path";
+var CDN_BASE_URL2 = "https://novac2c.cdn.weixin.qq.com/c2c";
+var UPLOAD_MAX_RETRIES = 3;
+var SEND_MAX_RETRIES = 2;
+var IMAGE_EXTENSIONS = {
+  ".png": true,
+  ".jpg": true,
+  ".jpeg": true,
+  ".gif": true,
+  ".webp": true,
+  ".bmp": true
+};
+function mediaTypeFor(fileName) {
+  return IMAGE_EXTENSIONS[extname(fileName).toLowerCase()] ? 1 /* IMAGE */ : 3 /* FILE */;
+}
+async function uploadAndSendFile(creds, to, contextToken, filePath, maxSizeBytes = 100 * 1024 * 1024) {
+  let size;
+  try {
+    size = statSync2(filePath).size;
+  } catch (err) {
+    return { status: "error", error: `cannot stat: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  if (size <= 0) {
+    return { status: "error", error: "empty file" };
+  }
+  if (size > maxSizeBytes) {
+    return { status: "too-large", bytes: size, maxBytes: maxSizeBytes };
+  }
+  const fileName = basename2(filePath);
+  const mediaType = mediaTypeFor(fileName);
+  const data = readFileSync5(filePath);
+  try {
+    const aesKey = generateAesKey();
+    const ciphertext = encryptAesEcb(data, aesKey);
+    const filekey = randomBytes4(16).toString("hex");
+    const rawMd5 = createHash("md5").update(data).digest("hex");
+    const uploadParams = await apiFetch(creds, "ilink/bot/getuploadurl", {
+      filekey,
+      media_type: mediaType,
+      to_user_id: to,
+      rawsize: data.length,
+      rawfilemd5: rawMd5,
+      filesize: ciphertext.length,
+      no_need_thumb: true,
+      aeskey: aesKey.toString("hex"),
+      base_info: { channel_version: "0.1.0" }
+    }, 15000);
+    const uploadFullUrl = uploadParams.upload_full_url?.trim();
+    if (!uploadFullUrl && !uploadParams.upload_param) {
+      return { status: "error", error: "getuploadurl returned no upload URL" };
+    }
+    const uploadUrl = uploadFullUrl || `${CDN_BASE_URL2}/upload?encrypted_query_param=${encodeURIComponent(uploadParams.upload_param)}&filekey=${encodeURIComponent(filekey)}`;
+    let encryptQueryParam;
+    let lastError;
+    for (let attempt = 1;attempt <= UPLOAD_MAX_RETRIES; attempt++) {
+      try {
+        const resp = await fetch(uploadUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/octet-stream" },
+          body: new Uint8Array(ciphertext),
+          signal: AbortSignal.timeout(60000)
+        });
+        if (resp.status >= 400 && resp.status < 500) {
+          return {
+            status: "error",
+            error: `CDN upload client error ${resp.status}: ${resp.headers.get("x-error-message") ?? "rejected"}`
+          };
+        }
+        if (!resp.ok) {
+          throw new Error(`CDN upload server error: ${resp.status}`);
+        }
+        encryptQueryParam = resp.headers.get("x-encrypted-param") ?? undefined;
+        if (!encryptQueryParam) {
+          throw new Error("CDN upload response missing x-encrypted-param header");
+        }
+        break;
+      } catch (err) {
+        lastError = err;
+        if (attempt < UPLOAD_MAX_RETRIES) {
+          logger.warn(`CDN upload attempt ${attempt}/${UPLOAD_MAX_RETRIES} failed, retrying:`, err);
+          await Bun.sleep(1000 * attempt);
+        }
+      }
+    }
+    if (!encryptQueryParam) {
+      return {
+        status: "error",
+        error: `CDN upload failed after ${UPLOAD_MAX_RETRIES} attempts: ${lastError instanceof Error ? lastError.message : String(lastError)}`
+      };
+    }
+    const media = {
+      encrypt_query_param: encryptQueryParam,
+      aes_key: aesKey.toString("base64"),
+      encrypt_type: 1
+    };
+    const item = mediaType === 1 /* IMAGE */ ? {
+      type: 2,
+      image_item: { media, mid_size: ciphertext.length }
+    } : {
+      type: 4,
+      file_item: {
+        media,
+        file_name: fileName,
+        md5: rawMd5,
+        len: String(data.length)
+      }
+    };
+    let lastSendError;
+    for (let attempt = 0;attempt <= SEND_MAX_RETRIES; attempt++) {
+      try {
+        await apiFetch(creds, "ilink/bot/sendmessage", {
+          msg: {
+            from_user_id: "",
+            to_user_id: to,
+            client_id: `omp-wechat-${Date.now()}-${randomBytes4(4).toString("hex")}`,
+            message_type: 2,
+            message_state: 2,
+            item_list: [item],
+            context_token: contextToken
+          },
+          base_info: { channel_version: "0.1.0" }
+        }, 15000);
+        logger.info(`Sent ${mediaType === 1 /* IMAGE */ ? "image" : "file"} to ${to}: ${fileName} (${data.length} bytes)`);
+        return { status: "sent", mediaType, bytes: data.length };
+      } catch (err) {
+        lastSendError = err;
+        if (attempt < SEND_MAX_RETRIES) {
+          logger.warn(`Send retry ${attempt + 1}/${SEND_MAX_RETRIES}:`, err);
+          await Bun.sleep(1000 * (attempt + 1));
+        }
+      }
+    }
+    return {
+      status: "error",
+      error: `send failed: ${lastSendError instanceof Error ? lastSendError.message : String(lastSendError)}`
+    };
+  } catch (err) {
+    return { status: "error", error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+// src/utils/markdown.ts
+function stripMarkdown(text) {
+  let result = text;
+  result = result.replace(/```[^\n]*\n?([\s\S]*?)```/g, (_match, code) => code.trim());
+  result = result.replace(/`([^`]+)`/g, "$1");
+  result = result.replace(/!\[[^\]]*\]\([^)]*\)/g, "");
+  result = result.replace(/\[([^\]]+)\]\([^)]*\)/g, "$1");
+  result = result.replace(/^\|[\s:|-]+\|$/gm, "");
+  result = result.replace(/^\|(.+)\|$/gm, (_match, inner) => inner.split("|").map((cell) => cell.trim()).join("  "));
+  result = result.replace(/^#{1,6}\s+/gm, "");
+  result = result.replace(/^[-*_]{3,}\s*$/gm, "");
+  result = result.replace(/\*\*\*(.+?)\*\*\*/g, "$1");
+  result = result.replace(/\*\*(.+?)\*\*/g, "$1");
+  result = result.replace(/\*(.+?)\*/g, "$1");
+  result = result.replace(/___(.+?)___/g, "$1");
+  result = result.replace(/__(.+?)__/g, "$1");
+  result = result.replace(/_(.+?)_/g, "$1");
+  result = result.replace(/~~(.+?)~~/g, "$1");
+  result = result.replace(/^>\s?/gm, "");
+  result = result.replace(/^[\s]*[-*+]\s+/gm, "\u2022 ");
+  result = result.replace(/^[\s]*\d+\.\s+/gm, "");
+  result = result.replace(/<[^>]+>/g, "");
+  result = result.replace(/\n{3,}/g, `
+
+`);
+  return result.trim();
+}
+
 // src/engine/session.ts
 import { createAgentSession, SessionManager } from "@oh-my-pi/pi-coding-agent";
 
 // src/engine/session-store.ts
 import { join as join7 } from "path";
 import { homedir as homedir6 } from "os";
-import { existsSync as existsSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync2, statSync as statSync2, rmSync } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync2, statSync as statSync3, rmSync } from "fs";
 var STATE_DIR4 = join7(homedir6(), ".omp-wechat");
 var SESSIONS_DIR = join7(STATE_DIR4, "sessions");
 var STALE_THRESHOLD_MS = 30 * 24 * 60 * 60 * 1000;
@@ -1839,7 +2040,7 @@ function cleanupStaleSessions() {
     let newestMtime = 0;
     try {
       for (const file of readdirSync2(dir)) {
-        const mtime = statSync2(join7(dir, file)).mtimeMs;
+        const mtime = statSync3(join7(dir, file)).mtimeMs;
         if (mtime > newestMtime)
           newestMtime = mtime;
       }
@@ -1879,6 +2080,28 @@ function clearAllSessions() {
 }
 
 // src/engine/session.ts
+import { mkdirSync as mkdirSync6, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join8 } from "path";
+var DEFAULT_OUTBOX_BASE = join8(homedir7(), ".omp-wechat", "outbox");
+function sanitizeChatId2(chatId) {
+  return chatId.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function outboxDirFor(chatId, config) {
+  return join8(config.outboxDir ?? DEFAULT_OUTBOX_BASE, sanitizeChatId2(chatId));
+}
+function outboxInstructions(outboxDir) {
+  return `## File delivery to WeChat
+
+You can send files (documents, spreadsheets, images, PDFs, code, etc.) to the WeChat user.
+
+Rules:
+- Write each final deliverable to the outbox directory:
+  ${outboxDir}
+- Only final deliverables belong there \u2014 never intermediate or scratch files.
+- You may write multiple files; every new file in the outbox is delivered to the user after your turn.
+- Mention the file name(s) in your reply so the user knows what to expect.`;
+}
 function extractAssistantText(message) {
   const content = message.content;
   if (!Array.isArray(content))
@@ -1899,14 +2122,30 @@ class ChatSession {
   contextToken;
   lastActive;
   replyCount = 0;
-  constructor(session, chatId, contextToken) {
+  outboxDir;
+  sendFilesEnabled;
+  onFiles;
+  outboxSnapshot = new Map;
+  constructor(session, chatId, contextToken, outboxDir, sendFilesEnabled, onFiles) {
     this.session = session;
     this.chatId = chatId;
     this.contextToken = contextToken;
     this.lastActive = Date.now();
+    this.outboxDir = outboxDir;
+    this.sendFilesEnabled = sendFilesEnabled;
+    this.onFiles = onFiles;
   }
-  static async create(chatId, contextToken, config, onReply) {
+  static async create(chatId, contextToken, config, onReply, onFiles) {
     logger.info(`Creating session: ${chatId}`);
+    const outboxDir = outboxDirFor(chatId, config);
+    const sendFilesEnabled = config.sendFiles !== false;
+    if (sendFilesEnabled) {
+      try {
+        mkdirSync6(outboxDir, { recursive: true });
+      } catch (err) {
+        logger.warn(`[${chatId}] Could not create outbox dir ${outboxDir}:`, err);
+      }
+    }
     ensureSessionsDir();
     const sessionDir = sessionDirFor(chatId);
     const sessionManager = await SessionManager.continueRecent(config.cwd || process.cwd(), sessionDir);
@@ -1915,17 +2154,23 @@ class ChatSession {
       sessionManager,
       enableMCP: false,
       enableLsp: false,
-      systemPrompt: config.systemPrompt,
+      systemPrompt: sendFilesEnabled ? `${config.systemPrompt}
+
+${outboxInstructions(outboxDir)}` : config.systemPrompt,
       modelPattern: config.model
     });
     session.setAdvisorEnabled(false);
     if (modelFallbackMessage) {
       logger.warn(`Model fallback: ${modelFallbackMessage}`);
     }
-    const wrapper = new ChatSession(session, chatId, contextToken);
+    const wrapper = new ChatSession(session, chatId, contextToken, outboxDir, sendFilesEnabled, onFiles);
     const visionRole = session.settings.getModelRole("vision");
     logger.info(`[${chatId}] Model: ${session.model?.id ?? "unknown"}, vision role: ${visionRole ?? "(not configured)"}`);
     session.subscribe((event) => {
+      if (event.type === "turn_end") {
+        wrapper.flushOutbox();
+        return;
+      }
       if (event.type !== "message_end")
         return;
       if (event.message.role !== "assistant")
@@ -1941,8 +2186,39 @@ class ChatSession {
   }
   async prompt(text, images) {
     this.lastActive = Date.now();
+    this.outboxSnapshot = this.snapshotOutbox();
     await this.session.prompt(text, images?.length ? { images } : undefined);
   }
+  flushOutbox() {
+    if (!this.sendFilesEnabled)
+      return;
+    const current = this.snapshotOutbox();
+    const fresh = [];
+    for (const [name, stat] of current) {
+      const prev = this.outboxSnapshot.get(name);
+      if (!prev || prev.size !== stat.size || prev.mtimeMs !== stat.mtimeMs) {
+        fresh.push(join8(this.outboxDir, name));
+      }
+    }
+    this.outboxSnapshot = current;
+    if (fresh.length > 0) {
+      logger.info(`[${this.chatId}] Outbox: ${fresh.length} new file(s) for delivery`);
+      this.onFiles(this.chatId, fresh);
+    }
+  }
+  snapshotOutbox() {
+    const map = new Map;
+    try {
+      for (const name of readdirSync3(this.outboxDir)) {
+        try {
+          const st = statSync4(join8(this.outboxDir, name));
+          if (st.isFile())
+            map.set(name, { size: st.size, mtimeMs: st.mtimeMs });
+        } catch {}
+      }
+    } catch {}
+    return map;
+  }
   supportsVision() {
     return this.session.settings.getModelRole("vision") !== undefined;
   }
@@ -1965,9 +2241,11 @@ class SessionPool {
   pool = new Map;
   maxSessions;
   replyHandler;
-  constructor(maxSessions, replyHandler) {
+  fileHandler;
+  constructor(maxSessions, replyHandler, fileHandler) {
     this.maxSessions = maxSessions;
     this.replyHandler = replyHandler;
+    this.fileHandler = fileHandler;
   }
   setMaxSessions(n) {
     this.maxSessions = n;
@@ -1981,7 +2259,7 @@ class SessionPool {
     if (this.pool.size >= this.maxSessions) {
       this.evictOldest();
     }
-    entry = await ChatSession.create(chatId, contextToken, config, this.replyHandler);
+    entry = await ChatSession.create(chatId, contextToken, config, this.replyHandler, this.fileHandler);
     this.pool.set(chatId, entry);
     return entry;
   }
@@ -2223,6 +2501,34 @@ var RETRY_MS = 2000;
 var MAX_SEND_RETRIES = 2;
 var CHUNK_LIMIT = 2000;
 var LOCK_PORT = 19821;
+var FILE_TEXT_LIMIT = 1e4;
+var TEXT_FILE_EXTENSIONS = {
+  ".txt": true,
+  ".md": true,
+  ".csv": true,
+  ".json": true,
+  ".xml": true,
+  ".html": true,
+  ".yaml": true,
+  ".yml": true,
+  ".toml": true,
+  ".log": true,
+  ".py": true,
+  ".js": true,
+  ".jsx": true,
+  ".ts": true,
+  ".tsx": true,
+  ".go": true,
+  ".rs": true,
+  ".java": true,
+  ".c": true,
+  ".cpp": true,
+  ".h": true,
+  ".sh": true,
+  ".bash": true,
+  ".sql": true,
+  ".css": true
+};
 
 class WeChatBridge {
   state = null;
@@ -2257,7 +2563,12 @@ class WeChatBridge {
         logger.error(`[${chatId}] Reply send failed:`, err);
       });
     };
-    this.pool = new SessionPool(config.maxSessions, replyHandler);
+    const fileHandler = (chatId, files) => {
+      this.sendFiles(creds, chatId, files).catch((err) => {
+        logger.error(`[${chatId}] File delivery failed:`, err);
+      });
+    };
+    this.pool = new SessionPool(config.maxSessions, replyHandler, fileHandler);
     this.state = { running: true, config, creds, lastError: null };
     logger.info("OMP-Wechat poll loop starting", {
       maxSessions: config.maxSessions,
@@ -2402,7 +2713,11 @@ class WeChatBridge {
       if (!text && !hasImages)
         return;
       const images = await this.downloadImages(creds, msg, senderId);
-      await session.prompt(text, images);
+      const fileTexts = await this.downloadFileTexts(creds, msg, senderId);
+      const fullText = [text, ...fileTexts].filter(Boolean).join(`
+
+`);
+      await session.prompt(fullText, images);
     } catch (err) {
       logger.error(`[${senderId}] prompt failed:`, err);
       await this.sendReply(creds, senderId, "Processing failed, please try again.");
@@ -2435,15 +2750,71 @@ class WeChatBridge {
     }
     return results;
   }
+  async sendFiles(creds, chatId, files) {
+    const contextToken = this.pool?.getContextToken(chatId) ?? "";
+    if (!contextToken) {
+      logger.warn(`[${chatId}] No context_token, cannot send files`);
+      return;
+    }
+    const config = loadConfig();
+    const maxBytes = (config.maxFileSizeMb ?? 100) * 1024 * 1024;
+    for (const filePath of files) {
+      const result = await uploadAndSendFile(creds, chatId, contextToken, filePath, maxBytes);
+      switch (result.status) {
+        case "sent":
+          logger.info(`[${chatId}] Delivered: ${filePath}`);
+          try {
+            rmSync2(filePath, { force: true });
+          } catch (err) {
+            logger.warn(`[${chatId}] Could not remove delivered file ${filePath}:`, err);
+          }
+          break;
+        case "too-large":
+          logger.warn(`[${chatId}] File too large, skipped: ${filePath}`);
+          await this.sendReply(creds, chatId, `[File not sent: ${basename3(filePath)} exceeds ${Math.round(result.maxBytes / 1024 / 1024)}MB limit]`);
+          break;
+        case "error":
+          logger.error(`[${chatId}] File send failed: ${filePath}: ${result.error}`);
+          await this.sendReply(creds, chatId, `[File delivery failed: ${basename3(filePath)} \u2014 ${result.error}]`);
+          break;
+      }
+    }
+  }
+  async downloadFileTexts(_creds, msg, chatId) {
+    const items = (msg.item_list ?? []).filter((item) => item.type === 4);
+    if (items.length === 0)
+      return [];
+    const results = [];
+    for (const item of items) {
+      const file = item.file_item;
+      const name = file.file_name ?? "unknown";
+      if (!TEXT_FILE_EXTENSIONS[extname2(name).toLowerCase()])
+        continue;
+      const buf = await downloadAndDecrypt(file.media?.encrypt_query_param, file.media?.full_url, undefined, file.media?.aes_key, `file[${chatId}]`);
+      if (!buf)
+        continue;
+      const len = parseInt(file.len ?? "", 10);
+      const text = buf.toString("utf-8");
+      const truncated = text.length > FILE_TEXT_LIMIT ? `${text.slice(0, FILE_TEXT_LIMIT)}
+... [truncated]` : text;
+      results.push(`[File: ${name}${Number.isFinite(len) && len > 0 ? ` (${formatSize(len)})` : ""}]
+
+\`\`\`
+${truncated}
+\`\`\``);
+      logger.info(`[${chatId}] Extracted text from file: ${name} (${buf.length} bytes)`);
+    }
+    return results;
+  }
   async sendReply(creds, chatId, text) {
     const contextToken = this.pool?.getContextToken(chatId) ?? "";
     if (!contextToken) {
       logger.warn(`[${chatId}] No context_token, cannot reply`);
       return;
     }
-    const chunks = chunkText(text, CHUNK_LIMIT);
+    const chunks = chunkText(stripMarkdown(text), CHUNK_LIMIT);
     for (const chunk of chunks) {
-      const clientId = `omp-wechat-${Date.now()}-${randomBytes3(4).toString("hex")}`;
+      const clientId = `omp-wechat-${Date.now()}-${randomBytes5(4).toString("hex")}`;
       let retries = 0;
       while (retries <= MAX_SEND_RETRIES) {
         try {
@@ -2464,9 +2835,9 @@ class WeChatBridge {
 }
 
 // src/service.ts
-import { platform, homedir as homedir7 } from "os";
-import { join as join8, basename as basename2 } from "path";
-import { existsSync as existsSync3, mkdirSync as mkdirSync6, writeFileSync as writeFileSync4, rmSync as rmSync2 } from "fs";
+import { platform, homedir as homedir8 } from "os";
+import { join as join9, basename as basename4 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync7, writeFileSync as writeFileSync4, rmSync as rmSync3 } from "fs";
 var PLIST_LABEL = "com.omp-wechat";
 var SERVICE_NAME = "omp-wechat";
 function detectPlatform() {
@@ -2480,14 +2851,14 @@ function detectPlatform() {
   return "other";
 }
 function getLogDir() {
-  return join8(homedir7(), ".omp", "logs");
+  return join9(homedir8(), ".omp", "logs");
 }
 function resolveHostBinary() {
   const exe = process.execPath || "omp";
-  return basename2(exe);
+  return basename4(exe);
 }
 function plistPath() {
-  return join8(homedir7(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+  return join9(homedir8(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
 }
 function generatePlist() {
   const omp = resolveHostBinary();
@@ -2523,16 +2894,16 @@ function generatePlist() {
     <key>PATH</key>
     <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
     <key>HOME</key>
-    <string>${homedir7()}</string>
+    <string>${homedir8()}</string>
   </dict>
 </dict>
 </plist>
 `;
 }
 function installLaunchd() {
-  const dir = join8(homedir7(), "Library", "LaunchAgents");
-  mkdirSync6(dir, { recursive: true });
-  mkdirSync6(getLogDir(), { recursive: true });
+  const dir = join9(homedir8(), "Library", "LaunchAgents");
+  mkdirSync7(dir, { recursive: true });
+  mkdirSync7(getLogDir(), { recursive: true });
   const plist = plistPath();
   if (existsSync3(plist)) {
     Bun.spawnSync(["launchctl", "unload", plist], { stderr: "ignore" });
@@ -2550,7 +2921,7 @@ function uninstallLaunchd() {
     throw new Error("No launchd service found (may not be installed)");
   }
   Bun.spawnSync(["launchctl", "unload", plist], { stderr: "inherit" });
-  rmSync2(plist);
+  rmSync3(plist);
 }
 function servicePath() {
   return `/etc/systemd/system/${SERVICE_NAME}.service`;
@@ -2572,7 +2943,7 @@ ExecStart=/bin/sh -c 'while true; do echo "{\\"id\\":\\"ka\\",\\"type\\":\\"get_
 Restart=always
 RestartSec=10
 
-Environment=HOME=${homedir7()}
+Environment=HOME=${homedir8()}
 Environment=PATH=/usr/local/bin:/usr/bin:/bin
 
 StandardOutput=null
@@ -2581,7 +2952,7 @@ StandardError=append:${logDir}/rpc.log
 NoNewPrivileges=true
 ProtectSystem=strict
 ProtectHome=read-only
-ReadWritePaths=${logDir} ${join8(homedir7(), ".omp-wechat")} ${join8(homedir7(), ".omp")}
+ReadWritePaths=${logDir} ${join9(homedir8(), ".omp-wechat")} ${join9(homedir8(), ".omp")}
 PrivateTmp=true
 
 [Install]
@@ -2590,7 +2961,7 @@ WantedBy=multi-user.target
 }
 function installSystemd() {
   const svc = servicePath();
-  mkdirSync6(getLogDir(), { recursive: true });
+  mkdirSync7(getLogDir(), { recursive: true });
   if (existsSync3(svc)) {
     Bun.spawnSync(["sudo", "systemctl", "stop", SERVICE_NAME], { stderr: "inherit" });
   }
@@ -2600,7 +2971,7 @@ function installSystemd() {
   if (result.exitCode !== 0) {
     result = Bun.spawnSync(["sudo", "cp", tmp, svc], { stderr: "inherit" });
   }
-  rmSync2(tmp);
+  rmSync3(tmp);
   if (result.exitCode !== 0) {
     throw new Error("Failed to write service file (need sudo)");
   }
@@ -2622,7 +2993,7 @@ function uninstallSystemd() {
 }
 var WIN_TASK_NAME = "OMP-Wechat";
 function winScriptPath() {
-  return join8(homedir7(), ".omp-wechat", "omp-wechat-rpc.ps1");
+  return join9(homedir8(), ".omp-wechat", "omp-wechat-rpc.ps1");
 }
 function generateWinScript() {
   const omp = process.execPath || "omp";
@@ -2665,8 +3036,8 @@ while ($true) {
 `;
 }
 function installWinTask() {
-  mkdirSync6(join8(homedir7(), ".omp-wechat"), { recursive: true });
-  mkdirSync6(getLogDir(), { recursive: true });
+  mkdirSync7(join9(homedir8(), ".omp-wechat"), { recursive: true });
+  mkdirSync7(getLogDir(), { recursive: true });
   writeFileSync4(winScriptPath(), generateWinScript());
   Bun.spawnSync(["schtasks", "/end", "/tn", WIN_TASK_NAME], { stderr: "ignore" });
   Bun.spawnSync(["schtasks", "/delete", "/tn", WIN_TASK_NAME, "/f"], { stderr: "ignore" });
@@ -2689,7 +3060,7 @@ function uninstallWinTask() {
   }
   const script = winScriptPath();
   if (existsSync3(script)) {
-    rmSync2(script);
+    rmSync3(script);
   }
 }
 function winTaskExists() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omp-wechat",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "OMP/Pi extension: bridge WeChat messages to OMP's AI engine via the iLink Bot API",
   "type": "module",
   "main": "dist/index.js",