weacpx 0.1.5 → 0.1.7

package/README.md

@@ -1,14 +1,34 @@
-# weacpx 
+# Weacpx
 
-使用微信 ClawBot 随时随地通过 `acpx` 控制 Claude Code、Codex 等 Agents。
+连接微信与 acpx 协议，让 Claude Code / Codex 成为你口袋里的 24/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)
+[![License](https://img.shields.io/npm/l/weacpx?style=flat-square)](./LICENSE)
+
+![weacpx logo](assets/weacpx.jpg)
+
+## Why Weacpx？
+
+在 Agent-First 的开发模式下，编码任务必须依托顶级 Agents，🙅‍♀️不要通过 openclaw 去开发，现在有一个更好的方案。Weacpx 通过微信提供一个轻量化的远程入口，随时随地通过手机驱动你的顶级 Agents。
+
+Weacpx 的核心价值主张很简单：
+
+**随时随地访问** — 只要你有微信，就能控制你的 Agent。无需 VPN、Web 界面或复杂的云服务配置。
+
+**统一的会话管理** — 通过 acpx 协议，weacpx 让你在微信里管理多个 Agent 会话（Codex、Claude Code 等），就像在本地终端一样。创建、切换、查询状态，全部通过简单的斜杠命令完成，这是其它简单基于 ACP 实现的远控 agent 所不具备的。
+
+**轻量守护进程** — weacpx 作为后台守护进程运行，资源占用极低。不用启动一个臃肿 openclaw，不用担心在工作机器上使用会占用资源。启动、停止、查看状态都通过简单的 CLI 命令完成。
+
+**权限可控** — 可以即时通过微信修改 agent 的权限，无论是 YOLO 还是只读。
 
 ## 安装前准备
 
 开始前，至少需要：
 
 - Node.js 22+ 或 Bun
-- 一个可用的微信登录环境
 - Claude Code 或 Codex
+- 装了微信的手机
 
 > `weacpx` 基于 `weixin-agent-sdk` 与 `acpx` 实现。
 > 正常情况下，不需要再额外全局安装 `acpx`。
@@ -155,6 +175,8 @@ bun run dev
 | `/ss attach <alias> -a <name> --ws <name> --name <transport-session>` | 恢复已存在的会话 |
 | `/use <alias>` | 切换当前会话 |
 | `/status` | 查看当前会话状态 |
+| `/mode` | 查看当前会话已保存的 mode |
+| `/mode <id>` | 设置当前会话 mode，例如 `/mode plan` |
 | `/session reset` | 重置当前会话上下文，保留 alias/agent/workspace，但重新绑定到一个新的后端 session |
 | `/clear` | `/session reset` 的快捷别名 |
 | `/cancel` | 取消当前会话 |
@@ -165,6 +187,8 @@ bun run dev
 - `/ss <agent> -d <path>` 是最常用入口，会自动按目录名推导并创建或复用 workspace，再创建或复用 session
 - `/ss new <agent> -d <path>` 表示强制新建 session
 - `/use <alias>` 用来切换当前会话
+- `/mode` 会显示当前逻辑会话里保存的 mode；如果还没设置过，会显示“未设置”
+- `/mode <id>` 会把 mode 透传给底层 `acpx set-mode`，成功后再写回当前逻辑会话
 - `/session reset` 和 `/clear` 会保留当前逻辑会话名，但重新创建一个新的后端 session，从空上下文重新开始
 - 非 `/` 开头的文本会发送到当前 session
 
@@ -248,12 +272,6 @@ bun run dev
 - `~/.weacpx/runtime/stdout.log`
 - `~/.weacpx/runtime/stderr.log`
 
-常用环境变量：
-
-- `WEACPX_CONFIG`
-- `WEACPX_STATE`
-- `WEACPX_WEIXIN_SDK`
-
 ### Transport 权限配置
 
 `config.json` 中的 `transport` 支持以下权限字段：
@@ -300,19 +318,25 @@ bun run dev
 
 ## 注意事项
 
-### `dry-run`
+### Adapter mode 参考
 
-`dry-run` 会复用同一套 router、session service、transport，只是把微信消息换成终端输入，适合本地排查。
+`acpx set-mode` / 计划中的 `/mode <id>` 本质上都是给底层 ACP session 发送 `session/set_mode`。
+这里的 `<id>` 不是 `weacpx` 或 `acpx` 统一规定的枚举，而是**各 adapter 自己定义**的值；填错时通常会收到 adapter 返回的 `Invalid params` 一类错误。
 
-示例：
+基于 `acpx` 内置 adapter 文档和各上游公开文档，当前能确认的信息如下：
 
-```bash
-bun run dry-run --chat-key wx:test -- \
-  "/agent add codex" \
-  "/ws new backend -d /absolute/path/to/backend" \
-  "/ss new demo -a codex --ws backend" \
-  "/status"
-```
+| adapter | 已确认可用的 mode id | 说明 |
+|------|------|------|
+| `codex` | `plan` | `acpx` 自身示例明确使用过 `acpx codex set-mode plan`。`codex-acp` 还暴露了 `mode` 运行时配置项，但上游目前没有公开一份完整、稳定的 mode id 列表。 |
+| `cursor` | `agent`、`plan`、`ask` | Cursor 官方文档/更新日志公开提到 `Plan mode`、`Ask mode`；Cursor 官方论坛在 ACP `session/configure` 示例中展示过 `availableModes` 为 `agent` / `plan` / `ask`。 |
+| 其他内置 adapter | 暂无公开、稳定的 mode id 列表 | 包括 `claude`、`copilot`、`gemini`、`qoder`、`qwen`、`kimi`、`kiro`、`iflow`、`opencode`、`trae`、`droid`、`kilocode` 等。即使某些产品本身有“Ask / Agent / Plan”之类概念，其 ACP `set-mode` 可接受的精确字符串也往往没有在官方文档中写死。 |
+
+建议：
+
+- 对 `codex`，优先把 `plan` 当作已知可用值。
+- 对 `cursor`，优先使用 `agent`、`plan`、`ask`。
+- 对其他 adapter，不要在 `weacpx` 里写死候选值；最好把 `/mode <id>` 设计成透传，由 adapter 自己决定是否接受。
+- 如果某个 adapter 后续补充了官方 mode 文档，再把它们补进这里。
 
 ### 如果 `/ss new` 失败
 

package/config.example.json

@@ -1,7 +1,9 @@
 {
   "transport": {
     "type": "acpx-bridge",
-    "sessionInitTimeoutMs": 120000
+    "sessionInitTimeoutMs": 120000,
+    "permissionMode": "approve-all",
+    "nonInteractivePermissions": "fail"
   },
   "logging": {
     "level": "info",

package/dist/bridge/bridge-main.js

@@ -4,25 +4,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -181,14 +199,28 @@ import { createInterface } from "node:readline";
 // src/bridge/bridge-server.ts
 init_prompt_output();
 
+class BridgeInvalidRequestError extends Error {
+}
+var BRIDGE_METHODS = new Set([
+  "ping",
+  "shutdown",
+  "hasSession",
+  "ensureSession",
+  "prompt",
+  "setMode",
+  "cancel"
+]);
+
 class BridgeServer {
   runtime;
   constructor(runtime) {
     this.runtime = runtime;
   }
   async handleLine(line) {
-    const request = JSON.parse(line);
+    let requestId = extractRequestId(line);
     try {
+      const request = parseBridgeRequest(line);
+      requestId = request.id;
       const result = await this.dispatch(request.method, request.params);
       return `${JSON.stringify({
         id: request.id,
@@ -199,10 +231,10 @@ class BridgeServer {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       return `${JSON.stringify({
-        id: request.id,
+        id: requestId,
         ok: false,
         error: {
-          code: "BRIDGE_INTERNAL_ERROR",
+          code: error instanceof BridgeInvalidRequestError ? "BRIDGE_INVALID_REQUEST" : "BRIDGE_INTERNAL_ERROR",
           message,
           ...error instanceof PromptCommandError ? {
             details: {
@@ -224,38 +256,97 @@ class BridgeServer {
         return await this.runtime.shutdown();
       case "hasSession":
         return await this.runtime.hasSession({
-          agent: String(params.agent),
+          agent: requireString(params, "agent"),
           agentCommand: asOptionalString(params.agentCommand),
-          cwd: String(params.cwd),
-          name: String(params.name)
+          cwd: requireString(params, "cwd"),
+          name: requireString(params, "name")
         });
       case "ensureSession":
         return await this.runtime.ensureSession({
-          agent: String(params.agent),
+          agent: requireString(params, "agent"),
           agentCommand: asOptionalString(params.agentCommand),
-          cwd: String(params.cwd),
-          name: String(params.name)
+          cwd: requireString(params, "cwd"),
+          name: requireString(params, "name")
         });
       case "prompt":
         return await this.runtime.prompt({
-          agent: String(params.agent),
+          agent: requireString(params, "agent"),
+          agentCommand: asOptionalString(params.agentCommand),
+          cwd: requireString(params, "cwd"),
+          name: requireString(params, "name"),
+          text: requireString(params, "text")
+        });
+      case "setMode":
+        return await this.runtime.setMode({
+          agent: requireString(params, "agent"),
           agentCommand: asOptionalString(params.agentCommand),
-          cwd: String(params.cwd),
-          name: String(params.name),
-          text: String(params.text)
+          cwd: requireString(params, "cwd"),
+          name: requireString(params, "name"),
+          modeId: requireString(params, "modeId")
         });
       case "cancel":
         return await this.runtime.cancel({
-          agent: String(params.agent),
+          agent: requireString(params, "agent"),
           agentCommand: asOptionalString(params.agentCommand),
-          cwd: String(params.cwd),
-          name: String(params.name)
+          cwd: requireString(params, "cwd"),
+          name: requireString(params, "name")
         });
       default:
         throw new Error(`unsupported bridge method: ${method}`);
     }
   }
 }
+function extractRequestId(line) {
+  try {
+    const raw = JSON.parse(line);
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      return "unknown";
+    }
+    const id = raw.id;
+    return typeof id === "string" && id.length > 0 ? id : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function parseBridgeRequest(line) {
+  let raw;
+  try {
+    raw = JSON.parse(line);
+  } catch {
+    throw new BridgeInvalidRequestError("request must be valid JSON");
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new BridgeInvalidRequestError("request must be a JSON object");
+  }
+  const request = raw;
+  const id = request.id;
+  const method = request.method;
+  const params = request.params;
+  if (typeof id !== "string" || id.length === 0) {
+    throw new BridgeInvalidRequestError("id must be a non-empty string");
+  }
+  if (typeof method !== "string" || method.length === 0) {
+    throw new BridgeInvalidRequestError("method must be a non-empty string");
+  }
+  if (!BRIDGE_METHODS.has(method)) {
+    throw new BridgeInvalidRequestError(`unsupported bridge method: ${method}`);
+  }
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    throw new BridgeInvalidRequestError("params must be an object");
+  }
+  return {
+    id,
+    method,
+    params
+  };
+}
+function requireString(params, key) {
+  const value = params[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new BridgeInvalidRequestError(`${key} must be a non-empty string`);
+  }
+  return value;
+}
 function asOptionalString(value) {
   if (typeof value !== "string" || value.length === 0) {
     return;
@@ -322,6 +413,19 @@ class BridgeRuntime {
     const result = await this.run(spawnSpec.command, spawnSpec.args);
     return { text: getPromptText(result) };
   }
+  async setMode(input) {
+    const spawnSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, [
+      "set-mode",
+      "-s",
+      input.name,
+      input.modeId
+    ]));
+    const result = await this.run(spawnSpec.command, spawnSpec.args);
+    if (result.code !== 0) {
+      throw new Error(result.stderr || result.stdout || "set-mode failed");
+    }
+    return {};
+  }
   async cancel(input) {
     const spawnSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, [
       "cancel",