coze_lab 0.1.16 → 0.1.17

package/index.js

@@ -4572,6 +4572,7 @@ function writeCodexHook(token, workspaceId, pythonCmd, codexHome, cloud) {
   if (!cloud) {
     envLines.push(`COZELOOP_API_TOKEN=${token}`);
   }
+  envLines.push(`CODEX_HOME=${home}`);
   envLines.push(`COZELOOP_HOOK_LOG=${logFile}`);
   envLines.push('TRACE_TO_COZELOOP=true');
   // PPE 泳道：cozeloop SDK 读这两个环境变量，自动注入 x-tt-env / x-use-ppe header

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coze_lab",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "Configure local AI agents (Claude Code, Codex, OpenClaw) to report traces to CozeLoop",
   "keywords": [
     "cozeloop",

package/scripts/codex/cozeloop_hook.py

@@ -366,6 +366,101 @@ def read_rollout_messages(transcript_path: str, start_line: int = 0) -> List[Dic
     return entries
 
 
+def _add_unique_path(paths: List[Path], p: Optional[Path]):
+    if not p:
+        return
+    try:
+        resolved = p.expanduser().resolve()
+    except Exception:
+        return
+    if resolved not in paths:
+        paths.append(resolved)
+
+
+def _candidate_codex_homes() -> List[Path]:
+    homes: List[Path] = []
+    _add_unique_path(homes, Path(os.environ["CODEX_HOME"]) if os.environ.get("CODEX_HOME") else None)
+
+    log_path = _log_file_path()
+    if log_path:
+        try:
+            log_parent = Path(log_path).expanduser().resolve().parent
+            if log_parent.name == "hooks":
+                _add_unique_path(homes, log_parent.parent)
+        except Exception:
+            pass
+
+    _add_unique_path(homes, Path.home() / ".codex")
+
+    agents_root = Path.home() / ".coze" / "agents"
+    try:
+        if agents_root.exists():
+            for child in agents_root.iterdir():
+                _add_unique_path(homes, child / "codex-home")
+    except Exception:
+        pass
+
+    return homes
+
+
+def _latest_file(paths: List[Path]) -> Optional[Path]:
+    existing = []
+    for p in paths:
+        try:
+            if p.is_file():
+                existing.append(p)
+        except Exception:
+            pass
+    if not existing:
+        return None
+    return max(existing, key=lambda p: p.stat().st_mtime)
+
+
+def find_latest_transcript() -> Optional[str]:
+    """Best-effort fallback when Codex does not pass hook stdin."""
+    candidates: List[Path] = []
+    for codex_home in _candidate_codex_homes():
+        sessions_dir = codex_home / "sessions"
+        if not sessions_dir.exists():
+            continue
+        try:
+            candidates.extend(sessions_dir.rglob("rollout-*.jsonl"))
+        except Exception as e:
+            hook_log(f"fallback scan failed dir={sessions_dir} error={repr(e)}")
+
+    latest = _latest_file(candidates)
+    if latest:
+        return str(latest)
+
+    for codex_home in _candidate_codex_homes():
+        sessions_dir = codex_home / "sessions"
+        if not sessions_dir.exists():
+            continue
+        try:
+            candidates.extend(sessions_dir.rglob("*.jsonl"))
+        except Exception:
+            pass
+
+    latest = _latest_file(candidates)
+    return str(latest) if latest else None
+
+
+def recover_hook_input(reason: str) -> Optional[Dict[str, Any]]:
+    transcript_path = find_latest_transcript()
+    if not transcript_path:
+        hook_log(f"fallback failed reason={reason} no transcript found")
+        print(f"[CozeLoop] Hook input missing ({reason}); no Codex transcript found.", file=sys.stderr)
+        return None
+    hook_log(f"fallback transcript reason={reason} path={transcript_path}")
+    print(f"[CozeLoop] Hook input missing ({reason}); fallback transcript: {transcript_path}", file=sys.stderr)
+    return {
+        "hook_event_name": "Stop",
+        "session_id": "",
+        "transcript_path": transcript_path,
+        "input_fallback": reason,
+    }
+
+
 def parse_session_meta(entries: List[Dict[str, Any]]) -> Dict[str, Any]:
     """Extract session identity from session_meta entry."""
     result = {
@@ -1076,28 +1171,41 @@ def main():
     try:
         raw_input = sys.stdin.read().strip()
         if not raw_input:
-            hook_log("skip no stdin")
+            hook_log("stdin empty, trying fallback")
             debug_log("No input received from stdin")
-            return
-        hook_input = json.loads(raw_input)
+            hook_input = recover_hook_input("empty_stdin")
+            if not hook_input:
+                return
+        else:
+            hook_input = json.loads(raw_input)
     except Exception as e:
-        hook_log(f"skip stdin parse error={repr(e)}")
+        hook_log(f"stdin parse error={repr(e)}, trying fallback")
         debug_log(f"Error reading hook input from stdin: {e}")
-        return
+        hook_input = recover_hook_input("stdin_parse_error")
+        if not hook_input:
+            return
 
     debug_log(f"Hook input: {json.dumps(hook_input, ensure_ascii=False)}")
 
     # Get transcript path
     transcript_path = hook_input.get("transcript_path")
     if not transcript_path:
-        hook_log("skip missing transcript_path")
+        hook_log("missing transcript_path, trying fallback")
         debug_log("No transcript_path in hook input")
-        return
+        recovered = recover_hook_input("missing_transcript_path")
+        if not recovered:
+            return
+        hook_input = recovered
+        transcript_path = hook_input.get("transcript_path")
 
     if not os.path.exists(transcript_path):
-        hook_log(f"skip transcript not found path={transcript_path}")
+        hook_log(f"transcript not found path={transcript_path}, trying fallback")
         debug_log(f"Transcript file not found: {transcript_path}")
-        return
+        recovered = recover_hook_input("transcript_not_found")
+        if not recovered:
+            return
+        hook_input = recovered
+        transcript_path = hook_input.get("transcript_path")
 
     # Load state
     state_file = get_state_file_path(transcript_path)