wechatbridge-cli 1.4.6__tar.gz → 1.4.8__tar.gz

{wechatbridge_cli-1.4.6/wechatbridge_cli.egg-info → wechatbridge_cli-1.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wechatbridge-cli
-Version: 1.4.6
+Version: 1.4.8
 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.6 → wechatbridge_cli-1.4.8}/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.6 → wechatbridge_cli-1.4.8}/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.6 → wechatbridge_cli-1.4.8}/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):

{wechatbridge_cli-1.4.6 → wechatbridge_cli-1.4.8}/wechatbridge/__init__.py

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

{wechatbridge_cli-1.4.6 → wechatbridge_cli-1.4.8}/wechatbridge/codex.py

@@ -633,26 +633,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.
 
@@ -831,12 +857,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 +882,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(

{wechatbridge_cli-1.4.6 → wechatbridge_cli-1.4.8}/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.6 → wechatbridge_cli-1.4.8/wechatbridge_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wechatbridge-cli
-Version: 1.4.6
+Version: 1.4.8
 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.