omp-wechat 1.2.1 → 1.4.0

package/README.md

@@ -12,9 +12,9 @@ WeChat user → iLink Bot API → [OMP/Pi process] → SDK → AI provider
                                   └──── reply ← message_end ─┘
 ```
 
-The extension runs **inside** the OMP/Pi process. On `session_start`, the iLink long-poll loop starts in-process as a background promise. A singleton port lock ensures only one process runs the poll loop at a time — other OMP/Pi processes standby with a 30s failover timer to take over if the lock holder crashes.
+The extension runs **inside** the OMP/Pi process. The iLink long-poll loop starts at extension load time (not `session_start`) as a background promise. A singleton port lock ensures only one process runs the poll loop at a time — other OMP/Pi processes standby with a 30s failover timer to take over if the lock holder crashes.
 
-For boot-time persistence, install a launchd/systemd service via `/wechat install`. The service runs `omp --mode rpc` (or `pi --mode rpc`) with `KeepAlive`/`Restart=always`, so the host (and the poll loop) survive crashes and reboots.
+For boot-time persistence, install a launchd/systemd service via `/wechat install`. The service runs `omp --mode rpc` (or `pi --mode rpc`) with a `get_state` JSON-RPC heartbeat piped to stdin every 5s — without an active RPC client, `omp --mode rpc` exits on idle stdin, so the heartbeat keeps the process alive. `KeepAlive`/`Restart=always` handles crashes and reboots.
 
 - **No external `bun` required** — OMP/Pi is a standalone binary with an embedded runtime
 - **Singleton** — port lock guarantees one poll loop across all concurrent OMP/Pi processes
@@ -26,11 +26,12 @@ For boot-time persistence, install a launchd/systemd service via `/wechat instal
 
 ## Features
 
-- **OMP/Pi extension**: installs via `omp plugin link .` or `pi plugin link .`, auto-starts poll loop on `session_start`
+- **OMP/Pi extension**: installs via `omp plugin link .` or `pi plugin link .`, auto-starts poll loop at extension load time
 - **Slash commands**: `/wechat login`, `/wechat status`, `/wechat pair`, `/wechat allow`, `/wechat revoke`, `/wechat list`, `/wechat stop`, `/wechat install`, `/wechat uninstall`
 - **Singleton**: port lock guarantees one poll loop across all concurrent OMP/Pi processes — no duplicate replies
 - **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
 - **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
@@ -55,7 +56,7 @@ bun run build
 omp plugin link .    # or: pi plugin link .
 ```
 
-This links the extension into OMP/Pi. The poll loop starts automatically on your next `session_start`.
+This links the extension into OMP/Pi. The poll loop starts at extension load time — no `session_start` required.
 
 ### Login (scan QR code)
 
@@ -67,7 +68,7 @@ A QR code appears in the terminal. Scan it with WeChat and confirm on your phone
 
 ### Run
 
-No explicit run command needed — the poll loop auto-starts on `session_start`. Once running, send a message to the bot on WeChat — it will be processed and the reply sent back.
+No explicit run command needed — the poll loop starts at extension load time. Once running, send a message to the bot on WeChat — it will be processed and the reply sent back.
 
 To check status: `/wechat status`. To stop: `/wechat stop`.
 
@@ -77,9 +78,9 @@ To check status: `/wechat status`. To stop: `/wechat stop`.
 /wechat install
 ```
 
-Installs a launchd (macOS) or systemd (Linux) service that runs the host (`omp --mode rpc` or `pi --mode rpc`) at boot. The host stays alive via `KeepAlive`/`Restart=always`, keeping the poll loop running across crashes and reboots.
+Installs a launchd (macOS) or systemd (Linux) service that runs the host (`omp --mode rpc` or `pi --mode rpc`) at boot. A `get_state` JSON-RPC heartbeat is piped to stdin every 5s to keep the process alive (without an active RPC client, `omp --mode rpc` exits on idle stdin). `KeepAlive`/`Restart=always` handles crashes and reboots.
 
-Logs: `~/.omp-wechat/logs/rpc.log`
+Logs: `~/.omp/logs/rpc.log` (stderr only; stdout discarded) and `~/.omp/logs/wechat.log` (poll loop)
 Manage: `launchctl start|stop com.omp-wechat` (macOS) or `sudo systemctl start|stop omp-wechat` (Linux)
 
 To remove: `/wechat uninstall`
