@respan/cli 0.5.3 → 0.6.1

package/dist/hooks/codex-cli.cjs

@@ -0,0 +1,793 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/hooks/codex-cli.ts
+var fs2 = __toESM(require("node:fs"), 1);
+var os2 = __toESM(require("node:os"), 1);
+var path2 = __toESM(require("node:path"), 1);
+
+// src/hooks/shared.ts
+var fs = __toESM(require("node:fs"), 1);
+var os = __toESM(require("node:os"), 1);
+var path = __toESM(require("node:path"), 1);
+function resolveTracesEndpoint(baseUrl) {
+  const DEFAULT = "https://api.respan.ai/api/v2/traces";
+  if (!baseUrl) return DEFAULT;
+  const normalized = baseUrl.replace(/\/+$/, "");
+  if (normalized.endsWith("/api")) return `${normalized}/v2/traces`;
+  return `${normalized}/api/v2/traces`;
+}
+var _logFile = null;
+var _debug = false;
+function initLogging(logFile, debug2) {
+  _logFile = logFile;
+  _debug = debug2;
+  const dir = path.dirname(logFile);
+  fs.mkdirSync(dir, { recursive: true });
+}
+function log(level, message) {
+  if (!_logFile) return;
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+  fs.appendFileSync(_logFile, `${ts} [${level}] ${message}
+`);
+}
+function debug(message) {
+  if (_debug) log("DEBUG", message);
+}
+var DEFAULT_BASE_URL = "https://api.respan.ai/api";
+function resolveCredentials() {
+  let apiKey = process.env.RESPAN_API_KEY ?? "";
+  let baseUrl = process.env.RESPAN_BASE_URL ?? DEFAULT_BASE_URL;
+  if (!apiKey) {
+    const credsFile = path.join(os.homedir(), ".respan", "credentials.json");
+    if (fs.existsSync(credsFile)) {
+      try {
+        const creds = JSON.parse(fs.readFileSync(credsFile, "utf-8"));
+        const configFile = path.join(os.homedir(), ".respan", "config.json");
+        let profile = "default";
+        if (fs.existsSync(configFile)) {
+          const cfg = JSON.parse(fs.readFileSync(configFile, "utf-8"));
+          profile = cfg.activeProfile ?? "default";
+        }
+        const cred = creds[profile] ?? {};
+        apiKey = cred.apiKey ?? cred.accessToken ?? "";
+        if (!baseUrl || baseUrl === DEFAULT_BASE_URL) {
+          baseUrl = cred.baseUrl ?? baseUrl;
+        }
+        if (baseUrl && !baseUrl.replace(/\/+$/, "").endsWith("/api")) {
+          baseUrl = baseUrl.replace(/\/+$/, "") + "/api";
+        }
+        if (apiKey) {
+          debug(`Using API key from credentials.json (profile: ${profile})`);
+        }
+      } catch (e) {
+        debug(`Failed to read credentials.json: ${e}`);
+      }
+    }
+  }
+  if (!apiKey) return null;
+  return { apiKey, baseUrl };
+}
+var KNOWN_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "customer_id",
+  "span_name",
+  "workflow_name",
+  "base_url",
+  "project_id"
+]);
+function loadRespanConfig(configPath) {
+  if (!fs.existsSync(configPath)) {
+    return { fields: {}, properties: {} };
+  }
+  try {
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      return { fields: {}, properties: {} };
+    }
+    const fields = {};
+    const properties = {};
+    for (const [k, v] of Object.entries(raw)) {
+      if (KNOWN_CONFIG_KEYS.has(k)) {
+        fields[k] = String(v);
+      } else {
+        properties[k] = String(v);
+      }
+    }
+    return { fields, properties };
+  } catch (e) {
+    debug(`Failed to load config from ${configPath}: ${e}`);
+    return { fields: {}, properties: {} };
+  }
+}
+function loadState(statePath) {
+  if (!fs.existsSync(statePath)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(statePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveState(statePath, state) {
+  const dir = path.dirname(statePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmpPath = statePath + ".tmp." + process.pid;
+  try {
+    fs.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
+    fs.renameSync(tmpPath, statePath);
+  } catch (e) {
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch {
+    }
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+  }
+}
+function acquireLock(lockPath, timeoutMs = 5e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      fs.mkdirSync(lockPath);
+      return () => {
+        try {
+          fs.rmdirSync(lockPath);
+        } catch {
+        }
+      };
+    } catch {
+      const waitMs = Math.min(100, deadline - Date.now());
+      if (waitMs > 0) {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, waitMs);
+      }
+    }
+  }
+  debug("Could not acquire lock within timeout, proceeding without lock");
+  return () => {
+  };
+}
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function parseTimestamp(ts) {
+  try {
+    const d = new Date(ts);
+    return isNaN(d.getTime()) ? null : d;
+  } catch {
+    return null;
+  }
+}
+function latencySeconds(start, end) {
+  const s = parseTimestamp(start);
+  const e = parseTimestamp(end);
+  if (s && e) return (e.getTime() - s.getTime()) / 1e3;
+  return void 0;
+}
+function truncate(text, maxChars = 4e3) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + "\n... (truncated)";
+}
+function addDefaultsToAll(spans) {
+  return spans;
+}
+function resolveSpanFields(config, defaults) {
+  const fields = config?.fields ?? {};
+  return {
+    workflowName: process.env.RESPAN_WORKFLOW_NAME ?? fields.workflow_name ?? defaults.workflowName,
+    spanName: process.env.RESPAN_SPAN_NAME ?? fields.span_name ?? defaults.spanName,
+    customerId: process.env.RESPAN_CUSTOMER_ID ?? fields.customer_id ?? ""
+  };
+}
+function buildMetadata(config, base = {}) {
+  const metadata = { ...base };
+  if (config?.properties) {
+    Object.assign(metadata, config.properties);
+  }
+  const envMetadata = process.env.RESPAN_METADATA;
+  if (envMetadata) {
+    try {
+      const extra = JSON.parse(envMetadata);
+      if (typeof extra === "object" && extra !== null) {
+        Object.assign(metadata, extra);
+      }
+    } catch {
+    }
+  }
+  return metadata;
+}
+function toOtlpValue(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") return { stringValue: value };
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value };
+  }
+  if (typeof value === "boolean") return { boolValue: value };
+  if (Array.isArray(value)) {
+    const values = value.map(toOtlpValue).filter(Boolean);
+    return { arrayValue: { values } };
+  }
+  if (typeof value === "object") {
+    const values = Object.entries(value).map(([k, v]) => {
+      const converted = toOtlpValue(v);
+      return converted ? { key: k, value: converted } : null;
+    }).filter(Boolean);
+    return { kvlistValue: { values } };
+  }
+  return { stringValue: String(value) };
+}
+function toOtlpAttributes(attrs) {
+  const result = [];
+  for (const [key, value] of Object.entries(attrs)) {
+    if (value === null || value === void 0) continue;
+    const converted = toOtlpValue(value);
+    if (converted) result.push({ key, value: converted });
+  }
+  return result;
+}
+function isoToNanos(iso) {
+  const d = new Date(iso);
+  if (isNaN(d.getTime())) return "0";
+  return String(BigInt(d.getTime()) * 1000000n);
+}
+function stringToTraceId(s) {
+  let hash = 0;
+  for (let i = 0; i < s.length; i++) {
+    hash = (hash << 5) - hash + s.charCodeAt(i) | 0;
+  }
+  let hash2 = 0;
+  for (let i = s.length - 1; i >= 0; i--) {
+    hash2 = (hash2 << 7) - hash2 + s.charCodeAt(i) | 0;
+  }
+  const hex1 = (hash >>> 0).toString(16).padStart(8, "0");
+  const hex2 = (hash2 >>> 0).toString(16).padStart(8, "0");
+  const hex3 = (s.length * 2654435761 >>> 0).toString(16).padStart(8, "0");
+  const hex4 = ((hash ^ hash2) >>> 0).toString(16).padStart(8, "0");
+  return (hex1 + hex2 + hex3 + hex4).slice(0, 32);
+}
+function stringToSpanId(s) {
+  let hash = 0;
+  for (let i = 0; i < s.length; i++) {
+    hash = (hash << 5) - hash + s.charCodeAt(i) | 0;
+  }
+  const hex1 = (hash >>> 0).toString(16).padStart(8, "0");
+  let hash2 = 0;
+  for (let i = s.length - 1; i >= 0; i--) {
+    hash2 = (hash2 << 3) - hash2 + s.charCodeAt(i) | 0;
+  }
+  const hex2 = (hash2 >>> 0).toString(16).padStart(8, "0");
+  return (hex1 + hex2).slice(0, 16);
+}
+function toOtlpPayload(spans) {
+  const otlpSpans = spans.map((span) => {
+    const attrs = {};
+    if (span.thread_identifier) attrs["respan.threads.thread_identifier"] = span.thread_identifier;
+    if (span.customer_identifier) attrs["respan.customer_params.customer_identifier"] = span.customer_identifier;
+    if (span.span_workflow_name) attrs["traceloop.workflow.name"] = span.span_workflow_name;
+    if (span.span_path) attrs["traceloop.entity.path"] = span.span_path;
+    const isRoot = !span.span_parent_id;
+    const isLlm = span.span_name.includes(".chat");
+    const isTool = span.span_name.startsWith("Tool:");
+    const isThinking = span.span_name.startsWith("Thinking") || span.span_name === "Reasoning";
+    if (isLlm) {
+      attrs["traceloop.span.kind"] = "task";
+      attrs["llm.request.type"] = "chat";
+    } else if (isTool) {
+      attrs["traceloop.span.kind"] = "tool";
+    } else if (isRoot) {
+      attrs["traceloop.span.kind"] = "workflow";
+    } else if (isThinking) {
+      attrs["traceloop.span.kind"] = "task";
+    }
+    if (span.model) attrs["gen_ai.request.model"] = span.model;
+    if (span.provider_id) attrs["gen_ai.system"] = span.provider_id;
+    if (span.prompt_tokens !== void 0) attrs["gen_ai.usage.prompt_tokens"] = span.prompt_tokens;
+    if (span.completion_tokens !== void 0) attrs["gen_ai.usage.completion_tokens"] = span.completion_tokens;
+    if (span.total_tokens !== void 0) attrs["llm.usage.total_tokens"] = span.total_tokens;
+    if (span.input) attrs["traceloop.entity.input"] = span.input;
+    if (span.output) attrs["traceloop.entity.output"] = span.output;
+    if (span.metadata && Object.keys(span.metadata).length > 0) {
+      attrs["respan.metadata"] = JSON.stringify(span.metadata);
+    }
+    attrs["respan.entity.log_method"] = "ts_tracing";
+    const startNanos = isoToNanos(span.start_time);
+    let endNanos = isoToNanos(span.timestamp);
+    if (startNanos === endNanos && span.latency && span.latency > 0) {
+      const startMs = new Date(span.start_time).getTime();
+      endNanos = String(BigInt(Math.round(startMs + span.latency * 1e3)) * 1000000n);
+    }
+    const otlpSpan = {
+      traceId: stringToTraceId(span.trace_unique_id),
+      spanId: stringToSpanId(span.span_unique_id),
+      name: span.span_name,
+      kind: isLlm ? 3 : 1,
+      // 3=CLIENT (LLM calls), 1=INTERNAL
+      startTimeUnixNano: startNanos,
+      endTimeUnixNano: endNanos,
+      attributes: toOtlpAttributes(attrs),
+      status: { code: 1 }
+      // STATUS_CODE_OK
+    };
+    if (span.span_parent_id) {
+      otlpSpan.parentSpanId = stringToSpanId(span.span_parent_id);
+    }
+    return otlpSpan;
+  });
+  return {
+    resourceSpans: [{
+      resource: {
+        attributes: toOtlpAttributes({
+          "service.name": "respan-cli-hooks"
+        })
+      },
+      scopeSpans: [{
+        scope: { name: "respan-cli-hooks", version: "0.5.3" },
+        spans: otlpSpans
+      }]
+    }]
+  };
+}
+async function sendSpans(spans, apiKey, baseUrl, context) {
+  const url = resolveTracesEndpoint(baseUrl);
+  const headers = {
+    "Authorization": `Bearer ${apiKey}`,
+    "Content-Type": "application/json",
+    "X-Respan-Dogfood": "1"
+    // Anti-recursion: prevent trace loops on ingest
+  };
+  const payload = toOtlpPayload(spans);
+  const body = JSON.stringify(payload);
+  const spanNames = spans.map((s) => s.span_name);
+  debug(`Sending ${spans.length} spans (${body.length} bytes) to ${url} for ${context}: ${spanNames.join(", ")}`);
+  if (_debug) {
+    const debugDir = _logFile ? path.dirname(_logFile) : os.tmpdir();
+    const debugFile = path.join(debugDir, `respan_spans_${context.replace(/\s+/g, "_")}.json`);
+    fs.writeFileSync(debugFile, body);
+    debug(`Dumped OTLP payload to ${debugFile}`);
+  }
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 3e4);
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body,
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      if (response.status < 400) {
+        const text = await response.text();
+        debug(`Sent ${spans.length} spans for ${context} (attempt ${attempt + 1}): ${text.slice(0, 300)}`);
+        return;
+      }
+      if (response.status < 500) {
+        const text = await response.text();
+        log("ERROR", `Spans rejected for ${context}: HTTP ${response.status} - ${text.slice(0, 200)}`);
+        return;
+      }
+      debug(`Server error for ${context} (attempt ${attempt + 1}), retrying...`);
+      await sleep(1e3);
+    } catch (e) {
+      if (attempt < 2) {
+        await sleep(1e3);
+      } else {
+        log("ERROR", `Failed to send spans for ${context}: ${e}`);
+      }
+    }
+  }
+  log("ERROR", `Failed to send ${spans.length} spans for ${context} after 3 attempts`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/hooks/codex-cli.ts
+var STATE_DIR = path2.join(os2.homedir(), ".codex", "state");
+var LOG_FILE = path2.join(STATE_DIR, "respan_hook.log");
+var STATE_FILE = path2.join(STATE_DIR, "respan_state.json");
+var LOCK_PATH = path2.join(STATE_DIR, "respan_hook.lock");
+var DEBUG_MODE = (process.env.CODEX_RESPAN_DEBUG ?? "").toLowerCase() === "true";
+var MAX_CHARS = parseInt(process.env.CODEX_RESPAN_MAX_CHARS ?? "4000", 10) || 4e3;
+initLogging(LOG_FILE, DEBUG_MODE);
+var TOOL_DISPLAY_NAMES = {
+  exec_command: "Shell",
+  apply_patch: "File Edit",
+  web_search: "Web Search"
+};
+function toolDisplayName(name) {
+  return TOOL_DISPLAY_NAMES[name] ?? name;
+}
+function formatToolInput(toolName, args) {
+  if (!args) return "";
+  try {
+    const parsed = typeof args === "string" ? JSON.parse(args) : args;
+    if (toolName === "exec_command" && typeof parsed === "object" && parsed !== null) {
+      const cmd = parsed.cmd ?? "";
+      const workdir = parsed.workdir ?? "";
+      return truncate(workdir ? `[${workdir}] Command: ${cmd}` : `Command: ${cmd}`, MAX_CHARS);
+    }
+    if (toolName === "apply_patch") return truncate(args, MAX_CHARS);
+    if (typeof parsed === "object") return truncate(JSON.stringify(parsed, null, 2), MAX_CHARS);
+  } catch {
+  }
+  return truncate(String(args), MAX_CHARS);
+}
+function formatToolOutput(output) {
+  if (!output) return "";
+  try {
+    const parsed = JSON.parse(output);
+    if (typeof parsed === "object" && parsed !== null && "output" in parsed) {
+      return truncate(String(parsed.output), MAX_CHARS);
+    }
+  } catch {
+  }
+  return truncate(output, MAX_CHARS);
+}
+function parseSession(lines) {
+  const events = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return events;
+}
+function extractTurns(events) {
+  const turns = [];
+  let current = null;
+  for (const event of events) {
+    const evtType = String(event.type ?? "");
+    const payload = event.payload ?? {};
+    const timestamp = String(event.timestamp ?? "");
+    if (evtType === "event_msg") {
+      const msgType = String(payload.type ?? "");
+      if (msgType === "task_started") {
+        current = {
+          turn_id: String(payload.turn_id ?? ""),
+          start_time: timestamp,
+          end_time: "",
+          model: "",
+          cwd: "",
+          user_message: "",
+          assistant_message: "",
+          commentary: [],
+          tool_calls: [],
+          tool_outputs: [],
+          reasoning: false,
+          reasoning_text: "",
+          token_usage: {}
+        };
+      } else if (msgType === "task_complete" && current) {
+        current.end_time = timestamp;
+        turns.push(current);
+        current = null;
+      } else if (msgType === "user_message" && current) {
+        current.user_message = String(payload.message ?? "");
+      } else if (msgType === "agent_message" && current) {
+        const phase = String(payload.phase ?? "");
+        const message = String(payload.message ?? "");
+        if (phase === "final_answer") current.assistant_message = message;
+        else if (phase === "commentary") current.commentary.push(message);
+      } else if (msgType === "token_count" && current) {
+        const info = payload.info ?? {};
+        const lastUsage = info.last_token_usage ?? {};
+        if (Object.keys(lastUsage).length) current.token_usage = lastUsage;
+      }
+    } else if (evtType === "turn_context" && current) {
+      current.model = String(payload.model ?? "");
+      current.cwd = String(payload.cwd ?? "");
+    } else if (evtType === "response_item" && current) {
+      const itemType = String(payload.type ?? "");
+      if (itemType === "function_call" || itemType === "custom_tool_call") {
+        current.tool_calls.push({
+          name: String(payload.name ?? "unknown"),
+          arguments: String(itemType === "custom_tool_call" ? payload.input ?? "" : payload.arguments ?? ""),
+          call_id: String(payload.call_id ?? ""),
+          timestamp
+        });
+      } else if (itemType === "function_call_output" || itemType === "custom_tool_call_output") {
+        current.tool_outputs.push({
+          call_id: String(payload.call_id ?? ""),
+          output: String(payload.output ?? ""),
+          timestamp
+        });
+      } else if (itemType === "reasoning") {
+        if (current) {
+          current.reasoning = true;
+          const summary = String(payload.summary ?? payload.text ?? "");
+          if (summary) current.reasoning_text += (current.reasoning_text ? "\n" : "") + summary;
+        }
+      } else if (itemType === "web_search_call") {
+        const action = payload.action ?? {};
+        const syntheticId = `web_search_${timestamp}`;
+        current.tool_calls.push({
+          name: "web_search",
+          arguments: JSON.stringify({ query: action.query ?? "" }),
+          call_id: syntheticId,
+          timestamp
+        });
+        current.tool_outputs.push({
+          call_id: syntheticId,
+          output: `Search: ${action.query ?? ""}`,
+          timestamp
+        });
+      }
+    }
+  }
+  return turns;
+}
+function createSpans(sessionId, turnNum, turn, config) {
+  const spans = [];
+  const now = nowISO();
+  const startTimeStr = turn.start_time || now;
+  const endTimeStr = turn.end_time || now;
+  const lat = latencySeconds(startTimeStr, endTimeStr);
+  const promptMessages = [];
+  if (turn.user_message) promptMessages.push({ role: "user", content: turn.user_message });
+  const completionMessage = turn.assistant_message ? { role: "assistant", content: turn.assistant_message } : null;
+  const { workflowName, spanName, customerId } = resolveSpanFields(config, {
+    workflowName: "codex-cli",
+    spanName: "codex-cli"
+  });
+  const traceUniqueId = `${sessionId}_turn_${turnNum}`;
+  const threadId = `codexcli_${sessionId}`;
+  const baseMeta = { codex_cli_turn: turnNum };
+  if (turn.cwd) baseMeta.cwd = turn.cwd;
+  if (turn.commentary.length) baseMeta.commentary = turn.commentary.join("\n");
+  const metadata = buildMetadata(config, baseMeta);
+  const usageFields = {};
+  const tu = turn.token_usage;
+  if (Object.keys(tu).length) {
+    const pt = Number(tu.input_tokens ?? 0);
+    const ct = Number(tu.output_tokens ?? 0);
+    usageFields.prompt_tokens = pt;
+    usageFields.completion_tokens = ct;
+    usageFields.total_tokens = Number(tu.total_tokens ?? pt + ct) || pt + ct;
+    const cached = Number(tu.cached_input_tokens ?? 0);
+    if (cached > 0) usageFields.prompt_tokens_details = { cached_tokens: cached };
+    const reasoning = Number(tu.reasoning_output_tokens ?? 0);
+    if (reasoning > 0) metadata.reasoning_tokens = reasoning;
+  }
+  const rootSpanId = `codexcli_${traceUniqueId}_root`;
+  spans.push({
+    trace_unique_id: traceUniqueId,
+    thread_identifier: threadId,
+    customer_identifier: customerId,
+    span_unique_id: rootSpanId,
+    span_name: spanName,
+    span_workflow_name: workflowName,
+    model: turn.model || "gpt-5.4",
+    provider_id: "",
+    span_path: "",
+    input: promptMessages.length ? JSON.stringify(promptMessages) : "",
+    output: turn.assistant_message,
+    timestamp: endTimeStr,
+    start_time: startTimeStr,
+    metadata,
+    ...lat !== void 0 ? { latency: lat } : {}
+  });
+  spans.push({
+    trace_unique_id: traceUniqueId,
+    span_unique_id: `codexcli_${traceUniqueId}_gen`,
+    span_parent_id: rootSpanId,
+    span_name: "openai.chat",
+    span_workflow_name: workflowName,
+    span_path: "openai_chat",
+    model: turn.model || "gpt-5.4",
+    provider_id: "openai",
+    metadata: {},
+    input: promptMessages.length ? JSON.stringify(promptMessages) : "",
+    output: turn.assistant_message,
+    prompt_messages: promptMessages,
+    completion_message: completionMessage,
+    timestamp: endTimeStr,
+    start_time: startTimeStr,
+    ...lat !== void 0 ? { latency: lat } : {},
+    ...usageFields
+  });
+  const reasoningTokens = Number(tu.reasoning_output_tokens ?? 0);
+  if (turn.reasoning || reasoningTokens > 0) {
+    spans.push({
+      trace_unique_id: traceUniqueId,
+      span_unique_id: `codexcli_${traceUniqueId}_reasoning`,
+      span_parent_id: rootSpanId,
+      span_name: "Reasoning",
+      span_workflow_name: workflowName,
+      span_path: "reasoning",
+      provider_id: "",
+      metadata: reasoningTokens > 0 ? { reasoning_tokens: reasoningTokens } : {},
+      input: "",
+      output: turn.reasoning_text || (reasoningTokens > 0 ? `[Reasoning: ${reasoningTokens} tokens]` : "[Reasoning]"),
+      timestamp: endTimeStr,
+      start_time: startTimeStr
+    });
+  }
+  const outputMap = /* @__PURE__ */ new Map();
+  for (const to of turn.tool_outputs) {
+    if (to.call_id) outputMap.set(to.call_id, to);
+  }
+  let toolNum = 0;
+  for (const tc of turn.tool_calls) {
+    toolNum++;
+    const display = toolDisplayName(tc.name);
+    const outputData = outputMap.get(tc.call_id);
+    const toolEnd = outputData?.timestamp ?? endTimeStr;
+    const toolLat = latencySeconds(tc.timestamp, toolEnd);
+    spans.push({
+      trace_unique_id: traceUniqueId,
+      span_unique_id: `codexcli_${traceUniqueId}_tool_${toolNum}`,
+      span_parent_id: rootSpanId,
+      span_name: `Tool: ${display}`,
+      span_workflow_name: workflowName,
+      span_path: `tool_${tc.name.toLowerCase()}`,
+      provider_id: "",
+      metadata: {},
+      input: formatToolInput(tc.name, tc.arguments),
+      output: formatToolOutput(outputData?.output ?? ""),
+      timestamp: toolEnd,
+      start_time: tc.timestamp || startTimeStr,
+      ...toolLat !== void 0 ? { latency: toolLat } : {}
+    });
+  }
+  return addDefaultsToAll(spans);
+}
+function findSessionFile(sessionId) {
+  const sessionsDir = path2.join(os2.homedir(), ".codex", "sessions");
+  if (!fs2.existsSync(sessionsDir)) return null;
+  const walk = (dir) => {
+    const entries = fs2.readdirSync(dir).sort().reverse();
+    for (const entry of entries) {
+      const full = path2.join(dir, entry);
+      if (fs2.statSync(full).isDirectory()) {
+        const result = walk(full);
+        if (result) return result;
+      } else if (entry.endsWith(".jsonl") && entry.includes(sessionId)) {
+        return full;
+      }
+    }
+    return null;
+  };
+  return walk(sessionsDir);
+}
+function findLatestSessionFile() {
+  const sessionsDir = path2.join(os2.homedir(), ".codex", "sessions");
+  if (!fs2.existsSync(sessionsDir)) return null;
+  let latestFile = null;
+  let latestMtime = 0;
+  const walk = (dir) => {
+    for (const entry of fs2.readdirSync(dir)) {
+      const full = path2.join(dir, entry);
+      const stat = fs2.statSync(full);
+      if (stat.isDirectory()) walk(full);
+      else if (entry.endsWith(".jsonl") && stat.mtimeMs > latestMtime) {
+        latestMtime = stat.mtimeMs;
+        latestFile = full;
+      }
+    }
+  };
+  walk(sessionsDir);
+  if (!latestFile) return null;
+  try {
+    const firstLine = fs2.readFileSync(latestFile, "utf-8").split("\n")[0];
+    if (!firstLine) return null;
+    const firstMsg = JSON.parse(firstLine);
+    const payload = firstMsg.payload ?? {};
+    const sessionId = String(payload.id ?? path2.basename(latestFile, ".jsonl"));
+    return { sessionId, sessionFile: latestFile };
+  } catch {
+    return null;
+  }
+}
+async function main() {
+  const scriptStart = Date.now();
+  debug("Codex hook started");
+  if (process.argv.length < 3) {
+    debug("No argument provided (expected JSON payload in argv[2])");
+    process.exit(0);
+  }
+  let payload;
+  try {
+    payload = JSON.parse(process.argv[2]);
+  } catch (e) {
+    debug(`Invalid JSON in argv[2]: ${e}`);
+    process.exit(0);
+  }
+  const eventType = String(payload.type ?? "");
+  if (eventType !== "agent-turn-complete") {
+    debug(`Ignoring event type: ${eventType}`);
+    process.exit(0);
+  }
+  let sessionId = String(payload["thread-id"] ?? "");
+  if (!sessionId) {
+    debug("No thread-id in notify payload");
+    process.exit(0);
+  }
+  debug(`Processing notify: type=${eventType}, session=${sessionId}`);
+  const creds = resolveCredentials();
+  if (!creds) {
+    log("ERROR", "No API key found. Run: respan auth login");
+    process.exit(0);
+  }
+  let sessionFile = findSessionFile(sessionId);
+  if (!sessionFile) {
+    const latest = findLatestSessionFile();
+    if (latest) {
+      sessionId = latest.sessionId;
+      sessionFile = latest.sessionFile;
+    } else {
+      debug("No session file found");
+      process.exit(0);
+    }
+  }
+  const cwd = String(payload.cwd ?? "");
+  const config = cwd ? loadRespanConfig(path2.join(cwd, ".codex", "respan.json")) : null;
+  if (config) debug(`Loaded respan.json config from ${cwd}`);
+  const maxAttempts = 3;
+  let turns = 0;
+  try {
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const unlock = acquireLock(LOCK_PATH);
+      try {
+        const state = loadState(STATE_FILE);
+        const sessionState = state[sessionId] ?? {};
+        const lastTurnCount = Number(sessionState.turn_count ?? 0);
+        const lines = fs2.readFileSync(sessionFile, "utf-8").trim().split("\n");
+        const events = parseSession(lines);
+        const allTurns = extractTurns(events);
+        if (allTurns.length > lastTurnCount) {
+          const newTurns = allTurns.slice(lastTurnCount);
+          for (const turn of newTurns) {
+            turns++;
+            const turnNum = lastTurnCount + turns;
+            const spans = createSpans(sessionId, turnNum, turn, config);
+            await sendSpans(spans, creds.apiKey, creds.baseUrl, `turn_${turnNum}`);
+          }
+          state[sessionId] = {
+            turn_count: lastTurnCount + turns,
+            updated: nowISO()
+          };
+          saveState(STATE_FILE, state);
+        }
+      } finally {
+        unlock?.();
+      }
+      if (turns > 0) break;
+      if (attempt < maxAttempts - 1) {
+        const delay = 500 * (attempt + 1);
+        debug(`No turns processed (attempt ${attempt + 1}/${maxAttempts}), retrying in ${delay}ms...`);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+    const duration = (Date.now() - scriptStart) / 1e3;
+    log("INFO", `Processed ${turns} turns in ${duration.toFixed(1)}s`);
+    if (duration > 180) log("WARN", `Hook took ${duration.toFixed(1)}s (>3min)`);
+  } catch (e) {
+    log("ERROR", `Failed to process session: ${e}`);
+    if (DEBUG_MODE) debug(String(e.stack ?? e));
+  }
+}
+main().catch((e) => {
+  log("ERROR", `Hook crashed: ${e}`);
+  process.exit(1);
+});