weacpx 0.1.7 → 0.2.1

package/README.md

@@ -4,6 +4,7 @@
 
 [![npm](https://img.shields.io/npm/v/weacpx?style=flat-square)](https://www.npmjs.com/package/weacpx)
 [![Node.js Version](https://img.shields.io/node/v/weacpx?style=flat-square)](https://nodejs.org)
+[![zread](https://img.shields.io/badge/Ask_Zread-_.svg?style=flat-square&color=00b0aa&labelColor=000000&logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%2CPHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHZpZXdCb3g9IjAgMCAxNiAxNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTQuOTYxNTYgMS42MDAxSDIuMjQxNTZDMS44ODgxIDEuNjAwMSAxLjYwMTU2IDEuODg2NjQgMS42MDE1NiAyLjI0MDFWNC45NjAxQzEuNjAxNTYgNS4zMTM1NiAxLjg4ODEgNS42MDAxIDIuMjQxNTYgNS42MDAxSDQuOTYxNTZDNS4zMTUwMiA1LjYwMDEgNS42MDE1NiA1LjMxMzU2IDUuNjAxNTYgNC45NjAxVjIuMjQwMUM1LjYwMTU2IDEuODg2NjQgNS4zMTUwMiAxLjYwMDEgNC45NjE1NiAxLjYwMDFaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik00Ljk2MTU2IDEwLjM5OTlIMi4yNDE1NkMxLjg4ODEgMTAuMzk5OSAxLjYwMTU2IDEwLjY4NjQgMS42MDE1NiAxMS4wMzk5VjEzLjc1OTlDMS42MDE1NiAxNC4xMTM0IDEuODg4MSAxNC4zOTk5IDIuMjQxNTYgMTQuMzk5OUg0Ljk2MTU2QzUuMzE1MDIgMTQuMzk5OSA1LjYwMTU2IDE0LjExMzQgNS42MDE1NiAxMy43NTk5VjExLjAzOTlDNS42MDE1NiAxMC42ODY0IDUuMzE1MDIgMTAuMzk5OSA0Ljk2MTU2IDEwLjM5OTlaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik0xMy43NTg0IDEuNjAwMUgxMS4wMzg0QzEwLjY4NSAxLjYwMDEgMTAuMzk4NCAxLjg4NjY0IDEwLjM5ODQgMi4yNDAxVjQuOTYwMUMxMC4zOTg0IDUuMzEzNTYgMTAuNjg1IDUuNjAwMSAxMS4wMzg0IDUuNjAwMUgxMy43NTg0QzE0LjExMTkgNS42MDAxIDE0LjM5ODQgNS4zMTM1NiAxNC4zOTg0IDQuOTYwMVYyLjI0MDFDMTQuMzk4NCAxLjg4NjY0IDE0LjExMTkgMS42MDAxIDEzLjc1ODQgMS42MDAxWiIgZmlsbD0iI2ZmZiIvPgo8cGF0aCBkPSJNNCAxMkwxMiA0TDQgMTJaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik00IDEyTDEyIDQiIHN0cm9rZT0iI2ZmZiIgc3Ryb2tlLXdpZHRoPSIxLjUiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIvPgo8L3N2Zz4K&logoColor=ffffff)](https://zread.ai/gadzan/weacpx)
 [![License](https://img.shields.io/npm/l/weacpx?style=flat-square)](./LICENSE)
 
 ![weacpx logo](assets/weacpx.jpg)
@@ -70,7 +71,9 @@ bun add -g weacpx
 hello
 ```
 
-如果任务比较长，`weacpx` 会优先把 Agent 的中间回复分段发回微信，而不是一直等到最后一条结果。
+如果任务比较长，`weacpx` 在支持流式中间回复的 transport（当前主要是 `acpx-cli`）下，会优先把 Agent 的中间回复分段发回微信，而不是一直等到最后一条结果。
+
+如果你更想要“一次性只回最终结果”，可以配置全局默认 `wechat.replyMode`，或在当前会话里用 `/replymode final` 临时覆盖。
 
 如果你是从源码仓库直接使用：
 
@@ -95,14 +98,55 @@ bun run dev
 - `weacpx start`
 - `weacpx status`
 - `weacpx stop`
+- `weacpx doctor`
+- `weacpx version`
 
-说明：
+其他说明：
 
 - `run` 前台运行，适合调试
 - `start` 后台启动
 - `status` 查看后台状态、PID、配置路径和日志路径
 - `stop` 停止后台实例
 - `logout` 清除本机已保存的微信登录凭证；如果当前没有已登录账号，会直接提示
+- `doctor` 运行诊断，默认检查 config / runtime / daemon / wechat / acpx / bridge
+- `version` 输出当前安装的 `weacpx` 版本号，可用于排查环境或确认升级是否生效
+
+### doctor 诊断
+
+`weacpx doctor` 用来快速检查本机环境是否能正常运行。
+
+```bash
+weacpx doctor
+weacpx doctor --verbose
+weacpx doctor --smoke
+weacpx doctor --smoke --agent codex --workspace backend
+```
+
+说明：
+
+- `--verbose` 会展开每个检查的技术细节，方便定位问题
+- `--smoke` 会额外执行一次真实 transport 级别的最小 prompt 检查
+- `--agent` / `--workspace` 只影响 `--smoke`，不会改变默认诊断检查
+- `--smoke` 可能留下一个临时的底层 `acpx` session；这是为了换取真实链路验证能力
+- 如果不传 `--smoke`，相关 smoke 检查会被标记为 `SKIP`
+
+### version 查看版本
+
+`weacpx version` 用来输出当前安装的 CLI 版本号。
+
+```bash
+weacpx version
+weacpx --version
+weacpx -v
+```
+
+说明：
+
+- 三种写法都会输出同一个版本号
+- 适合在升级后确认当前生效的是哪个版本
+- 排查用户环境问题时，建议先附上这里输出的版本信息
+
+### logout 退出登录
 
 说明：
 
@@ -169,14 +213,18 @@ bun run dev
 | 命令 | 说明 |
 |------|------|
 | `/sessions` / `/session` / `/ss` | 查看当前已添加的会话 |
-| `/ss <agent> -d <path>` | 新建会话（自动按目录名推导并创建或复用 workspace，再创建或复用 session） |
-| `/ss new <agent> -d <path>` | 强制新建会话 |
+| `/ss <agent> (-d <path> | --ws <name>)` | 新建会话；传 `-d` 时按目录自动创建或复用 workspace，传 `--ws` 时复用已注册 workspace |
+| `/ss new <agent> (-d <path> | --ws <name>)` | 强制新建会话；`--ws` 只复用已注册 workspace |
 | `/ss new <alias> -a <name> --ws <name>` | 强制新建会话，并指定 agent 和 workspace |
 | `/ss attach <alias> -a <name> --ws <name> --name <transport-session>` | 恢复已存在的会话 |
 | `/use <alias>` | 切换当前会话 |
 | `/status` | 查看当前会话状态 |
 | `/mode` | 查看当前会话已保存的 mode |
 | `/mode <id>` | 设置当前会话 mode，例如 `/mode plan` |
+| `/replymode` | 查看当前会话的回复输出模式（全局默认 / 当前覆盖 / 实际生效） |
+| `/replymode stream` | 当前逻辑会话使用流式回复 |
+| `/replymode final` | 当前逻辑会话只发送最终文本结果 |
+| `/replymode reset` | 清除当前逻辑会话覆盖，回退到全局默认 |
 | `/session reset` | 重置当前会话上下文，保留 alias/agent/workspace，但重新绑定到一个新的后端 session |
 | `/clear` | `/session reset` 的快捷别名 |
 | `/cancel` | 取消当前会话 |
@@ -185,13 +233,45 @@ bun run dev
 说明：
 
 - `/ss <agent> -d <path>` 是最常用入口，会自动按目录名推导并创建或复用 workspace，再创建或复用 session
-- `/ss new <agent> -d <path>` 表示强制新建 session
+- `/ss <agent> --ws <name>` 会直接复用已注册 workspace，再创建或复用 session
+- `/ss new <agent> (-d <path> | --ws <name>)` 表示强制新建 session
 - `/use <alias>` 用来切换当前会话
 - `/mode` 会显示当前逻辑会话里保存的 mode；如果还没设置过，会显示“未设置”
 - `/mode <id>` 会把 mode 透传给底层 `acpx set-mode`，成功后再写回当前逻辑会话
+- `/replymode` 修改的是**当前逻辑会话**的 reply mode override，不是底层 transport session 的全局属性
+- `wechat.replyMode` 是全局默认值；`/replymode reset` 会回退到这个默认值
+- `final` 只影响微信侧是否实时发送文本流式片段，不改变 acpx transport 本身的生成方式
 - `/session reset` 和 `/clear` 会保留当前逻辑会话名，但重新创建一个新的后端 session，从空上下文重新开始
 - 非 `/` 开头的文本会发送到当前 session
 
+### 配置命令
+
+`/config` 用来查看和修改一小部分**受支持的配置字段**，不是任意 JSON 编辑器。
+
+| 命令 | 说明 |
+|------|------|
+| `/config` | 查看当前支持通过微信修改的配置路径 |
+| `/config set <path> <value>` | 修改一个受支持的配置值 |
+
+常见示例：
+
+```text
+/config
+/config set wechat.replyMode final
+/config set logging.level debug
+/config set transport.permissionMode approve-reads
+/config set workspaces.backend.description backend repo
+```
+
+说明：
+
+- `/config` 只允许修改白名单字段，不支持任意路径写入
+- `agents.<name>.*` / `workspaces.<name>.*` 这类动态路径要求目标已经存在，不会自动创建
+- `/config set wechat.replyMode final` 修改的是**全局默认回复模式**
+- `/replymode final` 修改的是**当前逻辑会话覆盖**
+- 成功修改后会立即写回 `~/.weacpx/config.json`
+- 更完整的边界和支持字段，请参考 [docs/config-command.md](./docs/config-command.md)
+
 ### 权限策略
 
 `weacpx` 支持直接在微信里查看和切换 `acpx` 的权限策略。
@@ -203,7 +283,6 @@ bun run dev
 | `/pm set read` | 切到 `approve-reads` |
 | `/pm set deny` | 切到 `deny-all` |
 | `/pm auto` | 查看当前非交互策略 |
-| `/pm auto allow` | 切到 `allow` |
 | `/pm auto deny` | 切到 `deny` |
 | `/pm auto fail` | 切到 `fail` |
 
@@ -282,7 +361,7 @@ bun run dev
     "type": "acpx-bridge",
     "sessionInitTimeoutMs": 120000,
     "permissionMode": "approve-all",
-    "nonInteractivePermissions": "fail"
+    "nonInteractivePermissions": "deny"
   }
 }
 ```
@@ -290,8 +369,8 @@ bun run dev
 说明：
 
 - `permissionMode`: `approve-all`、`approve-reads`、`deny-all`
-- `nonInteractivePermissions`: `allow`、`deny`、`fail`
-- 默认值分别是 `approve-all` 和 `fail`
+- `nonInteractivePermissions`: `deny`、`fail`
+- 默认值分别是 `approve-all` 和 `deny`
 - 也可以直接在微信里通过 `/pm` 和 `/pm auto` 修改
 
 ### 日志配置

package/config.example.json

@@ -3,7 +3,7 @@
     "type": "acpx-bridge",
     "sessionInitTimeoutMs": 120000,
     "permissionMode": "approve-all",
-    "nonInteractivePermissions": "fail"
+    "nonInteractivePermissions": "deny"
   },
   "logging": {
     "level": "info",
@@ -11,6 +11,9 @@
     "maxFiles": 5,
     "retentionDays": 7
   },
+  "wechat": {
+    "replyMode": "stream"
+  },
   "agents": {
     "codex": {
       "driver": "codex"

package/dist/bridge/bridge-main.js

@@ -44,8 +44,19 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __promiseAll = (args) => Promise.all(args);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/transport/acpx-bridge/acpx-bridge-protocol.ts
+function encodeBridgeRequest(request) {
+  return `${JSON.stringify(request)}
+`;
+}
+function encodeBridgePromptSegmentEvent(event) {
+  return `${JSON.stringify(event)}
+`;
+}
+
 // src/transport/prompt-output.ts
 function getPromptText(result) {
   const stdoutOutput = extractPromptOutput(result.stdout);
@@ -193,9 +204,75 @@ var init_spawn_command = __esm(() => {
   SCRIPT_FILE_PATTERN = /\.(c|m)?js$/i;
 });
 
+// src/transport/streaming-prompt.ts
+function createStreamingPromptState() {
+  return {
+    buffer: "",
+    segments: [],
+    hasAgentMessage: false,
+    pendingLine: "",
+    finalize() {
+      if (this.pendingLine.trim().length > 0) {
+        parseStreamingChunks(this, this.pendingLine);
+      }
+      const remaining = this.buffer.trim();
+      this.buffer = "";
+      this.pendingLine = "";
+      return remaining;
+    }
+  };
+}
+function parseStreamingDataChunk(state, chunk) {
+  state.pendingLine += chunk;
+  let boundary;
+  while ((boundary = state.pendingLine.indexOf(`
+`)) !== -1) {
+    const line = state.pendingLine.slice(0, boundary);
+    state.pendingLine = state.pendingLine.slice(boundary + 1);
+    parseStreamingChunks(state, line);
+  }
+}
+function parseStreamingChunks(state, line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0)
+    return;
+  let event;
+  try {
+    event = JSON.parse(trimmed);
+  } catch {
+    return;
+  }
+  const isMessageChunk = event.method === "session/update" && event.params?.update?.sessionUpdate === "agent_message_chunk" && event.params.update.content?.type === "text" && typeof event.params.update.content.text === "string";
+  if (!isMessageChunk)
+    return;
+  state.hasAgentMessage = true;
+  const chunk = event.params.update.content.text ?? "";
+  if (chunk.length === 0)
+    return;
+  state.buffer += chunk;
+  let boundary;
+  while ((boundary = state.buffer.indexOf(`
+
+`)) !== -1) {
+    const segment = state.buffer.slice(0, boundary).trim();
+    state.buffer = state.buffer.slice(boundary + 2);
+    if (segment.length > 0) {
+      state.segments.push(segment);
+    }
+  }
+}
+
 // src/bridge/bridge-main.ts
 import { createInterface } from "node:readline";
 
+// src/bridge/bridge-env.ts
+function normalizeBridgePermissionMode(value) {
+  return value === "approve-reads" || value === "deny-all" || value === "approve-all" ? value : "approve-all";
+}
+function normalizeBridgeNonInteractivePermissions(value) {
+  return value === "deny" || value === "fail" ? value : "deny";
+}
+
 // src/bridge/bridge-server.ts
 init_prompt_output();
 
@@ -204,6 +281,7 @@ class BridgeInvalidRequestError extends Error {
 var BRIDGE_METHODS = new Set([
   "ping",
   "shutdown",
+  "updatePermissionPolicy",
   "hasSession",
   "ensureSession",
   "prompt",
@@ -216,12 +294,12 @@ class BridgeServer {
   constructor(runtime) {
     this.runtime = runtime;
   }
-  async handleLine(line) {
+  async handleLine(line, writeLine) {
     let requestId = extractRequestId(line);
     try {
       const request = parseBridgeRequest(line);
       requestId = request.id;
-      const result = await this.dispatch(request.method, request.params);
+      const result = await this.dispatch(request.id, request.method, request.params, writeLine);
       return `${JSON.stringify({
         id: request.id,
         ok: true,
@@ -248,12 +326,17 @@ class BridgeServer {
 `;
     }
   }
-  async dispatch(method, params) {
+  async dispatch(requestId, method, params, writeLine) {
     switch (method) {
       case "ping":
         return {};
       case "shutdown":
         return await this.runtime.shutdown();
+      case "updatePermissionPolicy":
+        return await this.runtime.updatePermissionPolicy({
+          permissionMode: requirePermissionMode(params, "permissionMode"),
+          nonInteractivePermissions: requireNonInteractivePermissions(params, "nonInteractivePermissions")
+        });
       case "hasSession":
         return await this.runtime.hasSession({
           agent: requireString(params, "agent"),
@@ -275,6 +358,14 @@ class BridgeServer {
           cwd: requireString(params, "cwd"),
           name: requireString(params, "name"),
           text: requireString(params, "text")
+        }, (event) => {
+          if (event.type === "prompt.segment") {
+            writeLine?.(encodeBridgePromptSegmentEvent({
+              id: requestId,
+              event: "prompt.segment",
+              text: event.text
+            }));
+          }
         });
       case "setMode":
         return await this.runtime.setMode({
@@ -347,6 +438,20 @@ function requireString(params, key) {
   }
   return value;
 }
+function requirePermissionMode(params, key) {
+  const value = params[key];
+  if (value === "approve-all" || value === "approve-reads" || value === "deny-all") {
+    return value;
+  }
+  throw new BridgeInvalidRequestError(`${key} must be approve-all, approve-reads, or deny-all`);
+}
+function requireNonInteractivePermissions(params, key) {
+  const value = params[key];
+  if (value === "deny" || value === "fail") {
+    return value;
+  }
+  throw new BridgeInvalidRequestError(`${key} must be deny or fail`);
+}
 function asOptionalString(value) {
   if (typeof value !== "string" || value.length === 0) {
     return;
@@ -357,19 +462,28 @@ function asOptionalString(value) {
 // src/bridge/bridge-runtime.ts
 init_spawn_command();
 init_prompt_output();
+import { copyFile, readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
 
 class BridgeRuntime {
   command;
   run;
   runSessionCreate;
   options;
-  constructor(command = "acpx", run = defaultRunner, runSessionCreate = shellSessionCreateRunner, options = {}) {
+  runPromptCommand;
+  constructor(command = "acpx", run = defaultRunner, runSessionCreate = shellSessionCreateRunner, options = {}, runPromptCommand = defaultPromptRunner) {
     this.command = command;
     this.run = run;
     this.runSessionCreate = runSessionCreate;
     this.options = options;
+    this.runPromptCommand = runPromptCommand;
+  }
+  async updatePermissionPolicy(policy) {
+    this.options.permissionMode = policy.permissionMode;
+    this.options.nonInteractivePermissions = policy.nonInteractivePermissions;
+    return {};
   }
   async hasSession(input) {
     const spawnSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, [
@@ -397,20 +511,27 @@ class BridgeRuntime {
       return {};
     }
     const createSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, ["sessions", "new", "--name", input.name]));
-    const createdWithHelper = await this.runSessionCreate(createSpec.command, createSpec.args, input.cwd);
-    if (createdWithHelper.code !== 0) {
-      throw new Error(createdWithHelper.stderr || createdWithHelper.stdout || ensured.stderr || ensured.stdout || "failed to create session");
+    const created = await this.runSessionCreate(createSpec.command, createSpec.args, input.cwd);
+    if (created.code === 0) {
+      return {};
     }
-    return {};
+    const output = created.stderr || created.stdout || "";
+    if (output.includes("EPERM") && await tryRepairAcpxSessionIndex()) {
+      const repaired = await this.run(existingSpec.command, existingSpec.args);
+      if (repaired.code === 0) {
+        return {};
+      }
+    }
+    throw new Error(output || ensured.stderr || ensured.stdout || "failed to create session");
   }
-  async prompt(input) {
+  async prompt(input, onEvent) {
     const spawnSpec = resolveSpawnCommand(this.command, this.buildPromptArgs(input, [
       "prompt",
       "-s",
       input.name,
       input.text
     ]));
-    const result = await this.run(spawnSpec.command, spawnSpec.args);
+    const result = onEvent ? await this.runPromptCommand(spawnSpec.command, spawnSpec.args, onEvent) : await this.run(spawnSpec.command, spawnSpec.args);
     return { text: getPromptText(result) };
   }
   async setMode(input) {
@@ -473,7 +594,7 @@ class BridgeRuntime {
   }
   buildPermissionArgs() {
     const permissionMode = this.options.permissionMode ?? "approve-all";
-    const nonInteractivePermissions = this.options.nonInteractivePermissions ?? "fail";
+    const nonInteractivePermissions = this.options.nonInteractivePermissions ?? "deny";
     const modeFlag = permissionMode === "approve-reads" ? "--approve-reads" : permissionMode === "deny-all" ? "--deny-all" : "--approve-all";
     return [modeFlag, "--non-interactive-permissions", nonInteractivePermissions];
   }
@@ -495,10 +616,66 @@ async function defaultRunner(command, args) {
     });
   });
 }
+async function runStreamingPrompt(command, args, onEvent, options = {}) {
+  const spawnPrompt = options.spawnPrompt ?? ((spawnCommand, spawnArgs) => spawn(spawnCommand, spawnArgs, { stdio: ["ignore", "pipe", "pipe"] }));
+  const setIntervalFn = options.setIntervalFn ?? ((fn, delay) => setInterval(fn, delay));
+  const clearIntervalFn = options.clearIntervalFn ?? ((timer) => clearInterval(timer));
+  const maxSegmentWaitMs = options.maxSegmentWaitMs ?? 30000;
+  const flushCheckIntervalMs = options.flushCheckIntervalMs ?? 5000;
+  const now = options.now ?? (() => Date.now());
+  return await new Promise((resolve, reject) => {
+    const child = spawnPrompt(command, args);
+    let stdout = "";
+    let stderr = "";
+    const state = createStreamingPromptState();
+    let lastReplyAt = now();
+    const flushBuffer = () => {
+      const remaining = state.buffer.trim();
+      if (remaining.length > 0) {
+        state.buffer = "";
+        onEvent?.({ type: "prompt.segment", text: remaining });
+        lastReplyAt = now();
+      }
+    };
+    const timer = setIntervalFn(() => {
+      if (state.buffer.trim().length > 0 && now() - lastReplyAt >= maxSegmentWaitMs) {
+        flushBuffer();
+      }
+    }, flushCheckIntervalMs);
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      const text = String(chunk);
+      stdout += text;
+      parseStreamingDataChunk(state, text);
+      for (const segment of state.segments.splice(0)) {
+        onEvent?.({ type: "prompt.segment", text: segment });
+        lastReplyAt = now();
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      clearIntervalFn(timer);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      clearIntervalFn(timer);
+      const remaining = state.finalize();
+      if (remaining.length > 0) {
+        onEvent?.({ type: "prompt.segment", text: remaining });
+      }
+      resolve({ code: code ?? 1, stdout, stderr });
+    });
+  });
+}
+async function defaultPromptRunner(command, args, onEvent) {
+  return await runStreamingPrompt(command, args, onEvent);
+}
 async function shellSessionCreateRunner(command, args, cwd) {
-  const helperPath = fileURLToPath(new URL("../../scripts/acpx-session-new-helper.sh", import.meta.url));
   return await new Promise((resolve, reject) => {
-    const child = spawn("/bin/zsh", [helperPath, command, cwd, ...args], {
+    const child = spawn(command, args, {
+      cwd,
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout = "";
@@ -515,17 +692,58 @@ async function shellSessionCreateRunner(command, args, cwd) {
     });
   });
 }
+async function tryRepairAcpxSessionIndex() {
+  if (process.platform !== "win32") {
+    return false;
+  }
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? homedir();
+  if (!home) {
+    return false;
+  }
+  const sessionsDir = join(home, ".acpx", "sessions");
+  const indexPath = join(sessionsDir, "index.json");
+  let files;
+  try {
+    files = await readdir(sessionsDir);
+  } catch {
+    return false;
+  }
+  const tmpFiles = files.filter((f) => f.startsWith("index.json.") && f.endsWith(".tmp"));
+  if (tmpFiles.length === 0) {
+    return false;
+  }
+  let latestTmp = "";
+  let latestTime = 0;
+  for (const f of tmpFiles) {
+    const match = f.match(/^index\.json\.\d+\.(\d+)\.tmp$/);
+    if (match && Number(match[1]) > latestTime) {
+      latestTime = Number(match[1]);
+      latestTmp = f;
+    }
+  }
+  if (!latestTmp) {
+    return false;
+  }
+  try {
+    await copyFile(join(sessionsDir, latestTmp), indexPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/bridge/bridge-main.ts
 var server = new BridgeServer(new BridgeRuntime(process.env.WEACPX_BRIDGE_ACPX_COMMAND ?? "acpx", undefined, undefined, {
-  permissionMode: process.env.WEACPX_BRIDGE_PERMISSION_MODE === "approve-reads" || process.env.WEACPX_BRIDGE_PERMISSION_MODE === "deny-all" ? process.env.WEACPX_BRIDGE_PERMISSION_MODE : "approve-all",
-  nonInteractivePermissions: process.env.WEACPX_BRIDGE_NON_INTERACTIVE_PERMISSIONS === "deny" ? "deny" : "fail"
+  permissionMode: normalizeBridgePermissionMode(process.env.WEACPX_BRIDGE_PERMISSION_MODE),
+  nonInteractivePermissions: normalizeBridgeNonInteractivePermissions(process.env.WEACPX_BRIDGE_NON_INTERACTIVE_PERMISSIONS)
 }));
 var input = createInterface({
   input: process.stdin,
   crlfDelay: Infinity
 });
 for await (const line of input) {
-  const response = await server.handleLine(line);
+  const response = await server.handleLine(line, (chunk) => {
+    process.stdout.write(chunk);
+  });
   process.stdout.write(response);
 }