wechatbridge-cli 1.4.3__tar.gz → 1.4.5__tar.gz

{wechatbridge_cli-1.4.3/wechatbridge_cli.egg-info → wechatbridge_cli-1.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wechatbridge-cli
-Version: 1.4.3
+Version: 1.4.5
 Summary: Bridge WeChat messages to agy, Grok Build, or Codex CLIs — text/image/file/voice in, CLI replies and generated files back.
 Author: WeChatBridge contributors
 License: MIT

{wechatbridge_cli-1.4.3 → wechatbridge_cli-1.4.5}/tests/test_codex.py

@@ -908,6 +908,262 @@ class TestCodexRunFakeCli(unittest.IsolatedAsyncioTestCase):
         self.assertFalse(os.path.isfile(os.path.join(sd, ".initialized.codex")))
 
 
+    # --- Fallback scan tests for shell-created artifacts ---
+
+    def test_shell_file_fallback_collects_new_files(self):
+        """ok_shell_files: new file created during execution is collected by fallback."""
+        display, artifacts = self._run("hi", "u-shell-new", mode="ok_shell_files")
+        self.assertIn("first(", display)
+        names = {n for n, _ in artifacts}
+        self.assertIn("result.txt", names, "fallback should collect new file")
+        self.assertNotIn("out.md", names, "old file should NOT be collected")
+        # All artifact paths must be absolute and under session_dir
+        for _n, ap in artifacts:
+            self.assertTrue(os.path.isabs(ap))
+            sd = os.path.join(self.td, _sanitize("u-shell-new"))
+            self.assertTrue(ap.startswith(sd))
+
+    def test_shell_file_fallback_dedup_with_file_change(self):
+        """ok_shell_and_file_change: file_change is authoritative, no duplicate."""
+        display, artifacts = self._run("hi", "u-shell-dedup", mode="ok_shell_and_file_change")
+        names = {n for n, _ in artifacts}
+        # file_change collected result.txt; fallback should NOT add a duplicate
+        self.assertEqual(names.count("result.txt") if hasattr(names, 'count')
+                         else len([n for n in artifacts if n[0] == "result.txt"]),
+                         len([n for n in artifacts if n[0] == "result.txt"]))
+        # Exactly one result.txt in artifacts (from file_change, not fallback)
+        result_entries = [a for a in artifacts if a[0] == "result.txt"]
+        self.assertEqual(len(result_entries), 1, "no duplicate from fallback")
+
+    def test_shell_file_fallback_old_files_not_collected(self):
+        """ok_shell_old_files: files with old mtimes are NOT collected."""
+        display, artifacts = self._run("hi", "u-shell-old", mode="ok_shell_old_files")
+        self.assertIn("first(", display)
+        names = {n for n, _ in artifacts}
+        self.assertNotIn("old_result.txt", names, "old file should not be collected")
+        self.assertNotIn("old_output.md", names, "old file should not be collected")
+
+    def test_shell_file_fallback_internal_metadata_excluded(self):
+        """ok_shell_internal_metadata: .codex/ and .git/ files are excluded."""
+        display, artifacts = self._run("hi", "u-shell-meta", mode="ok_shell_internal_metadata")
+        self.assertIn("first(", display)
+        names = {n for n, _ in artifacts}
+        self.assertIn("real_output.txt", names, "real file should be collected")
+        self.assertNotIn("meta.json", names, ".codex/ metadata should be excluded")
+        self.assertNotIn("config", names, ".git/ file should be excluded")
+        # No path should contain .codex or .git as a directory component
+        for _n, ap in artifacts:
+            parts = ap.split(os.sep)
+            self.assertNotIn(".codex", parts)
+            self.assertNotIn(".git", parts)
+
+    def test_shell_file_fallback_symlink_escape_excluded(self):
+        """ok_shell_escape: symlink pointing outside allowed roots is NOT collected."""
+        display, artifacts = self._run("hi", "u-shell-escape", mode="ok_shell_escape")
+        self.assertIn("first(", display)
+        names = {n for n, _ in artifacts}
+        self.assertNotIn("escaped.txt", names, "symlink escape should be excluded")
+        # Cleanup target
+        try:
+            os.unlink("/tmp/_codex_escape_test_target.txt")
+        except OSError:
+            pass
+
+    def test_fallback_realpath_alias_dedup(self):
+        """Symlink alias to a file collected via file_change: same realpath -> no duplicate."""
+        import os, sys, json, uuid, datetime
+        target = os.path.join(self.td, "_dedup_target.txt")
+        with open(target, "w") as f:
+            f.write("content")
+        link = os.path.join(self.td, "_dedup_alias.txt")
+        os.symlink(target, link)
+
+        # Build a custom shim that: emits file_change for the alias path AND writes the real file.
+        fake = os.path.join(self.td, "_fake_dedup.py")
+        with open(fake, "w") as f:
+            f.write(
+                '#!/usr/bin/env python3\n'
+                'import json, os, sys, uuid, datetime\n'
+                'session_dir = os.getcwd()\n'
+                'new_id = str(uuid.uuid4())\n'
+                'now = datetime.datetime.now()\n'
+                'ts = now.strftime("%Y-%m-%dT%H-%M-%S")\n'
+                'rollout_dir = os.path.join(session_dir, ".codex", "sessions",\n'
+                '    now.strftime("%Y"), now.strftime("%m"), now.strftime("%d"))\n'
+                'os.makedirs(rollout_dir, exist_ok=True)\n'
+                'with open(os.path.join(rollout_dir, f"rollout-{ts}-{new_id}.jsonl"), "w") as fo:\n'
+                '    fo.write(json.dumps({"type": "session_meta", "payload": {"id": new_id}}) + "\\n")\n'
+                '    fo.write(json.dumps({"type": "thread.started", "thread_id": new_id}) + "\\n")\n'
+                'lines = [\n'
+                '    json.dumps({"type": "thread.started", "thread_id": new_id}),\n'
+                '    json.dumps({"type": "turn.started"}),\n'
+                '    json.dumps({"type": "item.completed", "item": {"id": "i1", "type": "agent_message", "text": "done"}}),\n'
+                '    json.dumps({"type": "item.completed", "item": {\n'
+                '        "id": "i2", "type": "file_change", "status": "completed",\n'
+                '        "changes": [{"kind": "add", "path": "_dedup_alias.txt"}]\n'
+                '    }}),\n'
+                '    json.dumps({"type": "turn.completed", "usage": {}}),\n'
+                ']\n'
+                'sys.stdout.write("\\n".join(lines) + "\\n")\n'
+                'sys.stdout.flush()\n'
+                'with open(os.path.join(session_dir, "_dedup_target.txt"), "w") as fo:\n'
+                '    fo.write("content")\n'
+                'sys.exit(0)\n'
+            )
+        os.chmod(fake, 0o755)
+        shim = os.path.join(self.td, "_shim_dedup.py")
+        with open(shim, "w") as f:
+            f.write(
+                "#!/usr/bin/env python3\n"
+                "import sys, os\n"
+                f"sys.argv[0] = {fake!r}\n"
+                "sys.argv.insert(0, sys.executable)\n"
+                "os.execv(sys.executable, sys.argv)\n"
+            )
+        os.chmod(shim, 0o755)
+        from wechatbridge.config import config
+        orig = config.codex_binary_path
+        config.codex_binary_path = shim
+        try:
+            display, artifacts = self._run("hi", "u-dedup-realpath")
+            result_entries = [a for a in artifacts if a[0] == "_dedup_target.txt"]
+            self.assertEqual(len(result_entries), 1, "no duplicate from fallback for realpath alias")
+        finally:
+            config.codex_binary_path = orig
+
+    def test_add_dirs_retry_argv_consistent(self):
+        """Retry argv uses same validated add_dirs list as first run."""
+        import os, datetime
+        sd = os.path.join(self.td, _sanitize("u-retry-add"))
+        os.makedirs(sd, exist_ok=True)
+        from wechatbridge.codex import (
+            ensure_user_codex, mark_initialized, _write_codex_thread_id,
+            _has_codex_session,
+        )
+        mark_initialized(sd, backend="codex")
+        tid = "aabbccdd-0000-0000-0000-000000000000"
+        _write_codex_thread_id(sd, tid)
+        now = datetime.datetime.now()
+        rollout_dir = os.path.join(
+            sd, ".codex", "sessions", now.strftime("%Y"),
+            now.strftime("%m"), now.strftime("%d"),
+        )
+        os.makedirs(rollout_dir, exist_ok=True)
+        with open(os.path.join(rollout_dir, f"rollout-x-{tid}.jsonl"), "w") as f:
+            f.write("x")
+        self.assertTrue(_has_codex_session(sd, tid))
+
+        from wechatbridge.runner_common import save_prefs
+        save_prefs("u-retry-add", {"add_dirs": [sd]})
+
+        captured = []
+        from wechatbridge import codex as codex_mod
+
+        async def spawn(*args, **kwargs):
+            captured.append(list(args))
+            cmd_str = str(args)
+            if "resume" in cmd_str:
+                from tests.test_codex import _FakeProc
+                return _FakeProc("", "error: session not found", 1)
+            from tests.test_codex import _FakeProc
+            return _FakeProc(
+                '{"type":"thread.started","thread_id":"new-tid"}\n'
+                '{"type":"item.completed","item":{"type":"agent_message","text":"ok"}}\n',
+                "", 0,
+            )
+
+        with mock.patch("asyncio.create_subprocess_exec", side_effect=spawn):
+            display, _ = asyncio.run(codex_mod.run_codex("hi", "u-retry-add"))
+        self.assertEqual(len(captured), 2)
+        self.assertIn("--add-dir", captured[0])
+        self.assertIn(sd, captured[0])
+        self.assertIn("--add-dir", captured[1])
+        self.assertIn(sd, captured[1])
+
+    def test_fallback_scan_file_limit(self):
+        """When session_dir has >200 regular files, fallback scan returns empty."""
+        sd = os.path.join(self.td, _sanitize("u-file-limit"))
+        os.makedirs(sd, exist_ok=True)
+        for i in range(205):
+            with open(os.path.join(sd, f"f_{i}.txt"), "w") as f:
+                f.write("x")
+        from wechatbridge.codex import _snapshot_regular_files
+        snap = _snapshot_regular_files([sd])
+        self.assertEqual(snap, {}, ">200 files -> empty")
+
+    def test_fallback_scan_dir_limit(self):
+        """When session_dir has >50 subdirectories, fallback scan returns empty."""
+        sd = os.path.join(self.td, _sanitize("u-dir-limit"))
+        os.makedirs(sd, exist_ok=True)
+        for i in range(55):
+            d = os.path.join(sd, f"dir_{i}")
+            os.makedirs(d, exist_ok=True)
+            with open(os.path.join(d, "file.txt"), "w") as f:
+                f.write("x")
+        from wechatbridge.codex import _snapshot_regular_files
+        snap = _snapshot_regular_files([sd])
+        self.assertEqual(snap, {}, ">50 dirs -> empty")
+
+    def test_fallback_scan_timeout(self):
+        """When snapshot takes >2s, fallback scan returns empty."""
+        from wechatbridge import codex as codex_mod
+        original = codex_mod._snapshot_regular_files
+
+        def slow_snapshot(roots):
+            import time
+            time.sleep(2.5)
+            return {"/fake/file.txt": 1.0}
+
+        codex_mod._snapshot_regular_files = slow_snapshot
+        try:
+            display, artifacts = self._run("hi", "u-scan-timeout", mode="ok")
+            self.assertEqual(artifacts, [], "slow snapshot -> empty")
+        finally:
+            codex_mod._snapshot_regular_files = original
+
+    def test_fallback_scan_not_on_failure(self):
+        """Fallback scan must NOT run when process fails."""
+        display, artifacts = self._run("hi", "u-fail-noscan", mode="fail_first")
+        self.assertTrue(display.startswith("❌"))
+        self.assertEqual(artifacts, [])
+
+    def test_fallback_scan_not_on_timeout(self):
+        """Fallback scan must NOT run when process times out."""
+        from wechatbridge import codex as codex_mod
+        display, artifacts = self._run("hi", "u-to-noscan", timeout=1, mode="timeout")
+        self.assertIn("超时", display)
+        self.assertEqual(artifacts, [])
+
+    def test_add_dirs_consistency_between_build_and_scan(self):
+        """add_dirs in command builder and fallback scan use same validated paths."""
+        from wechatbridge import codex as codex_mod
+
+        # Create a real directory that validate_add_dir would accept
+        add_dir = os.path.join(self.td, "validated_workdir")
+        os.makedirs(add_dir, exist_ok=True)
+        # Write a file in add_dir with old mtime (should NOT be collected)
+        old_file = os.path.join(add_dir, "old_in_add.txt")
+        with open(old_file, "w") as f:
+            f.write("old")
+        os.utime(old_file, (1000000, 1000000))
+
+        # Mock validate_add_dir to return the resolved path (simulates valid dir)
+        with mock.patch("wechatbridge.codex.validate_add_dir", return_value=(True, add_dir)):
+            # Manually set prefs with raw add_dir to test resolution
+            from wechatbridge.runner_common import save_prefs, get_session_dir
+            save_prefs("u-add-consistency", {"add_dirs": [add_dir]})
+
+            display, artifacts = self._run("hi", "u-add-consistency")
+            self.assertIn("first(", display)
+            # old_in_add.txt should NOT be in artifacts (old mtime)
+            names = {n for n, _ in artifacts}
+            self.assertNotIn("old_in_add.txt", names)
+
+            # Verify the command used the resolved path
+            sd = os.path.join(self.td, _sanitize("u-add-consistency"))
+            self.assertTrue(os.path.isdir(sd))
+
+
 class TestCodexEnvOverride(unittest.IsolatedAsyncioTestCase):
     """CODEX_HOME must be overridden to session_dir/.codex, beating any global
     CODEX_HOME from the service environment. The retry reuses the same env.

{wechatbridge_cli-1.4.3 → wechatbridge_cli-1.4.5}/tests/test_hardening.py

@@ -399,7 +399,255 @@ class TestSendArtifactsBackCodexAddDirs(unittest.IsolatedAsyncioTestCase):
             # Exactly the two legitimate artifacts are uploaded; the send API is
             # never called for any deleted/file/oob/symlink-escape target.
             self.assertEqual(len(client.send_media.await_args_list), 2)
-            client.send_message.assert_not_awaited()
+
+            # Skipped (whitelist) artifacts get a short Chinese notice — no abs path.
+            self.assertEqual(client.send_message.await_count, 4)
+            for call in client.send_message.await_args_list:
+                text = call.kwargs["text"]
+                self.assertIn("未能发送", text)
+                self.assertNotIn(base, text)
+                self.assertNotIn(session_dir, text)
+                self.assertNotIn(oob, text)
+
+
+class TestAgyExtractArtifactsUnquote(unittest.TestCase):
+    """agy extract_artifacts must URL-decode percent-encoded paths/names."""
+
+    def test_space_and_cjk_percent_encoded(self):
+        from wechatbridge.agy import extract_artifacts
+
+        text = (
+            "here is [my report.pdf](file:///tmp/scratch/my%20report.pdf) "
+            "and [报告.pdf](file:///tmp/scratch/%E6%8A%A5%E5%91%8A.pdf)"
+        )
+        arts = extract_artifacts(text)
+        paths = {p for _, p in arts}
+        names = {n for n, _ in arts}
+        self.assertIn("/tmp/scratch/my report.pdf", paths)
+        self.assertIn("/tmp/scratch/报告.pdf", paths)
+        self.assertIn("my report.pdf", names)
+        self.assertIn("报告.pdf", names)
+        # Encoded forms must not leak into resolved paths
+        for p in paths:
+            self.assertNotIn("%20", p)
+            self.assertNotIn("%E6", p)
+
+
+class TestSendArtifactsBackAgyAddDirs(unittest.IsolatedAsyncioTestCase):
+    """agy must honour validated --add-dir roots at send time (like codex)."""
+
+    async def test_agy_add_dir_artifact_sent(self):
+        from wechatbridge.main import send_artifacts_back
+        from wechatbridge.config import config
+
+        with tempfile.TemporaryDirectory() as base:
+            session_dir = os.path.join(base, "session")
+            os.makedirs(session_dir)
+            scratch = os.path.join(
+                session_dir, ".gemini", "antigravity-cli", "scratch"
+            )
+            os.makedirs(scratch)
+
+            allowed_extra = os.path.join(base, "allowed_extra")
+            os.makedirs(allowed_extra)
+            good_dir = os.path.join(allowed_extra, "proj")
+            os.makedirs(good_dir)
+            good_art = os.path.join(good_dir, "doc.pdf")
+            with open(good_art, "w", encoding="utf-8") as f:
+                f.write("%PDF-1.4 ok")
+
+            scratch_art = os.path.join(scratch, "local.txt")
+            with open(scratch_art, "w", encoding="utf-8") as f:
+                f.write("scratch")
+
+            # out-of-bounds must still be blocked
+            oob = os.path.join(base, "oob")
+            os.makedirs(oob)
+            oob_art = os.path.join(oob, "secret.txt")
+            with open(oob_art, "w", encoding="utf-8") as f:
+                f.write("secret")
+
+            prefs = {"backend": "agy", "add_dirs": [good_dir]}
+            with open(
+                os.path.join(session_dir, "prefs.json"), "w", encoding="utf-8"
+            ) as f:
+                json.dump(prefs, f)
+
+            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)
+
+            artifacts = [
+                ("doc.pdf", good_art),
+                ("local.txt", scratch_art),
+                ("secret.txt", oob_art),
+            ]
+
+            with mock.patch(
+                "wechatbridge.main.get_session_dir", return_value=session_dir
+            ), mock.patch(
+                "wechatbridge.runner_common.get_session_dir", return_value=session_dir
+            ), mock.patch(
+                "wechatbridge.main._get_backend", return_value="agy"
+            ), mock.patch.object(
+                config, "add_dir_roots", [allowed_extra]
+            ):
+                await send_artifacts_back(
+                    client, "user-1", "ctx-token", artifacts
+                )
+
+            sent = {c.kwargs["path"] for c in client.send_media.await_args_list}
+            self.assertIn(good_art, sent)
+            self.assertIn(scratch_art, sent)
+            self.assertNotIn(oob_art, sent)
+            self.assertEqual(len(client.send_media.await_args_list), 2)
+
+
+class TestMediaTypeForPath(unittest.TestCase):
+    def test_pdf_png_svg(self):
+        from wechatbridge.ilink import media_type_for_path, MEDIA_IMAGE, MEDIA_FILE
+
+        self.assertEqual(media_type_for_path("/tmp/a.pdf"), MEDIA_FILE)
+        self.assertEqual(media_type_for_path("/tmp/a.docx"), MEDIA_FILE)
+        self.assertEqual(media_type_for_path("/tmp/a.xlsx"), MEDIA_FILE)
+        self.assertEqual(media_type_for_path("/tmp/a.txt"), MEDIA_FILE)
+        self.assertEqual(media_type_for_path("/tmp/a.zip"), MEDIA_FILE)
+        self.assertEqual(media_type_for_path("/tmp/a.png"), MEDIA_IMAGE)
+        self.assertEqual(media_type_for_path("/tmp/a.jpg"), MEDIA_IMAGE)
+        self.assertEqual(media_type_for_path("/tmp/a.jpeg"), MEDIA_IMAGE)
+        self.assertEqual(media_type_for_path("/tmp/a.gif"), MEDIA_IMAGE)
+        self.assertEqual(media_type_for_path("/tmp/a.webp"), MEDIA_IMAGE)
+        self.assertEqual(media_type_for_path("/tmp/a.svg"), MEDIA_FILE)
+        self.assertEqual(media_type_for_path("/tmp/a.heic"), MEDIA_FILE)
+        self.assertEqual(media_type_for_path("/tmp/a.bin"), MEDIA_FILE)
+
+
+class TestArtifactSendFailureNotice(unittest.TestCase):
+    def test_helper_no_absolute_path(self):
+        from wechatbridge.runner_common import format_artifact_send_failure_notice
+
+        art_path = "/root/.local/share/wechatbridge/default/sessions/u1/x.pdf"
+        for reason in ("skipped", "not_found", "send_failed", "error"):
+            text = format_artifact_send_failure_notice("x.pdf", reason)
+            self.assertNotIn(art_path, text)
+            self.assertNotIn("/root/", text)
+            self.assertIn("x.pdf", text)
+            self.assertIn("未能发送", text)
+
+    def test_send_failed_notifies_user(self):
+        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)
+                art = os.path.join(scratch, "report.pdf")
+                with open(art, "w", encoding="utf-8") as f:
+                    f.write("pdf")
+
+                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=False)  # send fails
+
+                with mock.patch(
+                    "wechatbridge.main.get_session_dir", return_value=td
+                ), mock.patch(
+                    "wechatbridge.main._get_backend", return_value="agy"
+                ):
+                    await send_artifacts_back(
+                        client, "user-1", "ctx-token", [("report.pdf", art)]
+                    )
+
+                client.send_media.assert_awaited()
+                client.send_message.assert_awaited()
+                text = client.send_message.await_args.kwargs["text"]
+                self.assertIn("report.pdf", text)
+                self.assertIn("未能发送", text)
+                self.assertNotIn(art, text)
+                self.assertNotIn(td, text)
+
+        asyncio.run(_run())
+
+    def test_not_found_notifies_user(self):
+        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)
+                missing = os.path.join(scratch, "gone.pdf")
+
+                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"
+                ):
+                    await send_artifacts_back(
+                        client, "user-1", "ctx-token", [("gone.pdf", missing)]
+                    )
+
+                client.send_media.assert_not_awaited()
+                client.send_message.assert_awaited()
+                text = client.send_message.await_args.kwargs["text"]
+                self.assertIn("gone.pdf", text)
+                self.assertIn("未能发送", text)
+                self.assertNotIn(missing, text)
+                self.assertNotIn(td, text)
+
+        asyncio.run(_run())
+
+
+class TestGrokRelativePathArtifacts(unittest.TestCase):
+    """grok relative file_path must join session_dir then abspath (like codex)."""
+
+    def test_relative_path_resolved(self):
+        from wechatbridge.grok import _extract_grok_artifacts
+        import urllib.parse
+
+        with tempfile.TemporaryDirectory() as session_dir:
+            # Create the relative file under session_dir
+            rel_name = "notes/out.txt"
+            abs_file = os.path.join(session_dir, "notes", "out.txt")
+            os.makedirs(os.path.dirname(abs_file))
+            with open(abs_file, "w", encoding="utf-8") as f:
+                f.write("hello")
+
+            # Fake grok chat_history.jsonl layout
+            cwd_encoded = urllib.parse.quote(session_dir, safe="")
+            session_id = "sess-rel-1"
+            hist_dir = os.path.join(
+                session_dir, ".grok", "sessions", cwd_encoded, session_id
+            )
+            os.makedirs(hist_dir)
+            hist = os.path.join(hist_dir, "chat_history.jsonl")
+            line = {
+                "type": "assistant",
+                "tool_calls": [
+                    {
+                        "name": "write",
+                        "arguments": json.dumps({"file_path": rel_name}),
+                    }
+                ],
+            }
+            with open(hist, "w", encoding="utf-8") as f:
+                f.write(json.dumps(line) + "\n")
+
+            arts = _extract_grok_artifacts(session_dir, session_id, since=0.0)
+            self.assertEqual(len(arts), 1)
+            name, path = arts[0]
+            self.assertEqual(name, "out.txt")
+            self.assertEqual(path, os.path.abspath(abs_file))
+            self.assertTrue(os.path.isabs(path))
 
 
 class TestILinkDeliveryAccepted(unittest.TestCase):

{wechatbridge_cli-1.4.3 → wechatbridge_cli-1.4.5}/wechatbridge/__init__.py

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

{wechatbridge_cli-1.4.3 → wechatbridge_cli-1.4.5}/wechatbridge/agy.py

@@ -11,6 +11,7 @@ import shutil
 import signal
 import sys
 import time
+from urllib.parse import unquote
 
 from .config import config
 from .runner_common import (
@@ -32,14 +33,19 @@ def extract_artifacts(text: str) -> list[tuple[str, str]]:
 
     Uses regex ``\\[([^\\]]+)\\](file:///([^)]+))`` to find agy-generated
     artifact references in stdout. Returns deduplicated, order-preserved list.
+
+    Paths and display names are URL-decoded (``urllib.parse.unquote``) so
+    percent-encoded spaces / CJK (e.g. ``my%20report.pdf``, ``%E6%8A%A5%E5%91%8A.pdf``)
+    resolve to real filesystem paths.
     """
     if not text:
         return []
     seen = set()
     result = []
     for match in re.finditer(r"\[([^\]]+)\]\(file:///([^)]+)\)", text):
-        name = match.group(1).split("#")[0]
-        abs_path = "/" + match.group(2).split("#")[0]
+        name = unquote(match.group(1).split("#")[0])
+        path_part = unquote(match.group(2).split("#")[0])
+        abs_path = path_part if path_part.startswith("/") else "/" + path_part
         key = (name, abs_path)
         if key not in seen:
             seen.add(key)

{wechatbridge_cli-1.4.3 → wechatbridge_cli-1.4.5}/wechatbridge/codex.py

@@ -22,7 +22,7 @@ from .runner_common import (
     sanitize_user_id, get_session_dir, ensure_session_dir, is_first_message, mark_initialized, clear_initialized,
     clean_output, load_prefs, save_prefs, is_dangerous, parse_model_effort,
     sanitize_env, terminate_process, update_active_prefs, is_bridge_formatted_reply,
-    format_error, format_cli_error, format_model_label, EMPTY_REPLY, validate_add_dir,
+    format_error, format_cli_error, format_model_label, EMPTY_REPLY, validate_add_dir, path_is_under,
 )
 
 logger = logging.getLogger("codex_runner")
@@ -388,6 +388,7 @@ def _build_codex_command(prompt: str, prefs: dict, first: bool, thread_id: str =
         cmd += ["-c", f"model_reasoning_effort={effort}"]
 
     # add_dirs -> each --add-dir (codex 原生支持，比 grok 的"仅记录"强)
+    # add_dirs 已由 _resolve_add_dirs 通过 validate_add_dir 规范化
     for d in prefs.get("add_dirs", []) or []:
         if d:
             cmd += ["--add-dir", d]
@@ -411,7 +412,7 @@ def _collect_codex_artifact(path: str, session_dir: str, since: float, seen: set
     if not os.path.isabs(path):
         path = os.path.join(session_dir, path)
     try:
-        path = os.path.abspath(path)
+        path = os.path.realpath(path)
     except (OSError, ValueError):
         return
     try:
@@ -428,6 +429,75 @@ def _collect_codex_artifact(path: str, session_dir: str, since: float, seen: set
         artifacts.append(key)
 
 
+def _resolve_add_dirs(raw_dirs: list, session_dir: str, user_id: str = "") -> list:
+    """Validate add_dirs via validate_add_dir for command building + fallback scan.
+
+    Calls validate_add_dir once per directory to get resolved realpaths.
+    Ensures consistency between the --add-dir flags passed to Codex and the
+    allowed roots used by the artifact fallback scan.
+    """
+    validated = []
+    for d in raw_dirs or []:
+        if not d:
+            continue
+        try:
+            ok, result = validate_add_dir(d, user_id)
+        except Exception as e:
+            logger.warning("validate_add_dir failed for %s: %s", d, e)
+            continue
+        if ok and result:
+            validated.append(result)
+    return validated
+
+
+_EXCLUDED_SCAN_NAMES = frozenset({".codex", ".git", "__pycache__", "node_modules", "venv", ".venv", "cache", ".cache"})
+
+
+def _snapshot_regular_files(roots: list) -> dict:
+    """Snapshot regular files (path, mtime) under allowed roots for fallback scan.
+
+    Enforces limits: <=200 files, <=50 directories, <=2 seconds. Returns empty
+    dict if any limit is exceeded (never partial results).
+
+    ``os.walk(followlinks=False)`` naturally excludes symlink traversal;
+    ``_EXCLUDED_SCAN_NAMES`` skips internal metadata dirs; only regular files
+    (not dirs/symlinks/special) are collected.
+    """
+    snap = {}
+    t_start = time.monotonic()
+    file_count = 0
+    dir_count = 0
+    _MAX_FILES = 200
+    _MAX_DIRS = 50
+    _MAX_SCAN_TIME = 2.0
+    for root in roots:
+        if not os.path.isdir(root):
+            continue
+        for dirpath, dirnames, filenames in os.walk(root, followlinks=False):
+            dir_count += 1
+            if dir_count > _MAX_DIRS:
+                return {}
+            if time.monotonic() - t_start > _MAX_SCAN_TIME:
+                return {}
+            # Exclude internal metadata directories in-place
+            dirnames[:] = [d for d in dirnames if d not in _EXCLUDED_SCAN_NAMES]
+            for fn in filenames:
+                file_count += 1
+                if file_count > _MAX_FILES:
+                    return {}
+                fp = os.path.join(dirpath, fn)
+                try:
+                    if not os.path.isfile(fp) or os.path.islink(fp):
+                        continue
+                    # Verify candidate is under one of the allowed roots
+                    if not any(path_is_under(fp, r) for r in roots):
+                        continue
+                    snap[fp] = os.path.getmtime(fp)
+                except OSError:
+                    continue
+    return snap
+
+
 def _parse_codex_output(stdout_text: str, session_dir: str, since: float = 0.0) -> tuple:
     """Parse codex JSONL output into (display_text, artifacts, thread_id, parse_failed).
 
@@ -561,6 +631,28 @@ def _extract_codex_error_messages(stdout_text: str) -> list:
 # codex CLI execution
 # ---------------------------------------------------------------------------
 
+
+def _collect_fallback_artifacts(session_dir: str, snapshot_before: dict, t0: float) -> list:
+    """Scan session_dir for new files created during codex execution.
+
+    Only runs when: returncode==0, parse_failed==False, no structured artifacts.
+    Scans only session_dir (never add_dirs). Excludes internal metadata dirs.
+    Each candidate realpath is verified to be under session_dir.
+    """
+    _internal_names = {".codex_thread_id"}
+    fallback = []
+    fallback_seen = set()
+    for fp, fmtime in _snapshot_regular_files([session_dir]).items():
+        if fmtime >= t0 and fp not in snapshot_before:
+            name = os.path.basename(fp)
+            if name in _internal_names or name.startswith(".initialized."):
+                continue
+            key = (name, fp)
+            if key not in fallback_seen:
+                fallback_seen.add(key)
+                fallback.append(key)
+    return fallback
+
 async def run_codex(prompt: str, user_id: str, timeout: int = None) -> tuple:
     """Execute codex CLI for a given user message.
 
@@ -610,9 +702,15 @@ async def run_codex(prompt: str, user_id: str, timeout: int = None) -> tuple:
             first = True
 
     prefs = load_prefs(user_id)
+    # 验证并规范化 add_dirs，确保命令构建与 fallback 扫描使用同一批目录
+    validated_add_dirs = _resolve_add_dirs(prefs.get("add_dirs"), session_dir, user_id)
+    prefs["add_dirs"] = validated_add_dirs
     # persona 经 AGENTS.md 由 codex 自动读取，这里无需注入 argv
     cmd = _build_codex_command(prompt, prefs, first, thread_id)
 
+    # 执行前快照现有文件，用于 shell 产物 fallback 扫描（仅 session_dir）
+    snapshot_before = _snapshot_regular_files([session_dir])
+
     if first:
         logger.info("First message for user %s, running: codex exec ...", user_id)
     else:
@@ -733,6 +831,12 @@ async def run_codex(prompt: str, user_id: str, timeout: int = None) -> tuple:
                     mark_initialized(session_dir, backend="codex")
                     if r_thread_id:
                         _write_codex_thread_id(session_dir, r_thread_id)
+                # Fallback: shell 产物扫描（仅重试成功且无结构化 artifacts 时触发）
+                if not r_failed and not r_artifacts:
+                    fallback = _collect_fallback_artifacts(session_dir, snapshot_before, t0)
+                    if fallback:
+                        r_artifacts = fallback
+                        logger.info("Fallback scan collected %d additional files on retry", len(r_artifacts))
                 elapsed = time.time() - t0
                 logger.info(
                     "codex retry done: user=%s elapsed=%.1fs artifacts=%d output=%d chars failed=%s",
@@ -746,6 +850,13 @@ async def run_codex(prompt: str, user_id: str, timeout: int = None) -> tuple:
             if parsed_thread_id:
                 _write_codex_thread_id(session_dir, parsed_thread_id)
 
+        # Fallback: shell 产物扫描（仅在成功且无结构化 artifacts 时触发）
+        if not failed and not artifacts:
+            fallback = _collect_fallback_artifacts(session_dir, snapshot_before, t0)
+            if fallback:
+                artifacts = fallback
+                logger.info("Fallback scan collected %d additional files", len(artifacts))
+
         elapsed = time.time() - t0
         logger.info(
             "codex done: user=%s elapsed=%.1fs artifacts=%d output=%d chars failed=%s",

{wechatbridge_cli-1.4.3 → wechatbridge_cli-1.4.5}/wechatbridge/grok.py

@@ -324,18 +324,26 @@ def _extract_grok_artifacts(session_dir: str, session_id: str, since: float = 0.
                                 continue
                         if name in ("write", "edit", "str_replace") and isinstance(args, dict):
                             fp = args.get("file_path", "")
-                            if fp and os.path.isabs(fp):
-                                # 只收录本轮运行期间新写/修改的文件
-                                try:
-                                    if since and os.path.getmtime(fp) < since - 2.0:
-                                        continue
-                                except OSError:
-                                    continue  # 文件已不存在，无需回传
-                                art_name = os.path.basename(fp)
-                                key = (art_name, fp)
-                                if key not in seen:
-                                    seen.add(key)
-                                    artifacts.append(key)
+                            if not fp:
+                                continue
+                            # Relative paths resolve against session_dir (cwd)
+                            if not os.path.isabs(fp):
+                                fp = os.path.join(session_dir, fp)
+                            try:
+                                fp = os.path.abspath(fp)
+                            except (OSError, ValueError):
+                                continue
+                            # 只收录本轮运行期间新写/修改的文件
+                            try:
+                                if since and os.path.getmtime(fp) < since - 2.0:
+                                    continue
+                            except OSError:
+                                continue  # 文件已不存在，无需回传
+                            art_name = os.path.basename(fp)
+                            key = (art_name, fp)
+                            if key not in seen:
+                                seen.add(key)
+                                artifacts.append(key)
     except OSError as e:
         logger.warning("Failed to read chat_history.jsonl: %s", e)
 

{wechatbridge_cli-1.4.3 → wechatbridge_cli-1.4.5}/wechatbridge/ilink.py

@@ -25,6 +25,30 @@ logger = logging.getLogger("ilink")
 
 ILINK_BASE = config.ilink_base_url.rstrip("/")
 
+# WeChat image_item handles these well; other image/* (svg/heic/…) go as FILE.
+_DISPLAYABLE_IMAGE_MIMES = frozenset({
+    "image/jpeg",
+    "image/png",
+    "image/gif",
+    "image/webp",
+    "image/bmp",
+})
+
+MEDIA_IMAGE = 1
+MEDIA_FILE = 3
+
+
+def media_type_for_path(path: str) -> int:
+    """Return MEDIA_IMAGE or MEDIA_FILE for a local path based on guessed MIME.
+
+    Only common displayable raster images use IMAGE; everything else
+    (pdf/doc/xlsx/txt/zip, svg/heic, unknown) uses FILE so file_name is kept.
+    """
+    mime = mimetypes.guess_type(path)[0] or "application/octet-stream"
+    if mime in _DISPLAYABLE_IMAGE_MIMES:
+        return MEDIA_IMAGE
+    return MEDIA_FILE
+
 
 def ilink_delivery_accepted(ret, message_id) -> bool:
     """Whether an iLink sendmessage JSON body means the message was accepted.
@@ -530,12 +554,8 @@ class ILinkClient:
         ciphertext = _encrypt_aes_ecb(plaintext, aes_key)
         filesize = len(ciphertext)
 
-        # Determine media_type from mime
-        mime = mimetypes.guess_type(path)[0] or "application/octet-stream"
-        if mime.startswith("image/"):
-            media_type = 1  # MEDIA_IMAGE
-        else:
-            media_type = 3  # MEDIA_FILE
+        # Determine media_type from mime (only common rasters → IMAGE)
+        media_type = media_type_for_path(path)
 
         # Get CDN upload URL
         upload_param, upload_full_url = await self.get_upload_url(

{wechatbridge_cli-1.4.3 → wechatbridge_cli-1.4.5}/wechatbridge/main.py

@@ -23,6 +23,7 @@ from .runner_common import (
     clean_session_media,
     clear_initialized,
     classify_upstream_failure,
+    format_artifact_send_failure_notice,
     format_error,
     format_model_label,
     format_oversized_artifact_notice,
@@ -646,8 +647,9 @@ async def gate_and_run(
 async def send_artifacts_back(client, from_user, context_token, artifacts) -> None:
     """Filter artifacts: only send back those under per-user session dir.
 
-    For agy: artifacts under .gemini/antigravity-cli/scratch
-    For grok: artifacts under session_dir (cwd where grok ran)
+    For agy: artifacts under .gemini/antigravity-cli/scratch (plus validated --add-dir)
+    For codex: artifacts under session_dir (plus validated --add-dir)
+    For grok: artifacts under session_dir (cwd where grok ran; no add-dir gate)
     """
     session_dir = get_session_dir(from_user)
     backend = _get_backend(from_user)
@@ -659,22 +661,34 @@ async def send_artifacts_back(client, from_user, context_token, artifacts) -> No
         # codex runs with cwd=session_dir; file_change paths may also land in
         # user-approved --add-dir roots, so allow those too.
         allowed_root = session_dir
+    else:
+        # agy writes to .gemini/antigravity-cli/scratch under session_dir
+        allowed_root = os.path.join(session_dir, ".gemini", "antigravity-cli", "scratch")
+
+    # codex and agy both support --add-dir; re-verify stored roots at send time.
+    # Only keep roots that currently exist, are real directories, and still
+    # resolve inside the configured allowed roots (session dir + config
+    # add_dir_roots). Deleted dirs, plain files, out-of-bounds paths and
+    # symlink escapes must not become artifact allow roots. Legitimate
+    # directories are kept (and still re-checked against each artifact path
+    # below). session_dir itself is never relaxed. grok does not use add-dir.
+    if backend in ("codex", "agy"):
         prefs = load_prefs(from_user)
-        # Second-factor verification of stored --add-dir roots at send time.
-        # Only keep roots that currently exist, are real directories, and still
-        # resolve inside the configured allowed roots (session dir + config
-        # add_dir_roots). Deleted dirs, plain files, out-of-bounds paths and
-        # symlink escapes must not become artifact allow roots. Legitimate
-        # directories are kept (and still re-checked against each artifact path
-        # below). session_dir itself is never relaxed.
-        add_dirs = []
         for d in prefs.get("add_dirs", []) or []:
             ok, resolved = validate_add_dir(d, from_user)
             if ok:
                 add_dirs.append(resolved)
-    else:
-        # agy writes to .gemini/antigravity-cli/scratch under session_dir
-        allowed_root = os.path.join(session_dir, ".gemini", "antigravity-cli", "scratch")
+
+    async def _notify_failure(name: str, reason: str) -> None:
+        # Never echo server absolute paths to WeChat users
+        await client.send_message(
+            to_user_id=from_user,
+            text=format_artifact_send_failure_notice(name, reason),
+            context_token=context_token,
+            baseurl=client.state.baseurl,
+            bot_token=client.state.bot_token,
+        )
+
     for art_name, art_path in artifacts:
         try:
             # realpath check blocks symlink escape outside allowed root
@@ -686,9 +700,11 @@ async def send_artifacts_back(client, from_user, context_token, artifacts) -> No
                         break
                 if not ok_root:
                     logger.debug("skip non-scratch artifact: %s", art_path)
+                    await _notify_failure(art_name, "skipped")
                     continue
             if not os.path.isfile(os.path.realpath(art_path)):
                 logger.warning("Artifact not found: %s", art_path)
+                await _notify_failure(art_name, "not_found")
                 continue
             art_path = os.path.realpath(art_path)
             file_size = os.path.getsize(art_path)
@@ -719,8 +735,13 @@ async def send_artifacts_back(client, from_user, context_token, artifacts) -> No
                 logger.info("Artifact sent: %s -> %s", art_name, from_user)
             else:
                 logger.warning("Failed to send artifact: %s", art_name)
+                await _notify_failure(art_name, "send_failed")
         except Exception as e:
             logger.exception("Error sending artifact %s: %s", art_name, e)
+            try:
+                await _notify_failure(art_name, "error")
+            except Exception:
+                logger.exception("Failed to notify user about artifact error: %s", art_name)
 
 
 # ---------------------------------------------------------------------------

{wechatbridge_cli-1.4.3 → wechatbridge_cli-1.4.5}/wechatbridge/runner_common.py

@@ -259,6 +259,30 @@ def format_oversized_artifact_notice(art_name: str, size_mb: float) -> str:
     )
 
 
+# Internal reason codes for format_artifact_send_failure_notice
+_ARTIFACT_FAIL_REASONS = {
+    "skipped": "不在允许回传的目录内，已跳过",
+    "not_found": "文件不存在或不是普通文件",
+    "send_failed": "发送失败，请稍后重试",
+    "error": "发送出错，请稍后重试",
+}
+
+
+def format_artifact_send_failure_notice(art_name: str, reason: str) -> str:
+    """User-facing text when an artifact cannot be sent back to WeChat.
+
+    ``reason`` is an internal code: skipped / not_found / send_failed / error.
+    Must never include server absolute paths — only the display name and reason.
+    """
+    name = (art_name or "file").replace("`", "'").strip() or "file"
+    detail = _ARTIFACT_FAIL_REASONS.get(reason) or _ARTIFACT_FAIL_REASONS["error"]
+    return (
+        f"⚠️ **文件未能发送** ⚠️\n\n"
+        f"`{name}`\n"
+        f"{detail}"
+    )
+
+
 def format_cli_error(raw_message: str, *, backend: str = "") -> str:
     """Map backend stderr/JSON error text into a short Chinese user reply.
 

{wechatbridge_cli-1.4.3 → wechatbridge_cli-1.4.5/wechatbridge_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wechatbridge-cli
-Version: 1.4.3
+Version: 1.4.5
 Summary: Bridge WeChat messages to agy, Grok Build, or Codex CLIs — text/image/file/voice in, CLI replies and generated files back.
 Author: WeChatBridge contributors
 License: MIT