@ghl-ai/aw 0.1.37-beta.77 → 0.1.37-beta.79

package/hooks/capabilities/telemetry.mjs

@@ -8,7 +8,7 @@
 //
 // MUST never throw unhandled. Callers (dispatch.mjs) catch, but we guard anyway.
 
-import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, unlinkSync, readdirSync, rmSync } from 'node:fs';
+import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, unlinkSync, readdirSync, rmSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { createHash } from 'node:crypto';
@@ -155,6 +155,13 @@ function normalizeCursorInput(input) {
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
+function resolveSessionId(input) {
+  return input?.session_id
+    || input?.conversation_id
+    || process.env.CODEX_THREAD_ID
+    || 'unknown';
+}
+
 function resolveApiUrl() {
   if (process.env.AW_API_URL) return `${process.env.AW_API_URL}/telemetry/ingest`;
   const configPath = join(HOME, '.aw', 'config.json');
@@ -193,6 +200,9 @@ function resolveNamespace() {
 
 function detectPlatform(input) {
   if (input?.hook_event_name || input?.cursor_version || input?.conversation_id) return 'cursor';
+  if (input?.platform) return input.platform;
+  if (input?.transcript_path) return 'claude-code';
+  if (input?.session_id && !process.env.CODEX_THREAD_ID) return 'claude-code';
   if (process.env.CLAUDECODE) return 'claude-code';
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_PROJECT_DIR) return 'cursor';
   if (Object.keys(process.env).some(k => k.startsWith('WINDSURF_'))) return 'windsurf';
@@ -200,6 +210,61 @@ function detectPlatform(input) {
   return 'claude-code';
 }
 
+function findCodexTranscriptPath(sessionId) {
+  if (!sessionId || sessionId === 'unknown') return null;
+
+  const sessionsRoot = join(HOME, '.codex', 'sessions');
+  if (!existsSync(sessionsRoot)) return null;
+
+  const stack = [sessionsRoot];
+  let newestMatch = null;
+  let newestStamp = 0;
+
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries = [];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith('.jsonl')) continue;
+      if (!entry.name.includes(sessionId)) continue;
+
+      try {
+        const stamp = statSync(fullPath).mtimeMs;
+        if (Number.isFinite(stamp) && stamp >= newestStamp) {
+          newestStamp = stamp;
+          newestMatch = fullPath;
+        }
+      } catch {
+        newestMatch = newestMatch || fullPath;
+      }
+    }
+  }
+
+  return newestMatch;
+}
+
+function classifyError(errStr) {
+  if (!errStr) return { errorType: null, errorMessage: null };
+  const errorMessage = String(errStr).slice(0, 1024);
+  let errorType = 'unknown';
+  if (/rate.?limit|429|too many requests/i.test(errorMessage)) errorType = 'rate_limit';
+  else if (/context.?(overflow|length|window|limit|too long)/i.test(errorMessage)) errorType = 'context_overflow';
+  else if (/timeout|timed?\s*out|ETIMEDOUT/i.test(errorMessage)) errorType = 'timeout';
+  else if (/cancel|abort|interrupt/i.test(errorMessage)) errorType = 'user_cancel';
+  else if (/tool.?(fail|error)|execution.?error|process exited with code [1-9]/i.test(errorMessage)) errorType = 'tool_failure';
+  return { errorType, errorMessage };
+}
+
 function computeProjectHash(cwd) {
   try {
     const remote = execSync('git remote get-url origin 2>/dev/null', {
@@ -361,14 +426,7 @@ function extractFromTranscript(transcriptPath) {
         const entryError = entry.error || entry.message?.error;
         if (entryError) {
           const errStr = typeof entryError === 'string' ? entryError : (entryError.message || JSON.stringify(entryError));
-          errorMessage = errStr.slice(0, 1024);
-          // Classify error type
-          if (/rate.?limit|429|too many requests/i.test(errStr)) errorType = 'rate_limit';
-          else if (/context.?(overflow|length|window|limit|too long)/i.test(errStr)) errorType = 'context_overflow';
-          else if (/timeout|timed?\s*out|ETIMEDOUT/i.test(errStr)) errorType = 'timeout';
-          else if (/cancel|abort|interrupt/i.test(errStr)) errorType = 'user_cancel';
-          else if (/tool.?(fail|error)|execution.?error/i.test(errStr)) errorType = 'tool_failure';
-          else errorType = 'unknown';
+          ({ errorType, errorMessage } = classifyError(errStr));
         }
       } catch { /* skip malformed lines */ }
     }
@@ -417,6 +475,129 @@ function extractFromTranscript(transcriptPath) {
   }
 }
 
+function extractFromCodexSession(transcriptPath) {
+  if (!transcriptPath || !existsSync(transcriptPath)) return null;
+
+  try {
+    const content = readFileSync(transcriptPath, 'utf8');
+    const lines = content.split('\n').filter(Boolean);
+
+    let lastInputTokens = 0;
+    let lastOutputTokens = 0;
+    let lastCacheCreation = 0;
+    let lastCacheRead = 0;
+    let model = null;
+    let command = null;
+    let cwd = null;
+    let platformVersion = null;
+    const agentsUsed = new Set();
+    const skillsApplied = new Set();
+    const mcpToolsUsed = new Set();
+    const prUrls = new Set();
+    let toolTotal = 0;
+    let toolFailed = 0;
+    let errorType = null;
+    let errorMessage = null;
+
+    for (const line of lines) {
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+
+      if (entry.type === 'session_meta') {
+        const meta = entry.payload || {};
+        cwd = meta.cwd || cwd;
+        platformVersion = meta.cli_version || platformVersion;
+      }
+
+      if (entry.type === 'event_msg' && entry.payload?.type === 'token_count') {
+        const totals = entry.payload?.info?.total_token_usage || {};
+        lastInputTokens = totals.input_tokens || 0;
+        lastOutputTokens = (totals.output_tokens || 0) + (totals.reasoning_output_tokens || 0);
+        lastCacheRead = totals.cached_input_tokens || 0;
+      }
+
+      if (entry.type === 'response_item') {
+        const payload = entry.payload || {};
+        if (payload.type === 'function_call') {
+          const name = payload.name || '';
+          const argsRaw = typeof payload.arguments === 'string' ? payload.arguments : JSON.stringify(payload.arguments || {});
+
+          if (name) toolTotal++;
+          if (name === 'spawn_agent') {
+            try {
+              const parsed = JSON.parse(argsRaw || '{}');
+              const agentType = parsed.agent_type || parsed.model || 'spawn_agent';
+              agentsUsed.add(String(agentType).slice(0, 128));
+            } catch {
+              agentsUsed.add('spawn_agent');
+            }
+          }
+          if (name === 'Skill') {
+            try {
+              const parsed = JSON.parse(argsRaw || '{}');
+              if (parsed.skill) {
+                command = String(parsed.skill).slice(0, 128);
+                skillsApplied.add(command);
+              }
+            } catch { /* ignore */ }
+          }
+          if (name.startsWith('mcp__')) {
+            mcpToolsUsed.add(name.slice(0, 128));
+          }
+          scanForPrUrls(argsRaw, prUrls);
+        }
+
+        if (payload.type === 'function_call_output') {
+          const outputText = String(payload.output || '');
+          scanForPrUrls(outputText, prUrls);
+          const failureMatch = outputText.match(/Process exited with code\s+(\d+)/i);
+          if (failureMatch) {
+            const exitCode = Number.parseInt(failureMatch[1], 10);
+            if (Number.isFinite(exitCode) && exitCode !== 0) {
+              toolFailed++;
+              ({ errorType, errorMessage } = classifyError(outputText));
+            }
+          }
+        }
+
+        if (payload.type === 'message') {
+          const textContent = Array.isArray(payload.content)
+            ? payload.content.map(part => part?.text || '').join('\n')
+            : '';
+          scanForPrUrls(textContent, prUrls);
+        }
+      }
+    }
+
+    return {
+      inputTokens: lastInputTokens,
+      outputTokens: lastOutputTokens,
+      cacheCreation: lastCacheCreation,
+      cacheRead: lastCacheRead,
+      totalTokens: lastInputTokens + lastOutputTokens + lastCacheCreation + lastCacheRead,
+      model,
+      command,
+      cwd,
+      platformVersion,
+      agentsUsed: [...agentsUsed],
+      skillsApplied: [...skillsApplied],
+      mcpToolsUsed: [...mcpToolsUsed],
+      toolTotal,
+      toolPassed: Math.max(0, toolTotal - toolFailed),
+      toolFailed,
+      prUrls: [...prUrls],
+      errorType,
+      errorMessage,
+    };
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Estimate token counts from Cursor's inline response text.
  * Cursor doesn't provide token usage, so we estimate ~4 chars/token.
@@ -647,8 +828,14 @@ async function pushPerfSummaries(cwd, transcript, deltaTotal, deltaCost, model,
  */
 export async function handleSessionStart(rawInput) {
   const input = normalizeCursorInput(rawInput);
-  const sessionId = input.session_id || `s-${Date.now()}`;
-  const cwd = input.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const sessionId = resolveSessionId(input);
+  const codexTranscriptPath = detectPlatform(input) === 'codex'
+    ? findCodexTranscriptPath(sessionId)
+    : null;
+  const codexTranscript = codexTranscriptPath
+    ? extractFromCodexSession(codexTranscriptPath)
+    : null;
+  const cwd = input.cwd || codexTranscript?.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
 
   // Refresh pricing from LiteLLM if stale (>24h). Non-blocking — if it fails,
   // existing cached pricing or hardcoded fallback is used.
@@ -659,10 +846,10 @@ export async function handleSessionStart(rawInput) {
     branch: getBranch(cwd),
     project_hash: computeProjectHash(cwd),
     platform: detectPlatform(rawInput),
-    platform_version: input.platform_version || null,
+    platform_version: input.platform_version || codexTranscript?.platformVersion || null,
     namespace: resolveNamespace(),
     start_ts: new Date().toISOString(),
-    model: input.model || null,
+    model: input.model || codexTranscript?.model || null,
     cwd,
     entry_id: 0,           // monotonic counter for costs.jsonl entries
     last_flushed_entry: 0, // checkpoint: last entry_id pushed to API
@@ -682,17 +869,25 @@ export async function handleSessionStart(rawInput) {
  */
 export async function handleStop(rawInput) {
   const input = normalizeCursorInput(rawInput);
-  const sessionId = input.session_id || 'unknown';
-  const transcriptPath = input.transcript_path || process.env.CURSOR_TRANSCRIPT_PATH || null;
+  const sessionId = resolveSessionId(input);
+  const platform = detectPlatform(rawInput);
+  const transcriptPath = input.transcript_path
+    || process.env.CURSOR_TRANSCRIPT_PATH
+    || (platform === 'codex' ? findCodexTranscriptPath(sessionId) : null);
   const cwd = input.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
   const status = input.status || 'completed';
   const stdinModel = input.model || null;
 
   // For Cursor: if no transcript file, estimate from inline text
-  let transcript = extractFromTranscript(transcriptPath);
+  let transcript = platform === 'codex'
+    ? extractFromCodexSession(transcriptPath)
+    : extractFromTranscript(transcriptPath);
   if (!transcript && input._cursor_text) {
     transcript = estimateFromCursorText(input._cursor_text, stdinModel);
   }
+  if (!transcript && platform === 'codex' && transcriptPath) {
+    transcript = extractFromCodexSession(transcriptPath);
+  }
   const model = stdinModel || transcript?.model || 'unknown';
 
   // ── Token delta via snapshot diffing ─────────────────────────────────────
@@ -726,6 +921,16 @@ export async function handleStop(rawInput) {
 
   // ── Append to costs.jsonl with incrementing entry_id ───────────────────
   let session = readSession(sessionId);
+  if (!session && platform === 'codex') {
+    await handleSessionStart({
+      ...input,
+      session_id: sessionId,
+      cwd: input.cwd || transcript?.cwd || cwd,
+      model: stdinModel || transcript?.model || null,
+      platform_version: input.platform_version || transcript?.platformVersion || null,
+    });
+    session = readSession(sessionId);
+  }
   const entryId = (session?.entry_id || 0) + 1;
 
   try {
@@ -742,7 +947,7 @@ export async function handleStop(rawInput) {
       total_tokens: deltaTotal,
       cost_usd: Math.round(deltaCost * 1_000_000) / 1_000_000,
       status,
-      platform: detectPlatform(rawInput),
+      platform,
     };
     appendFileSync(costPath, JSON.stringify(record) + '\n');
   } catch { /* never block */ }
@@ -751,6 +956,8 @@ export async function handleStop(rawInput) {
   if (session) {
     session.entry_id = entryId;
     session.model = model !== 'unknown' ? model : session.model;
+    session.platform_version = input.platform_version || transcript?.platformVersion || session.platform_version;
+    session.cwd = transcript?.cwd || session.cwd;
 
     // Merge PR URLs
     if (transcript?.prUrls?.length) {

package/integrate.mjs

@@ -669,18 +669,43 @@ export function installIdeHooks() {
   for (const [event, { cmd, timeout }] of Object.entries(codexEvents)) {
     if (!codexHooksFile.hooks[event]) codexHooksFile.hooks[event] = [];
 
-    // Remove old aw entries
-    codexHooksFile.hooks[event] = codexHooksFile.hooks[event].filter(h =>
-      !h.command?.includes('.aw/hooks/')
-    );
+    // Codex expects grouped hook entries:
+    // { matcher?, hooks: [{ type, command, timeoutSec, statusMessage }] }
+    // Preserve non-AW groups and non-AW hooks inside mixed groups.
+    const existingGroups = Array.isArray(codexHooksFile.hooks[event]) ? codexHooksFile.hooks[event] : [];
+    const preservedGroups = existingGroups
+      .map(group => {
+        if (!group || !Array.isArray(group.hooks)) return null;
+        const hooks = group.hooks.filter(h => !h.command?.includes('.aw/hooks/'));
+        return hooks.length > 0 ? { ...group, hooks } : null;
+      })
+      .filter(Boolean);
 
-    // Codex hooks are flat objects: { command, type, timeoutSec, statusMessage }
-    codexHooksFile.hooks[event].push({
+    const awHook = {
       type: 'command',
       command: cmd,
       timeoutSec: timeout,
       statusMessage: `AW telemetry (${event})`,
-    });
+    };
+
+    const awGroup = event === 'SessionStart'
+      ? { matcher: 'startup', hooks: [awHook] }
+      : { hooks: [awHook] };
+
+    codexHooksFile.hooks[event] = [...preservedGroups, awGroup];
+
+    // Clean up incorrect top-level event wrappers from prior installs.
+    if (Array.isArray(codexHooksFile[event])) {
+      const cleaned = codexHooksFile[event]
+        .map(group => {
+          if (!group || !Array.isArray(group.hooks)) return null;
+          const hooks = group.hooks.filter(h => !h.command?.includes('.aw/hooks/'));
+          return hooks.length > 0 ? { ...group, hooks } : null;
+        })
+        .filter(Boolean);
+      if (cleaned.length > 0) codexHooksFile[event] = cleaned;
+      else delete codexHooksFile[event];
+    }
   }
 
   writeFileSync(codexHooksPath, JSON.stringify(codexHooksFile, null, 2) + '\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.37-beta.77",
+  "version": "0.1.37-beta.79",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": "bin.js",