wechatbridge-cli 1.4.7__tar.gz → 1.4.9__tar.gz

{wechatbridge_cli-1.4.7/wechatbridge_cli.egg-info → wechatbridge_cli-1.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wechatbridge-cli
-Version: 1.4.7
+Version: 1.4.9
 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
@@ -78,13 +78,13 @@ Per-user switch: `/backend agy`, `/backend grok`, or `/backend codex`. Each back
 ### Grok backend notes
 
 - Isolation: each WeChat user runs with `HOME` pointed at their own session directory. Conversation state stays there; login is machine-wide.
-- Auth: the session links to the host `~/.grok/auth.json` (copied as a fallback), reusing the host `grok login`. Alternatively, set `XAI_API_KEY` in the bridge process environment (the grok child is given that key after env sanitizing). A grok-remote TUI session being signed in is not the same as the host CLI login. No key or token values are stored in this repository.
+- Auth: the session links to the host `~/.grok/auth.json` (copied as a fallback), reusing the host `grok login`. The grok CLI rewrites `auth.json` via temp-file + rename, which replaces the session symlink with a regular file; the bridge promotes such session files back to the host (atomic copy) and re-links, so refreshed tokens never get overwritten by the revoked host copy. Alternatively, set `XAI_API_KEY` in the bridge process environment (the grok child is given that key after env sanitizing). A grok-remote TUI session being signed in is not the same as the host CLI login. No key or token values are stored in this repository.
 
 ### Codex backend notes
 
 - Runs `codex exec --json` for each single turn; conversation continuation uses `codex exec resume <thread_id> <prompt>` with the thread id persisted per user.
 - Isolation: each WeChat user runs with `HOME` and `CODEX_HOME` pointed at their own per-user session directory (`session_dir/.codex`), so sessions, logs, and caches never cross users.
-- Auth: the per-user session links to the host `~/.codex/auth.json` (copied as a fallback), reusing the host `codex login`. Alternatively, set `CODEX_API_KEY` in the bridge process environment to authenticate. No key or token values are stored in this repository.
+- Auth: the per-user session links to the host `~/.codex/auth.json` (copied as a fallback), reusing the host `codex login`. The codex CLI rewrites `auth.json` via temp-file + rename, which replaces the session symlink with a regular file; the bridge promotes such session files back to the host (atomic copy) and re-links, so refreshed tokens never get overwritten by the revoked host copy. Alternatively, set `CODEX_API_KEY` in the bridge process environment to authenticate. No key or token values are stored in this repository.
 - **Status:** there is currently no real Codex subscription or CLI available for live testing. The codex backend is implemented from source research, a JSONL fixture, and a fake CLI used by the test suite (which passes). Final acceptance depends on a real user running it against the actual Codex CLI.
 
 ## Prerequisites

{wechatbridge_cli-1.4.7 → wechatbridge_cli-1.4.9}/README.md

@@ -47,13 +47,13 @@ Per-user switch: `/backend agy`, `/backend grok`, or `/backend codex`. Each back
 ### Grok backend notes
 
 - Isolation: each WeChat user runs with `HOME` pointed at their own session directory. Conversation state stays there; login is machine-wide.
-- Auth: the session links to the host `~/.grok/auth.json` (copied as a fallback), reusing the host `grok login`. Alternatively, set `XAI_API_KEY` in the bridge process environment (the grok child is given that key after env sanitizing). A grok-remote TUI session being signed in is not the same as the host CLI login. No key or token values are stored in this repository.
+- Auth: the session links to the host `~/.grok/auth.json` (copied as a fallback), reusing the host `grok login`. The grok CLI rewrites `auth.json` via temp-file + rename, which replaces the session symlink with a regular file; the bridge promotes such session files back to the host (atomic copy) and re-links, so refreshed tokens never get overwritten by the revoked host copy. Alternatively, set `XAI_API_KEY` in the bridge process environment (the grok child is given that key after env sanitizing). A grok-remote TUI session being signed in is not the same as the host CLI login. No key or token values are stored in this repository.
 
 ### Codex backend notes
 
 - Runs `codex exec --json` for each single turn; conversation continuation uses `codex exec resume <thread_id> <prompt>` with the thread id persisted per user.
 - Isolation: each WeChat user runs with `HOME` and `CODEX_HOME` pointed at their own per-user session directory (`session_dir/.codex`), so sessions, logs, and caches never cross users.
-- Auth: the per-user session links to the host `~/.codex/auth.json` (copied as a fallback), reusing the host `codex login`. Alternatively, set `CODEX_API_KEY` in the bridge process environment to authenticate. No key or token values are stored in this repository.
+- Auth: the per-user session links to the host `~/.codex/auth.json` (copied as a fallback), reusing the host `codex login`. The codex CLI rewrites `auth.json` via temp-file + rename, which replaces the session symlink with a regular file; the bridge promotes such session files back to the host (atomic copy) and re-links, so refreshed tokens never get overwritten by the revoked host copy. Alternatively, set `CODEX_API_KEY` in the bridge process environment to authenticate. No key or token values are stored in this repository.
 - **Status:** there is currently no real Codex subscription or CLI available for live testing. The codex backend is implemented from source research, a JSONL fixture, and a fake CLI used by the test suite (which passes). Final acceptance depends on a real user running it against the actual Codex CLI.
 
 ## Prerequisites

{wechatbridge_cli-1.4.7 → wechatbridge_cli-1.4.9}/tests/test_codex.py

@@ -935,6 +935,34 @@ class TestCodexRunFakeCli(unittest.IsolatedAsyncioTestCase):
         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_pdf_merged_with_file_change(self):
+        """file_change for helper.py plus a shell-written report.pdf — both return."""
+        display, artifacts = self._run("hi", "u-shell-mix", mode="ok_shell_mixed_docs")
+        self.assertEqual(display, "done")
+        names = {n for n, _ in artifacts}
+        self.assertIn("helper.py", names)
+        self.assertIn("report.pdf", names)
+        self.assertEqual(len([a for a in artifacts if a[0] == "helper.py"]), 1)
+        self.assertEqual(len([a for a in artifacts if a[0] == "report.pdf"]), 1)
+
+    def test_shell_overwrite_existing_pdf(self):
+        """Rewriting a pre-existing pdf must still collect it."""
+        from wechatbridge.runner_common import sanitize_user_id
+
+        uid = "u-shell-ow"
+        sd = os.path.join(self.td, sanitize_user_id(uid))
+        os.makedirs(sd)
+        pdf = os.path.join(sd, "report.pdf")
+        with open(pdf, "wb") as f:
+            f.write(b"%PDF-old")
+        os.utime(pdf, (1_000_000, 1_000_000))
+        display, artifacts = self._run("hi", uid, mode="ok_shell_mixed_docs")
+        self.assertEqual(display, "done")
+        names = {n for n, _ in artifacts}
+        self.assertIn("report.pdf", names)
+        with open(pdf, "rb") as f:
+            self.assertEqual(f.read(), b"%PDF-1.4")
+
     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")

wechatbridge_cli-1.4.9/tests/test_codex_auth.py

@@ -0,0 +1,266 @@
+"""Unit tests for wechatbridge.codex auth promote/re-link (symlink credential sync).
+
+Mirrors tests/test_grok_auth.py: the CLI rewrites auth.json via
+temp-file + rename, which replaces the session symlink with a regular file.
+The bridge must promote that regular file back to host atomically (creating
+the host dir when missing) and then re-link the session. All tests mock
+_host_codex_dir to a temp dir; the real /root/.codex/auth.json is never
+touched. Fixtures are fake {"probe": ...} JSON — no real tokens.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import tempfile
+import unittest
+from unittest import mock
+from unittest.mock import AsyncMock, MagicMock
+
+from wechatbridge.codex import (
+    _session_auth_is_regular,
+    _sync_codex_auth,
+)
+
+
+def _write_json(path: str, data) -> None:
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f)
+
+
+def _read_json(path: str) -> dict:
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _is_symlink_to(path: str, target: str) -> bool:
+    return os.path.islink(path) and os.path.realpath(path) == os.path.realpath(target)
+
+
+class CodexAuthSyncTest(unittest.TestCase):
+    """_sync_codex_auth promote / re-link behavior."""
+
+    def setUp(self):
+        self.td = tempfile.mkdtemp(prefix="wb-codex-auth-")
+        self.host_dir = os.path.join(self.td, "host_codex")
+        os.makedirs(self.host_dir, mode=0o700)
+        self.codex_dir = os.path.join(self.td, "session", ".codex")
+        os.makedirs(self.codex_dir, mode=0o700)
+        self.host_auth = os.path.join(self.host_dir, "auth.json")
+        self.dest = os.path.join(self.codex_dir, "auth.json")
+        self._host_patcher = mock.patch(
+            "wechatbridge.codex._host_codex_dir", return_value=self.host_dir
+        )
+        self._host_patcher.start()
+
+    def tearDown(self):
+        self._host_patcher.stop()
+        shutil.rmtree(self.td, ignore_errors=True)
+
+    def test_regular_session_file_promotes_to_host_and_relinks(self):
+        # session carries NEW credentials as a regular file (CLI rename broke
+        # the symlink); host still has OLD credentials
+        _write_json(self.dest, {"probe": "new"})
+        _write_json(self.host_auth, {"probe": "old"})
+
+        self.assertTrue(_sync_codex_auth(self.codex_dir))
+        self.assertEqual(_read_json(self.host_auth), {"probe": "new"})
+        self.assertTrue(_is_symlink_to(self.dest, self.host_auth))
+
+    def test_cli_rename_over_symlink_promotes_on_next_sync(self):
+        # start as a correct symlink
+        _write_json(self.host_auth, {"probe": "old"})
+        self.assertTrue(_sync_codex_auth(self.codex_dir))
+        self.assertTrue(_is_symlink_to(self.dest, self.host_auth))
+
+        # simulate CLI refresh: temp file + os.replace replaces the symlink
+        # with a regular file holding the new credentials
+        fd, tmp = tempfile.mkstemp(dir=self.codex_dir, prefix=".auth.json.", suffix=".tmp")
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            json.dump({"probe": "new"}, f)
+        os.replace(tmp, self.dest)
+        self.assertTrue(_session_auth_is_regular(self.dest))
+
+        # next message sync must promote and re-link
+        self.assertTrue(_sync_codex_auth(self.codex_dir))
+        self.assertEqual(_read_json(self.host_auth), {"probe": "new"})
+        self.assertTrue(_is_symlink_to(self.dest, self.host_auth))
+
+    def test_correct_symlink_untouched(self):
+        _write_json(self.host_auth, {"probe": "old"})
+        self.assertTrue(_sync_codex_auth(self.codex_dir))
+        link_target = os.readlink(self.dest)
+
+        self.assertTrue(_sync_codex_auth(self.codex_dir))
+        self.assertEqual(os.readlink(self.dest), link_target)
+        self.assertEqual(_read_json(self.host_auth), {"probe": "old"})
+
+    def test_missing_session_file_creates_symlink(self):
+        _write_json(self.host_auth, {"probe": "old"})
+        self.assertTrue(_sync_codex_auth(self.codex_dir))
+        self.assertTrue(_is_symlink_to(self.dest, self.host_auth))
+
+    def test_promote_failure_keeps_session_file(self):
+        _write_json(self.dest, {"probe": "new"})
+        _write_json(self.host_auth, {"probe": "old"})
+        with mock.patch(
+            "wechatbridge.codex._atomic_copy_auth", return_value=False
+        ) as copy_mock:
+            self.assertTrue(_sync_codex_auth(self.codex_dir))
+
+        # session file must NOT be unlinked; host must NOT be overwritten
+        self.assertTrue(_session_auth_is_regular(self.dest))
+        self.assertEqual(_read_json(self.dest), {"probe": "new"})
+        self.assertEqual(_read_json(self.host_auth), {"probe": "old"})
+        copy_mock.assert_called_once_with(self.dest, self.host_auth)
+
+    def test_host_missing_regular_session_promotes_and_creates_host_dir(self):
+        # no host dir / auth.json at all; session has refreshed credentials
+        shutil.rmtree(self.host_dir)
+        _write_json(self.dest, {"probe": "new"})
+
+        self.assertTrue(_sync_codex_auth(self.codex_dir))
+        self.assertEqual(_read_json(self.host_auth), {"probe": "new"})
+        self.assertTrue(_is_symlink_to(self.dest, self.host_auth))
+
+    def test_empty_session_file_not_promoted(self):
+        # CLI left a 0-byte / half-written auth.json behind: must not be
+        # promoted over host credentials, and the session file stays put
+        _write_json(self.host_auth, {"probe": "old"})
+        open(self.dest, "wb").close()
+        self.assertTrue(_session_auth_is_regular(self.dest))
+
+        self.assertTrue(_sync_codex_auth(self.codex_dir))
+        self.assertEqual(_read_json(self.host_auth), {"probe": "old"})
+        self.assertTrue(_session_auth_is_regular(self.dest))
+        self.assertEqual(os.path.getsize(self.dest), 0)
+
+
+class CodexRunPromoteTest(unittest.IsolatedAsyncioTestCase):
+    """run_codex / _run_codex_subcommand harvest (promote) after exit."""
+
+    async def asyncSetUp(self):
+        self.td = tempfile.mkdtemp(prefix="wb-codex-run-")
+        self.session_dir = os.path.join(self.td, "s1")
+        os.makedirs(os.path.join(self.session_dir, ".codex"), mode=0o700)
+        self._patchers = [
+            mock.patch(
+                "wechatbridge.codex.ensure_user_codex",
+                return_value=self.session_dir,
+            ),
+            mock.patch("wechatbridge.codex.is_dangerous", return_value=False),
+            mock.patch("wechatbridge.codex.is_first_message", return_value=True),
+            mock.patch("wechatbridge.codex.load_prefs", return_value={}),
+            mock.patch(
+                "wechatbridge.codex._resolve_add_dirs", return_value=[]
+            ),
+            mock.patch(
+                "wechatbridge.codex._build_codex_command",
+                return_value=["codex", "exec", "--json", "hi"],
+            ),
+            mock.patch(
+                "wechatbridge.codex._snapshot_regular_files", return_value=[]
+            ),
+            mock.patch(
+                "wechatbridge.codex.sanitize_env",
+                side_effect=lambda d: {"HOME": d},
+            ),
+            mock.patch(
+                "wechatbridge.codex._collect_fallback_artifacts",
+                return_value=[],
+            ),
+            mock.patch(
+                "wechatbridge.codex._parse_codex_output",
+                return_value=("ok", [], None, False),
+            ),
+        ]
+        for p in self._patchers:
+            p.start()
+
+    async def asyncTearDown(self):
+        for p in self._patchers:
+            p.stop()
+        shutil.rmtree(self.td, ignore_errors=True)
+
+    def _fake_proc(self, returncode: int = 0, out: bytes = b"", err: bytes = b""):
+        proc = MagicMock()
+        proc.returncode = returncode
+        proc.communicate = AsyncMock(return_value=(out, err))
+        return proc
+
+    async def test_run_codex_exit_harvests_and_keeps_session_env(self):
+        from wechatbridge import codex as codex_mod
+
+        proc = self._fake_proc(returncode=0, out=b"ok")
+        with mock.patch.object(
+            codex_mod.asyncio,
+            "create_subprocess_exec",
+            AsyncMock(return_value=proc),
+        ) as spawn:
+            with mock.patch.object(
+                codex_mod, "_promote_session_auth", return_value=True
+            ) as promote:
+                display, artifacts = await codex_mod.run_codex(
+                    "hi", "u1", timeout=30
+                )
+
+        promote.assert_called_once_with(
+            os.path.join(self.session_dir, ".codex")
+        )
+        self.assertEqual(display, "ok")
+        self.assertEqual(artifacts, [])
+        env = spawn.call_args.kwargs["env"]
+        # HOME still points at the session dir; CODEX_HOME stays session-private
+        self.assertEqual(env["HOME"], self.session_dir)
+        self.assertEqual(
+            env["CODEX_HOME"], os.path.join(self.session_dir, ".codex")
+        )
+
+    async def test_run_codex_nonzero_exit_still_promotes(self):
+        from wechatbridge import codex as codex_mod
+
+        proc = self._fake_proc(returncode=1, err=b"boom")
+        with mock.patch.object(
+            codex_mod.asyncio,
+            "create_subprocess_exec",
+            AsyncMock(return_value=proc),
+        ):
+            with mock.patch.object(
+                codex_mod, "_promote_session_auth", return_value=True
+            ) as promote:
+                display, artifacts = await codex_mod.run_codex(
+                    "hi", "u1", timeout=30
+                )
+
+        promote.assert_called_once_with(
+            os.path.join(self.session_dir, ".codex")
+        )
+        self.assertEqual(artifacts, [])
+        # 非零退出 → 格式化错误气泡（"boom" 无已知分类时是通用执行失败）
+        self.assertIn("❌", display)
+
+    async def test_subcommand_exit_harvests(self):
+        from wechatbridge import codex as codex_mod
+
+        proc = self._fake_proc(returncode=0, out=b"models list")
+        with mock.patch.object(
+            codex_mod.asyncio,
+            "create_subprocess_exec",
+            AsyncMock(return_value=proc),
+        ):
+            with mock.patch.object(
+                codex_mod, "_promote_session_auth", return_value=True
+            ) as promote:
+                result = await codex_mod._run_codex_subcommand(
+                    ["debug", "models"], "u1"
+                )
+
+        promote.assert_called_once_with(
+            os.path.join(self.session_dir, ".codex")
+        )
+        self.assertIn("models", result)
+
+
+if __name__ == "__main__":
+    unittest.main()

wechatbridge_cli-1.4.9/tests/test_grok_auth.py

@@ -0,0 +1,238 @@
+"""Unit tests for wechatbridge.grok auth promote/re-link (symlink credential sync).
+
+Covers the credential-refresh bug: the CLI rewrites auth.json via
+temp-file + rename, which replaces the session symlink with a regular file.
+The bridge must promote that regular file back to host atomically and then
+re-link the session. All tests mock _host_grok_dir to a temp dir; the real
+/root/.grok/auth.json is never touched. Fixtures are fake {"probe": ...}
+JSON — no real tokens.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import shutil
+import tempfile
+import unittest
+from unittest import mock
+from unittest.mock import AsyncMock, MagicMock
+
+from wechatbridge.grok import (
+    _session_auth_is_regular,
+    _sync_grok_auth,
+)
+
+
+def _write_json(path: str, data) -> None:
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f)
+
+
+def _read_json(path: str) -> dict:
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _is_symlink_to(path: str, target: str) -> bool:
+    return os.path.islink(path) and os.path.realpath(path) == os.path.realpath(target)
+
+
+class GrokAuthSyncTest(unittest.TestCase):
+    """_sync_grok_auth promote / re-link behavior."""
+
+    def setUp(self):
+        self.td = tempfile.mkdtemp(prefix="wb-grok-auth-")
+        self.host_dir = os.path.join(self.td, "host_grok")
+        os.makedirs(self.host_dir, mode=0o700)
+        self.grok_dir = os.path.join(self.td, "session", ".grok")
+        os.makedirs(self.grok_dir, mode=0o700)
+        self.host_auth = os.path.join(self.host_dir, "auth.json")
+        self.dest = os.path.join(self.grok_dir, "auth.json")
+        self._host_patcher = mock.patch(
+            "wechatbridge.grok._host_grok_dir", return_value=self.host_dir
+        )
+        self._host_patcher.start()
+
+    def tearDown(self):
+        self._host_patcher.stop()
+        shutil.rmtree(self.td, ignore_errors=True)
+
+    def test_regular_session_file_promotes_to_host_and_relinks(self):
+        # session carries NEW credentials as a regular file (CLI rename broke
+        # the symlink); host still has OLD credentials
+        _write_json(self.dest, {"probe": "new"})
+        _write_json(self.host_auth, {"probe": "old"})
+
+        self.assertTrue(_sync_grok_auth(self.grok_dir))
+        self.assertEqual(_read_json(self.host_auth), {"probe": "new"})
+        self.assertTrue(_is_symlink_to(self.dest, self.host_auth))
+
+    def test_cli_rename_over_symlink_promotes_on_next_sync(self):
+        # start as a correct symlink
+        _write_json(self.host_auth, {"probe": "old"})
+        self.assertTrue(_sync_grok_auth(self.grok_dir))
+        self.assertTrue(_is_symlink_to(self.dest, self.host_auth))
+
+        # simulate CLI refresh: temp file + os.replace replaces the symlink
+        # with a regular file holding the new credentials
+        fd, tmp = tempfile.mkstemp(dir=self.grok_dir, prefix=".auth.json.", suffix=".tmp")
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            json.dump({"probe": "new"}, f)
+        os.replace(tmp, self.dest)
+        self.assertTrue(_session_auth_is_regular(self.dest))
+
+        # next message sync must promote and re-link
+        self.assertTrue(_sync_grok_auth(self.grok_dir))
+        self.assertEqual(_read_json(self.host_auth), {"probe": "new"})
+        self.assertTrue(_is_symlink_to(self.dest, self.host_auth))
+
+    def test_correct_symlink_untouched(self):
+        _write_json(self.host_auth, {"probe": "old"})
+        self.assertTrue(_sync_grok_auth(self.grok_dir))
+        link_target = os.readlink(self.dest)
+
+        self.assertTrue(_sync_grok_auth(self.grok_dir))
+        self.assertEqual(os.readlink(self.dest), link_target)
+        self.assertEqual(_read_json(self.host_auth), {"probe": "old"})
+
+    def test_missing_session_file_creates_symlink(self):
+        _write_json(self.host_auth, {"probe": "old"})
+        self.assertTrue(_sync_grok_auth(self.grok_dir))
+        self.assertTrue(_is_symlink_to(self.dest, self.host_auth))
+
+    def test_promote_failure_keeps_session_file(self):
+        _write_json(self.dest, {"probe": "new"})
+        _write_json(self.host_auth, {"probe": "old"})
+        with mock.patch(
+            "wechatbridge.grok._atomic_copy_auth", return_value=False
+        ) as copy_mock:
+            self.assertTrue(_sync_grok_auth(self.grok_dir))
+
+        # session file must NOT be unlinked; host must NOT be overwritten
+        self.assertTrue(_session_auth_is_regular(self.dest))
+        self.assertEqual(_read_json(self.dest), {"probe": "new"})
+        self.assertEqual(_read_json(self.host_auth), {"probe": "old"})
+        copy_mock.assert_called_once_with(self.dest, self.host_auth)
+
+    def test_host_missing_regular_session_promotes(self):
+        # no host auth.json at all; session has refreshed credentials
+        _write_json(self.dest, {"probe": "new"})
+        self.assertTrue(_sync_grok_auth(self.grok_dir))
+        self.assertEqual(_read_json(self.host_auth), {"probe": "new"})
+        self.assertTrue(_is_symlink_to(self.dest, self.host_auth))
+
+    def test_host_dir_missing_regular_session_promotes_and_creates_host_dir(self):
+        # host dir removed entirely (never ran `grok login`): promote must
+        # create it (0o700) before the atomic copy
+        shutil.rmtree(self.host_dir)
+        _write_json(self.dest, {"probe": "new"})
+
+        self.assertTrue(_sync_grok_auth(self.grok_dir))
+        self.assertEqual(_read_json(self.host_auth), {"probe": "new"})
+        self.assertTrue(_is_symlink_to(self.dest, self.host_auth))
+
+    def test_empty_session_file_not_promoted(self):
+        # CLI left a 0-byte / half-written auth.json behind: must not be
+        # promoted over host credentials, and the session file stays put
+        _write_json(self.host_auth, {"probe": "old"})
+        open(self.dest, "wb").close()
+        self.assertTrue(_session_auth_is_regular(self.dest))
+
+        self.assertTrue(_sync_grok_auth(self.grok_dir))
+        self.assertEqual(_read_json(self.host_auth), {"probe": "old"})
+        self.assertTrue(_session_auth_is_regular(self.dest))
+        self.assertEqual(os.path.getsize(self.dest), 0)
+
+
+class GrokRunPromoteTest(unittest.IsolatedAsyncioTestCase):
+    """run_grok harvests (promotes) after the subprocess exits, even non-zero."""
+
+    async def asyncSetUp(self):
+        self.td = tempfile.mkdtemp(prefix="wb-grok-run-")
+        self.session_dir = os.path.join(self.td, "s1")
+        os.makedirs(os.path.join(self.session_dir, ".grok"), mode=0o700)
+        self._patchers = [
+            mock.patch(
+                "wechatbridge.grok.ensure_user_grok", return_value=self.session_dir
+            ),
+            mock.patch("wechatbridge.grok._grok_has_credentials", return_value=True),
+            mock.patch("wechatbridge.grok.is_dangerous", return_value=False),
+            mock.patch("wechatbridge.grok.is_first_message", return_value=True),
+            mock.patch("wechatbridge.grok.load_prefs", return_value={}),
+            mock.patch("wechatbridge.grok._read_persona", return_value=None),
+            mock.patch(
+                "wechatbridge.grok._build_grok_command",
+                return_value=["grok", "-p", "hi"],
+            ),
+            mock.patch(
+                "wechatbridge.grok.sanitize_env",
+                side_effect=lambda d: {"HOME": d},
+            ),
+            mock.patch(
+                "wechatbridge.grok._apply_grok_runtime_env",
+                side_effect=lambda env: dict(env),
+            ),
+            mock.patch(
+                "wechatbridge.grok._parse_grok_output",
+                return_value=("oops", []),
+            ),
+        ]
+        for p in self._patchers:
+            p.start()
+
+    async def asyncTearDown(self):
+        for p in self._patchers:
+            p.stop()
+        shutil.rmtree(self.td, ignore_errors=True)
+
+    async def test_nonzero_exit_still_promotes(self):
+        from wechatbridge import grok as grok_mod
+
+        proc = MagicMock()
+        proc.returncode = 1
+        proc.communicate = AsyncMock(return_value=(b"", b"boom"))
+        with mock.patch.object(
+            grok_mod.asyncio,
+            "create_subprocess_exec",
+            AsyncMock(return_value=proc),
+        ):
+            with mock.patch.object(
+                grok_mod, "_promote_session_auth", return_value=True
+            ) as promote:
+                display, artifacts = await grok_mod.run_grok(
+                    "hi", "u1", timeout=30
+                )
+
+        promote.assert_called_once_with(
+            os.path.join(self.session_dir, ".grok")
+        )
+        self.assertEqual(artifacts, [])
+        # 非零退出 → 格式化错误气泡（"boom" 无已知分类时是通用执行失败）
+        self.assertIn("❌", display)
+
+    async def test_subcommand_exit_harvests(self):
+        from wechatbridge import grok as grok_mod
+
+        proc = MagicMock()
+        proc.returncode = 0
+        proc.communicate = AsyncMock(return_value=(b"models list", b""))
+        with mock.patch.object(
+            grok_mod.asyncio,
+            "create_subprocess_exec",
+            AsyncMock(return_value=proc),
+        ):
+            with mock.patch.object(
+                grok_mod, "_promote_session_auth", return_value=True
+            ) as promote:
+                result = await grok_mod._run_grok_subcommand(["models"], "u1")
+
+        promote.assert_called_once_with(
+            os.path.join(self.session_dir, ".grok")
+        )
+        self.assertIn("models", result)
+
+
+if __name__ == "__main__":
+    unittest.main()

