coze_lab 0.1.15 → 0.1.17

package/README.md

@@ -61,6 +61,11 @@ For cloud Codex with `--cloud --agent-id=<agentId>`, Codex hooks are written to
 does not already exist, so callers do not need to pass `--codex-home` for the
 standard coze-bridge layout.
 
+Codex hook diagnostics are appended to `hooks/cozeloop.log` under the same
+Codex home. For cloud Codex, check
+`~/.coze/agents/<agentId>/codex-home/hooks/cozeloop.log`. If that file is not
+created after a new Codex turn, Codex did not load or execute the hook.
+
 ## Token lifecycle
 
 OAuth tokens are stored in `~/.cozeloop/credentials.json` (mode 600).

package/index.js

@@ -4554,6 +4554,7 @@ function writeCodexHook(token, workspaceId, pythonCmd, codexHome, cloud) {
   const hooksDir   = path.join(home, 'hooks');
   const hookScript = path.join(hooksDir, 'cozeloop_hook.py');
   const envFile    = path.join(hooksDir, 'cozeloop.env');
+  const logFile    = path.join(hooksDir, 'cozeloop.log');
   const hooksJson  = path.join(home, 'hooks.json');
 
   // 1. Write Python hook scripts (trace + refresh)
@@ -4571,6 +4572,8 @@ 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
   envLines.push(`x_tt_env=${PPE_TT_ENV}`);
@@ -4615,7 +4618,7 @@ function writeCodexHook(token, workspaceId, pythonCmd, codexHome, cloud) {
   ok(`Hook registered in ${hooksJson}`);
   warn('Codex hook trust: 首次启动 Codex 会提示 "Hooks need review"。在该提示按 t（Trust all and continue），或在会话内运行 /hooks 后按 t，即可一次性信任全部 hook 启用 trace 上报。');
 
-  return { hookScript, envFile, hooksJson };
+  return { hookScript, envFile, hooksJson, logFile };
 }
 
 function resolveCodexHome(args) {
@@ -5325,6 +5328,7 @@ async function main() {
     summaryLines.push(`Hook script: ${written.hookScript || '~/.codex/hooks/cozeloop_hook.py'}`);
     summaryLines.push(`Config:      ${written.hooksJson || '~/.codex/hooks.json'}`);
     summaryLines.push(`Credentials: ${written.envFile || '~/.codex/hooks/cozeloop.env'}`);
+    if (written.logFile) summaryLines.push(`Hook log:    ${written.logFile}`);
   } else {
     summaryLines.push(`Config:      ~/.openclaw/openclaw.json`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coze_lab",
-  "version": "0.1.15",
+  "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

@@ -130,12 +130,15 @@ def _make_finish_event_processor():
     def _processor(info):
         try:
             if not getattr(info, "is_event_fail", False):
+                hook_log("upload success")
                 return
             detail = getattr(info, "detail_msg", "") or ""
             logid = _extract_logid(detail)
             if logid:
+                hook_log(f"upload failed logid={logid} detail={detail[:500]}")
                 print(f"[CozeLoop] 上报失败 logid={logid} (可用 bytedcli log get-logid-log {logid} 排查)", file=sys.stderr)
             else:
+                hook_log(f"upload failed detail={detail[:500]}")
                 print(f"[CozeLoop] 上报失败: {detail[:300]}", file=sys.stderr)
         except Exception:
             pass
@@ -255,8 +258,27 @@ else:
 DEBUG = os.environ.get("CC_COZELOOP_DEBUG", "").lower() == "true"
 
 
+def _log_file_path() -> str:
+    return os.environ.get("COZELOOP_HOOK_LOG", "").strip()
+
+
+def hook_log(message: str):
+    """Append one diagnostic line to the hook log, if configured."""
+    log_path = _log_file_path()
+    if not log_path:
+        return
+    try:
+        p = Path(log_path).expanduser()
+        p.parent.mkdir(parents=True, exist_ok=True)
+        with p.open("a", encoding="utf-8") as f:
+            f.write(f"{datetime.now().isoformat()} {message}\n")
+    except Exception:
+        pass
+
+
 def debug_log(message: str):
     """Print debug message if debug mode is enabled."""
+    hook_log(f"DEBUG {message}")
     if DEBUG:
         print(f"[COZELOOP_HOOK_DEBUG] {datetime.now().isoformat()} - {message}", file=sys.stderr)
 
@@ -344,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 = {
@@ -690,12 +807,15 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
     token = get_fresh_token()
     if token:
         os.environ["COZELOOP_API_TOKEN"] = token
+        hook_log(f"token resolved prefix={token[:12]}...")
         print(f"[CozeLoop] Token 获取成功 ({token[:12]}...)", file=sys.stderr)
     else:
+        hook_log("token missing")
         print("[CozeLoop] 警告: 未找到有效 Token，上报可能失败", file=sys.stderr)
     creds = _load_credentials()
     workspace_id = (creds or {}).get("workspace_id") or os.environ.get("COZELOOP_WORKSPACE_ID", "") or _DEFAULT_WORKSPACE_ID
     os.environ["COZELOOP_WORKSPACE_ID"] = workspace_id
+    hook_log(f"workspace_id={workspace_id}")
     client_kwargs = {
         "ultra_large_report": True,
         "upload_timeout": 120,
@@ -1018,13 +1138,16 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                     debug_log(f"Error processing turn {i}: {e}")
                     continue
 
+        hook_log(f"processed turns={len(turns)} session_id={session_id}")
         debug_log(f"Successfully processed {len(turns)} turn(s) for session {session_id}")
 
     except Exception as e:
+        hook_log(f"send exception={repr(e)}")
         debug_log(f"An error occurred while sending traces to CozeLoop: {e}")
         return None
     finally:
         client.close()
+        hook_log("client closed")
         debug_log("CozeLoop client closed.")
 
     return ctx
@@ -1035,10 +1158,12 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
 def main():
     """Main entry point for the Codex CozeLoop hook."""
     print("[CozeLoop] Hook triggered (Codex).", file=sys.stderr)
+    hook_log("hook triggered")
     debug_log("Codex CozeLoop hook started.")
 
     # Check if tracing is enabled
     if os.environ.get("TRACE_TO_COZELOOP", "").lower() == "false":
+        hook_log("skip trace disabled")
         debug_log("TRACE_TO_COZELOOP is set to 'false', skipping")
         return
 
@@ -1046,24 +1171,41 @@ def main():
     try:
         raw_input = sys.stdin.read().strip()
         if not raw_input:
+            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"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("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"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)
@@ -1073,9 +1215,11 @@ def main():
     entries = read_rollout_messages(transcript_path, state["last_processed_line"])
 
     if not entries:
+        hook_log(f"skip no new entries transcript={transcript_path}")
         debug_log("No new entries to process")
         return
 
+    hook_log(f"read entries={len(entries)} from_line={state['last_processed_line']} transcript={transcript_path}")
     debug_log(f"Read {len(entries)} new entries from line {state['last_processed_line']}")
 
     # Parse session identity
@@ -1125,6 +1269,7 @@ def main():
         last_line = max(e.get("_line_number", 0) for e in entries) + 1
         state["last_processed_line"] = last_line
         save_state(state_file, state)
+        hook_log(f"subagent saved session_id={session_id} turns={len(turns[-1:])} last_line={last_line}")
         debug_log("Subagent data saved, hook completed")
         return
 
@@ -1135,6 +1280,7 @@ def main():
             for t in turns
         )
         if not has_coze_ctx:
+            hook_log(f"skip no coze-context turns={len(turns)} session_id={session_id}")
             debug_log("No coze-context found in any turn, skipping upload.")
             return
         history_context = state.get("conversation_history", [])
@@ -1147,12 +1293,16 @@ def main():
             state["last_processed_line"] = last_line
             state["conversation_history"] = updated_history
             save_state(state_file, state)
+            hook_log(f"state advanced last_line={last_line} session_id={session_id}")
             debug_log(f"State updated, last processed line: {last_line}")
         else:
+            hook_log(f"send failed state not advanced session_id={session_id}")
             debug_log("Send failed, state not advanced")
     else:
+        hook_log(f"skip no turns session_id={session_id}")
         debug_log("No turns to send")
 
+    hook_log("hook completed")
     debug_log("Codex CozeLoop hook completed.")