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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wechatbridge-cli
-Version: 1.4.5
+Version: 1.4.7
 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
@@ -75,6 +75,11 @@ Default data paths expand from `~` (e.g. `~/.local/share/wechatbridge/<instance>
 
 Per-user switch: `/backend agy`, `/backend grok`, or `/backend codex`. Each backend keeps its own model / effort / mode memory and persona file layout. Global default is `WECHATBRIDGE_BACKEND`.
 
+### 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.
+
 ### 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.

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

@@ -44,6 +44,11 @@ Default data paths expand from `~` (e.g. `~/.local/share/wechatbridge/<instance>
 
 Per-user switch: `/backend agy`, `/backend grok`, or `/backend codex`. Each backend keeps its own model / effort / mode memory and persona file layout. Global default is `WECHATBRIDGE_BACKEND`.
 
+### 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.
+
 ### 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.

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

@@ -649,6 +649,96 @@ class TestGrokRelativePathArtifacts(unittest.TestCase):
             self.assertEqual(path, os.path.abspath(abs_file))
             self.assertTrue(os.path.isabs(path))
 
+    def test_search_replace_path_key(self):
+        from wechatbridge.grok import _extract_grok_artifacts
+        import urllib.parse
+
+        with tempfile.TemporaryDirectory() as session_dir:
+            abs_file = os.path.join(session_dir, "report.docx")
+            with open(abs_file, "w", encoding="utf-8") as f:
+                f.write("doc")
+            session_id = "sess-sr-1"
+            hist_dir = os.path.join(
+                session_dir,
+                ".grok",
+                "sessions",
+                urllib.parse.quote(session_dir, safe=""),
+                session_id,
+            )
+            os.makedirs(hist_dir)
+            line = {
+                "type": "assistant",
+                "tool_calls": [
+                    {
+                        "name": "search_replace",
+                        "arguments": {"path": "report.docx"},
+                    }
+                ],
+            }
+            with open(os.path.join(hist_dir, "chat_history.jsonl"), "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(arts, [("report.docx", os.path.abspath(abs_file))])
+
+
+class TestGrokSessionScanArtifacts(unittest.TestCase):
+    def test_scan_picks_new_pdf_skips_bundled(self):
+        from wechatbridge.grok import _scan_grok_session_artifacts, _merge_grok_artifacts
+
+        with tempfile.TemporaryDirectory() as session_dir:
+            pdf = os.path.join(session_dir, "out.pdf")
+            with open(pdf, "wb") as f:
+                f.write(b"%PDF-1.4")
+            bundled_dir = os.path.join(session_dir, ".grok", "bundled", "skills", "pdf")
+            os.makedirs(bundled_dir)
+            bundled = os.path.join(bundled_dir, "form.pdf")
+            with open(bundled, "wb") as f:
+                f.write(b"%PDF-1.4")
+            old = os.path.join(session_dir, "old.docx")
+            with open(old, "wb") as f:
+                f.write(b"PK")
+            os.utime(old, (1_000_000, 1_000_000))
+            arts = _scan_grok_session_artifacts(session_dir, since=time.time())
+            paths = {p for _, p in arts}
+            self.assertIn(os.path.realpath(pdf), paths)
+            self.assertNotIn(os.path.realpath(bundled), paths)
+            self.assertNotIn(os.path.realpath(old), paths)
+
+    def test_merge_dedupes_by_realpath(self):
+        from wechatbridge.grok import _merge_grok_artifacts
+
+        with tempfile.TemporaryDirectory() as td:
+            p = os.path.join(td, "a.pdf")
+            with open(p, "wb") as f:
+                f.write(b"x")
+            merged = _merge_grok_artifacts(
+                [("a.pdf", p)],
+                [("a.pdf", os.path.realpath(p))],
+            )
+            self.assertEqual(merged, [("a.pdf", p)])
+
+
+class TestGrokAuthPassthrough(unittest.TestCase):
+    def test_apply_reinjects_xai_key(self):
+        from wechatbridge.grok import _apply_grok_runtime_env, _grok_has_credentials
+        from wechatbridge.runner_common import sanitize_env
+
+        with tempfile.TemporaryDirectory() as td:
+            with mock.patch.dict(os.environ, {"XAI_API_KEY": "secret-xai"}, clear=False):
+                env = sanitize_env(td)
+                self.assertNotIn("XAI_API_KEY", env)
+                env = _apply_grok_runtime_env(env)
+                self.assertEqual(env["XAI_API_KEY"], "secret-xai")
+                self.assertTrue(_grok_has_credentials())
+
+    def test_has_credentials_false_without_auth_or_key(self):
+        from wechatbridge.grok import _grok_has_credentials
+
+        with mock.patch("wechatbridge.grok._host_grok_dir", return_value="/no/such/grok-home"):
+            with mock.patch.dict(os.environ, {"XAI_API_KEY": ""}, clear=False):
+                os.environ.pop("XAI_API_KEY", None)
+                self.assertFalse(_grok_has_credentials())
+
 
 class TestILinkDeliveryAccepted(unittest.TestCase):
     def test_predicate(self):
@@ -1890,3 +1980,450 @@ class TestPreflightBeforeSlot(unittest.IsolatedAsyncioTestCase):
 
 if __name__ == "__main__":
     unittest.main()
+
+
+
+class TestClassifyCliError(unittest.TestCase):
+    """_classify_cli_error returns correct category for each error pattern."""
+
+    def _cat(self, raw: str, backend: str = "agy") -> str:
+        from wechatbridge.runner_common import _classify_cli_error
+        return _classify_cli_error(raw, backend=backend)
+
+    def _fmt(self, raw: str, backend: str = "agy") -> str:
+        from wechatbridge.runner_common import format_cli_error
+        return format_cli_error(raw, backend=backend)
+
+    # --- payload_too_large --------------------------------------------------------
+
+    def test_request_payload_size_exceeds(self):
+        self.assertEqual(self._cat("request payload size exceeds the limit"), "payload_too_large")
+
+    def test_payload_too_large(self):
+        self.assertEqual(self._cat("payload too large"), "payload_too_large")
+
+    def test_request_entity_too_large(self):
+        self.assertEqual(self._cat("Request Entity Too Large"), "payload_too_large")
+
+    def test_content_length_exceeds(self):
+        self.assertEqual(self._cat("Content-Length exceeds the limit of 8MB"), "payload_too_large")
+
+    def test_content_length_is_too_large(self):
+        self.assertEqual(self._cat("content length is too large"), "payload_too_large")
+
+    def test_http_status_413_explicit(self):
+        self.assertEqual(self._cat("HTTP status 413"), "payload_too_large")
+        self.assertEqual(self._cat("status code 413"), "payload_too_large")
+        self.assertEqual(self._cat("http code 413"), "payload_too_large")
+        self.assertEqual(self._cat("code=413"), "payload_too_large")
+
+    def test_json_code_413(self):
+        self.assertEqual(self._cat('{"code": 413, "message": "too big"}'), "payload_too_large")
+
+    def test_413_in_date_not_matched(self):
+        """A bare 413 in a date string must NOT be classified as payload_too_large."""
+        self.assertNotEqual(self._cat("Session expired on 2024-04-13 at 10:00"), "payload_too_large")
+
+    def test_413_in_path_not_matched(self):
+        """A bare 413 in a file path or directory name must NOT match."""
+        self.assertNotEqual(self._cat("file not found: /tmp/record-413.txt"), "payload_too_large")
+
+    def test_413_in_version_not_matched(self):
+        """Version numbers containing 413 must NOT match."""
+        self.assertNotEqual(self._cat("library version 1.413.0"), "payload_too_large")
+
+    # --- context_too_large --------------------------------------------------------
+
+    def test_input_token_count_exceeds(self):
+        self.assertEqual(self._cat("input token count exceeds the maximum"), "context_too_large")
+
+    def test_context_length_exceeded(self):
+        self.assertEqual(self._cat("context length exceeded"), "context_too_large")
+
+    def test_maximum_context_length(self):
+        self.assertEqual(self._cat("maximum context length is 128k tokens"), "context_too_large")
+
+    def test_context_window_exceeded(self):
+        self.assertEqual(self._cat("context window exceeded"), "context_too_large")
+
+    def test_too_many_tokens(self):
+        self.assertEqual(self._cat("too many tokens in this conversation"), "context_too_large")
+
+    def test_your_input_context_is_too_long(self):
+        self.assertEqual(self._cat("your input context is too long for this model"), "context_too_large")
+
+    def test_invalid_argument_with_context(self):
+        self.assertEqual(self._cat("INVALID_ARGUMENT: context is too long"), "context_too_large")
+
+    def test_resource_exhausted_with_token(self):
+        self.assertEqual(self._cat("RESOURCE_EXHAUSTED: token limit exceeded"), "context_too_large")
+
+    def test_resource_exhausted_with_maximum(self):
+        self.assertEqual(self._cat("resource_exhausted: maximum context size reached"), "context_too_large")
+
+    # --- invalid_argument (generic) -----------------------------------------------
+
+    def test_generic_invalid_argument(self):
+        self.assertEqual(self._cat("INVALID_ARGUMENT: unknown field xyz"), "invalid_argument")
+
+    def test_invalid_argument_no_context_token(self):
+        self.assertEqual(self._cat("invalid_argument: bad request format"), "invalid_argument")
+
+    # --- auth ---------------------------------------------------------------------
+
+    def test_auth_generic(self):
+        self.assertEqual(self._cat("Not signed in. Please run login --device"), "auth")
+
+    def test_auth_unauthorized(self):
+        self.assertEqual(self._cat("unauthorized access"), "auth")
+
+    def test_auth_401_with_token(self):
+        self.assertEqual(self._cat("401 error: token expired"), "auth")
+
+    def test_auth_codex_specific(self):
+        self.assertEqual(self._cat("codex login required", backend="codex"), "auth")
+
+    def test_auth_codex_api_key(self):
+        self.assertEqual(self._cat("codex_api_key missing", backend="codex"), "auth")
+
+    # --- rate_limit ---------------------------------------------------------------
+
+    def test_eligibility_resource_exhausted(self):
+        self.assertEqual(self._cat("Eligibility check failed: RESOURCE_EXHAUSTED"), "resource_exhausted")
+
+    def test_resource_exhausted_generic(self):
+        self.assertEqual(self._cat("RESOURCE_EXHAUSTED: resource has been exhausted"), "resource_exhausted")
+
+    def test_rate_limit_exceeded(self):
+        self.assertEqual(self._cat("rate limit exceeded, please slow down"), "rate_limit")
+
+    def test_too_many_requests(self):
+        self.assertEqual(self._cat("HTTP 429 Too Many Requests"), "rate_limit")
+
+    def test_bare_429(self):
+        self.assertEqual(self._cat("upstream returned status 429"), "bare_429")
+
+    # --- quota --------------------------------------------------------------------
+
+    def test_quota_exceeded(self):
+        self.assertEqual(self._cat("You exceeded your current quota"), "quota")
+
+    def test_daily_quota(self):
+        self.assertEqual(self._cat("daily quota exceeded"), "quota")
+
+    def test_usage_limit(self):
+        self.assertEqual(self._cat("usage limit reached"), "quota")
+
+    # --- network ------------------------------------------------------------------
+
+    def test_connection_refused(self):
+        self.assertEqual(self._cat("connection refused"), "network")
+
+    def test_connection_reset(self):
+        self.assertEqual(self._cat("connection reset by peer"), "network")
+
+    def test_network_unreachable(self):
+        self.assertEqual(self._cat("network is unreachable"), "network")
+
+    # --- cascade_timeout ----------------------------------------------------------
+
+    def test_cascade_timeout(self):
+        self.assertEqual(self._cat("timeout waiting for cascade"), "cascade_timeout")
+
+    def test_cascade_response_timeout(self):
+        self.assertEqual(self._cat("timeout waiting for response"), "cascade_timeout")
+
+    # --- timeout ------------------------------------------------------------------
+
+    def test_generic_timeout(self):
+        self.assertEqual(self._cat("timeout occurred"), "timeout")
+
+    def test_timed_out(self):
+        self.assertEqual(self._cat("operation timed out"), "timeout")
+
+    def test_deadline_exceeded(self):
+        self.assertEqual(self._cat("deadline exceeded"), "timeout")
+
+    # --- permission ---------------------------------------------------------------
+
+    def test_permission_denied(self):
+        self.assertEqual(self._cat("permission denied"), "permission")
+
+    # --- session_not_found --------------------------------------------------------
+
+    def test_no_session_found(self):
+        self.assertEqual(self._cat("no session found"), "session_not_found")
+
+    # --- model_invalid ------------------------------------------------------------
+
+    def test_model_not_found(self):
+        self.assertEqual(self._cat("model not found"), "model_invalid")
+
+    def test_model_unknown(self):
+        self.assertEqual(self._cat("unknown model xyz"), "model_invalid")
+
+    # --- command_not_found --------------------------------------------------------
+
+    def test_command_not_found(self):
+        self.assertEqual(self._cat("command not found: xyz"), "command_not_found")
+
+    # --- not_found ----------------------------------------------------------------
+
+    def test_not_found_generic(self):
+        self.assertEqual(self._cat("not found"), "not_found")
+
+    def test_enoent(self):
+        self.assertEqual(self._cat("enoent: no such file"), "not_found")
+
+    # --- unknown ------------------------------------------------------------------
+
+    def test_empty_is_unknown(self):
+        self.assertEqual(self._cat(""), "unknown")
+
+    def test_garbage_is_unknown(self):
+        self.assertEqual(self._cat("abc123 random noise"), "unknown")
+
+
+class TestFormatCliErrorCategories(unittest.TestCase):
+    """format_cli_error produces correct user-facing copy for each category."""
+
+    def _fmt(self, raw: str, backend: str = "agy") -> str:
+        from wechatbridge.runner_common import format_cli_error
+        return format_cli_error(raw, backend=backend)
+
+    def test_payload_too_large_title(self):
+        out = self._fmt("request payload size exceeds the limit")
+        self.assertIn("请求内容过大", out)
+        self.assertIn("❌", out)
+        self.assertIn("/new", out)
+
+    def test_context_too_large_title(self):
+        out = self._fmt("context length exceeded")
+        self.assertIn("会话内容过长", out)
+        self.assertIn("❌", out)
+        self.assertIn("/new", out)
+
+    def test_invalid_argument_title(self):
+        out = self._fmt("INVALID_ARGUMENT: bad field")
+        self.assertIn("请求参数无效", out)
+        self.assertIn("❌", out)
+
+    def test_rate_limit_still_notice(self):
+        out = self._fmt("rate limit exceeded")
+        self.assertIn("🔔", out)
+        self.assertIn("请求较多", out)
+
+    def test_quota_still_notice(self):
+        out = self._fmt("quota exceeded")
+        self.assertIn("🔔", out)
+        self.assertIn("额度相关", out)
+
+    def test_auth_still_error(self):
+        out = self._fmt("not signed in")
+        self.assertIn("❌", out)
+        self.assertIn("未登录", out)
+
+    def test_network_still_error(self):
+        out = self._fmt("connection refused")
+        self.assertIn("网络错误", out)
+
+    def test_timeout_still_error(self):
+        out = self._fmt("timeout")
+        self.assertIn("超时", out)
+
+    def test_unknown_still_generic(self):
+        out = self._fmt("something weird happened")
+        self.assertIn("执行失败", out)
+
+
+class TestFormatCliErrorNoRawInReply(unittest.TestCase):
+    """format_cli_error must never echo raw English text to WeChat users."""
+
+    def _fmt(self, raw: str) -> str:
+        from wechatbridge.runner_common import format_cli_error
+        return format_cli_error(raw, backend="agy")
+
+    def test_no_raw_payload_error(self):
+        out = self._fmt("request payload size exceeds the limit")
+        self.assertNotIn("payload", out.lower())
+        self.assertNotIn("request", out.lower())
+
+    def test_no_raw_context_error(self):
+        out = self._fmt("context length exceeded")
+        self.assertNotIn("context", out.lower())
+        self.assertNotIn("exceeded", out.lower())
+
+    def test_no_raw_invalid_argument(self):
+        out = self._fmt("INVALID_ARGUMENT: bad field")
+        self.assertNotIn("INVALID_ARGUMENT", out)
+
+    def test_no_raw_rate_limit(self):
+        out = self._fmt("rate limit exceeded")
+        self.assertNotIn("rate", out.lower())
+        self.assertNotIn("limit", out.lower())
+
+
+class TestFormatCliErrorLogging(unittest.TestCase):
+    """format_cli_error logs category, not raw text."""
+
+    def test_log_contains_category_not_raw(self):
+        from wechatbridge.runner_common import format_cli_error, _classify_cli_error
+        import logging
+        import io
+
+        # First, verify the category is correct
+        category = _classify_cli_error("request payload size exceeds the limit")
+        self.assertEqual(category, "payload_too_large")
+
+        # Capture log output — set logger level to INFO so our info() call propagates
+        log_capture = io.StringIO()
+        handler = logging.StreamHandler(log_capture)
+        handler.setLevel(logging.DEBUG)
+        logger = logging.getLogger("wechatbridge.runner")
+        old_level = logger.level
+        logger.setLevel(logging.DEBUG)
+        logger.addHandler(handler)
+        try:
+            format_cli_error("request payload size exceeds the limit", backend="agy")
+        finally:
+            logger.removeHandler(handler)
+            logger.setLevel(old_level)
+
+        log_output = log_capture.getvalue()
+        self.assertIn("category=payload_too_large", log_output)
+        # Verify raw text is NOT in the log
+        self.assertNotIn("request payload", log_output)
+
+    def test_category_independent_of_raw(self):
+        """_classify_cli_error is a pure function; verify it directly."""
+        from wechatbridge.runner_common import _classify_cli_error
+
+        # payload_too_large
+        self.assertEqual(_classify_cli_error("request payload size exceeds the limit"), "payload_too_large")
+        self.assertEqual(_classify_cli_error("payload too large"), "payload_too_large")
+        # context_too_large
+        self.assertEqual(_classify_cli_error("context length exceeded"), "context_too_large")
+        self.assertEqual(_classify_cli_error("too many tokens"), "context_too_large")
+        # invalid_argument
+        self.assertEqual(_classify_cli_error("INVALID_ARGUMENT: bad field"), "invalid_argument")
+        # rate_limit (resource_exhausted without context/token keyword)
+        self.assertEqual(_classify_cli_error("RESOURCE_EXHAUSTED: quota"), "resource_exhausted")
+        # rate_limit (explicit)
+        self.assertEqual(_classify_cli_error("rate limit exceeded"), "rate_limit")
+        # bare 429
+        self.assertEqual(_classify_cli_error("status 429"), "bare_429")
+        # quota
+        self.assertEqual(_classify_cli_error("quota exceeded"), "quota")
+
+
+class TestFormatCliError413Boundary(unittest.TestCase):
+    """413 must not be misclassified when appearing in dates, paths, or versions."""
+
+    def _cat(self, raw: str) -> str:
+        from wechatbridge.runner_common import _classify_cli_error
+        return _classify_cli_error(raw)
+
+    def test_date_with_413(self):
+        self.assertNotEqual(self._cat("2024-04-13T10:00:00"), "payload_too_large")
+
+    def test_path_with_413(self):
+        self.assertNotEqual(self._cat("/tmp/file-413.txt"), "payload_too_large")
+
+    def test_version_with_413(self):
+        self.assertNotEqual(self._cat("version 1.413.2"), "payload_too_large")
+
+    def test_error_code_413_without_prefix(self):
+        """A bare '413' without status/code/http prefix should NOT match."""
+        self.assertNotEqual(self._cat("error 413 occurred"), "payload_too_large")
+
+    def test_explicit_status_413(self):
+        self.assertEqual(self._cat("status 413"), "payload_too_large")
+
+    def test_explicit_code_413(self):
+        self.assertEqual(self._cat("code: 413"), "payload_too_large")
+
+
+class TestFormatCliErrorContextResourceExhausted(unittest.TestCase):
+    """RESOURCE_EXHAUSTED with context/token keywords must classify as context_too_large."""
+
+    def _cat(self, raw: str) -> str:
+        from wechatbridge.runner_common import _classify_cli_error
+        return _classify_cli_error(raw)
+
+    def test_resource_exhausted_with_context(self):
+        self.assertEqual(self._cat("RESOURCE_EXHAUSTED: context length exceeded"), "context_too_large")
+
+    def test_resource_exhausted_with_token(self):
+        self.assertEqual(self._cat("RESOURCE_EXHAUSTED: token limit reached"), "context_too_large")
+
+    def test_resource_exhausted_with_maximum(self):
+        self.assertEqual(self._cat("RESOURCE_EXHAUSTED: maximum context size"), "context_too_large")
+
+    def test_invalid_argument_with_context(self):
+        self.assertEqual(self._cat("INVALID_ARGUMENT: context too long"), "context_too_large")
+
+
+class TestFormatCliErrorPreservesExistingThrottle(unittest.TestCase):
+    """Existing throttle/quota behavior must not be regressed."""
+
+    def _fmt(self, raw: str) -> str:
+        from wechatbridge.runner_common import format_cli_error
+        return format_cli_error(raw, backend="agy")
+
+    def test_eligibility_still_busy(self):
+        out = self._fmt("Eligibility check failed: RESOURCE_EXHAUSTED (code 429)")
+        self.assertIn("助手通道繁忙", out)
+        self.assertIn("🔔", out)
+
+    def test_quota_exceeded_still_quota(self):
+        out = self._fmt("You exceeded your current quota")
+        self.assertIn("额度相关", out)
+        self.assertIn("🔔", out)
+
+    def test_rate_limit_still_busy(self):
+        out = self._fmt("rate limit exceeded")
+        self.assertIn("请求较多", out)
+        self.assertIn("🔔", out)
+
+    def test_bare_429_still_busy(self):
+        out = self._fmt("upstream returned status 429")
+        self.assertIn("助手通道繁忙", out)
+        self.assertIn("🔔", out)
+
+
+class TestClearInitializedPreservesHistory(unittest.TestCase):
+    """clear_initialized must only remove .initialized flags, not conversation history."""
+
+    def test_clear_initialized_only_removes_flags(self):
+        from wechatbridge.runner_common import clear_initialized, ensure_session_dir
+
+        with tempfile.TemporaryDirectory() as td:
+            sd = os.path.join(td, "user_test")
+            os.makedirs(sd, exist_ok=True)
+            # Create .initialized flag
+            flag = os.path.join(sd, ".initialized.agy")
+            with open(flag, "w") as f:
+                f.write("1")
+            # Create some history files
+            history_dir = os.path.join(sd, ".gemini", "antigravity-cli", "conversations")
+            os.makedirs(history_dir, exist_ok=True)
+            history_file = os.path.join(history_dir, "conv.db")
+            with open(history_file, "w") as f:
+                f.write("history data")
+            # Create prefs
+            prefs_file = os.path.join(sd, "prefs.json")
+            with open(prefs_file, "w") as f:
+                f.write("{}")
+
+            clear_initialized(sd, backend="agy")
+
+            # Flag is removed
+            self.assertFalse(os.path.exists(flag))
+            # History is preserved
+            self.assertTrue(os.path.exists(history_file))
+            # Prefs are preserved
+            self.assertTrue(os.path.exists(prefs_file))
+
+
+if __name__ == "__main__":
+    unittest.main()

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

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

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

@@ -19,6 +19,7 @@ from .runner_common import (
     clean_output, load_prefs, save_prefs, is_dangerous, parse_model_effort,
     sanitize_env, terminate_process, update_active_prefs,
     format_error, format_cli_error, is_bridge_formatted_reply, EMPTY_REPLY, validate_add_dir,
+    path_is_under,
 )
 
 logger = logging.getLogger("grok_runner")
@@ -26,6 +27,37 @@ logger = logging.getLogger("grok_runner")
 # execve 单参数上限（Linux MAX_ARG_STRLEN = 128KB），留安全余量
 _MAX_ARG_BYTES = 120 * 1024
 
+# grok CLI 写文件工具名（新旧混用）。只用这些调用的 path 抽产物会漏掉
+# 经 run_terminal_command 生成的 pdf/docx，所以后面还有目录扫描兜底。
+_GROK_WRITE_TOOLS = frozenset({
+    "write",
+    "edit",
+    "str_replace",
+    "search_replace",
+    "Write",
+    "Edit",
+    "StrReplace",
+    "SearchReplace",
+})
+_GROK_PATH_KEYS = ("file_path", "path", "target_file")
+_GROK_PASSTHROUGH_ENV = ("XAI_API_KEY",)
+_GROK_SKIP_DIR_NAMES = frozenset({
+    ".grok",
+    ".gemini",
+    ".codex",
+    ".git",
+    "__pycache__",
+    "node_modules",
+    "venv",
+    ".venv",
+    "cache",
+    ".cache",
+})
+_GROK_SKIP_FILE_NAMES = frozenset({
+    "prefs.json",
+    "grok_persona.txt",
+})
+
 
 # ---------------------------------------------------------------------------
 # Per-user .grok directory setup
@@ -108,6 +140,28 @@ def ensure_user_grok(user_id: str) -> str:
     return session_dir
 
 
+def _grok_has_credentials() -> bool:
+    """True if the grok child can authenticate: host auth.json or XAI_API_KEY."""
+    if os.path.isfile(os.path.join(_host_grok_dir(), "auth.json")):
+        return True
+    key = os.environ.get("XAI_API_KEY")
+    return bool(key and str(key).strip())
+
+
+def _apply_grok_runtime_env(env: dict) -> dict:
+    """Re-inject grok auth env after sanitize_env (which strips *API_KEY).
+
+    Host `grok login` uses ~/.grok/auth.json (symlinked into the session).
+    Headless alternative is XAI_API_KEY on the bridge process; without this
+    passthrough the child always sees "Not signed in".
+    """
+    for key in _GROK_PASSTHROUGH_ENV:
+        val = os.environ.get(key)
+        if val:
+            env[key] = val
+    return env
+
+
 # ---------------------------------------------------------------------------
 # Persona persistence (via --rules injection)
 # ---------------------------------------------------------------------------
@@ -280,11 +334,43 @@ def _has_grok_session(session_dir: str) -> bool:
 # Artifact extraction from chat_history.jsonl
 # ---------------------------------------------------------------------------
 
+def _grok_tool_path(args) -> str:
+    """Path from a grok write/edit tool argument object."""
+    if not isinstance(args, dict):
+        return ""
+    for key in _GROK_PATH_KEYS:
+        val = args.get(key)
+        if isinstance(val, str) and val.strip():
+            return val.strip()
+    return ""
+
+
+def _resolve_grok_artifact_path(fp: str, session_dir: str, since: float, seen: set, artifacts: list) -> None:
+    """Resolve one candidate path and append if it is a new file from this turn."""
+    if not fp:
+        return
+    if not os.path.isabs(fp):
+        fp = os.path.join(session_dir, fp)
+    try:
+        fp = os.path.abspath(fp)
+    except (OSError, ValueError):
+        return
+    try:
+        if since and os.path.getmtime(fp) < since - 2.0:
+            return
+    except OSError:
+        return
+    key = (os.path.basename(fp), fp)
+    if key not in seen:
+        seen.add(key)
+        artifacts.append(key)
+
+
 def _extract_grok_artifacts(session_dir: str, session_id: str, since: float = 0.0) -> list:
     """Extract (name, abs_path) tuples from grok session chat_history.jsonl.
 
     grok stores sessions under $HOME/.grok/sessions/<url-encoded-cwd>/<session-id>/.
-    The chat_history.jsonl contains structured tool_calls with file_path arguments
+    The chat_history.jsonl contains structured tool_calls with path arguments
     from write/edit operations.
 
     ``since``: 只收录 mtime >= since 的文件——chat_history.jsonl 跨轮累积，
@@ -315,6 +401,8 @@ def _extract_grok_artifacts(session_dir: str, session_id: str, since: float = 0.
                     continue
                 if d.get("type") == "assistant" and d.get("tool_calls"):
                     for tc in d.get("tool_calls", []):
+                        if not isinstance(tc, dict):
+                            continue
                         name = tc.get("name", "")
                         args = tc.get("arguments", "")
                         if isinstance(args, str):
@@ -322,28 +410,11 @@ def _extract_grok_artifacts(session_dir: str, session_id: str, since: float = 0.
                                 args = json.loads(args)
                             except json.JSONDecodeError:
                                 continue
-                        if name in ("write", "edit", "str_replace") and isinstance(args, dict):
-                            fp = args.get("file_path", "")
-                            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)
+                        if name not in _GROK_WRITE_TOOLS:
+                            continue
+                        _resolve_grok_artifact_path(
+                            _grok_tool_path(args), session_dir, since, seen, artifacts
+                        )
     except OSError as e:
         logger.warning("Failed to read chat_history.jsonl: %s", e)
 
@@ -352,6 +423,78 @@ def _extract_grok_artifacts(session_dir: str, session_id: str, since: float = 0.
     return artifacts
 
 
+def _scan_grok_session_artifacts(session_dir: str, since: float = 0.0) -> list:
+    """Collect regular files written under session_dir during this turn.
+
+    grok often creates pdf/docx via run_terminal_command, which never appears
+    in write/edit tool_calls. Skip .grok / .gemini / .codex and other internal
+    trees so bundled skill PDFs are not sent back.
+
+    Bounded like the codex fallback: empty result if the walk exceeds
+    200 files, 50 directories, or 2 seconds.
+    """
+    if not since or not session_dir or not os.path.isdir(session_dir):
+        return []
+
+    artifacts = []
+    seen = set()
+    cutoff = since - 2.0
+    t_start = time.monotonic()
+    file_count = 0
+    dir_count = 0
+    max_files = 200
+    max_dirs = 50
+    max_scan_time = 2.0
+
+    for dirpath, dirnames, filenames in os.walk(session_dir, followlinks=False):
+        dir_count += 1
+        if dir_count > max_dirs or time.monotonic() - t_start > max_scan_time:
+            return []
+        dirnames[:] = [d for d in dirnames if d not in _GROK_SKIP_DIR_NAMES]
+        for fn in filenames:
+            file_count += 1
+            if file_count > max_files:
+                return []
+            if fn in _GROK_SKIP_FILE_NAMES or fn.startswith(".initialized."):
+                continue
+            fp = os.path.join(dirpath, fn)
+            try:
+                if os.path.islink(fp) or not os.path.isfile(fp):
+                    continue
+                if os.path.getmtime(fp) < cutoff:
+                    continue
+                if not path_is_under(fp, session_dir):
+                    continue
+                real = os.path.realpath(fp)
+            except OSError:
+                continue
+            key = (os.path.basename(real), real)
+            if key not in seen:
+                seen.add(key)
+                artifacts.append(key)
+    return artifacts
+
+
+def _merge_grok_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
+
+
 def _parse_grok_output(stdout_text: str, session_dir: str, since: float = 0.0) -> tuple:
     """Parse grok JSON output into (display_text, artifacts).
 
@@ -378,6 +521,10 @@ def _parse_grok_output(stdout_text: str, session_dir: str, since: float = 0.0) -
     artifacts = []
     if session_id:
         artifacts = _extract_grok_artifacts(session_dir, session_id, since=since)
+    # Merge directory scan so pdf/docx created via shell still go back.
+    artifacts = _merge_grok_artifacts(
+        artifacts, _scan_grok_session_artifacts(session_dir, since)
+    )
 
     # Strip file:/// links from display (in case grok emits them)
     display = re.sub(
@@ -413,6 +560,16 @@ async def run_grok(prompt: str, user_id: str, timeout: int = None) -> tuple:
     t0 = time.time()
     session_dir = ensure_user_grok(user_id)
 
+    if not _grok_has_credentials():
+        logger.warning(
+            "grok credentials missing: no host auth.json and no XAI_API_KEY"
+        )
+        return format_cli_error(
+            "Not signed in. To authenticate without a browser, run:\n"
+            "  grok login --device-code",
+            backend="grok",
+        ), []
+
     # Audit logging
     logger.info("[AUDIT] user=%s prompt=%.200s", user_id, prompt)
     if is_dangerous(prompt):
@@ -441,7 +598,7 @@ async def run_grok(prompt: str, user_id: str, timeout: int = None) -> tuple:
 
     process = None
     try:
-        env = sanitize_env(session_dir)
+        env = _apply_grok_runtime_env(sanitize_env(session_dir))
         env["PAGER"] = "cat"
         env["CI"] = "true"
         env["NONINTERACTIVE"] = "1"
@@ -581,7 +738,7 @@ async def _run_grok_subcommand(subcmd_args: list, user_id: str) -> str:
     cmd = [config.grok_binary_path] + subcmd_args
     process = None
     try:
-        env = sanitize_env(session_dir)
+        env = _apply_grok_runtime_env(sanitize_env(session_dir))
         process = await asyncio.create_subprocess_exec(
             *cmd,
             stdout=asyncio.subprocess.PIPE,

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

@@ -283,25 +283,65 @@ def format_artifact_send_failure_notice(art_name: str, reason: str) -> str:
     )
 
 
-def format_cli_error(raw_message: str, *, backend: str = "") -> str:
-    """Map backend stderr/JSON error text into a short Chinese user reply.
-
-    Never put English raw blobs or internal path/env names into user text.
-    Details stay in the server log only.
+def _classify_cli_error(raw_message: str, *, backend: str = "") -> str:
+    """Classify a backend error string into a category label.
+
+    Returns one of:
+      payload_too_large, context_too_large, invalid_argument,
+      auth, resource_exhausted, rate_limit, bare_429, quota,
+      network, timeout, cascade_timeout, permission,
+      session_not_found, model_invalid, command_not_found, not_found,
+      unknown
+
+    This is a pure function (no I/O, no logging).  ``format_cli_error``
+    drives user-facing copy from the category; callers that need the
+    category directly (e.g. structured logging) can use this too.
     """
-    raw = clean_output(raw_message or "") or "未知错误"
+    raw = clean_output(raw_message or "") or ""
     lower = raw.lower()
     backend = (backend or "").strip().lower()
-    logger.info(
-        "format_cli_error backend=%s raw=%.300s",
-        backend or "?",
-        raw,
-    )
 
-    # codex-specific auth/login recognition (backend-scoped, precise).
-    # Only explicit login semantics match, so ordinary API errors, rate
-    # limits and model errors are never misclassified as a login problem.
-    # agy/grok keep using the generic block below (results unchanged).
+    # --- 1. Payload / request body too large (413) --------------------------------
+    # Match explicit payload/body-size phrases first to avoid
+    # catching a bare 413 that appears in dates or path segments.
+    _PAYLOAD_SIZE_RE = re.compile(
+        r"request\s+payload\s+size\s+exceeds\s+the\s+limit"
+        r"|payload\s+too\s+large"
+        r"|request\s+entity\s+too\s+large"
+        r"|content[-\s]?length\s+(?:exceeds|exceeded|is\s+too\s+large)",
+        re.IGNORECASE,
+    )
+    if _PAYLOAD_SIZE_RE.search(lower):
+        return "payload_too_large"
+    # HTTP 413 with surrounding context (status/code/http prefix or JSON \"code\":413)
+    if re.search(
+        r"(?:status|code|http)\s*[:=]?\s*413\b", lower
+    ) or re.search(r'\"code\"\s*:\s*413', lower):
+        return "payload_too_large"
+
+    # --- 2. Context / token limit -------------------------------------------------
+    _CONTEXT_TOKEN_RE = re.compile(
+        r"input\s+token\s+count\s+exceeds\s+the\s+maximum"
+        r"|context\s+length\s+exceeded"
+        r"|maximum\s+context\s+length"
+        r"|context\s+window\s+exceeded"
+        r"|too\s+many\s+tokens"
+        r"|your\s+input\s+context\s+is\s+too\s+long",
+        re.IGNORECASE,
+    )
+    if _CONTEXT_TOKEN_RE.search(lower):
+        return "context_too_large"
+    # INVALID_ARGUMENT or RESOURCE_EXHAUSTED combined with context/token max signals
+    _ISAE = re.compile(r"invalid_argument|resource_exhausted", re.IGNORECASE)
+    _CTX_KW = re.compile(r"context|token|maximum", re.IGNORECASE)
+    if _ISAE.search(lower) and _CTX_KW.search(lower):
+        return "context_too_large"
+
+    # --- 3. Generic INVALID_ARGUMENT (not payload/context) ------------------------
+    if "invalid_argument" in lower:
+        return "invalid_argument"
+
+    # --- 4. Auth / login ----------------------------------------------------------
     if backend == "codex":
         if (
             "codex login" in lower
@@ -326,12 +366,8 @@ def format_cli_error(raw_message: str, *, backend: str = "") -> str:
             or "unauthorized" in lower
             or "401" in lower and ("auth" in lower or "token" in lower or "login" in lower)
         ):
-            return format_error(
-                "未登录",
-                "助手尚未登录或凭证失效，请联系管理员处理。",
-            )
+            return "auth"
 
-    # Auth / login — ops details stay in logs; users contact admin
     if (
         "not signed in" in lower
         or "authenticate" in lower
@@ -345,28 +381,18 @@ def format_cli_error(raw_message: str, *, backend: str = "") -> str:
         or ("xai_api_key" in lower and ("sign" in lower or "login" in lower or "auth" in lower))
         or "api_key" in lower and ("missing" in lower or "invalid" in lower or "required" in lower)
     ):
-        return format_error(
-            "未登录",
-            "助手尚未登录或凭证失效，请联系管理员处理。",
-        )
+        return "auth"
 
-    # Upstream eligibility / control-plane RESOURCE_EXHAUSTED (short-window throttle).
-    # Typical agy stderr: "Eligibility check failed: RESOURCE_EXHAUSTED (code 429):
-    # Resource has been exhausted (e.g. check quota)." — not daily-quota zero,
-    # not bridge concurrency, not user spam. More specific patterns first.
+    # --- 5. Rate limit / quota (RESOURCE_EXHAUSTED without context/token) ---------
+    # Must come AFTER context_too_large so "context/token + RESOURCE_EXHAUSTED"
+    # does not land here.
     if (
         "eligibility" in lower
         or "resource_exhausted" in lower
         or "resource exhausted" in lower
     ):
-        return format_notice(
-            "助手通道繁忙",
-            "上游助手通道暂时限流或繁忙，请稍等片刻再试。",
-        )
+        return "resource_exhausted"
 
-    # Explicit account / daily quota (after resource-exhausted so "check quota"
-    # in that message does not steal this branch).
-    # Require exceed/limit/daily/… semantics — bare "quota usage report" must not match.
     if (
         "quota exceeded" in lower
         or "quota_exceeded" in lower
@@ -384,33 +410,22 @@ def format_cli_error(raw_message: str, *, backend: str = "") -> str:
             )
         )
     ):
-        return format_notice(
-            "额度相关",
-            "当前额度或配额可能受限，请稍后再试或联系管理员。",
-        )
+        return "quota"
 
-    # Explicit rate limit / too many requests (no resource-exhausted wording).
     if (
         "rate limit" in lower
         or "rate_limit" in lower
         or "too many requests" in lower
     ):
-        return format_notice(
-            "请求较多",
-            "当前请求较多，请稍后再试。",
-        )
+        return "rate_limit"
 
     # Bare 429 fallback — word-boundary so "1429" / "x4290" do not match.
-    # Also accept explicit "status 429" / "code 429" forms.
     if re.search(r"\b429\b", lower) or re.search(
         r"(?:status|code|http)\s*[:=]?\s*429\b", lower
     ):
-        return format_notice(
-            "助手通道繁忙",
-            "上游暂时限流或繁忙，请稍等片刻再试。",
-        )
+        return "bare_429"
 
-    # Network
+    # --- 6. Network ---------------------------------------------------------------
     if (
         "connection refused" in lower
         or "connection reset" in lower
@@ -423,26 +438,21 @@ def format_cli_error(raw_message: str, *, backend: str = "") -> str:
         or "fetch failed" in lower
         or "socket hang up" in lower
     ):
-        return format_error("网络错误", "连不上服务，请检查网络后重试。")
+        return "network"
 
-    # Cascade / API hang (agy) — plain language for users
+    # --- 7. Timeout / cascade -----------------------------------------------------
     if "timeout waiting for cascade" in lower or "timeout waiting for response" in lower:
-        return format_error(
-            "模型响应超时",
-            "模型响应超时，请稍后重试或简化指令。",
-        )
-
-    if "permission" in lower and ("denied" in lower or "refuse" in lower or "rejected" in lower):
-        return format_error("权限不足", "没有执行该操作的权限。")
+        return "cascade_timeout"
 
     if "timeout" in lower or "timed out" in lower or "deadline exceeded" in lower:
-        return format_error("超时", "等待响应超时，请稍后重试。")
+        return "timeout"
+
+    # --- 8. Permission / misc specific --------------------------------------------
+    if "permission" in lower and ("denied" in lower or "refuse" in lower or "rejected" in lower):
+        return "permission"
 
     if "no session found" in lower:
-        return format_error(
-            "会话不存在",
-            "上一轮对话记录已过期，请重新发一次消息即可。",
-        )
+        return "session_not_found"
 
     if "model" in lower and (
         "not found" in lower
@@ -453,15 +463,119 @@ def format_cli_error(raw_message: str, *, backend: str = "") -> str:
         or "not supported" in lower
         or "no such" in lower
     ):
-        return format_error("模型无效", "指定的模型不可用，请用 `/models` 查看后重选。")
+        return "model_invalid"
 
     if "command not found" in lower or "not a command" in lower:
+        return "command_not_found"
+
+    if "not found" in lower or "no such file" in lower or "enoent" in lower:
+        return "not_found"
+
+    return "unknown"
+
+
+def format_cli_error(raw_message: str, *, backend: str = "") -> str:
+    """Map backend stderr/JSON error text into a short Chinese user reply.
+
+    Never put English raw blobs or internal path/env names into user text.
+    Details stay in the server log only.
+    """
+    raw = clean_output(raw_message or "") or "未知错误"
+    category = _classify_cli_error(raw, backend=backend)
+    logger.info(
+        "format_cli_error backend=%s category=%s",
+        backend or "?",
+        category,
+    )
+
+    # --- category → user-facing copy -----------------------------------------------
+    if category == "auth":
+        return format_error(
+            "未登录",
+            "助手尚未登录或凭证失效，请联系管理员处理。",
+        )
+
+    if category == "payload_too_large":
+        return format_error(
+            "请求内容过大",
+            (
+                "本次发送的内容超出服务端限制。\n"
+                "如果已续聊很久，请发 /new 开始新会话；\n"
+                "若新会话仍失败，请减少本次文字、图片或文件。"
+            ),
+        )
+
+    if category == "context_too_large":
+        return format_error(
+            "会话内容过长",
+            (
+                "会话累积内容超出模型上下文限制。\n"
+                "请发 /new 开始新会话后重试。"
+            ),
+        )
+
+    if category == "invalid_argument":
+        return format_error(
+            "请求参数无效",
+            "本次输入参数有误，请检查内容后重试。",
+        )
+
+    # --- throttle / quota (🔔 notice style — existing behaviour preserved) ---------
+    if category == "resource_exhausted":
+        return format_notice(
+            "助手通道繁忙",
+            "上游助手通道暂时限流或繁忙，请稍等片刻再试。",
+        )
+
+    if category == "rate_limit":
+        return format_notice(
+            "请求较多",
+            "当前请求较多，请稍后再试。",
+        )
+
+    if category == "bare_429":
+        return format_notice(
+            "助手通道繁忙",
+            "上游暂时限流或繁忙，请稍等片刻再试。",
+        )
+
+    if category == "quota":
+        return format_notice(
+            "额度相关",
+            "当前额度或配额可能受限，请稍后再试或联系管理员。",
+        )
+
+    if category == "network":
+        return format_error("网络错误", "连不上服务，请检查网络后重试。")
+
+    if category == "cascade_timeout":
+        return format_error(
+            "模型响应超时",
+            "模型响应超时，请稍后重试或简化指令。",
+        )
+
+    if category == "permission":
+        return format_error("权限不足", "没有执行该操作的权限。")
+
+    if category == "timeout":
+        return format_error("超时", "等待响应超时，请稍后重试。")
+
+    if category == "session_not_found":
+        return format_error(
+            "会话不存在",
+            "上一轮对话记录已过期，请重新发一次消息即可。",
+        )
+
+    if category == "model_invalid":
+        return format_error("模型无效", "指定的模型不可用，请用 `/models` 查看后重选。")
+
+    if category == "command_not_found":
         return format_error(
             "助手不可用",
             "助手程序未正确安装或配置，请联系管理员。",
         )
 
-    if "not found" in lower or "no such file" in lower or "enoent" in lower:
+    if category == "not_found":
         return format_error("未找到", "请求的资源或文件不存在。")
 
     # Unknown: fixed Chinese only — never echo English raw to WeChat users

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wechatbridge-cli
-Version: 1.4.5
+Version: 1.4.7
 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
@@ -75,6 +75,11 @@ Default data paths expand from `~` (e.g. `~/.local/share/wechatbridge/<instance>
 
 Per-user switch: `/backend agy`, `/backend grok`, or `/backend codex`. Each backend keeps its own model / effort / mode memory and persona file layout. Global default is `WECHATBRIDGE_BACKEND`.
 
+### 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.
+
 ### 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.