{wechatbridge_cli-1.4.7 → wechatbridge_cli-1.4.9}/wechatbridge/__init__.py

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

{wechatbridge_cli-1.4.7 → wechatbridge_cli-1.4.9}/wechatbridge/codex.py

@@ -14,6 +14,8 @@ import logging
 import os
 import re
 import shutil
+import stat
+import tempfile
 import time
 import uuid
 
@@ -101,16 +103,117 @@ def _host_codex_dir() -> str:
     return os.path.join(host_home, ".codex")
 
 
+def _session_auth_is_regular(path: str) -> bool:
+    """True if path exists as a regular file (lstat, no symlink follow)."""
+    try:
+        return stat.S_ISREG(os.lstat(path).st_mode)
+    except OSError:
+        return False
+
+
+def _atomic_copy_auth(src: str, dst: str) -> bool:
+    """Atomically copy src -> dst (same-dir temp file + os.replace).
+
+    The temp file lives in dirname(dst) to stay on the same filesystem.
+    Never logs auth file content — only paths and the failure reason.
+    """
+    tmp_path = None
+    try:
+        fd, tmp_path = tempfile.mkstemp(
+            dir=os.path.dirname(dst), prefix=".auth.json.", suffix=".tmp"
+        )
+        with os.fdopen(fd, "wb") as fout:
+            with open(src, "rb") as fin:
+                shutil.copyfileobj(fin, fout)
+        os.chmod(tmp_path, 0o600)
+        os.replace(tmp_path, dst)
+        tmp_path = None
+        return True
+    except OSError as e:
+        logger.error("Atomic copy auth -> %s failed: %s", dst, e)
+        return False
+    finally:
+        if tmp_path is not None:
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+
+
+def _promote_session_auth(codex_dir: str) -> bool:
+    """Treat a regular session auth.json as refreshed credentials.
+
+    The CLI refreshes tokens via temp-file + rename; the rename replaces the
+    session symlink with a regular file, so the new credentials (incl. the
+    rotated refresh token) exist only in the session while host keeps the
+    already-revoked old ones. Promote the session file back to host
+    atomically, then re-link the session to the host file. The session
+    file is never unlinked when the copy fails or the non-empty
+    validation fails; after a successful copy the re-link step does
+    unlink the session file and rebuild the symlink (the new credentials
+    already live in host at that point, so no data is lost). Creates the
+    host dir (0o700) when missing.
+    """
+    dest = os.path.join(codex_dir, "auth.json")
+    if not _session_auth_is_regular(dest):
+        return True
+    host = os.path.join(_host_codex_dir(), "auth.json")
+    host_dir = os.path.dirname(host)
+    try:
+        if not os.path.isdir(host_dir):
+            os.makedirs(host_dir, mode=0o700, exist_ok=True)
+    except OSError as e:
+        logger.error("Cannot create host codex dir %s: %s", host_dir, e)
+        return False
+    try:
+        if os.path.getsize(dest) <= 0:
+            logger.error(
+                "Refusing to promote empty session auth %s (host %s untouched)",
+                dest,
+                host,
+            )
+            return False
+    except OSError as e:
+        logger.error("Cannot stat session auth %s: %s", dest, e)
+        return False
+    if not _atomic_copy_auth(dest, host):
+        logger.error(
+            "Promote session auth failed; keeping %s (host %s untouched)", dest, host
+        )
+        return False
+    try:
+        host_real = os.path.realpath(host)
+        os.unlink(dest)
+        os.symlink(host_real, dest)
+        logger.info("Promoted session auth.json -> %s", host_real)
+        return True
+    except OSError as e:
+        logger.error("Re-link %s after promote failed: %s", dest, e)
+        return False
+
+
 def _sync_codex_auth(codex_dir: str) -> bool:
     """Make session .codex/auth.json track the host login credentials.
 
-    Strategy: symlink session auth.json -> host auth.json (shared refresh).
-    Falls back to copy2 if symlink is not possible.
+    CLI refresh writes $CODEX_HOME/auth.json via temp-file + rename; the
+    rename replaces a session symlink with a regular file, so refreshed
+    credentials (incl. the rotated refresh token) land only in the session
+    while host keeps the old, already-revoked ones. A regular session
+    auth.json is therefore always treated as newer credentials: promote it
+    back to host atomically, then re-link the session to the host file. On
+    promote failure the session file is never unlinked. Falls back to copy2
+    if symlink is not possible.
     Returns True if credentials are available for the child process.
     """
     auth_src = os.path.join(_host_codex_dir(), "auth.json")
     auth_dst = os.path.join(codex_dir, "auth.json")
 
