omp-wechat 1.5.0 → 1.7.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,22 +1825,201 @@ 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 DEFAULT_OUTBOX_BASE = join7(STATE_DIR4, "outbox");
 var STALE_THRESHOLD_MS = 30 * 24 * 60 * 60 * 1000;
 function sanitizeChatId(chatId) {
   return chatId.replace(/[^a-zA-Z0-9_@.-]/g, "_").slice(0, 200);
 }
+function sanitizeOutboxChatId(chatId) {
+  return chatId.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
 function sessionDirFor(chatId) {
   return join7(SESSIONS_DIR, sanitizeChatId(chatId));
 }
+function outboxDirFor(chatId, outboxBase) {
+  return join7(outboxBase ?? DEFAULT_OUTBOX_BASE, sanitizeOutboxChatId(chatId));
+}
 function ensureSessionsDir() {
   mkdirSync5(SESSIONS_DIR, { recursive: true, mode: 448 });
 }
@@ -1827,6 +2035,54 @@ function removeSessionDir(chatId) {
     return false;
   }
 }
+function removeOutboxDir(chatId, outboxBase) {
+  const dir = outboxDirFor(chatId, outboxBase);
+  if (!existsSync2(dir))
+    return false;
+  try {
+    rmSync(dir, { recursive: true, force: true });
+    logger.info(`Removed outbox dir: ${dir}`);
+    return true;
+  } catch (err) {
+    logger.warn(`Failed to remove outbox dir ${dir}: ${err}`);
+    return false;
+  }
+}
+function cleanupStaleOutboxes(outboxBase) {
+  const base = outboxBase ?? DEFAULT_OUTBOX_BASE;
+  if (!existsSync2(base))
+    return 0;
+  const now = Date.now();
+  let removed = 0;
+  for (const entry of readdirSync2(base, { withFileTypes: true })) {
+    if (!entry.isDirectory())
+      continue;
+    const dir = join7(base, entry.name);
+    let newestMtime = 0;
+    try {
+      for (const file of readdirSync2(dir)) {
+        const mtime = statSync3(join7(dir, file)).mtimeMs;
+        if (mtime > newestMtime)
+          newestMtime = mtime;
+      }
+    } catch {
+      continue;
+    }
+    if (newestMtime === 0 || now - newestMtime > STALE_THRESHOLD_MS) {
+      try {
+        rmSync(dir, { recursive: true, force: true });
+        removed++;
+        logger.info(`Cleaned up stale outbox dir: ${entry.name}`);
+      } catch (err) {
+        logger.warn(`Failed to cleanup outbox dir ${entry.name}: ${err}`);
+      }
+    }
+  }
+  if (removed > 0) {
+    logger.info(`Outbox cleanup: removed ${removed} stale outbox(es)`);
+  }
+  return removed;
+}
 function cleanupStaleSessions() {
   if (!existsSync2(SESSIONS_DIR))
     return 0;
@@ -1839,7 +2095,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 +2135,20 @@ function clearAllSessions() {
 }
 
 // src/engine/session.ts
+import { mkdirSync as mkdirSync6, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
+import { join as join8 } from "path";
+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 +2169,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.outboxDir);
+    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 +2201,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 +2233,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 +2288,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 +2306,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;
   }
@@ -1992,13 +2317,14 @@ class SessionPool {
   get(chatId) {
     return this.pool.get(chatId);
   }
-  async resetSession(chatId) {
+  async resetSession(chatId, config) {
     const entry = this.pool.get(chatId);
     if (entry) {
       await entry.dispose();
       this.pool.delete(chatId);
     }
     removeSessionDir(chatId);
+    removeOutboxDir(chatId, config.outboxDir);
   }
   getContextToken(chatId) {
     return this.pool.get(chatId)?.getContextToken() ?? "";
@@ -2201,7 +2527,7 @@ class ModelCommand {
 // src/command/new-session-command.ts
 class NewSessionInvocation {
   async execute(ctx) {
-    await ctx.pool.resetSession(ctx.chatId);
+    await ctx.pool.resetSession(ctx.chatId, ctx.config);
     return "Session reset. Your next message starts a fresh conversation.";
   }
 }
@@ -2223,6 +2549,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 +2611,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,
@@ -2272,7 +2631,11 @@ class WeChatBridge {
       this.releaseLock();
     });
     cleanupStaleSessions();
-    this.cleanupTimer = setInterval(() => cleanupStaleSessions(), 6 * 60 * 60 * 1000);
+    cleanupStaleOutboxes(config.outboxDir);
+    this.cleanupTimer = setInterval(() => {
+      cleanupStaleSessions();
+      cleanupStaleOutboxes(config.outboxDir);
+    }, 6 * 60 * 60 * 1000);
     return this.state;
   }
   async stop() {
@@ -2402,7 +2765,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 +2802,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 {
@@ -2465,8 +2888,8 @@ 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 { 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 +2903,14 @@ function detectPlatform() {
   return "other";
 }
 function getLogDir() {
-  return join8(homedir7(), ".omp", "logs");
+  return join9(homedir7(), ".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(homedir7(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
 }
 function generatePlist() {
   const omp = resolveHostBinary();
@@ -2530,9 +2953,9 @@ function generatePlist() {
 `;
 }
 function installLaunchd() {
-  const dir = join8(homedir7(), "Library", "LaunchAgents");
-  mkdirSync6(dir, { recursive: true });
-  mkdirSync6(getLogDir(), { recursive: true });
+  const dir = join9(homedir7(), "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 +2973,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`;
@@ -2581,7 +3004,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(homedir7(), ".omp-wechat")} ${join9(homedir7(), ".omp")}
 PrivateTmp=true
 
 [Install]
@@ -2590,7 +3013,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 +3023,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 +3045,7 @@ function uninstallSystemd() {
 }
 var WIN_TASK_NAME = "OMP-Wechat";
 function winScriptPath() {
-  return join8(homedir7(), ".omp-wechat", "omp-wechat-rpc.ps1");
+  return join9(homedir7(), ".omp-wechat", "omp-wechat-rpc.ps1");
 }
 function generateWinScript() {
   const omp = process.execPath || "omp";
@@ -2665,8 +3088,8 @@ while ($true) {
 `;
 }
 function installWinTask() {
-  mkdirSync6(join8(homedir7(), ".omp-wechat"), { recursive: true });
-  mkdirSync6(getLogDir(), { recursive: true });
+  mkdirSync7(join9(homedir7(), ".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 +3112,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.7.0",
   "description": "OMP/Pi extension: bridge WeChat messages to OMP's AI engine via the iLink Bot API",
   "type": "module",
   "main": "dist/index.js",