@jagit/hook-codex 0.0.0

package/README.md

@@ -0,0 +1,42 @@
+# @jagit/hook-codex
+
+Reports per-session OpenAI Codex CLI usage to JaGit.
+
+## Setup
+
+Codex has no built-in hook mechanism, so install a shell function that wraps
+the real `codex` binary and reports after each session ends:
+
+    codex() {
+      command codex "$@"
+      local status=$?
+      npx -y @jagit/hook-codex >/dev/null 2>&1 || true
+      return $status
+    }
+
+Add that function to your shell rc (`~/.zshrc`, `~/.bashrc`, etc.) — it must
+appear before any `alias`/`PATH` entry that would otherwise shadow it. On
+exit, the reporter locates the most-recently-modified file under
+`~/.codex/sessions/**/*.jsonl`, parses it, and posts the session summary.
+Uninstall by removing the shell function.
+
+For a permanent binary instead of `npx -y`:
+`npm i -g @jagit/hook-codex`, then call `jagit-hook-codex` in the wrapper.
+
+You can also point the reporter at a specific transcript:
+
+    jagit-hook-codex --file ~/.codex/sessions/2026/06/20/rollout-...jsonl
+
+## Environment
+
+    export JAGIT_BASE_URL="https://your-jagit-host"
+    export JAGIT_API_KEY="<your DASHBOARD_API_TOKEN>"
+
+Identity defaults to `git config user.email` (read from the session's `cwd`);
+override with `JAGIT_GIT_USERNAME`.
+
+## Notes
+
+- Token counts are cumulative per Codex session; the reporter reads the last
+  non-null `token_count` event, not a sum across events.
+- `costUsd` is always `null` — Codex JSONL logs do not expose a cost field.

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { type AgentSessionPayload } from "@jagit/agent-reporter";
+export interface CodexRecord {
+    type?: string;
+    timestamp?: string;
+    payload?: {
+        id?: string;
+        cwd?: string;
+        timestamp?: string;
+        model?: string;
+        type?: string;
+        info?: {
+            total_token_usage?: {
+                input_tokens?: number;
+                cached_input_tokens?: number;
+                output_tokens?: number;
+            };
+        } | null;
+    };
+}
+export declare function buildPayload(sessionId: string, cwd: string | undefined, records: CodexRecord[]): AgentSessionPayload;

package/dist/index.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveGitUsername, reportSession } from "@jagit/agent-reporter";
+const TOOL_CALL_SUBTYPES = new Set(["function_call", "custom_tool_call", "web_search_call"]);
+export function buildPayload(sessionId, cwd, records) {
+    let model = "unknown";
+    let inputTokens = 0;
+    let cachedInputTokens = 0;
+    let outputTokens = 0;
+    let toolCallCount = 0;
+    for (const r of records) {
+        if (r.type === "turn_context" && r.payload?.model) {
+            model = r.payload.model;
+        }
+        if (r.type === "event_msg" && r.payload?.type === "token_count" && r.payload.info) {
+            const usage = r.payload.info.total_token_usage;
+            if (usage) {
+                inputTokens = usage.input_tokens ?? 0;
+                cachedInputTokens = usage.cached_input_tokens ?? 0;
+                outputTokens = usage.output_tokens ?? 0;
+            }
+        }
+        if (r.type === "response_item" && r.payload?.type && TOOL_CALL_SUBTYPES.has(r.payload.type)) {
+            toolCallCount += 1;
+        }
+    }
+    const sessionMeta = records.find((r) => r.type === "session_meta");
+    const startedAt = records.find((r) => r.timestamp)?.timestamp ?? sessionMeta?.payload?.timestamp ?? new Date().toISOString();
+    return {
+        tool: "codex",
+        sessionId,
+        gitUsername: resolveGitUsername(cwd),
+        model,
+        inputTokens,
+        cachedInputTokens,
+        outputTokens,
+        costUsd: null,
+        toolCallCount,
+        startedAt,
+    };
+}
+function readJsonl(path) {
+    return readFileSync(path, "utf-8")
+        .split("\n")
+        .filter((l) => l.trim().length > 0)
+        .map((l) => {
+        try {
+            return JSON.parse(l);
+        }
+        catch {
+            return {};
+        }
+    });
+}
+function findLatestSessionFile(root) {
+    let latestPath;
+    let latestMtime = -Infinity;
+    function walk(dir) {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = join(dir, entry);
+            let stat;
+            try {
+                stat = statSync(fullPath);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isDirectory()) {
+                walk(fullPath);
+            }
+            else if (entry.endsWith(".jsonl") && stat.mtimeMs > latestMtime) {
+                latestMtime = stat.mtimeMs;
+                latestPath = fullPath;
+            }
+        }
+    }
+    walk(root);
+    return latestPath;
+}
+function parseArgs(argv) {
+    const fileIdx = argv.indexOf("--file");
+    if (fileIdx !== -1 && argv[fileIdx + 1]) {
+        return { file: argv[fileIdx + 1] };
+    }
+    return {};
+}
+async function main() {
+    try {
+        const { file } = parseArgs(process.argv.slice(2));
+        const filePath = file ?? findLatestSessionFile(join(homedir(), ".codex", "sessions"));
+        if (!filePath)
+            return;
+        const records = readJsonl(filePath);
+        const sessionMeta = records.find((r) => r.type === "session_meta");
+        const sessionId = sessionMeta?.payload?.id ?? filePath;
+        const cwd = sessionMeta?.payload?.cwd;
+        await reportSession(buildPayload(sessionId, cwd, records));
+    }
+    catch (err) {
+        console.error("[hook-codex]", err instanceof Error ? err.message : err);
+    }
+    finally {
+        process.exit(0);
+    }
+}
+const isMain = import.meta.url.startsWith("file://") &&
+    realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1]);
+if (isMain)
+    void main();

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@jagit/hook-codex",
+  "version": "0.0.0",
+  "type": "module",
+  "bin": {
+    "jagit-hook-codex": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@jagit/agent-reporter": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.3",
+    "vitest": "^2.1.9"
+  }
+}