+    # 普通文件 = CLI rename 拆掉 symlink 后留下的更新凭证，先回流 host
+    if _session_auth_is_regular(auth_dst):
+        if not _promote_session_auth(codex_dir):
+            # promote 失败：session 文件是唯一的新凭证，绝不 unlink
+            return os.path.isfile(auth_dst)
+
     if not os.path.isfile(auth_src):
         logger.warning("Host codex auth missing: %s", auth_src)
         return False
@@ -633,26 +736,52 @@ def _extract_codex_error_messages(stdout_text: str) -> list:
 
 
 def _collect_fallback_artifacts(session_dir: str, snapshot_before: dict, t0: float) -> list:
-    """Scan session_dir for new files created during codex execution.
+    """Scan session_dir for files created or overwritten during this turn.
 
-    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.
+    Codex often emits a ``file_change`` for a helper script and then writes
+    the real pdf/docx via the shell. Always merge this list with structured
+    artifacts (dedupe by realpath). Scans only session_dir (never add_dirs).
+    Excludes internal metadata dirs. Each candidate is verified 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."):
+        prev = snapshot_before.get(fp)
+        if prev is None:
+            if fmtime < t0:
                 continue
-            key = (name, fp)
-            if key not in fallback_seen:
-                fallback_seen.add(key)
-                fallback.append(key)
+        elif fmtime <= prev:
+            continue
+        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
 
