wechatbridge-cli 1.3.3__tar.gz → 1.3.4__tar.gz

{wechatbridge_cli-1.3.3 → wechatbridge_cli-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wechatbridge-cli
-Version: 1.3.3
+Version: 1.3.4
 Summary: Bridge WeChat messages to agy or Grok Build CLIs — text/image/file/voice in, CLI replies and generated files back.
 Author: WeChatBridge contributors
 License: MIT
@@ -155,7 +155,7 @@ Key variables (all have defaults):
 | `AGY_TIMEOUT` | `600` | CLI run timeout in seconds (both backends) |
 | `WECHATBRIDGE_MAX_OUTBOUND_BYTES` | `104857600` | max file size sent back to WeChat (100 MB) |
 | `WECHATBRIDGE_MAX_INBOUND_BYTES` | `20971520` | max inbound image/file after download (20 MB) |
-| `WECHATBRIDGE_MAX_CONCURRENT` | `4` | global concurrent handlers; extras get a busy reply |
+| `WECHATBRIDGE_MAX_CONCURRENT` | `4` | global concurrent process slots; same user serial (queue does not hold a slot); extras get a busy reply |
 | `WECHATBRIDGE_CONFIRM_TOKEN` | `y` | reply this token to approve a gated dangerous prompt |
 | `WECHATBRIDGE_ENABLE_MCP` | `true` | enable the `/mcp` help text command |
 | `WECHATBRIDGE_ENABLE_SUBAGENT` | `true` | enable the `/agent` prompt-rewrite command |
@@ -262,7 +262,7 @@ Other `/…` commands are either rejected (e.g. `/exit`), reported as unsupporte
 - **Danger gate is keyword-based**, not full intent understanding. Defaults target concrete patterns (`rm -rf /`, pipe-to-shell, `mkfs`, `format c:`, a few heavy Chinese phrases, …). Everyday wording like bare “delete” is **not** gated. Override list via `WECHATBRIDGE_CONFIRM_KEYWORDS`; approve with `WECHATBRIDGE_CONFIRM_TOKEN` (default `y`), TTL `WECHATBRIDGE_PENDING_TTL`.
 - **Inbound media** is size-capped (default 20 MB), streamed, and CDN hosts are allowlisted. Missing `aes_key` returns a clear error.
 - **Outbound artifacts** only leave the allowed per-user tree (agy: session scratch; grok: under session dir), after `realpath` checks, and only if under `WECHATBRIDGE_MAX_OUTBOUND_BYTES`.
-- **Concurrency:** global cap (`WECHATBRIDGE_MAX_CONCURRENT`, default 4); same user is serialized, different users can run in parallel.
+- **Concurrency:** global process-slot cap (`WECHATBRIDGE_MAX_CONCURRENT`, default 4). Same user is serialized and does **not** hold a global slot while waiting on their previous message; different users can run in parallel up to the cap.
 - **Long replies** are split into chunks (`WECHATBRIDGE_MESSAGE_CHUNK`, default 2000 characters).
 - **Data layout:** instance data under `~/.local/share/wechatbridge/<instance>/` (override with env). Runtime dirs prefer `0700`; token/QR files prefer `0600` (Unix; Windows relies on NTFS ACLs).
 - **Retention:** session temps vs dialogue history use separate TTLs (`WECHATBRIDGE_SESSION_RETENTION_DAYS`, `WECHATBRIDGE_HISTORY_RETENTION_DAYS`). Prefs/auth are kept.

{wechatbridge_cli-1.3.3 → wechatbridge_cli-1.3.4}/README.md

@@ -124,7 +124,7 @@ Key variables (all have defaults):
 | `AGY_TIMEOUT` | `600` | CLI run timeout in seconds (both backends) |
 | `WECHATBRIDGE_MAX_OUTBOUND_BYTES` | `104857600` | max file size sent back to WeChat (100 MB) |
 | `WECHATBRIDGE_MAX_INBOUND_BYTES` | `20971520` | max inbound image/file after download (20 MB) |
-| `WECHATBRIDGE_MAX_CONCURRENT` | `4` | global concurrent handlers; extras get a busy reply |
+| `WECHATBRIDGE_MAX_CONCURRENT` | `4` | global concurrent process slots; same user serial (queue does not hold a slot); extras get a busy reply |
 | `WECHATBRIDGE_CONFIRM_TOKEN` | `y` | reply this token to approve a gated dangerous prompt |
 | `WECHATBRIDGE_ENABLE_MCP` | `true` | enable the `/mcp` help text command |
 | `WECHATBRIDGE_ENABLE_SUBAGENT` | `true` | enable the `/agent` prompt-rewrite command |
@@ -231,7 +231,7 @@ Other `/…` commands are either rejected (e.g. `/exit`), reported as unsupporte
 - **Danger gate is keyword-based**, not full intent understanding. Defaults target concrete patterns (`rm -rf /`, pipe-to-shell, `mkfs`, `format c:`, a few heavy Chinese phrases, …). Everyday wording like bare “delete” is **not** gated. Override list via `WECHATBRIDGE_CONFIRM_KEYWORDS`; approve with `WECHATBRIDGE_CONFIRM_TOKEN` (default `y`), TTL `WECHATBRIDGE_PENDING_TTL`.
 - **Inbound media** is size-capped (default 20 MB), streamed, and CDN hosts are allowlisted. Missing `aes_key` returns a clear error.
 - **Outbound artifacts** only leave the allowed per-user tree (agy: session scratch; grok: under session dir), after `realpath` checks, and only if under `WECHATBRIDGE_MAX_OUTBOUND_BYTES`.
-- **Concurrency:** global cap (`WECHATBRIDGE_MAX_CONCURRENT`, default 4); same user is serialized, different users can run in parallel.
+- **Concurrency:** global process-slot cap (`WECHATBRIDGE_MAX_CONCURRENT`, default 4). Same user is serialized and does **not** hold a global slot while waiting on their previous message; different users can run in parallel up to the cap.
 - **Long replies** are split into chunks (`WECHATBRIDGE_MESSAGE_CHUNK`, default 2000 characters).
 - **Data layout:** instance data under `~/.local/share/wechatbridge/<instance>/` (override with env). Runtime dirs prefer `0700`; token/QR files prefer `0600` (Unix; Windows relies on NTFS ACLs).
 - **Retention:** session temps vs dialogue history use separate TTLs (`WECHATBRIDGE_SESSION_RETENTION_DAYS`, `WECHATBRIDGE_HISTORY_RETENTION_DAYS`). Prefs/auth are kept.

{wechatbridge_cli-1.3.3 → wechatbridge_cli-1.3.4}/tests/test_hardening.py

@@ -145,7 +145,7 @@ class TestOversizedArtifactNotice(unittest.TestCase):
         self.assertNotIn("/root/", text)
         self.assertNotIn("sessions/", text)
         self.assertIn("report.pdf", text)
-        self.assertIn("未回传", text)
+        self.assertIn("无法发到微信", text)
 
     def test_send_artifacts_back_uses_safe_notice(self):
         """Call the real async helper; assert user text has no server path."""
@@ -187,7 +187,7 @@ class TestOversizedArtifactNotice(unittest.TestCase):
                 self.assertNotIn(big_path, text)
                 self.assertNotIn(td, text)
                 self.assertIn("huge.bin", text)
-                self.assertIn("未回传", text)
+                self.assertIn("无法发到微信", text)
 
         asyncio.run(_run())
 

{wechatbridge_cli-1.3.3 → wechatbridge_cli-1.3.4}/wechatbridge/__init__.py

@@ -1,2 +1,2 @@
 """WeChatBridge — bridge WeChat messages to agy or Grok Build CLIs."""
-__version__ = "1.3.3"
+__version__ = "1.3.4"

{wechatbridge_cli-1.3.3 → wechatbridge_cli-1.3.4}/wechatbridge/agy.py

@@ -117,7 +117,7 @@ async def run_agy(prompt: str, user_id: str, timeout: int = None) -> tuple[str,
         logger.warning("Prompt too large for argv from user %s", user_id)
         return format_error(
             "消息过长",
-            f"单条消息超过 {_MAX_ARG_BYTES // 1024}KB 无法传给 CLI，请精简或分段发送。",
+            f"这条消息太长了（超过 {_MAX_ARG_BYTES // 1024}KB），请精简或分段发送。",
         ), []
 
     t0 = time.time()
@@ -252,8 +252,8 @@ async def run_agy(prompt: str, user_id: str, timeout: int = None) -> tuple[str,
                         )
                         await terminate_process(retry_process, graceful=True)
                         return format_error(
-                            "级联超时",
-                            "模型 API 级联推理超时，自动重试仍超时。请稍后重试或简化指令。",
+                            "模型响应超时",
+                            "模型响应超时，自动重试仍超时。请稍后重试或简化指令。",
                         ), []
                     except (asyncio.CancelledError, Exception):
                         await terminate_process(retry_process, graceful=False)
@@ -269,12 +269,12 @@ async def run_agy(prompt: str, user_id: str, timeout: int = None) -> tuple[str,
                             mark_initialized(session_dir)
                         return r_display, r_artifacts
                     return format_error(
-                        "级联超时",
-                        "模型 API 级联推理超时，自动重试仍失败。请稍后重试或简化指令。",
+                        "模型响应超时",
+                        "模型响应超时，自动重试仍失败。请稍后重试或简化指令。",
                     ), []
                 return format_cli_error(stderr_text, backend="agy"), []
             # Non-zero exit: never treat raw stdout as a normal success reply
-            raw = stderr_text or stdout_text or display or "agy 进程异常退出"
+            raw = stderr_text or stdout_text or display or "process exited abnormally"
             return format_cli_error(raw, backend="agy"), []
 
         # Success path only
@@ -305,7 +305,10 @@ async def run_agy(prompt: str, user_id: str, timeout: int = None) -> tuple[str,
     except Exception as e:
         logger.exception("Unexpected error running agy: %s", e)
         await terminate_process(process, graceful=False)
-        return format_error("执行出错", "内部错误，详情见服务端日志。"), []
+        return format_error(
+            "执行出错",
+            "这次没处理好，请稍后再试。若一直失败，请联系管理员。",
+        ), []
 
 
 # ---------------------------------------------------------------------------
@@ -352,16 +355,19 @@ async def _run_agy_subcommand(subcmd_args: list, user_id: str) -> str:
         return clean_output(stdout_text) or EMPTY_REPLY
 
     except asyncio.TimeoutError:
-        # 超时必须回收子进程，否则挂死的子命令成为孤儿进程
+        # 超时必须回收子进程，否则挂死的查询进程成为孤儿
         await terminate_process(process, graceful=True)
-        return format_error("指令超时", "子命令 30 秒内未完成。")
+        return format_error("查询超时", "查询超时，请稍后再试。")
     except asyncio.CancelledError:
         await terminate_process(process, graceful=False)
         raise
     except Exception as e:
         logger.exception("Subcommand error: %s", e)
         await terminate_process(process, graceful=False)
-        return format_error("执行出错", "内部错误，详情见服务端日志。")
+        return format_error(
+            "执行出错",
+            "这次没处理好，请稍后再试。若一直失败，请联系管理员。",
+        )
 
 
 def _cmd_help() -> str:
@@ -372,28 +378,28 @@ def _cmd_help() -> str:
         "**模型控制**",
         "- `/model <名称>` — 切换模型（用 `/models` 查看可用列表）",
         "- `/models` — 查看可用模型列表",
-        "- `/backend <agy|grok>` — 切换后端 CLI",
+        "- `/backend <agy|grok>` — 切换助手引擎",
         "",
         "**对话控制**",
         "- `/clear` 或 `/new` — 重置对话（开始新会话）",
-        "- `/fast` — 开启**快速模式**（低推理开销）",
-        "- `/planning` — 开启 **planning 模式**",
+        "- `/fast` — 开启**快速模式**（回答更快，思考更少）",
+        "- `/planning` — 开启**规划模式**（先想清楚再动手）",
         "",
         "**工具**",
         "- `/add-dir <路径>` — 添加工作目录",
-        "- `/agents` — 查看可用 agent",
+        "- `/agents` — 查看可用助手",
         "",
-        "**MCP & 子代理**",
-        "- `/mcp` — MCP 工具使用引导",
-        "- `/agent <名称> <任务>` — 调用子代理执行任务",
+        "**扩展工具 & 子助手**",
+        "- `/mcp` — 扩展工具使用说明",
+        "- `/agent <名称> <任务>` — 调用子助手执行任务",
         "",
         "**人格**",
-        "- `/persona <内容>` — 设置你专属的人格文档（支持 show / clear / reset 子命令）",
+        "- `/persona <内容>` — 设置你专属的人格文档（另有 show / clear / reset）",
         "",
         "**其他**",
         "- `/help` — 显示本帮助",
         "",
-        "提示：其他 `/` 指令（如 `/goal`、`/grill-me`、`/schedule` 等）会直接交给 agy 处理。",
+        "提示：其他 `/` 指令（如 `/goal`、`/grill-me`、`/schedule` 等）会直接交给助手处理。",
     ]
     return "\n".join(lines)
 
@@ -496,13 +502,13 @@ def _cmd_clear(user_id: str) -> str:
 def _cmd_fast(user_id: str) -> str:
     """Handle /fast: set effort=low (scoped to current backend)."""
     update_active_prefs(user_id, effort="low")
-    return "✅ **已开启 fast 模式** ✅"
+    return "✅ **已开启快速模式** ✅"
 
 
 def _cmd_planning(user_id: str) -> str:
     """Handle /planning: set mode=plan (scoped to current backend)."""
     update_active_prefs(user_id, mode="plan")
-    return "✅ **已开启 planning 模式** ✅"
+    return "✅ **已开启规划模式** ✅"
 
 
 def _cmd_add_dir(args: str, user_id: str) -> str:
@@ -627,8 +633,9 @@ async def handle_slash_command(text: str, user_id: str) -> str | None:
 
     if cmd == "/agents":
         output = await _run_agy_subcommand(["agents"], user_id)
-        if not output or output == "Available agents:":
-            output = "**Available agents**\n\n（当前没有自定义 agent。）"
+        # Match CLI empty output; rewrite user-facing wording only
+        if not output or output.strip() in ("Available agents:", "Available agents"):
+            output = "**可用助手**\n\n（当前没有自定义助手。）"
         return output
 
     if cmd == "/models":
@@ -642,12 +649,11 @@ async def handle_slash_command(text: str, user_id: str) -> str | None:
         if not config.enable_mcp:
             return "ℹ️ **该功能已禁用** ℹ️"
         return (
-            "ℹ️ **MCP 工具使用引导** ℹ️\n\n"
-            "agy 已配置 MCP server（ctxmode / codegraph）。\n\n"
-            "使用方法：用自然语言描述调用，格式为：\n"
-            "> 用 call_mcp_tool 调用 `<工具名>`，参数 `<json>`\n\n"
+            "ℹ️ **扩展工具说明** ℹ️\n\n"
+            "可以直接用自然语言让助手调用已配置的扩展工具（如代码检索等）。\n\n"
             "示例：\n"
-            "> 用 codegraph 的 search 工具搜 ctxmode"
+            "> 用 codegraph 的 search 搜一下 ctxmode\n"
+            "> 帮我查一下这个项目里 xxx 怎么实现的"
         )
 
     # /agent 已上移到 main.py 统一处理（必须经过危险确认门，不能再绕过）

{wechatbridge_cli-1.3.3 → wechatbridge_cli-1.3.4}/wechatbridge/config.py

@@ -191,7 +191,8 @@ class AppConfig:
     # Maximum inbound image/file size after download (bytes) — default 20 MB
     max_inbound_file_bytes: int = _env_int("WECHATBRIDGE_MAX_INBOUND_BYTES", 20 * 1024 * 1024)
 
-    # Max concurrent message handlers (global). Extra messages get a busy reply.
+    # Global concurrent process_message slots. Same user serializes first and
+    # does not hold a slot while waiting on their previous message; extras get a busy reply.
     max_concurrent_tasks: int = _env_int("WECHATBRIDGE_MAX_CONCURRENT", 4)
 
     # WeChat text chunk size (characters) when splitting long replies

{wechatbridge_cli-1.3.3 → wechatbridge_cli-1.3.4}/wechatbridge/grok.py

@@ -372,7 +372,7 @@ async def run_grok(prompt: str, user_id: str, timeout: int = None) -> tuple:
         logger.warning("Prompt too large for argv from user %s", user_id)
         return format_error(
             "消息过长",
-            f"单条消息超过 {_MAX_ARG_BYTES // 1024}KB 无法传给 CLI，请精简或分段发送。",
+            f"这条消息太长了（超过 {_MAX_ARG_BYTES // 1024}KB），请精简或分段发送。",
         ), []
 
     t0 = time.time()
@@ -432,7 +432,7 @@ async def run_grok(prompt: str, user_id: str, timeout: int = None) -> tuple:
             )
             artifacts = []
             if not (isinstance(display, str) and display.startswith("❌")):
-                raw_err = stderr_text or ("" if display == EMPTY_REPLY else display) or "grok 进程异常退出"
+                raw_err = stderr_text or ("" if display == EMPTY_REPLY else display) or "process exited abnormally"
                 display = format_cli_error(raw_err, backend="grok")
 
         # Only mark session initialized on a real successful reply
@@ -459,7 +459,10 @@ async def run_grok(prompt: str, user_id: str, timeout: int = None) -> tuple:
     except Exception as e:
         logger.exception("Unexpected error running grok: %s", e)
         await terminate_process(process, graceful=False)
-        return format_error("执行出错", "内部错误，详情见服务端日志。"), []
+        return format_error(
+            "执行出错",
+            "这次没处理好，请稍后再试。若一直失败，请联系管理员。",
+        ), []
 
 
 async def _run_grok_subcommand(subcmd_args: list, user_id: str) -> str:
@@ -502,16 +505,19 @@ async def _run_grok_subcommand(subcmd_args: list, user_id: str) -> str:
         return clean_output(stdout_text) or EMPTY_REPLY
 
     except asyncio.TimeoutError:
-        # 超时必须回收子进程，否则挂死的子命令成为孤儿进程
+        # 超时必须回收子进程，否则挂死的查询进程成为孤儿
         await terminate_process(process, graceful=True)
-        return format_error("指令超时", "子命令 30 秒内未完成。")
+        return format_error("查询超时", "查询超时，请稍后再试。")
     except asyncio.CancelledError:
         await terminate_process(process, graceful=False)
         raise
     except Exception as e:
         logger.exception("Subcommand error: %s", e)
         await terminate_process(process, graceful=False)
-        return format_error("执行出错", "内部错误，详情见服务端日志。")
+        return format_error(
+            "执行出错",
+            "这次没处理好，请稍后再试。若一直失败，请联系管理员。",
+        )
 
 
 # ---------------------------------------------------------------------------
@@ -582,24 +588,24 @@ def _cmd_help() -> str:
         "**模型控制**",
         "- `/model <名称>` — 切换模型（用 `/models` 查看可用列表）",
         "- `/models` — 查看可用模型列表",
-        "- `/backend <agy|grok>` — 切换后端 CLI",
+        "- `/backend <agy|grok>` — 切换助手引擎",
         "",
         "**对话控制**",
         "- `/clear` 或 `/new` — 重置对话（开始新会话）",
-        "- `/fast` — 开启**快速模式**（低推理开销）",
-        "- `/planning` — 开启 **planning 模式**",
+        "- `/fast` — 开启**快速模式**（回答更快，思考更少）",
+        "- `/planning` — 开启**规划模式**（先想清楚再动手）",
         "",
         "**工具**",
-        "- `/add-dir <路径>` — 添加工作目录（grok 后端暂不支持，仅记录）",
-        "- `/agents` — 查看可用 agent",
+        "- `/add-dir <路径>` — 添加工作目录（当前 grok 引擎暂不支持，仅记录）",
+        "- `/agents` — 查看可用助手",
         "",
         "**人格**",
-        "- `/persona <内容>` — 设置你专属的人格文档（支持 show / clear / reset 子命令）",
+        "- `/persona <内容>` — 设置你专属的人格文档（另有 show / clear / reset）",
         "",
         "**其他**",
         "- `/help` — 显示本帮助",
         "",
-        "提示：其他 `/` 指令会直接交给 grok 处理。",
+        "提示：其他 `/` 指令会直接交给助手处理。",
     ]
     return "\n".join(lines)
 
@@ -646,11 +652,11 @@ async def handle_grok_slash_command(text: str, user_id: str) -> str | None:
 
     if cmd == "/fast":
         update_active_prefs(user_id, effort="low")
-        return "✅ **已开启 fast 模式** ✅"
+        return "✅ **已开启快速模式** ✅"
 
     if cmd == "/planning":
         update_active_prefs(user_id, mode="plan")
-        return "✅ **已开启 planning 模式** ✅"
+        return "✅ **已开启规划模式** ✅"
 
     if cmd == "/model":
         return await _cmd_model(args, user_id)
@@ -671,7 +677,7 @@ async def handle_grok_slash_command(text: str, user_id: str) -> str | None:
             save_prefs(user_id, prefs)
         return (
             f"✅ **已记录工作目录** ✅\n\n```\n{resolved}\n```\n\n"
-            "ℹ️ grok 后端暂不支持通过命令行传递额外目录。"
+            "ℹ️ 当前引擎暂不支持额外工作目录，路径已记下备用。"
         )
 
     if cmd == "/agents":
@@ -689,12 +695,11 @@ async def handle_grok_slash_command(text: str, user_id: str) -> str | None:
         if not config.enable_mcp:
             return "ℹ️ **该功能已禁用** ℹ️"
         return (
-            "ℹ️ **MCP 工具使用引导** ℹ️\n\n"
-            "grok 已配置 MCP server。\n\n"
-            "使用方法：用自然语言描述调用，格式为：\n"
-            "> 用 `<工具名>` 调用，参数 `<json>`\n\n"
+            "ℹ️ **扩展工具说明** ℹ️\n\n"
+            "可以直接用自然语言让助手调用已配置的扩展工具。\n\n"
             "示例：\n"
-            "> 用 codegraph 的 search 工具搜 ctxmode"
+            "> 用 codegraph 的 search 搜一下 ctxmode\n"
+            "> 帮我查一下这个项目里 xxx 怎么实现的"
         )
 
     # /agent 已上移到 main.py 统一处理（必须经过危险确认门，不能再绕过）

{wechatbridge_cli-1.3.3 → wechatbridge_cli-1.3.4}/wechatbridge/main.py

@@ -158,7 +158,7 @@ async def _handle_slash(client: ILinkClient, text: str, user_id: str, context_to
     if cmd == "/version":
         return (
             f"📦 **版本信息** 📦\n\n当前版本: `{__version__}`\n"
-            f"实例: `{config.instance}`  后端: `{_get_backend(user_id)}`"
+            f"实例: `{config.instance}`  引擎: `{_get_backend(user_id)}`"
         ) + format_update_hint()
 
     backend = _get_backend(user_id)
@@ -183,12 +183,12 @@ def _cmd_backend(args: str, user_id: str) -> str:
         current = prefs.get("backend", config.backend)
         model_label = format_model_label(prefs.get("model", ""))
         return (
-            f"📋 **当前后端** 📋\n\n`{current}`\n"
+            f"📋 **当前助手引擎** 📋\n\n`{current}`\n"
             f"模型: `{model_label}`\n\n"
             "用法: `/backend agy` 或 `/backend grok`"
         )
     if name not in ("agy", "grok"):
-        return "❌ **未知后端** ❌\n\n支持: `agy` / `grok`\n\n`/backend agy` 或 `/backend grok`"
+        return "❌ **未知引擎** ❌\n\n支持: `agy` / `grok`\n\n`/backend agy` 或 `/backend grok`"
     prefs = load_prefs(user_id)
     old, new = switch_backend_prefs(prefs, name)
     save_prefs(user_id, prefs)
@@ -200,19 +200,19 @@ def _cmd_backend(args: str, user_id: str) -> str:
         if os.path.exists(flag):
             os.remove(flag)
         return (
-            f"✅ **后端已切换** ✅\n\n"
+            f"✅ **助手引擎已切换** ✅\n\n"
             f"`{old}` → `{new}`\n"
             f"模型: `{model_label}`\n\n"
-            "⚠️ 对话已重置，新后端将开始新会话。"
+            "⚠️ 对话已重置，新引擎将开始新会话。"
         )
     return (
-        f"📋 **当前后端** 📋\n\n`{name}`（未变化）\n"
+        f"📋 **当前助手引擎** 📋\n\n`{name}`（未变化）\n"
         f"模型: `{model_label}`"
     )
 
 
 async def _cmd_agent(client: ILinkClient, args: str, user_id: str, context_token: str):
-    """Handle /agent <名称> <任务> — 调用子代理执行任务。
+    """Handle /agent <名称> <任务> — 调用子助手执行任务。
 
     必须经过 gate_and_run 的危险确认门（历史上后端各自实现时绕过了该检查）。
     """
@@ -223,9 +223,18 @@ async def _cmd_agent(client: ILinkClient, args: str, user_id: str, context_token
     agent_parts = args.split(maxsplit=1)
     agent_name = agent_parts[0]
     agent_task = agent_parts[1] if len(agent_parts) > 1 else ""
+    # Execution path still uses the invoke_subagent wording for the backend;
+    # confirmation UI shows the user's original agent/task only.
     crafted = f"请用 invoke_subagent 调用 agent {agent_name} 执行任务：{agent_task}"
+    display = (
+        f"调用助手「{agent_name}」执行：{agent_task}"
+        if agent_task
+        else f"调用助手「{agent_name}」"
+    )
     logger.info("Agent subcmd: user=%s agent=%s task=%.100s", user_id, agent_name, agent_task)
-    result = await gate_and_run(client, user_id, context_token, crafted)
+    result = await gate_and_run(
+        client, user_id, context_token, crafted, display_prompt=display,
+    )
     if result is None:
         return _HANDLED  # 已进入危险确认流程
     return result  # (reply, artifacts)
@@ -326,10 +335,20 @@ async def login_flow(client: ILinkClient) -> bool:
         return False
 
 
-async def gate_and_run(client, from_user, context_token, prompt) -> tuple[str, list] | None:
+async def gate_and_run(
+    client,
+    from_user,
+    context_token,
+    prompt,
+    *,
+    display_prompt: str | None = None,
+) -> tuple[str, list] | None:
     """Check prompt with is_dangerous; if dangerous, ask for confirmation.
 
     Returns (reply, artifacts) on safe prompt, None if confirmation asked.
+
+    ``display_prompt`` (optional) is what the user sees in the confirm bubble;
+    the stored/executed prompt remains ``prompt`` (execution path unchanged).
     """
     if is_dangerous(prompt):
         expire_at = time.time() + config.pending_confirm_ttl
@@ -338,10 +357,11 @@ async def gate_and_run(client, from_user, context_token, prompt) -> tuple[str, l
             "expire_at": expire_at,
             "context_token": context_token,
         }
+        shown = display_prompt if display_prompt is not None else prompt
         await client.send_message(
             to_user_id=from_user,
             text=(
-                f"⚠️ **危险操作确认** ⚠️\n\n```\n{prompt}\n```\n\n"
+                f"⚠️ **危险操作确认** ⚠️\n\n```\n{shown}\n```\n\n"
                 f"- 回复 **{config.confirm_token}** → 执行\n"
                 f"- 回复其他 → 取消"
             ),
@@ -537,7 +557,7 @@ async def process_message(client: ILinkClient, msg: dict) -> None:
     reply = ""
     if image_media:
         if not image_media.get("aes_key"):
-            reply = format_error("图片无法处理", "缺少解密密钥，请重新发送图片。")
+            reply = format_error("图片处理失败", "图片信息不完整，请重新发。")
             logger.warning("图片缺少 aes_key from=%s", from_user)
         else:
             try:
@@ -572,15 +592,21 @@ async def process_message(client: ILinkClient, msg: dict) -> None:
                 reply, artifacts = result
 
             except Exception as e:
+                # ilink 细节（aes_key / CDN / 字节数等）只写日志，不直出给用户
                 logger.exception("图片下载/解密失败: %s", e)
-                # ValueError 是自定义的中文可读原因；其他异常（httpx 等）含内部 URL，不外发
-                detail = str(e) if isinstance(e, ValueError) else "请重新发送图片。"
-                reply = format_error("图片下载或解密失败", detail)
+                err_s = str(e)
+                if isinstance(e, ValueError) and "过大" in err_s:
+                    reply = format_error(
+                        "文件太大了",
+                        "图片太大，发不进来。请压缩后再发，或换成更小的图。",
+                    )
+                else:
+                    reply = format_error("图片处理失败", "图片没处理好，请重新发。")
 
     # ---- Case 1.5: Message contains a file (non-image) ----
     elif file_media:
         if not file_media.get("aes_key"):
-            reply = format_error("文件无法处理", "缺少解密密钥，请重新发送文件。")
+            reply = format_error("文件处理失败", "文件信息不完整，请重新发。")
             logger.warning("文件缺少 aes_key from=%s", from_user)
         else:
             try:
@@ -612,10 +638,16 @@ async def process_message(client: ILinkClient, msg: dict) -> None:
                 reply, artifacts = result
 
             except Exception as e:
+                # ilink 细节（aes_key / CDN / 字节数等）只写日志，不直出给用户
                 logger.exception("文件下载/解密失败: %s", e)
-                # ValueError 是自定义的中文可读原因；其他异常（httpx 等）含内部 URL，不外发
-                detail = str(e) if isinstance(e, ValueError) else "请重新发送文件。"
-                reply = format_error("文件下载或解密失败", detail)
+                err_s = str(e)
+                if isinstance(e, ValueError) and "过大" in err_s:
+                    reply = format_error(
+                        "文件太大了",
+                        "文件太大，发不进来。请压缩后再发，或换成更小的文件。",
+                    )
+                else:
+                    reply = format_error("文件处理失败", "文件没处理好，请重新发。")
 
     # ---- Case 1.6: Voice message (text transcription passthrough) ----
     elif has_voice:
@@ -627,7 +659,7 @@ async def process_message(client: ILinkClient, msg: dict) -> None:
             reply, artifacts = result
         else:
             # WeChat failed to transcribe the voice → ask user to type.
-            reply = "🤔 **听不清，请打字** 🤔"
+            reply = "🤔 **没听清语音** 🤔\n\n请改成打字发。"
             logger.info("语音未识别出文字 from=%s", from_user)
 
     # ---- Case 2: Text-only message (original logic) ----
@@ -849,43 +881,56 @@ def _prune_user_locks() -> None:
 
 
 async def _safe_process_message(client: ILinkClient, msg: dict) -> None:
-    """Run process_message inside global concurrency + per-user locks.
+    """Run process_message with per-user serial queue then global concurrency.
+
+    Order matters:
+      1) Take per-user lock first — same-user messages queue here and do NOT
+         hold a global slot while waiting for the previous one.
+      2) Acquire global semaphore only immediately before process_message.
+      3) Fail-fast (short timeout) if global slots are full; release only if held.
 
-    This ensures the main get_updates long-polling loop is NEVER blocked,
-    keeping WeChat heartbeats 100% active while ensuring per-user message ordering.
+    Thus one user can occupy at most one global slot at a time; cross-user
+    parallelism is still capped by WECHATBRIDGE_MAX_CONCURRENT.
     """
     from_user = msg.get("from_user_id", "")
     context_token = msg.get("context_token", "")
     sem = _get_global_sem()
+    sem_held = False
 
-    # Fail fast when all slots are busy (do not queue unbounded work)
-    try:
-        await asyncio.wait_for(sem.acquire(), timeout=0.05)
-    except asyncio.TimeoutError:
-        logger.warning("并发已满，拒绝处理 from=%s", from_user)
-        if context_token and from_user:
-            try:
-                await client.send_message(
-                    to_user_id=from_user,
-                    text="⏳ **系统繁忙** ⏳\n\n当前处理人数已满，请稍后再试。",
-                    context_token=context_token,
-                    baseurl=client.state.baseurl,
-                    bot_token=client.state.bot_token,
-                )
-            except Exception as e:
-                logger.warning("发送繁忙提示失败: %s", e)
-        return
+    # Serialize same user first (empty from_user still gets a dedicated lock key)
+    if from_user not in user_locks:
+        user_locks[from_user] = asyncio.Lock()
 
-    try:
-        if from_user not in user_locks:
-            user_locks[from_user] = asyncio.Lock()
-        async with user_locks[from_user]:
-            try:
-                await process_message(client, msg)
-            except Exception as e:
-                logger.exception("处理消息异常 (from=%s): %s", from_user, e)
-    finally:
-        sem.release()
+    async with user_locks[from_user]:
+        # Global slot only after we own the user lock
+        try:
+            await asyncio.wait_for(sem.acquire(), timeout=0.05)
+            sem_held = True
+        except asyncio.TimeoutError:
+            logger.warning("并发已满，拒绝处理 from=%s", from_user)
+            if context_token and from_user:
+                try:
+                    await client.send_message(
+                        to_user_id=from_user,
+                        text=(
+                            "⏳ **现在有点忙** ⏳\n\n"
+                            "同时处理的消息太多，请过几秒再发。"
+                        ),
+                        context_token=context_token,
+                        baseurl=client.state.baseurl,
+                        bot_token=client.state.bot_token,
+                    )
+                except Exception as e:
+                    logger.warning("发送繁忙提示失败: %s", e)
+            return
+
+        try:
+            await process_message(client, msg)
+        except Exception as e:
+            logger.exception("处理消息异常 (from=%s): %s", from_user, e)
+        finally:
+            if sem_held:
+                sem.release()
 
 
 # ---------------------------------------------------------------------------

{wechatbridge_cli-1.3.3 → wechatbridge_cli-1.3.4}/wechatbridge/runner_common.py

@@ -113,8 +113,8 @@ def validate_add_dir(path: str, user_id: str) -> tuple[bool, str]:
     if not any(path_is_under(resolved, root) for root in allowed_roots):
         return False, (
             "路径不在允许范围内。"
-            "仅允许会话目录"
-            + (" 或 WECHATBRIDGE_ADD_DIR_ROOTS 内路径" if config.add_dir_roots else "")
+            "仅允许你的工作区"
+            + (" 或管理员已开放的目录" if config.add_dir_roots else "")
             + "。"
         )
     return True, resolved
@@ -151,8 +151,8 @@ def clean_output(text: str) -> str:
 # WeChat error reply format (fixed header + body)
 # ---------------------------------------------------------------------------
 
-# Shown when CLI returns successfully but with no display text
-EMPTY_REPLY = "（无回复内容）"
+# Shown when backend returns successfully but with no display text
+EMPTY_REPLY = "（这次没有文字回复）"
 
 
 def format_error(title: str, detail: str = "") -> str:
@@ -161,7 +161,7 @@ def format_error(title: str, detail: str = "") -> str:
     Example:
         ❌ **未登录** ❌
 
-        Grok 凭证不可用。
+        助手尚未登录，请联系管理员。
     """
     title = (title or "错误").strip().replace("\n", " ")
     detail = (detail or "").strip()
@@ -179,29 +179,26 @@ def format_oversized_artifact_notice(art_name: str, size_mb: float) -> str:
     return (
         f"⚠️ **文件过大** ⚠️\n\n"
         f"`{name}` {float(size_mb):.1f} MB\n"
-        f"已保存在服务器会话目录，未回传微信。"
+        f"文件已生成，但太大无法发到微信。请联系管理员获取，或让我改小后再试。"
     )
 
 
 def format_cli_error(raw_message: str, *, backend: str = "") -> str:
-    """Map CLI stderr/JSON error text into Chinese title + fixed header.
+    """Map backend stderr/JSON error text into a short Chinese user reply.
 
-    Never put the whole raw English blob into the ❌ **...** ❌ title line.
-    Known cases get a Chinese title + short Chinese explanation; raw text
-    is kept under「原始信息」only when it is not already Chinese-heavy.
+    Never put English raw blobs or internal path/env names into user text.
+    Details stay in the server log only.
     """
     raw = clean_output(raw_message or "") or "未知错误"
     lower = raw.lower()
     backend = (backend or "").strip().lower()
-    name = "Grok" if backend == "grok" else ("agy" if backend == "agy" else "CLI")
-
-    def _with_raw(title: str, zh: str) -> str:
-        # Avoid duplicating if raw is already the zh line
-        if raw.strip() == zh.strip():
-            return format_error(title, zh)
-        return format_error(title, f"{zh}\n\n原始信息：\n{raw}")
+    logger.info(
+        "format_cli_error backend=%s raw=%.300s",
+        backend or "?",
+        raw,
+    )
 
-    # Auth / login
+    # Auth / login — ops details stay in logs; users contact admin
     if (
         "not signed in" in lower
         or "authenticate" in lower
@@ -213,11 +210,11 @@ def format_cli_error(raw_message: str, *, backend: str = "") -> str:
         or "unauthorized" in lower
         or "401" in lower and ("auth" in lower or "token" in lower or "login" in lower)
         or ("xai_api_key" in lower and ("sign" in lower or "login" in lower or "auth" in lower))
+        or "api_key" in lower and ("missing" in lower or "invalid" in lower or "required" in lower)
     ):
-        return _with_raw(
+        return format_error(
             "未登录",
-            f"{name} 未登录，或读不到有效凭证。"
-            + (" 请在本机执行 `grok login --device-code`，或设置 `XAI_API_KEY`。" if backend == "grok" else " 请检查本机登录/凭证是否有效。"),
+            "助手尚未登录或凭证失效，请联系管理员处理。",
         )
 
     # Rate limit / quota
@@ -229,7 +226,10 @@ def format_cli_error(raw_message: str, *, backend: str = "") -> str:
         or "resource exhausted" in lower
         or "429" in lower
     ):
-        return _with_raw("请求过于频繁", "触发限流或额度不足，请稍后再试。")
+        return format_error(
+            "请求过于频繁",
+            "用得有点多，暂时被限制了，请稍后再试。",
+        )
 
     # Network
     if (
@@ -244,17 +244,20 @@ def format_cli_error(raw_message: str, *, backend: str = "") -> str:
         or "fetch failed" in lower
         or "socket hang up" in lower
     ):
-        return _with_raw("网络错误", "连不上服务，请检查网络后重试。")
+        return format_error("网络错误", "连不上服务，请检查网络后重试。")
 
-    # Cascade / API hang (agy)
+    # Cascade / API hang (agy) — plain language for users
     if "timeout waiting for cascade" in lower or "timeout waiting for response" in lower:
-        return _with_raw("级联超时", "模型 API 级联推理超时，请稍后重试或简化指令。")
+        return format_error(
+            "模型响应超时",
+            "模型响应超时，请稍后重试或简化指令。",
+        )
 
     if "permission" in lower and ("denied" in lower or "refuse" in lower or "rejected" in lower):
-        return _with_raw("权限不足", "没有执行该操作的权限。")
+        return format_error("权限不足", "没有执行该操作的权限。")
 
     if "timeout" in lower or "timed out" in lower or "deadline exceeded" in lower:
-        return _with_raw("超时", "等待响应超时，请稍后重试。")
+        return format_error("超时", "等待响应超时，请稍后重试。")
 
     if "model" in lower and (
         "not found" in lower
@@ -265,21 +268,19 @@ def format_cli_error(raw_message: str, *, backend: str = "") -> str:
         or "not supported" in lower
         or "no such" in lower
     ):
-        return _with_raw("模型无效", "指定的模型不可用，请用 `/models` 查看后重选。")
+        return format_error("模型无效", "指定的模型不可用，请用 `/models` 查看后重选。")
 
     if "command not found" in lower or "not a command" in lower:
-        return _with_raw("命令不可用", f"{name} 可执行文件可能未安装或不在 PATH 中。")
+        return format_error(
+            "助手不可用",
+            "助手程序未正确安装或配置，请联系管理员。",
+        )
 
     if "not found" in lower or "no such file" in lower or "enoent" in lower:
-        return _with_raw("未找到", "请求的资源或文件不存在。")
+        return format_error("未找到", "请求的资源或文件不存在。")
 
-    # Generic CLI failure — short Chinese title, body is raw (may still be English)
-    title = "执行失败"
-    if backend == "grok":
-        title = "Grok 执行失败"
-    elif backend == "agy":
-        title = "agy 执行失败"
-    return format_error(title, raw)
+    # Unknown: fixed Chinese only — never echo English raw to WeChat users
+    return format_error("执行失败", "这次没处理好，请稍后再试。")
 
 
 # ---------------------------------------------------------------------------
@@ -454,7 +455,7 @@ def format_model_label(model: str) -> str:
     """Human-readable model for switch replies."""
     model = (model or "").strip()
     if not model:
-        return "后端默认（未指定）"
+        return "默认（未指定）"
     return model
 
 

{wechatbridge_cli-1.3.3 → wechatbridge_cli-1.3.4}/wechatbridge_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wechatbridge-cli
-Version: 1.3.3
+Version: 1.3.4
 Summary: Bridge WeChat messages to agy or Grok Build CLIs — text/image/file/voice in, CLI replies and generated files back.
 Author: WeChatBridge contributors
 License: MIT
@@ -155,7 +155,7 @@ Key variables (all have defaults):
 | `AGY_TIMEOUT` | `600` | CLI run timeout in seconds (both backends) |
 | `WECHATBRIDGE_MAX_OUTBOUND_BYTES` | `104857600` | max file size sent back to WeChat (100 MB) |
 | `WECHATBRIDGE_MAX_INBOUND_BYTES` | `20971520` | max inbound image/file after download (20 MB) |
-| `WECHATBRIDGE_MAX_CONCURRENT` | `4` | global concurrent handlers; extras get a busy reply |
+| `WECHATBRIDGE_MAX_CONCURRENT` | `4` | global concurrent process slots; same user serial (queue does not hold a slot); extras get a busy reply |
 | `WECHATBRIDGE_CONFIRM_TOKEN` | `y` | reply this token to approve a gated dangerous prompt |
 | `WECHATBRIDGE_ENABLE_MCP` | `true` | enable the `/mcp` help text command |
 | `WECHATBRIDGE_ENABLE_SUBAGENT` | `true` | enable the `/agent` prompt-rewrite command |
@@ -262,7 +262,7 @@ Other `/…` commands are either rejected (e.g. `/exit`), reported as unsupporte
 - **Danger gate is keyword-based**, not full intent understanding. Defaults target concrete patterns (`rm -rf /`, pipe-to-shell, `mkfs`, `format c:`, a few heavy Chinese phrases, …). Everyday wording like bare “delete” is **not** gated. Override list via `WECHATBRIDGE_CONFIRM_KEYWORDS`; approve with `WECHATBRIDGE_CONFIRM_TOKEN` (default `y`), TTL `WECHATBRIDGE_PENDING_TTL`.
 - **Inbound media** is size-capped (default 20 MB), streamed, and CDN hosts are allowlisted. Missing `aes_key` returns a clear error.
 - **Outbound artifacts** only leave the allowed per-user tree (agy: session scratch; grok: under session dir), after `realpath` checks, and only if under `WECHATBRIDGE_MAX_OUTBOUND_BYTES`.
-- **Concurrency:** global cap (`WECHATBRIDGE_MAX_CONCURRENT`, default 4); same user is serialized, different users can run in parallel.
+- **Concurrency:** global process-slot cap (`WECHATBRIDGE_MAX_CONCURRENT`, default 4). Same user is serialized and does **not** hold a global slot while waiting on their previous message; different users can run in parallel up to the cap.
 - **Long replies** are split into chunks (`WECHATBRIDGE_MESSAGE_CHUNK`, default 2000 characters).
 - **Data layout:** instance data under `~/.local/share/wechatbridge/<instance>/` (override with env). Runtime dirs prefer `0700`; token/QR files prefer `0600` (Unix; Windows relies on NTFS ACLs).
 - **Retention:** session temps vs dialogue history use separate TTLs (`WECHATBRIDGE_SESSION_RETENTION_DAYS`, `WECHATBRIDGE_HISTORY_RETENTION_DAYS`). Prefs/auth are kept.