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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wechatbridge-cli
-Version: 1.3.2
+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.2 → 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.4/tests/test_hardening.py

@@ -0,0 +1,314 @@
+"""Hardening / cleanup / message-safety probes (stdlib unittest only).
+
+Exercises real production helpers and async methods with mocks — not
+string-copied stand-ins of the user-facing copy.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import tempfile
+import time
+import unittest
+from unittest import mock
+from unittest.mock import AsyncMock, MagicMock
+
+
+class TestSplitMessageChunks(unittest.TestCase):
+    def test_join_equals_original_fixed(self):
+        from wechatbridge.runner_common import split_message_chunks
+
+        samples = [
+            "",
+            "short",
+            "a" * 50,
+            "line1\nline2\nline3",
+            "word " * 400,
+            "x" * 10 + "\n" + "y" * 10,
+            "  keep  spaces  at  edges  ",
+            "\n\n\n",
+            "中文" * 300,
+        ]
+        for text in samples:
+            for limit in (5, 20, 80, 2000):
+                chunks = split_message_chunks(text, limit)
+                self.assertEqual("".join(chunks), text, msg=repr(text[:40]))
+                for c in chunks:
+                    self.assertLessEqual(len(c), limit if limit > 0 else len(c))
+
+    def test_random_join_equals_original(self):
+        import random
+        from wechatbridge.runner_common import split_message_chunks
+
+        rng = random.Random(42)
+        alphabet = "abc \n中文，。"
+        for _ in range(30):
+            text = "".join(rng.choice(alphabet) for _ in range(rng.randint(0, 500)))
+            limit = rng.randint(1, 120)
+            chunks = split_message_chunks(text, limit)
+            self.assertEqual("".join(chunks), text)
+
+
+class TestPathIsUnder(unittest.TestCase):
+    def test_child_and_escape(self):
+        from wechatbridge.runner_common import path_is_under
+
+        with tempfile.TemporaryDirectory() as td:
+            child = os.path.join(td, "a", "b")
+            os.makedirs(child)
+            self.assertTrue(path_is_under(child, td))
+            self.assertTrue(path_is_under(td, td))
+            outside = os.path.join(
+                tempfile.gettempdir(), "not-under-" + os.path.basename(td)
+            )
+            self.assertFalse(path_is_under(outside, td))
+
+    def test_symlink_escape_blocked(self):
+        from wechatbridge.runner_common import path_is_under
+
+        with tempfile.TemporaryDirectory() as td:
+            allowed = os.path.join(td, "allowed")
+            secret = os.path.join(td, "secret")
+            os.makedirs(allowed)
+            os.makedirs(secret)
+            leak = os.path.join(allowed, "leak")
+            os.symlink(secret, leak)
+            self.assertFalse(path_is_under(leak, allowed))
+
+
+class TestRemoveOldFilesDangling(unittest.TestCase):
+    def test_dangling_file_and_dir_links_removed_immediately(self):
+        from wechatbridge.runner_common import _remove_old_files_under
+
+        with tempfile.TemporaryDirectory() as td:
+            bad_file = os.path.join(td, "python")
+            os.symlink("/no/such/target/python-xyz", bad_file)
+            bad_dir = os.path.join(td, "lib64")
+            os.symlink("/no/such/lib", bad_dir)
+            keep = os.path.join(td, "keep.txt")
+            with open(keep, "w", encoding="utf-8") as f:
+                f.write("ok")
+            old = os.path.join(td, "old.txt")
+            with open(old, "w", encoding="utf-8") as f:
+                f.write("bye")
+            old_mtime = time.time() - 10 * 86400
+            os.utime(old, (old_mtime, old_mtime))
+
+            cutoff = time.time() - 7 * 86400
+            removed = _remove_old_files_under(td, cutoff)
+
+            self.assertGreaterEqual(removed, 3)
+            self.assertFalse(os.path.lexists(bad_file))
+            self.assertFalse(os.path.lexists(bad_dir))
+            self.assertFalse(os.path.exists(old))
+            self.assertTrue(os.path.exists(keep))
+
+    def test_intact_young_symlink_kept(self):
+        from wechatbridge.runner_common import _remove_old_files_under
+
+        with tempfile.TemporaryDirectory() as td:
+            target = os.path.join(td, "real.txt")
+            with open(target, "w", encoding="utf-8") as f:
+                f.write("data")
+            link = os.path.join(td, "alias")
+            os.symlink(target, link)
+            cutoff = time.time() - 7 * 86400
+            _remove_old_files_under(td, cutoff)
+            self.assertTrue(os.path.lexists(link))
+            self.assertTrue(os.path.exists(target))
+
+    def test_does_not_follow_symlink_into_outside_tree(self):
+        """followlinks=False: must not age-delete files outside root via symlink."""
+        from wechatbridge.runner_common import _remove_old_files_under
+
+        with tempfile.TemporaryDirectory() as outer:
+            with tempfile.TemporaryDirectory() as root:
+                victim = os.path.join(outer, "outside-old.txt")
+                with open(victim, "w", encoding="utf-8") as f:
+                    f.write("keep-me")
+                old_mtime = time.time() - 10 * 86400
+                os.utime(victim, (old_mtime, old_mtime))
+                os.symlink(outer, os.path.join(root, "escape"))
+                cutoff = time.time() - 7 * 86400
+                _remove_old_files_under(root, cutoff)
+                self.assertTrue(os.path.exists(victim), "must not delete outside tree")
+
+
+class TestOversizedArtifactNotice(unittest.TestCase):
+    def test_helper_never_embeds_absolute_path(self):
+        from wechatbridge.runner_common import format_oversized_artifact_notice
+
+        art_path = "/root/.local/share/wechatbridge/default/sessions/u1/scratch/report.pdf"
+        text = format_oversized_artifact_notice("report.pdf", 120.5)
+        self.assertNotIn(art_path, text)
+        self.assertNotIn("/root/", text)
+        self.assertNotIn("sessions/", text)
+        self.assertIn("report.pdf", 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."""
+        from wechatbridge.main import send_artifacts_back
+
+        async def _run():
+            with tempfile.TemporaryDirectory() as td:
+                scratch = os.path.join(td, ".gemini", "antigravity-cli", "scratch")
+                os.makedirs(scratch)
+                big_path = os.path.join(scratch, "huge.bin")
+                with open(big_path, "wb") as f:
+                    f.write(b"x" * 64)
+
+                client = MagicMock()
+                client.state.baseurl = "https://example.test"
+                client.state.bot_token = "tok"
+                client.send_message = AsyncMock(return_value=True)
+                client.send_media = AsyncMock(return_value=True)
+
+                with mock.patch(
+                    "wechatbridge.main.get_session_dir", return_value=td
+                ), mock.patch(
+                    "wechatbridge.main._get_backend", return_value="agy"
+                ), mock.patch(
+                    "wechatbridge.main.config"
+                ) as cfg:
+                    cfg.max_outbound_file_bytes = 8  # force oversized
+                    await send_artifacts_back(
+                        client,
+                        "user-1",
+                        "ctx-token",
+                        [("huge.bin", big_path)],
+                    )
+
+                client.send_media.assert_not_awaited()
+                client.send_message.assert_awaited()
+                kwargs = client.send_message.await_args.kwargs
+                text = kwargs["text"]
+                self.assertNotIn(big_path, text)
+                self.assertNotIn(td, text)
+                self.assertIn("huge.bin", text)
+                self.assertIn("无法发到微信", text)
+
+        asyncio.run(_run())
+
+
+class TestILinkDeliveryAccepted(unittest.TestCase):
+    def test_predicate(self):
+        from wechatbridge.ilink import ilink_delivery_accepted
+
+        self.assertTrue(ilink_delivery_accepted(0, ""))
+        self.assertTrue(ilink_delivery_accepted(0, None))
+        self.assertTrue(ilink_delivery_accepted(-1, "7487118974343175304"))
+        self.assertTrue(ilink_delivery_accepted(1, "abc"))
+        self.assertTrue(ilink_delivery_accepted(-1, 42))  # non-empty non-str id
+        self.assertFalse(ilink_delivery_accepted(-1, ""))
+        self.assertFalse(ilink_delivery_accepted(-1, "   "))
+        self.assertFalse(ilink_delivery_accepted(1, None))
+        self.assertFalse(ilink_delivery_accepted(1, 0))
+
+
+class TestILinkPostSendmessageRetry(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        from wechatbridge.ilink import ILinkClient
+
+        self.client = ILinkClient()
+
+    async def asyncTearDown(self):
+        await self.client.http_client.aclose()
+
+    async def test_ret_minus_one_with_message_id_is_success(self):
+        mock_resp = MagicMock()
+        mock_resp.raise_for_status = MagicMock()
+        mock_resp.json.return_value = {"ret": -1, "message_id": "mid-ok-1"}
+        self.client.http_client.post = AsyncMock(return_value=mock_resp)
+
+        ok = await self.client._post_sendmessage_with_retry(
+            url="https://example.test/send",
+            headers={},
+            body={},
+            to_user_id="u1",
+            max_attempts=1,
+        )
+        self.assertTrue(ok)
+        self.client.http_client.post.assert_awaited_once()
+
+    async def test_ret_nonzero_without_message_id_fails_fast(self):
+        mock_resp = MagicMock()
+        mock_resp.raise_for_status = MagicMock()
+        mock_resp.json.return_value = {"ret": -1, "message_id": ""}
+        self.client.http_client.post = AsyncMock(return_value=mock_resp)
+
+        with mock.patch("wechatbridge.ilink.asyncio.sleep", new_callable=AsyncMock):
+            ok = await self.client._post_sendmessage_with_retry(
+                url="https://example.test/send",
+                headers={},
+                body={},
+                to_user_id="u1",
+                max_attempts=2,
+            )
+        self.assertFalse(ok)
+        self.assertEqual(self.client.http_client.post.await_count, 2)
+
+    async def test_ret_zero_succeeds(self):
+        mock_resp = MagicMock()
+        mock_resp.raise_for_status = MagicMock()
+        mock_resp.json.return_value = {"ret": 0, "message_id": "m0"}
+        self.client.http_client.post = AsyncMock(return_value=mock_resp)
+        ok = await self.client._post_sendmessage_with_retry(
+            url="https://example.test/send",
+            headers={},
+            body={},
+            to_user_id="u1",
+            max_attempts=1,
+        )
+        self.assertTrue(ok)
+
+
+class TestInboundStreamCapLogic(unittest.TestCase):
+    def test_content_length_and_stream_abort_rules(self):
+        max_in = 100
+
+        def reject_cl(declared: int | None) -> bool:
+            return declared is not None and declared > max_in
+
+        def reject_buf(buf_len: int, piece_len: int) -> bool:
+            return buf_len + piece_len > max_in
+
+        self.assertTrue(reject_cl(101))
+        self.assertFalse(reject_cl(100))
+        self.assertFalse(reject_cl(None))
+        self.assertTrue(reject_buf(90, 20))
+        self.assertFalse(reject_buf(90, 10))
+
+
+class TestSensitiveEnv(unittest.TestCase):
+    def test_strips_api_keys_keeps_harmless(self):
+        from wechatbridge.runner_common import _is_sensitive_env_name, sanitize_env
+
+        self.assertTrue(_is_sensitive_env_name("XAI_API_KEY"))
+        self.assertTrue(_is_sensitive_env_name("OPENAI_API_KEY"))
+        self.assertTrue(_is_sensitive_env_name("BOT_TOKEN"))
+        self.assertFalse(_is_sensitive_env_name("HOME"))
+        self.assertFalse(_is_sensitive_env_name("PATH"))
+        self.assertFalse(_is_sensitive_env_name("LANG"))
+
+        with tempfile.TemporaryDirectory() as td:
+            with mock.patch.dict(
+                os.environ,
+                {
+                    "PATH": "/usr/bin",
+                    "XAI_API_KEY": "secret",
+                    "LANG": "C",
+                    "HOME": "/tmp/other",
+                },
+                clear=False,
+            ):
+                env = sanitize_env(td)
+            self.assertEqual(env["HOME"], td)
+            self.assertNotIn("XAI_API_KEY", env)
+            self.assertIn("LANG", env)
+            self.assertEqual(env["LANG"], "C")
+
+
+if __name__ == "__main__":
+    unittest.main()

{wechatbridge_cli-1.3.2 → 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.2"
+__version__ = "1.3.4"

{wechatbridge_cli-1.3.2 → 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.2 → 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.2 → 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 统一处理（必须经过危险确认门，不能再绕过）