+
+def _merge_codex_artifacts(*groups) -> list:
+    """Dedupe (name, path) tuples by realpath, preserve first-seen order."""
+    merged = []
+    seen = set()
+    for group in groups:
+        for item in group or []:
+            if not isinstance(item, (tuple, list)) or len(item) != 2:
+                continue
+            name, path = item
+            try:
+                key = os.path.realpath(path)
+            except OSError:
+                key = path
+            if key in seen:
+                continue
+            seen.add(key)
+            merged.append((name, path))
+    return merged
+
 async def run_codex(prompt: str, user_id: str, timeout: int = None) -> tuple:
     """Execute codex CLI for a given user message.
 
@@ -680,6 +809,7 @@ async def run_codex(prompt: str, user_id: str, timeout: int = None) -> tuple:
 
     t0 = time.time()
     session_dir = ensure_user_codex(user_id)
+    codex_dir = os.path.join(session_dir, ".codex")
 
     # Audit logging
     logger.info("[AUDIT] user=%s prompt=%.200s", user_id, prompt)
@@ -831,12 +961,18 @@ 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))
+                # Fallback: 重试成功也扫本轮新建/覆盖的文件，与 file_change 合并
+                if not r_failed:
+                    extra = _collect_fallback_artifacts(session_dir, snapshot_before, t0)
+                    if extra:
+                        before = len(r_artifacts)
+                        r_artifacts = _merge_codex_artifacts(r_artifacts, extra)
+                        added = len(r_artifacts) - before
+                        if added:
+                            logger.info(
+                                "Fallback scan collected %d additional files on retry",
+                                added,
+                            )
                 elapsed = time.time() - t0
                 logger.info(
                     "codex retry done: user=%s elapsed=%.1fs artifacts=%d output=%d chars failed=%s",
@@ -850,12 +986,16 @@ 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))
+        # Fallback: 成功就扫本轮新建/覆盖的文件，与 file_change 合并去重。
+        # 不能再要求 artifacts 为空——先写出脚本再终端生成 pdf 时会漏文档。
+        if not failed:
+            extra = _collect_fallback_artifacts(session_dir, snapshot_before, t0)
+            if extra:
+                before = len(artifacts)
+                artifacts = _merge_codex_artifacts(artifacts, extra)
+                added = len(artifacts) - before
+                if added:
+                    logger.info("Fallback scan collected %d additional files", added)
 
         elapsed = time.time() - t0
         logger.info(
@@ -882,6 +1022,11 @@ async def run_codex(prompt: str, user_id: str, timeout: int = None) -> tuple:
             "这次没处理好，请稍后再试。若一直失败，请联系管理员。",
         ), []
 
+    finally:
+        # 子进程结束后立刻 harvest：CLI 可能刚用 rename 拆掉 symlink 刷新了
+        # 凭证，普通文件一律回流 host（成功/非零退出/超时/取消均覆盖）
+        _promote_session_auth(codex_dir)
+
 
 # ---------------------------------------------------------------------------
 # Slash command support
@@ -895,6 +1040,7 @@ async def _run_codex_subcommand(subcmd_args: list, user_id: str) -> str:
     ``sanitize_env``.
     """
     session_dir = ensure_user_codex(user_id)