@@ -108,6 +109,8 @@ systemPrompt: |
 | `systemPrompt` | Built-in | System prompt for WeChat chat sessions |
 
 > **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.
 
 ## Slash Commands
 
@@ -146,14 +149,14 @@ The logged-in user (who scanned the QR code) is automatically added to the allow
 
 | Scenario | Behavior |
 |---|---|
-| Host process starts | Poll loop starts automatically (acquires singleton lock) |
+| Host process starts | Poll loop starts at extension load time (acquires singleton lock) |
 | Other host processes | Standby with 30s failover timer, take over if lock holder dies |
 | Host process exits | Poll loop stops, lock released, all sessions disposed |
 | Host crashes | Failover timer in another process detects dead lock and takes over; or launchd/systemd restarts the host (if `/wechat install` was run) |
 | Machine reboots | Service auto-starts the host (if installed), poll loop resumes |
 | No boot service | Poll loop only runs while a host process is active |
 
-Logs: `~/.omp-wechat/logs/daemon.log` (poll loop) and `~/.omp-wechat/logs/rpc.log` (boot service RPC output)
+Logs: `~/.omp/logs/wechat.log` (poll loop) and `~/.omp/logs/rpc.log` (boot service stderr)
 
 ## Project Structure
 
@@ -161,7 +164,7 @@ Logs: `~/.omp-wechat/logs/daemon.log` (poll loop) and `~/.omp-wechat/logs/rpc.lo
 OMP-Wechat/
 ├── package.json              # omp.extensions / pi.extensions manifest
 ├── src/
-│   ├── index.ts              # OMP/Pi extension entry (session_start + /wechat commands)
+│   ├── index.ts              # OMP/Pi extension entry (extension load + /wechat commands)
 │   ├── bridge.ts             # In-process poll loop + message handling + singleton port lock
 │   ├── service.ts            # Boot-time launchd/systemd install
 │   ├── config.ts             # Config loading (config.yml + defaults)
@@ -188,11 +191,12 @@ OMP-Wechat/
 - **Reply-only**: iLink requires `context_token` from an inbound message; you cannot initiate conversations
 - **1:1 only**: iLink Bot API does not support group chats
 - **Single instance**: iLink allows only one bot connection per account
-- **Text only (Phase 1)**: images/voice/video are represented as `(image)` / `(voice)` placeholders; media support is planned
+- **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
 
 ## Roadmap
 
-- [ ] **Phase 2**: Media support (inbound images as base64, voice transcription)
+- [x] **Phase 2a**: Inbound image support (CDN download + AES decrypt + vision model)
+- [ ] **Phase 2b**: Voice transcription / video support
 - [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

@@ -1758,17 +1758,15 @@ function decryptAesEcb(ciphertext, key) {
   const decipher = createDecipheriv("aes-128-ecb", key, null);
   return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
 }
-function buildCdnUrl(fileUrl, fullUrl) {
+function buildCdnUrl(encryptQueryParam, fullUrl) {
   if (fullUrl)
     return fullUrl;
-  if (!fileUrl)
+  if (!encryptQueryParam)
     return null;
-  if (fileUrl.startsWith("http"))
-    return fileUrl;
-  return `${CDN_BASE_URL}/download?encrypted_query_param=${encodeURIComponent(fileUrl)}`;
+  return `${CDN_BASE_URL}/download?encrypted_query_param=${encodeURIComponent(encryptQueryParam)}`;
 }
-async function downloadAndDecrypt(fileUrl, fullUrl, aeskeyHex, aesKeyBase64, label = "media") {
-  const url = buildCdnUrl(fileUrl, fullUrl);
+async function downloadAndDecrypt(encryptQueryParam, fullUrl, aeskeyHex, aesKeyBase64, label = "media") {
+  const url = buildCdnUrl(encryptQueryParam, fullUrl);
   if (!url) {
     logger.warn(`[${label}] No CDN URL available`);
     return null;
@@ -2411,7 +2409,8 @@ class WeChatBridge {
     const results = [];
     for (const item of imageItems) {
       const img = item.image_item;
-      const buf = await downloadAndDecrypt(img.file_url, img.full_url, img.aeskey, img.aes_key ?? img.media?.aes_key, `image[${chatId}]`);
+      logger.debug(`[${chatId}] image_item raw: ${JSON.stringify(img)}`);
+      const buf = await downloadAndDecrypt(img.media?.encrypt_query_param, img.media?.full_url, img.aeskey, img.media?.aes_key, `image[${chatId}]`);
       if (buf) {
         const mimeType = buf.length > 4 && buf[0] === 137 && buf[1] === 80 ? "image/png" : "image/jpeg";
         results.push({
@@ -2472,7 +2471,9 @@ function getLogDir() {
   return join8(homedir7(), ".omp", "logs");
 }
 function resolveHostBinary() {
-  return process.execPath || "omp";
+  const exe = process.execPath || "omp";
+  const basename2 = exe.split("/").pop() || "omp";
+  return basename2;
 }
 function plistPath() {
   return join8(homedir7(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
@@ -2489,10 +2490,9 @@ function generatePlist() {
 
   <key>ProgramArguments</key>
   <array>
-    <string>${omp}</string>
-    <string>--mode</string>
-    <string>rpc</string>
-    <string>--no-title</string>
+    <string>/bin/sh</string>
+    <string>-c</string>
+    <string>while true; do echo '{"id":"ka","type":"get_state"}'; sleep 5; done | exec ${omp} --mode rpc --no-title >/dev/null</string>
   </array>
 
   <key>RunAtLoad</key>
@@ -2504,11 +2504,6 @@ function generatePlist() {
   <key>ThrottleInterval</key>
   <integer>10</integer>
 
-  <key>StandardInputPath</key>
-  <string>/dev/null</string>
-
-  <key>StandardOutPath</key>
-  <string>${logDir}/rpc.log</string>
   <key>StandardErrorPath</key>
   <string>${logDir}/rpc.log</string>
 
@@ -2562,15 +2557,14 @@ Wants=network-online.target
 Type=simple
 User=${user}
 Group=${user}
-ExecStart=${omp} --mode rpc --no-title
-StandardInput=null
+ExecStart=/bin/sh -c 'while true; do echo "{\\"id\\":\\"ka\\",\\"type\\":\\"get_state\\"}"; sleep 5; done | exec ${omp} --mode rpc --no-title >/dev/null'
 Restart=always
 RestartSec=10
 
 Environment=HOME=${homedir7()}
 Environment=PATH=/usr/local/bin:/usr/bin:/bin
 
-StandardOutput=append:${logDir}/rpc.log
+StandardOutput=null
 StandardError=append:${logDir}/rpc.log
 
 NoNewPrivileges=true
@@ -2660,21 +2654,27 @@ function wechatExtension(pi) {
   if (pi.pi && typeof pi.setLabel === "function") {
     pi.setLabel("OMP-Wechat Bridge");
   }
+  bridge = new WeChatBridge;
+  daemonState = bridge.start();
+  if (daemonState.running) {
+    logger.info("WeChat bridge started at extension load");
+  } else {
+    logger.debug("WeChat bridge: another instance holds the lock, starting failover watch");
+    setInterval(() => {
+      if (daemonState?.running)
+        return;
+      daemonState = bridge.start();
+      if (daemonState.running) {
+        logger.info("WeChat bridge: took over from failed instance");
+      }
+    }, 30000);
+  }
   pi.on("session_start", async (_event, ctx) => {
-    bridge = new WeChatBridge;
-    daemonState = bridge.start();
-    if (daemonState.running) {
-      ctx.ui.notify("WeChat bridge started", "info");
-    } else {
-      logger.debug("WeChat bridge: another instance holds the lock, starting failover watch");
-      ctx.setInterval(() => {
-        if (daemonState?.running)
-          return;
-        daemonState = bridge.start();
-        if (daemonState.running) {
-          ctx.ui.notify("WeChat bridge: took over from failed instance", "info");
-        }
-      }, 30000);
+    if (bridge && !daemonState?.running) {
+      daemonState = bridge.start();
+      if (daemonState.running) {
+        ctx.ui.notify("WeChat bridge started", "info");
+      }
     }
   });
   pi.registerCommand("wechat", {

package/package.json

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