@unlinearity/cli-wechat-bridge 1.0.4 → 1.0.5

package/README.md

@@ -2,9 +2,18 @@
 
 <p align='center'><img src='docs/images/logo.png' width=90%></p> 
 
+<p align="center"><img alt="Typing SVG" src="https://readme-typing-svg.herokuapp.com?font=JetBrains+Mono&amp;weight=600&amp;duration=4000&amp;pause=500&amp;color=06C763&amp;center=true&amp;vCenter=true&amp;width=660&amp;lines=CLI+WeChat+Bridge+%E5%BE%AE%E4%BF%A1%E6%A1%A5%E6%8E%A5;%E7%9C%9F%E6%AD%A3%E7%9A%84%E2%80%9C%E7%BB%88%E7%AB%AF-%E5%BE%AE%E4%BF%A1%E2%80%9D%E5%8E%9F%E7%94%9F%E5%8F%8C%E5%90%91%E4%BA%A4%E4%BA%92"></p>
+
+<p align="center">
+  <a href="https://github.com/UNLINEARITY/CLI-WeChat-Bridge"><img alt="GitHub stars" src="https://img.shields.io/github/stars/UNLINEARITY/CLI-WeChat-Bridge?label=Stars&amp;style=for-the-badge&amp;logo=github&amp;color=0891b2&amp;labelColor=1c1917"></a>
+  <a href="https://www.npmjs.com/package/@unlinearity/cli-wechat-bridge"><img alt="npm version" src="https://img.shields.io/npm/v/@unlinearity/cli-wechat-bridge?label=npm&amp;style=for-the-badge&amp;logo=npm&amp;color=cb3837&amp;labelColor=1c1917"></a>
+  <a href="https://www.npmjs.com/package/@unlinearity/cli-wechat-bridge"><img alt="npm downloads" src="https://img.shields.io/npm/dm/@unlinearity/cli-wechat-bridge?label=Downloads&amp;style=for-the-badge&amp;logo=npm&amp;color=16a34a&amp;labelColor=1c1917"></a>
+  <a href="https://github.com/UNLINEARITY/CLI-WeChat-Bridge/blob/main/LICENSE.txt"><img alt="License" src="https://img.shields.io/github/license/UNLINEARITY/CLI-WeChat-Bridge?label=License&amp;style=for-the-badge&amp;color=7c3aed&amp;labelColor=1c1917"></a>
+</p>
+
 **命令行工具的微信桥接**：本项目用于桥接微信消息与本地运行的 [`Codex`](https://github.com/openai/codex)、[`Claude Code`](https://code.claude.com/docs/en/overview)、`OpenCode` 或持久化 `powershell.exe` 会话，并将本地输出、审批请求与运行状态同步回微信。
 
-当前实现以本地工作流为中心展开，重点是保留本地原生终端体验，并在此基础上提供微信侧的远程输入、结果回流与状态同步能力。
+当前实现以本地工作流为中心展开，重点是保留**本地原生终端体验**，支持原生使用以及高级参数注入，并在此基础上提供微信侧的远程输入、结果回流与状态同步能力。
 
 <p align='center'><img src='docs/images/animation.webp' width=90%></p> 
 
@@ -26,9 +35,8 @@
 
 ### 1. 环境要求
 
-- Windows 为当前主要验证环境
 - [Node.js](https://nodejs.org/en/download) `>= 24.0.0`（建议直接安装官网 LTS 版本）
-- [Bun](https://bun.sh/docs/installation) `>= 1.0.0`
+- [Bun](https://bun.sh/docs/installation) `>= 1.0.0` （开发者需要，普通用户无需安装）
 - 已安装以下至少一种本地 CLI：（最好更新至最新版本）
   - [Codex](https://github.com/openai/codex)
   - [Claude Code](https://code.claude.com/docs/en/overview)
@@ -43,7 +51,7 @@
 npm install -g @unlinearity/cli-wechat-bridge@latest
 ```
 
-安装后可在任意项目目录中直接使用 `wechat-codex-start`、`wechat-claude-start`、`wechat-opencode-start` 等命令。
+安装后可在任意项目目录中直接使用 `wechat-daemon`、`wechat-codex-start`、`wechat-claude-start`、`wechat-opencode-start` 等命令。
 
 如果你希望从源码运行或参与开发，也可以克隆仓库并安装依赖：
 
@@ -113,14 +121,60 @@ bun run setup # 绑定微信 ClawBot
 默认凭据文件路径：
 
 ```text
-~/.claude/channels/wechat/account.json
+~/.cli-bridge/account.json
 ```
 
 登录成功后会清理旧的 `sync_buf.txt` 和 `context_tokens.json`，避免旧会话状态污染新的登录状态。
 
+从旧版本升级时，bridge 会自动从旧的 `~/.claude/channels/wechat` 迁移数据到 `~/.cli-bridge`，包括登录凭据、同步游标、上下文 token、工作区状态和已接收附件；已有的新目录文件不会被覆盖，旧目录也会原样保留。旧运行锁不会迁移，旧 `bridge.log` 会保存为 `legacy-bridge.log`，避免覆盖新的运行日志。
+
 如果是首次安装或微信登录已过期，`wechat-codex-start`、`wechat-claude-start`、`wechat-opencode-start` 也会在前台提示扫码登录。
 
-### 4. 单命令启动桥接（优先推荐）
+### 4. 先从微信发一条同步消息（重要）
+
+启动 bridge 后，建议先在微信里向 Bot 发送一条消息，例如 `hello`、你要执行的任务或任意一句话。这样 bridge 能拿到最新的微信会话 `context_token`，之后本地终端里的输入、最终回复和审批提示才能稳定同步回微信。
+
+如果冷启动或长时间闲置后直接从本地终端先发消息，bridge 通常仍会捕获这条本地输入并交给 Codex / Claude Code / OpenCode 处理，但微信侧出站发送可能因为旧的 `context_token` 失效而失败。表现就是：本地已经有回复，微信暂时收不到；等你先从微信发来一条消息后，后续双向同步就能恢复正常。
+
+### 5. 常驻 daemon 模式（推荐用于多 CLI 切换）
+
+如果你希望微信连接长期保持在线，并在 Codex / Claude Code / OpenCode 之间来回切换，推荐在项目目录启动一个统一 daemon：
+
+```bash
+cd D:\work\your-project
+wechat-daemon
+```
+
+启动后，在微信里发送以下指令即可选择当前活动终端：
+
+| 指令 | 行为 |
+| --- | --- |
+| `/codex` | 切换到 Codex |
+| `/claude` | 切换到 Claude Code |
+| `/opencode` | 切换到 OpenCode |
+
+daemon 启动后，后续切换都可以直接从微信发起；如果对应 CLI 还没有可见窗口，daemon 会自动打开或复用它，不需要再手动运行 `wechat-codex`、`wechat-claude` 或 `wechat-opencode`。
+
+daemon 的 v1 行为是：
+
+- daemon 绑定启动时的工作目录；暂不支持在微信里切换工作目录；
+- 启动时会自动接管并清理旧的单 bridge 进程、失效 lock 和旧 endpoint；
+- 切换适配器不会关闭之前的 CLI；
+- 如果对应适配器已经有可见 CLI 在运行，则直接复用；
+- 如果还没有对应 CLI，daemon 会自动打开一个新的可见终端；
+- Codex / Claude / OpenCode 的重要输出都会带上 `[codex]`、`[claude]`、`[opencode]` 标签再发回微信；
+- 可以在微信发送 `/daemon-stop` 停止 daemon。
+
+也可以启动时直接打开某个初始 CLI：
+
+```bash
+wechat-daemon --adapter codex
+wechat-daemon --adapter claude --profile work
+```
+
+当同一工作目录已有 `wechat-daemon` 在运行时，`wechat-codex-start` / `wechat-claude-start` / `wechat-opencode-start` 会自动委托给 daemon：请求 daemon 切到对应 CLI，并在需要时打开可见终端，而不是停止 daemon 或关闭其他 CLI。
+
+### 6. 单命令启动桥接（兼容模式）
 
 先进入你要操作的项目目录：
 
@@ -139,12 +193,13 @@ cd D:\work\your-project
 三者会自动完成以下动作：
 
 1. 校验或刷新微信登录凭据；
-2. 复用当前目录已运行的 bridge，或在当前目录启动新的 bridge；
-3. 如果 bridge 正在服务其他目录，则停止旧 bridge 并切换到当前目录；
-4. 等待当前目录对应的本地 companion endpoint 就绪；
-5. 打开可见的本地 CLI 会话。
+2. 如果当前目录已有 `wechat-daemon`，则委托 daemon 切换到对应 CLI；
+3. 如果没有 daemon，则复用当前目录已运行的 bridge，或在当前目录启动新的 bridge；
+4. 如果独立 bridge 正在服务其他目录，则停止旧 bridge 并切换到当前目录；
+5. 等待当前目录对应的本地 companion endpoint 就绪；
+6. 打开可见的本地 CLI 会话。
 
-`wechat-codex-start` / `wechat-claude-start` / `wechat-opencode-start` 现在按**单活工作区切换器**工作：
+在没有 daemon 时，`wechat-codex-start` / `wechat-claude-start` / `wechat-opencode-start` 仍按**单活工作区切换器**工作：
 
 - 同一时间只有一个项目与微信对话；
 - 在当前目录重复执行是幂等的；
@@ -152,7 +207,7 @@ cd D:\work\your-project
 - 如果检测到可见端仍在但 worker 状态异常（如 `stopped` / `error`），会自动重启 bridge 再重新打开可见端；
 - 在其他目录执行会显式切换活动工作区。
 
-### 5. 手动双终端模式（调试开发）
+### 7. 手动双终端模式（调试开发）
 
 如果你希望明确观察 bridge 与本地 CLI companion，也可以分两个终端启动。
 
@@ -168,6 +223,12 @@ cd D:\work\your-project
 
 ![文件传输](docs/images/image-8.png)
 
+微信发来的图片和普通文件也会被接收并保存到本地数据目录：
+
+- 保存位置：`~/.cli-bridge/inbound-attachments/<日期>/`
+- bridge 会把本地路径追加到转发给 Codex / Claude Code / OpenCode 的 prompt 中，模型可按需读取或解析这些文件；
+- 当前不会自动 OCR 图片，也不会自动抽取 PDF / DOCX 正文；解析动作由本地 CLI 根据路径完成。
+
 | 适配器 | 当前状态 | 说明 |
 | --- | --- | --- |
 | `codex` | 已接入 | 双终端模式；本地 companion 为线程权威；微信跟随本地线程 |
@@ -223,6 +284,7 @@ OpenCode 模式下，微信侧支持 `/new` 或 `/new-session` 创建新 session
 | 类型 | 命令 |
 | --- | --- |
 | 登录与更新 | `wechat-setup`、`wechat-check-update` |
+| 常驻 daemon | `wechat-daemon` |
 | Codex | `wechat-bridge-codex`、`wechat-codex`、`wechat-codex-start` |
 | Claude Code | `wechat-bridge-claude`、`wechat-claude`、`wechat-claude-start` |
 | OpenCode | `wechat-bridge-opencode`、`wechat-opencode`、`wechat-opencode-start` |
@@ -232,6 +294,7 @@ OpenCode 模式下，微信侧支持 `/new` 或 `/new-session` 创建新 session
 
 ```bash
 bun run setup
+bun run daemon
 bun run bridge:codex
 bun run codex:panel
 bun run codex:start
@@ -247,6 +310,27 @@ bun run check
 bun run test
 ```
 
+### Daemon CLI 参数
+
+适用于：
+
+- `wechat-daemon`
+
+示例：
+
+```bash
+wechat-daemon --cwd D:\work\my-project
+wechat-daemon --adapter codex
+wechat-daemon --adapter claude --profile work
+```
+
+支持参数：
+
+- `--cwd <path>`：指定 daemon 绑定的工作目录；
+- `--adapter <codex|claude|opencode>`：启动 daemon 后立即切换到指定 CLI；
+- `--profile <name-or-path>`：传给 daemon 创建的适配器；
+- `--no-open`：只创建 bridge slot，不自动打开可见 CLI。
+
 ### Bridge CLI 参数
 
 适用于：
@@ -292,16 +376,29 @@ wechat-opencode-start --cwd D:\work\my-project
 - `--profile <name-or-path>`：转发给后台启动的 `wechat-bridge-codex` / `wechat-bridge-claude` / `wechat-bridge-opencode`；
 - `--timeout-ms <ms>`：等待当前目录 endpoint 的最长时间，默认 `15000`。
 
+高级用法：除上述启动器参数外，未知参数会继续透传给可见的底层 CLI。这样可以在保留微信登录、工作区切换与 bridge 生命周期管理的同时，启用 Codex / Claude Code 自己的高级启动模式。
+
+```bash
+wechat-codex-start --yolo
+wechat-codex-start --model gpt-5.2 --yolo
+wechat-claude-start --dangerously-skip-permissions
+wechat-claude-start --model sonnet --dangerously-skip-permissions
+```
+
+其中 `--yolo` 会传给 Codex；`--dangerously-skip-permissions` 会传给 Claude Code。它们只影响本地可见 CLI，不会覆盖 bridge 托管的 Codex remote 连接参数、Claude settings、微信登录状态或当前工作区锁。由于这两类参数会降低审批保护，建议只在可信工作区中使用。
+
 ## 微信侧支持的指令
 
 | 指令 | 说明 |
 | --- | --- |
 | 普通文本 | 发送给当前活动会话 |
+| `/codex` / `/claude` / `/opencode` | daemon 模式下切换活动 CLI；已有 CLI 会复用，没有则自动打开 |
 | `/status` | 查看 bridge 当前状态 |
 | `/stop` | 中断当前任务 |
 | `/reset` | 重建当前本地会话 |
 | `/new` 或 `/new-session` | OpenCode 模式下新建 session |
 | `/confirm` / `/deny` | 处理 Claude Code 权限请求；shell 等需要一次性 code 的请求会在消息中提示具体确认格式 |
+| `/daemon-stop` | daemon 模式下停止常驻进程 |
 
 说明：微信侧 `/resume` 目前仍保持禁用；需要切换 Codex / Claude / OpenCode 会话时，优先在本地 companion 中使用原生 `/resume`、`/new` 或对应 CLI 命令，微信会跟随本地活动会话。
 
@@ -313,15 +410,15 @@ wechat-opencode-start --cwd D:\work\my-project
 - 对应的本地 companion 必须连接同一工作区；
 - 不同工作区的状态文件相互隔离。
 
-当前不是“一个全局守护进程同时管理多个仓库”的架构，而是：
+当前支持两种运行模型：
 
-- 单 owner
-- 单 bridge
-- 单活动工作区
+- 独立 bridge：单 owner、单 bridge、单活动工作区；
+- `wechat-daemon`：单 owner、单 daemon、绑定一个启动工作区，但可在这个工作区内同时保留 Codex / Claude Code / OpenCode 三个 CLI slot。
 
 对 `wechat-codex-start` / `wechat-claude-start` / `wechat-opencode-start` 来说，这意味着：
 
-- 它们是**单活工作区切换器**；
+- 如果同一工作区已有 daemon，它们会委托 daemon 切换 CLI；
+- 如果没有 daemon，它们是**单活工作区切换器**；
 - 当前目录重复执行是幂等的；
 - 其他目录重复执行会触发工作区切换，而不是并行多开。
 
@@ -330,7 +427,7 @@ wechat-opencode-start --cwd D:\work\my-project
 默认数据目录：
 
 ```text
-~/.claude/channels/wechat
+~/.cli-bridge
 ```
 
 主要文件如下：
@@ -342,21 +439,28 @@ wechat-opencode-start --cwd D:\work\my-project
 | `context_tokens.json` | 微信上下文 token 缓存 |
 | `bridge.log` | bridge 运行日志 |
 | `bridge.lock.json` | bridge 运行锁 |
+| `daemon-endpoint.json` | `wechat-daemon` 本地 IPC endpoint |
+| `inbound-attachments/` | 微信入站图片和普通文件的本地保存目录 |
 | `workspaces/<workspace-key>/bridge-state.json` | 当前工作区状态 |
 | `workspaces/<workspace-key>/codex-panel-endpoint.json` | 当前工作区 companion endpoint；文件名保留历史兼容 |
+| `workspaces/<workspace-key>/<adapter>-companion-endpoint.json` | daemon / 多适配器模式下的适配器独立 companion endpoint |
 
 ### 环境变量
 
 | 变量名 | 说明 |
 | --- | --- |
 | `WECHAT_ILINK_BASE_URL` | 覆盖默认 iLink API 地址 |
-| `CLAUDE_WECHAT_CHANNEL_DATA_DIR` | 覆盖默认数据目录 |
+| `CLI_BRIDGE_DATA_DIR` | 覆盖默认数据目录 |
 | `WECHAT_MAX_IMAGE_MB` | 覆盖图片上传大小限制，默认 20 MB |
 | `WECHAT_MAX_FILE_MB` | 覆盖普通文件上传大小限制，默认 50 MB |
 | `WECHAT_MAX_VOICE_MB` | 覆盖语音上传大小限制，默认 20 MB |
 | `WECHAT_MAX_VIDEO_MB` | 覆盖视频上传大小限制，默认 100 MB |
+| `WECHAT_MAX_INBOUND_IMAGE_MB` | 覆盖微信入站图片下载大小限制，默认 20 MB |
+| `WECHAT_MAX_INBOUND_FILE_MB` | 覆盖微信入站普通文件下载大小限制，默认 50 MB |
 | `WECHAT_OPENCODE_DEBUG` | 开启 OpenCode 适配器调试输出 |
 
+旧版 `CLAUDE_WECHAT_CHANNEL_DATA_DIR` 不再作为活动数据目录配置项；如旧环境中设置过该变量，它只会被视为一次性旧数据迁移来源。新的自定义目录请使用 `CLI_BRIDGE_DATA_DIR`。
+
 ## 版本更新
 
 ### 检查更新
@@ -442,7 +546,7 @@ npm link
 3. 检查：
 
 ```text
-~/.claude/channels/wechat/bridge.log
+~/.cli-bridge/bridge.log
 ```
 
 ### 6. 本地 `/resume` 后微信不同步
@@ -456,7 +560,7 @@ npm link
 如果 `bridge-state.json` 看起来正常，但微信仍然没有收到回复，优先检查：
 
 ```text
-~/.claude/channels/wechat/bridge.log
+~/.cli-bridge/bridge.log
 ```
 
 如果日志中出现 `wechat_send_failed`、`UND_ERR_CONNECT_TIMEOUT` 或 `ilinkai.weixin.qq.com:443`，通常是 bridge 到 iLink 的出站网络或代理问题，而不是本地 CLI 没有完成任务。请确认当前终端是否继承 `HTTP_PROXY`、`HTTPS_PROXY`、`ALL_PROXY`，以及 Node 是否需要 `NODE_OPTIONS=--use-env-proxy`。
@@ -465,7 +569,7 @@ npm link
 
 - 微信 `/resume` 暂时被禁用（可能导致对话双向不稳定）
 - Codex 不支持底层任务的远程审批！建议给好权限，正常使用，几乎不会主动请求较为低级的远程审批；Claude Code 支持远程审批，但是测试的不够，如有问题可以提 issue。
-- 当前模型是单 owner、单 bridge、单活动工作区。
+- `wechat-daemon` v1 绑定启动工作区；暂不支持从微信切换到另一个本地目录。
 
 ## 开发说明
 
@@ -474,6 +578,8 @@ npm link
 | 文件 | 作用 |
 | --- | --- |
 | `src/bridge/wechat-bridge.ts` | bridge 主事件循环 |
+| `src/daemon/wechat-daemon.ts` | 常驻 WeChat daemon 与多 CLI slot 管理 |
+| `src/daemon/daemon-link.ts` | daemon 本地 IPC endpoint 与请求协议 |
 | `src/bridge/bridge-adapters.ts` | `codex` / `claude` / `opencode` / `shell` 适配器入口 |
 | `src/bridge/bridge-adapters.opencode.ts` | OpenCode 适配器实现 |
 | `src/companion/local-companion.ts` | `wechat-claude` / `wechat-opencode` 本地 companion 入口 |

package/bin/wechat-daemon.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runJsEntry } from "./_run-entry.mjs";
+
+runJsEntry("dist/daemon/wechat-daemon.js");

package/dist/bridge/bridge-adapters.core.js

@@ -47,7 +47,10 @@ export class LocalCompanionProxyAdapter {
         this.shuttingDown = false;
         this.expectedCloseReason = null;
         this.clearReconnectShutdownTimer();
-        this.setStatus("starting", `Waiting for manual ${this.options.kind} companion connection. Run "${getLocalCompanionCommandName(this.options.kind)}" in a second terminal for this directory.`);
+        this.setStatus("starting", formatLocalCompanionStartupMessage({
+            kind: this.options.kind,
+            launchMode: this.options.companionLaunchMode,
+        }));
         await new Promise((resolve, reject) => {
             const server = net.createServer((socket) => {
                 this.handlePanelSocket(socket);
@@ -133,7 +136,9 @@ export class LocalCompanionProxyAdapter {
         this.expectedCloseReason = null;
         this.clearReconnectShutdownTimer();
         this.rejectPendingRequests(`${this.options.kind} companion proxy is shutting down.`);
-        clearLocalCompanionEndpoint(this.options.cwd, this.endpoint?.instanceId);
+        clearLocalCompanionEndpoint(this.options.cwd, this.endpoint?.instanceId, {
+            adapter: this.options.kind,
+        });
         if (this.socket) {
             try {
                 sendLocalCompanionMessage(this.socket, {
@@ -185,10 +190,15 @@ export class LocalCompanionProxyAdapter {
                 this.expectedCloseReason = null;
                 this.socket = socket;
                 this.detachMessageListener = detachListener;
+                const companionConnectedAt = nowIso();
+                if (this.endpoint) {
+                    this.endpoint.companionPid = message.companionPid;
+                    this.endpoint.companionConnectedAt = companionConnectedAt;
+                }
                 updateLocalCompanionOccupancy(this.options.cwd, {
                     companionPid: message.companionPid,
-                    companionConnectedAt: nowIso(),
-                }, this.endpoint?.instanceId);
+                    companionConnectedAt,
+                }, this.endpoint?.instanceId, { adapter: this.options.kind });
                 sendLocalCompanionMessage(socket, { type: "hello_ack" });
                 return;
             }
@@ -198,7 +208,9 @@ export class LocalCompanionProxyAdapter {
             if (this.socket === socket) {
                 const expectedCloseReason = this.expectedCloseReason;
                 this.expectedCloseReason = null;
-                clearLocalCompanionOccupancy(this.options.cwd, this.endpoint?.instanceId);
+                clearLocalCompanionOccupancy(this.options.cwd, this.endpoint?.instanceId, {
+                    adapter: this.options.kind,
+                });
                 this.detachPanelSocket();
                 if (!this.shuttingDown) {
                     this.handleCompanionDisconnect(expectedCloseReason);
@@ -296,6 +308,7 @@ export class LocalCompanionProxyAdapter {
             lifecycle: this.options.lifecycle,
             expectedClose: isExpectedLocalCompanionClose(expectedCloseReason),
             reconnectGraceMs: LOCAL_COMPANION_RECONNECT_GRACE_MS,
+            launchMode: this.options.companionLaunchMode,
         });
         if (disposition.action === "shutdown") {
             this.clearReconnectShutdownTimer();
@@ -362,7 +375,10 @@ export class LocalCompanionProxyAdapter {
     async sendRequest(payload) {
         const socket = this.socket;
         if (!socket) {
-            throw new Error(`${this.options.kind} companion is not connected. Run "${getLocalCompanionCommandName(this.options.kind)}" in a second terminal for this directory.`);
+            throw new Error(formatCompanionNotConnectedMessage({
+                kind: this.options.kind,
+                launchMode: this.options.companionLaunchMode,
+            }));
         }
         if (!this.state.pid && payload.command !== "dispose") {
             throw new Error(`${this.options.kind} companion is connected but not ready yet. Wait for it to finish starting.`);
@@ -389,6 +405,18 @@ export function buildCompanionHealthPatch(state, timestamp) {
         companionWorkerPid: state.pid,
     };
 }
+export function formatLocalCompanionStartupMessage(params) {
+    if (params.launchMode === "daemon_auto") {
+        return `Waiting for daemon-managed ${params.kind} companion connection. The daemon will open or reuse the visible CLI automatically.`;
+    }
+    return `Waiting for manual ${params.kind} companion connection. Run "${getLocalCompanionCommandName(params.kind)}" in a second terminal for this directory.`;
+}
+export function formatCompanionNotConnectedMessage(params) {
+    if (params.launchMode === "daemon_auto") {
+        return `${params.kind} companion is not connected yet. Send /${params.kind} in WeChat to open or reconnect the visible CLI automatically.`;
+    }
+    return `${params.kind} companion is not connected. Run "${getLocalCompanionCommandName(params.kind)}" in a second terminal for this directory.`;
+}
 export function isExpectedLocalCompanionClose(reason) {
     return typeof reason === "string" && reason.length > 0;
 }
@@ -411,11 +439,23 @@ export function getCompanionDisconnectDisposition(params) {
         };
     }
     if (params.expectedClose) {
+        if (params.launchMode === "daemon_auto") {
+            return {
+                action: "await_manual_reconnect",
+                message: `${params.kind} companion closed. Send /${params.kind} in WeChat to reopen the visible CLI automatically.`,
+            };
+        }
         return {
             action: "await_manual_reconnect",
             message: `${params.kind} companion closed. Run "${commandName}" again in a second terminal for this directory.`,
         };
     }
+    if (params.launchMode === "daemon_auto") {
+        return {
+            action: "await_manual_reconnect",
+            message: `${params.kind} companion disconnected unexpectedly. Send /${params.kind} in WeChat to reopen the visible CLI automatically.`,
+        };
+    }
     return {
         action: "await_manual_reconnect",
         message: `${params.kind} companion disconnected unexpectedly. Run "${commandName}" again in a second terminal for this directory to reconnect.`,

package/dist/bridge/bridge-controller.js

@@ -17,7 +17,9 @@ export class BridgeController {
             this.clearLocalClientEndpoint();
             return;
         }
-        const existing = readLocalCompanionEndpoint(this.cwd);
+        const existing = readLocalCompanionEndpoint(this.cwd, {
+            adapter: endpoint.kind,
+        });
         const adapterState = this.adapter.getState();
         const nextEndpoint = existing?.instanceId === endpoint.instanceId
             ? {
@@ -38,7 +40,9 @@ export class BridgeController {
         writeLocalCompanionEndpoint(nextEndpoint);
     }
     clearLocalClientEndpoint() {
-        clearLocalCompanionEndpoint(this.cwd, this.endpointInstanceId ?? undefined);
+        clearLocalCompanionEndpoint(this.cwd, this.endpointInstanceId ?? undefined, {
+            adapter: this.adapter.getState().kind,
+        });
         this.endpointInstanceId = null;
     }
 }

package/dist/bridge/bridge-utils.js

@@ -211,15 +211,51 @@ export function shouldInjectWechatAttachmentPrompt(text) {
         mentionsLocalPath ||
         looksLikeShortSendCommand);
 }
-export function buildWechatInboundPrompt(text) {
-    if (!shouldInjectWechatAttachmentPrompt(text)) {
-        return text;
+function formatPromptByteSize(bytes) {
+    if (bytes === undefined || !Number.isFinite(bytes) || bytes < 0) {
+        return null;
     }
-    const normalized = normalizeOutput(text).trim();
-    if (!normalized) {
-        return text;
+    if (bytes >= 1024 * 1024) {
+        return `${(bytes / (1024 * 1024)).toFixed(bytes >= 100 * 1024 * 1024 ? 0 : 1)} MB`;
+    }
+    if (bytes >= 1024) {
+        return `${(bytes / 1024).toFixed(bytes >= 100 * 1024 ? 0 : 1)} KB`;
+    }
+    return `${bytes} B`;
+}
+function formatWechatInboundAttachmentPrompt(attachments) {
+    const lines = [
+        "[WeChat inbound attachments]",
+        "The user sent attachment files through WeChat. They have been saved locally. Read the local paths directly if the user's request requires inspecting them.",
+    ];
+    attachments.forEach((attachment, index) => {
+        const sizeText = formatPromptByteSize(attachment.sizeBytes);
+        const metadata = [
+            `kind=${attachment.kind}`,
+            attachment.fileName ? `name=${attachment.fileName}` : "",
+            sizeText ? `size=${sizeText}` : "",
+        ].filter(Boolean);
+        lines.push(`${index + 1}. ${metadata.join(" ")} path=${attachment.path}`);
+    });
+    return lines.join("\n");
+}
+export function buildWechatInboundPrompt(text, attachments = []) {
+    const trimmedAttachments = attachments.filter((attachment) => attachment.path.trim());
+    if (!trimmedAttachments.length) {
+        if (!shouldInjectWechatAttachmentPrompt(text)) {
+            return text;
+        }
+        const normalized = normalizeOutput(text).trim();
+        if (!normalized) {
+            return text;
+        }
+        return `${WECHAT_ATTACHMENT_PROMPT_PREFIX}\n${normalized}`;
     }
-    return `${WECHAT_ATTACHMENT_PROMPT_PREFIX}\n${normalized}`;
+    const baseText = normalizeOutput(text).trim() || "Received WeChat attachment(s).";
+    const userPrompt = shouldInjectWechatAttachmentPrompt(baseText)
+        ? `${WECHAT_ATTACHMENT_PROMPT_PREFIX}\n${baseText.trim()}`
+        : baseText;
+    return `${userPrompt.trim()}\n\n${formatWechatInboundAttachmentPrompt(trimmedAttachments)}`;
 }
 export function parseWechatFinalReply(text) {
     const normalized = normalizeOutput(text);

package/dist/bridge/wechat-bridge.js

@@ -9,8 +9,9 @@ import { BridgeStateStore } from "./bridge-state.js";
 import { reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses } from "./bridge-process-reaper.js";
 import { createRuntimeHost } from "../runtime/create-runtime-host.js";
 import { buildWechatInboundPrompt, buildOneTimeCode, formatApprovalMessage, formatPendingApprovalReminder, formatDuration, formatMirroredUserInputMessage, formatSessionSwitchMessage, formatStatusReport, formatTaskFailedMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parseWechatControlCommand, truncatePreview, } from "./bridge-utils.js";
-import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, WeChatTransport, describeWechatTransportError, } from "../wechat/wechat-transport.js";
+import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, WeChatTransport, describeWechatTransportError, isWechatContextTokenStaleError, } from "../wechat/wechat-transport.js";
 import { checkForUpdate, formatUpdateMessage, } from "../utils/version-checker.js";
+import { clearDaemonEndpoint, isDaemonEndpointAlive, readDaemonEndpoint, } from "../daemon/daemon-link.js";
 const POLL_RETRY_BASE_MS = 1_000;
 const POLL_RETRY_MAX_MS = 30_000;
 const PARENT_PROCESS_POLL_MS = 5_000;
@@ -75,16 +76,22 @@ export function formatUserFacingInboundError(params) {
 export function formatWechatSendFailureLogEntry(params) {
     return `wechat_send_failed: context=${params.context} recipient=${params.recipientId} error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
 }
+export function formatWechatContextTokenStaleLogEntry(params) {
+    return `wechat_context_token_stale: context=${params.context} recipient=${params.recipientId} action=wechat_message_required error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
+}
 function formatWechatSendRetryLogEntry(params) {
     return `wechat_send_retry: context=${params.context} recipient=${params.recipientId} attempt=${params.attempt} delay_ms=${params.delayMs} error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
 }
-function isRetryableWechatSendError(error) {
+export function isRetryableWechatSendError(error) {
+    if (isWechatContextTokenStaleError(error)) {
+        return false;
+    }
     const classification = classifyWechatTransportError(error);
     if (classification.retryable) {
         return true;
     }
     const details = describeWechatTransportError(error);
-    return /^Error: sendmessage failed:/i.test(details) &&
+    return /^(?:Error|WechatApiResponseError): sendmessage failed:/i.test(details) &&
         !/errcode=-14\b.*session timeout/i.test(details);
 }
 function computeWechatSendRetryDelayMs(attempt) {
@@ -214,6 +221,14 @@ function printUsageAndExit() {
 }
 async function main() {
     const options = parseCliArgs(process.argv.slice(2));
+    const daemonEndpoint = readDaemonEndpoint();
+    if (daemonEndpoint && await isDaemonEndpointAlive(daemonEndpoint, { timeoutMs: 500 })) {
+        throw new Error(`wechat-daemon is already running (pid=${daemonEndpoint.pid}, cwd=${daemonEndpoint.cwd}). Stop it before starting a standalone bridge.`);
+    }
+    if (daemonEndpoint) {
+        clearDaemonEndpoint(daemonEndpoint.pid);
+        log(`Cleared stale wechat-daemon endpoint for pid=${daemonEndpoint.pid}.`);
+    }
     const credentials = await ensureWechatCredentials({
         requireUserId: true,
         validateExisting: true,
@@ -313,6 +328,17 @@ async function main() {
                     return true;
                 }
                 catch (err) {
+                    if (isWechatContextTokenStaleError(err)) {
+                        transport.clearCachedContextToken(senderId);
+                        const hint = "WeChat conversation context is stale. Ask the WeChat owner to send any message first, then local terminal replies can sync back to WeChat.";
+                        logError(`Failed to send WeChat ${context}: ${hint}`);
+                        stateStore.appendLog(formatWechatContextTokenStaleLogEntry({
+                            context,
+                            recipientId: senderId,
+                            error: err,
+                        }));
+                        return false;
+                    }
                     if (attempt < WECHAT_SEND_MAX_ATTEMPTS && isRetryableWechatSendError(err)) {
                         const delayMs = computeWechatSendRetryDelayMs(attempt);
                         logError(`Failed to send WeChat ${context} (attempt ${attempt}). Retrying in ${formatDuration(delayMs)}. ${describeWechatTransportError(err)}`);
@@ -837,6 +863,17 @@ function buildCompletionSummary(params) {
     lines.push(`recent_output:\n${params.recentOutput}`);
     return lines.join("\n");
 }
+function formatInboundMessagePreview(message) {
+    if (message.text.trim()) {
+        return message.text;
+    }
+    if (message.attachments.length > 0) {
+        return message.attachments
+            .map((attachment) => `${attachment.kind}: ${attachment.path}`)
+            .join("\n");
+    }
+    return "(empty)";
+}
 async function handleInboundMessage(params) {
     const { message, options, stateStore, adapter, queueWechatMessage, outputBatcher, deferInboundMessage, } = params;
     const state = stateStore.getState();
@@ -971,12 +1008,13 @@ async function handleInboundMessage(params) {
 }
 async function dispatchInboundWechatText(params) {
     const { message, options, stateStore, adapter } = params;
+    const preview = formatInboundMessagePreview(message);
     const activeTask = {
         startedAt: Date.now(),
-        inputPreview: truncatePreview(message.text, 180),
+        inputPreview: truncatePreview(preview, 180),
     };
-    stateStore.appendLog(`Forwarded input to ${options.adapter}: ${truncatePreview(message.text)}`);
-    await adapter.sendInput(buildWechatInboundPrompt(message.text));
+    stateStore.appendLog(`Forwarded input to ${options.adapter}: ${truncatePreview(preview)}`);
+    await adapter.sendInput(buildWechatInboundPrompt(message.text, message.attachments));
     return activeTask;
 }
 const isDirectRun = Boolean(import.meta.main);

package/dist/companion/codex-remote-client.js

@@ -40,7 +40,7 @@ export function parseCliArgs(argv) {
     return { cwd, cliArgs };
 }
 export function readCodexRuntimeEndpoint(cwd) {
-    const endpoint = readLocalCompanionEndpoint(cwd);
+    const endpoint = readLocalCompanionEndpoint(cwd, { adapter: "codex" });
     if (!endpoint || endpoint.kind !== "codex") {
         throw new Error(`No active Codex bridge endpoint was found for ${cwd}. Start "wechat-bridge-codex" in that directory first.`);
     }
@@ -83,14 +83,18 @@ export async function runCodexRemoteClientFromEndpoint(endpoint, options = {}) {
             updateLocalCompanionOccupancy(endpoint.cwd, {
                 companionPid: child.pid,
                 companionConnectedAt: new Date().toISOString(),
-            }, endpoint.instanceId);
+            }, endpoint.instanceId, { adapter: "codex" });
         }
         child.once("error", (error) => {
-            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId);
+            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId, {
+                adapter: "codex",
+            });
             reject(error);
         });
         child.once("exit", (code, signal) => {
-            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId);
+            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId, {
+                adapter: "codex",
+            });
             if (signal) {
                 process.kill(process.pid, signal);
                 return;