+    codex_dir = os.path.join(session_dir, ".codex")
     cmd = [config.codex_binary_path] + list(subcmd_args)
     process = None
     try:
@@ -950,6 +1096,9 @@ async def _run_codex_subcommand(subcmd_args: list, user_id: str) -> str:
             "这次没处理好，请稍后再试。若一直失败，请联系管理员。",
         )
 
+    finally:
+        _promote_session_auth(codex_dir)
+
 
 def _parse_codex_models(output: str) -> list[str]:
     """Loose-parse model slug list from ``codex debug models`` stdout.

{wechatbridge_cli-1.4.7 → wechatbridge_cli-1.4.9}/wechatbridge/grok.py

@@ -10,6 +10,8 @@ import logging
 import os
 import re
 import shutil
+import stat
+import tempfile
 import time
 import urllib.parse
 
@@ -73,20 +75,117 @@ def _host_grok_dir() -> str:
     return os.path.join(host_home, ".grok")
 
 
+def _session_auth_is_regular(path: str) -> bool:
+    """True if path exists as a regular file (lstat, no symlink follow)."""
+    try:
+        return stat.S_ISREG(os.lstat(path).st_mode)
+    except OSError:
+        return False
+
+
+def _atomic_copy_auth(src: str, dst: str) -> bool:
+    """Atomically copy src -> dst (same-dir temp file + os.replace).
+
+    The temp file lives in dirname(dst) to stay on the same filesystem.
+    Never logs auth file content — only paths and the failure reason.
+    """
+    tmp_path = None
+    try:
+        fd, tmp_path = tempfile.mkstemp(
+            dir=os.path.dirname(dst), prefix=".auth.json.", suffix=".tmp"
+        )
+        with os.fdopen(fd, "wb") as fout:
+            with open(src, "rb") as fin:
+                shutil.copyfileobj(fin, fout)
+        os.chmod(tmp_path, 0o600)
+        os.replace(tmp_path, dst)
+        tmp_path = None
+        return True
+    except OSError as e:
+        logger.error("Atomic copy auth -> %s failed: %s", dst, e)
+        return False
+    finally:
+        if tmp_path is not None:
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+
+
+def _promote_session_auth(grok_dir: str) -> bool:
+    """Treat a regular session auth.json as refreshed credentials.
+
+    The CLI refreshes tokens via temp-file + rename; the rename replaces the
+    session symlink with a regular file, so the new credentials (incl. the
+    rotated refresh token) exist only in the session while host keeps the
+    already-revoked old ones. Promote the session file back to host
+    atomically, then re-link the session to the host file. The session
+    file is never unlinked when the copy fails or the non-empty
+    validation fails; after a successful copy the re-link step does
+    unlink the session file and rebuild the symlink (the new credentials
+    already live in host at that point, so no data is lost). Creates the
+    host dir (0o700) when missing.
+    """
+    dest = os.path.join(grok_dir, "auth.json")
+    if not _session_auth_is_regular(dest):
+        return True
+    host = os.path.join(_host_grok_dir(), "auth.json")
+    host_dir = os.path.dirname(host)
+    try:
+        if not os.path.isdir(host_dir):
+            os.makedirs(host_dir, mode=0o700, exist_ok=True)
+    except OSError as e:
+        logger.error("Cannot create host grok dir %s: %s", host_dir, e)
+        return False
+    try:
+        if os.path.getsize(dest) <= 0:
+            logger.error(
+                "Refusing to promote empty session auth %s (host %s untouched)",
+                dest,
+                host,
+            )
+            return False
+    except OSError as e:
+        logger.error("Cannot stat session auth %s: %s", dest, e)
+        return False
+    if not _atomic_copy_auth(dest, host):
+        logger.error(
+            "Promote session auth failed; keeping %s (host %s untouched)", dest, host
+        )
+        return False
+    try:
+        host_real = os.path.realpath(host)
+        os.unlink(dest)
+        os.symlink(host_real, dest)
+        logger.info("Promoted session auth.json -> %s", host_real)
+        return True
+    except OSError as e:
+        logger.error("Re-link %s after promote failed: %s", dest, e)
+        return False
+
+
 def _sync_grok_auth(grok_dir: str) -> bool:
     """Make session .grok/auth.json track the host login credentials.
 
-    Bug fixed: we used to copy auth.json only once. Token refresh updates the
-    host ~/.grok/auth.json, while the session kept a stale/missing copy →
-    false "Not signed in" even when host login is still valid.
-
-    Strategy: symlink session auth.json → host auth.json (shared refresh).
-    Fall back to copy2 if symlink is not possible.
+    CLI refresh writes HOME/.grok/auth.json via temp-file + rename; the
+    rename replaces a session symlink with a regular file, so refreshed
+    credentials (incl. the rotated refresh token) land only in the session
+    while host keeps the old, already-revoked ones. A regular session
+    auth.json is therefore always treated as newer credentials: promote it
+    back to host atomically, then re-link the session to the host file. On
+    promote failure the session file is never unlinked. Falls back to copy2
+    if symlink is not possible.
     Returns True if credentials are available for the child process.
     """
     auth_src = os.path.join(_host_grok_dir(), "auth.json")
     auth_dst = os.path.join(grok_dir, "auth.json")
 
+    # 普通文件 = CLI rename 拆掉 symlink 后留下的更新凭证，先回流 host
+    if _session_auth_is_regular(auth_dst):
+        if not _promote_session_auth(grok_dir):
+            # promote 失败：session 文件是唯一的新凭证，绝不 unlink
+            return os.path.isfile(auth_dst)
+
     if not os.path.isfile(auth_src):
         logger.warning("Host grok auth missing: %s", auth_src)
         return False
@@ -559,6 +658,7 @@ async def run_grok(prompt: str, user_id: str, timeout: int = None) -> tuple:
 
     t0 = time.time()
     session_dir = ensure_user_grok(user_id)
+    grok_dir = os.path.join(session_dir, ".grok")
 
     if not _grok_has_credentials():
         logger.warning(
@@ -727,6 +827,11 @@ async def run_grok(prompt: str, user_id: str, timeout: int = None) -> tuple:
             "这次没处理好，请稍后再试。若一直失败，请联系管理员。",
         ), []
 
+    finally:
+        # 子进程结束后立刻 harvest：CLI 可能刚用 rename 拆掉 symlink 刷新了
+        # 凭证，普通文件一律回流 host（成功/非零退出/超时/取消均覆盖）
+        _promote_session_auth(grok_dir)
+
 
 async def _run_grok_subcommand(subcmd_args: list, user_id: str) -> str:
     """Run a grok subcommand (e.g., 'models', 'agent') and return cleaned output.
@@ -735,6 +840,7 @@ async def _run_grok_subcommand(subcmd_args: list, user_id: str) -> str:
     Uses per-user session isolation matching run_grok.
     """
     session_dir = ensure_user_grok(user_id)
+    grok_dir = os.path.join(session_dir, ".grok")
     cmd = [config.grok_binary_path] + subcmd_args
     process = None
     try:
@@ -782,6 +888,9 @@ async def _run_grok_subcommand(subcmd_args: list, user_id: str) -> str:
             "这次没处理好，请稍后再试。若一直失败，请联系管理员。",
         )
 
+    finally:
+        _promote_session_auth(grok_dir)
+
 
 # ---------------------------------------------------------------------------
 # Slash command support

{wechatbridge_cli-1.4.7 → wechatbridge_cli-1.4.9/wechatbridge_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wechatbridge-cli
-Version: 1.4.7
+Version: 1.4.9
 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
@@ -78,13 +78,13 @@ Per-user switch: `/backend agy`, `/backend grok`, or `/backend codex`. Each back
 ### Grok backend notes
 
 - Isolation: each WeChat user runs with `HOME` pointed at their own session directory. Conversation state stays there; login is machine-wide.
-- Auth: the session links to the host `~/.grok/auth.json` (copied as a fallback), reusing the host `grok login`. Alternatively, set `XAI_API_KEY` in the bridge process environment (the grok child is given that key after env sanitizing). A grok-remote TUI session being signed in is not the same as the host CLI login. No key or token values are stored in this repository.
+- Auth: the session links to the host `~/.grok/auth.json` (copied as a fallback), reusing the host `grok login`. The grok CLI rewrites `auth.json` via temp-file + rename, which replaces the session symlink with a regular file; the bridge promotes such session files back to the host (atomic copy) and re-links, so refreshed tokens never get overwritten by the revoked host copy. Alternatively, set `XAI_API_KEY` in the bridge process environment (the grok child is given that key after env sanitizing). A grok-remote TUI session being signed in is not the same as the host CLI login. No key or token values are stored in this repository.
 
 ### Codex backend notes
 
 - Runs `codex exec --json` for each single turn; conversation continuation uses `codex exec resume <thread_id> <prompt>` with the thread id persisted per user.
 - Isolation: each WeChat user runs with `HOME` and `CODEX_HOME` pointed at their own per-user session directory (`session_dir/.codex`), so sessions, logs, and caches never cross users.
-- Auth: the per-user session links to the host `~/.codex/auth.json` (copied as a fallback), reusing the host `codex login`. Alternatively, set `CODEX_API_KEY` in the bridge process environment to authenticate. No key or token values are stored in this repository.
+- Auth: the per-user session links to the host `~/.codex/auth.json` (copied as a fallback), reusing the host `codex login`. The codex CLI rewrites `auth.json` via temp-file + rename, which replaces the session symlink with a regular file; the bridge promotes such session files back to the host (atomic copy) and re-links, so refreshed tokens never get overwritten by the revoked host copy. Alternatively, set `CODEX_API_KEY` in the bridge process environment to authenticate. No key or token values are stored in this repository.
 - **Status:** there is currently no real Codex subscription or CLI available for live testing. The codex backend is implemented from source research, a JSONL fixture, and a fake CLI used by the test suite (which passes). Final acceptance depends on a real user running it against the actual Codex CLI.
 
 ## Prerequisites

{wechatbridge_cli-1.4.7 → wechatbridge_cli-1.4.9}/wechatbridge_cli.egg-info/SOURCES.txt

@@ -2,6 +2,8 @@ LICENSE
 README.md
 pyproject.toml
 tests/test_codex.py
+tests/test_codex_auth.py
+tests/test_grok_auth.py
 tests/test_hardening.py
 wechatbridge/__init__.py
 wechatbridge/__main__.py