@fml-inc/panopticon 0.1.0

package/dist/chunk-QVK6VGCV.js

@@ -0,0 +1,1703 @@
+import {
+  config
+} from "./chunk-K7YUPLES.js";
+
+// src/targets/registry.ts
+var targets = /* @__PURE__ */ new Map();
+function registerTarget(adapter) {
+  if (targets.has(adapter.id)) {
+    throw new Error(`Target "${adapter.id}" is already registered`);
+  }
+  targets.set(adapter.id, adapter);
+}
+function getTarget(id) {
+  return targets.get(id);
+}
+function getTargetOrThrow(id) {
+  const v = targets.get(id);
+  if (!v) {
+    throw new Error(
+      `Unknown target: "${id}". Known: ${[...targets.keys()].join(", ")}`
+    );
+  }
+  return v;
+}
+function allTargets() {
+  return [...targets.values()];
+}
+function targetIds() {
+  return [...targets.keys()];
+}
+
+// src/targets/claude.ts
+import fs2 from "fs";
+import os from "os";
+import path from "path";
+
+// src/scanner/categories.ts
+function defaultToolCategory(_toolName) {
+  return "";
+}
+
+// src/scanner/reader.ts
+import fs from "fs";
+function readNewLines(filePath, fromByteOffset) {
+  let fd;
+  try {
+    fd = fs.openSync(filePath, "r");
+  } catch {
+    return { lines: [], newByteOffset: fromByteOffset };
+  }
+  try {
+    const size = fs.fstatSync(fd).size;
+    if (size <= fromByteOffset) {
+      return { lines: [], newByteOffset: fromByteOffset };
+    }
+    const bytesToRead = size - fromByteOffset;
+    const buf = Buffer.alloc(bytesToRead);
+    fs.readSync(fd, buf, 0, bytesToRead, fromByteOffset);
+    const text = buf.toString("utf-8");
+    const lastNewline = text.lastIndexOf("\n");
+    if (lastNewline === -1) {
+      return { lines: [], newByteOffset: fromByteOffset };
+    }
+    const complete = text.slice(0, lastNewline);
+    const lines = complete.split("\n").filter((l) => l.length > 0);
+    const bytesConsumed = Buffer.byteLength(
+      text.slice(0, lastNewline + 1),
+      "utf-8"
+    );
+    return {
+      lines,
+      newByteOffset: fromByteOffset + bytesConsumed
+    };
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+// src/targets/claude.ts
+var CLAUDE_TOOL_CATEGORIES = {
+  Read: "Read",
+  read_file: "Read",
+  ReadNotebook: "Read",
+  Edit: "Edit",
+  StrReplace: "Edit",
+  MultiEdit: "Edit",
+  Write: "Write",
+  create_file: "Write",
+  NotebookEdit: "Write",
+  Bash: "Bash",
+  Grep: "Grep",
+  Glob: "Glob",
+  list_dir: "Glob",
+  Task: "Task",
+  Agent: "Task",
+  TaskCreate: "Task",
+  TaskUpdate: "Task",
+  Skill: "Tool",
+  WebSearch: "Web",
+  WebFetch: "Web",
+  ToolSearch: "Web"
+};
+function claudeToolCategory(toolName) {
+  const mapped = CLAUDE_TOOL_CATEGORIES[toolName];
+  if (mapped) return mapped;
+  if (toolName.startsWith("mcp__")) return "MCP";
+  if (toolName.toLowerCase().includes("subagent")) return "Task";
+  return defaultToolCategory(toolName);
+}
+var SYSTEM_MESSAGE_PREFIXES = [
+  "This session is being continued",
+  "[Request interrupted",
+  "<task-notification>",
+  "<local-command-",
+  "Stop hook feedback:"
+];
+function isSystemMessage(content) {
+  const trimmed = content.trimStart();
+  return SYSTEM_MESSAGE_PREFIXES.some((p) => trimmed.startsWith(p));
+}
+var CMD_NAME_RE = /<command-name>([^<]+)<\/command-name>/;
+var CMD_ARGS_RE = /<command-args>([^<]*)<\/command-args>/;
+var CMD_MSG_RE = /<command-message>([^<]+)<\/command-message>/;
+var CMD_STRIP_RE = /<\/?(?:command-name|command-message|command-args)>[^<]*<\/(?:command-name|command-message|command-args)>|<\/?(?:command-name|command-message|command-args)>/g;
+function extractCommandText(content) {
+  const trimmed = content.replace(/^\uFEFF/, "").trimStart();
+  if (!trimmed.startsWith("<command-message>") && !trimmed.startsWith("<command-name>")) {
+    return [content, false];
+  }
+  const stripped = trimmed.replace(CMD_STRIP_RE, "");
+  if (stripped.trim() !== "") {
+    return [content, false];
+  }
+  const nameMatch = CMD_NAME_RE.exec(content);
+  if (!nameMatch) {
+    const msgMatch = CMD_MSG_RE.exec(content);
+    if (msgMatch) return [`/${msgMatch[1]}`, true];
+    return [content, false];
+  }
+  let name = nameMatch[1];
+  if (!name.startsWith("/")) name = `/${name}`;
+  const argsMatch = CMD_ARGS_RE.exec(content);
+  const args = argsMatch?.[1]?.trim();
+  return [args ? `${name} ${args}` : name, true];
+}
+function extractToolResultTextLength(content) {
+  if (typeof content === "string") return content.length;
+  if (Array.isArray(content)) {
+    let len = 0;
+    for (const b of content) {
+      if (typeof b === "object" && b !== null && b.type === "text") {
+        const text = b.text;
+        if (typeof text === "string") len += text.length;
+      }
+    }
+    return len;
+  }
+  return 0;
+}
+var FORK_THRESHOLD = 3;
+function hasDAGFork(entries) {
+  for (let i = 1; i < entries.length; i++) {
+    if (entries[i].parentUuid !== entries[i - 1].uuid) return true;
+  }
+  return false;
+}
+function detectForks(entries, sessionId) {
+  const children = /* @__PURE__ */ new Map();
+  const roots = [];
+  const uuidSet = /* @__PURE__ */ new Set();
+  for (let i = 0; i < entries.length; i++) {
+    const e = entries[i];
+    uuidSet.add(e.uuid);
+    if (!e.parentUuid) {
+      roots.push(i);
+    } else {
+      const kids = children.get(e.parentUuid) ?? [];
+      kids.push(i);
+      children.set(e.parentUuid, kids);
+    }
+  }
+  if (roots.length !== 1) {
+    return { mainDagIndices: entries.map((_, i) => i), forkBranches: [] };
+  }
+  for (const e of entries) {
+    if (e.parentUuid && !uuidSet.has(e.parentUuid)) {
+      return { mainDagIndices: entries.map((_, i) => i), forkBranches: [] };
+    }
+  }
+  const forkBranches = [];
+  function countUserTurns(startIdx) {
+    const stack = [startIdx];
+    let count = 0;
+    while (stack.length > 0) {
+      const idx = stack.pop();
+      if (entries[idx].type === "user") count++;
+      for (const k of children.get(entries[idx].uuid) ?? []) stack.push(k);
+    }
+    return count;
+  }
+  function walkBranch(startIdx, ownerId) {
+    const pathIndices = [];
+    let current = startIdx;
+    while (current !== null) {
+      pathIndices.push(current);
+      const kids = children.get(entries[current].uuid) ?? [];
+      if (kids.length === 0) {
+        current = null;
+      } else if (kids.length === 1) {
+        current = kids[0];
+      } else {
+        const firstChildTurns = countUserTurns(kids[0]);
+        if (firstChildTurns <= FORK_THRESHOLD) {
+          current = kids[kids.length - 1];
+        } else {
+          for (let k = 1; k < kids.length; k++) {
+            const branchIndices = walkBranch(kids[k], ownerId);
+            forkBranches.push({
+              parentId: ownerId,
+              dagIndices: branchIndices
+            });
+          }
+          current = kids[0];
+        }
+      }
+    }
+    return pathIndices;
+  }
+  const mainDagIndices = walkBranch(roots[0], sessionId);
+  return { mainDagIndices, forkBranches };
+}
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var CLAUDE_DIR = path.join(os.homedir(), ".claude");
+var claude = {
+  id: "claude",
+  config: {
+    dir: CLAUDE_DIR,
+    configPath: path.join(CLAUDE_DIR, "settings.json"),
+    configFormat: "json"
+  },
+  hooks: {
+    // Claude Code uses plugin marketplace, not direct hook registration.
+    // Marketplace setup is handled separately in the install command;
+    // this method handles the settings.json portion only.
+    events: [],
+    applyInstallConfig(existing, _opts) {
+      const settings = { ...existing };
+      settings.extraKnownMarketplaces = settings.extraKnownMarketplaces ?? {};
+      settings.extraKnownMarketplaces["local-plugins"] = {
+        source: { source: "directory", path: config.marketplaceDir }
+      };
+      settings.enabledPlugins = settings.enabledPlugins ?? {};
+      settings.enabledPlugins["panopticon@local-plugins"] = true;
+      const hooks = settings.hooks;
+      if (hooks) {
+        for (const event of Object.keys(hooks)) {
+          const entries = hooks[event];
+          if (!Array.isArray(entries)) continue;
+          hooks[event] = entries.filter(
+            (h) => !(typeof h === "object" && h !== null && JSON.stringify(h).includes("hook-handler"))
+          );
+          if (hooks[event].length === 0) delete hooks[event];
+        }
+        if (Object.keys(hooks).length === 0) delete settings.hooks;
+      }
+      return settings;
+    },
+    removeInstallConfig(existing) {
+      const settings = { ...existing };
+      const marketplaces = settings.extraKnownMarketplaces;
+      if (marketplaces) {
+        delete marketplaces["local-plugins"];
+        if (Object.keys(marketplaces).length === 0)
+          delete settings.extraKnownMarketplaces;
+      }
+      const plugins = settings.enabledPlugins;
+      if (plugins) {
+        delete plugins["panopticon@local-plugins"];
+        delete plugins["fml@local-plugins"];
+        if (Object.keys(plugins).length === 0) delete settings.enabledPlugins;
+      }
+      return settings;
+    }
+  },
+  shellEnv: {
+    envVars(port, proxy) {
+      const vars = [
+        ["CLAUDE_CODE_ENABLE_TELEMETRY", "1"]
+      ];
+      if (proxy) {
+        vars.push([
+          "ANTHROPIC_BASE_URL",
+          `http://localhost:${port}/proxy/anthropic`
+        ]);
+      }
+      return vars;
+    }
+  },
+  events: {
+    // Claude Code already sends canonical event names
+    eventMap: {},
+    formatPermissionResponse({ allow, reason }) {
+      return {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: allow ? "allow" : "deny",
+          permissionDecisionReason: reason
+        }
+      };
+    }
+  },
+  detect: {
+    displayName: "Claude Code",
+    isInstalled: () => fs2.existsSync(CLAUDE_DIR),
+    isConfigured() {
+      try {
+        const settings = JSON.parse(
+          fs2.readFileSync(path.join(CLAUDE_DIR, "settings.json"), "utf-8")
+        );
+        const plugins = settings.enabledPlugins ?? {};
+        return !!plugins["panopticon@local-plugins"] || !!plugins["fml@local-plugins"];
+      } catch {
+        return false;
+      }
+    }
+  },
+  proxy: {
+    upstreamHost: "api.anthropic.com",
+    accumulatorType: "anthropic"
+  },
+  otel: {
+    metrics: {
+      metricNames: ["claude_code.token.usage"],
+      aggregation: "SUM",
+      tokenTypeAttrs: ["$.type"],
+      modelAttrs: ["$.model"]
+    }
+  },
+  ident: {
+    modelPatterns: [/^claude-/]
+  },
+  scanner: {
+    normalizeToolCategory: claudeToolCategory,
+    discover() {
+      const projectsDir = path.join(CLAUDE_DIR, "projects");
+      const files = [];
+      const safeReaddir = (d) => {
+        try {
+          return fs2.readdirSync(d);
+        } catch {
+          return [];
+        }
+      };
+      const safeIsDir = (d) => {
+        try {
+          return fs2.statSync(d).isDirectory();
+        } catch {
+          return false;
+        }
+      };
+      try {
+        for (const slug of fs2.readdirSync(projectsDir)) {
+          const slugDir = path.join(projectsDir, slug);
+          if (!safeIsDir(slugDir)) continue;
+          for (const entry of fs2.readdirSync(slugDir)) {
+            const entryPath = path.join(slugDir, entry);
+            if (entry.endsWith(".jsonl")) {
+              files.push({ filePath: entryPath });
+            }
+            if (safeIsDir(entryPath)) {
+              const subagentsDir = path.join(entryPath, "subagents");
+              for (const sub of safeReaddir(subagentsDir)) {
+                if (sub.endsWith(".jsonl")) {
+                  files.push({
+                    filePath: path.join(subagentsDir, sub)
+                  });
+                }
+              }
+            }
+          }
+        }
+      } catch {
+      }
+      return files;
+    },
+    parseFile(filePath, fromByteOffset) {
+      const { lines, newByteOffset } = readNewLines(filePath, fromByteOffset);
+      if (lines.length === 0) return null;
+      const fileUuid = path.basename(filePath, ".jsonl");
+      const isSubagentPath = filePath.includes("/subagents/");
+      let meta;
+      const turns = [];
+      const events = [];
+      const messages = [];
+      let turnIndex = 0;
+      let ordinal = 0;
+      let firstPrompt;
+      const subagentMap = /* @__PURE__ */ new Map();
+      const orphanedToolResults = /* @__PURE__ */ new Map();
+      const dagEntries = [];
+      const msgLineIdx = [];
+      const turnLineIdx = [];
+      for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const line = lines[lineIdx];
+        let obj;
+        try {
+          obj = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const type = obj.type;
+        const sessionId = obj.sessionId;
+        const agentId = obj.agentId;
+        const tsMs = obj.timestamp ? new Date(obj.timestamp).getTime() : Date.now();
+        const uuid = obj.uuid;
+        const parentUuid = obj.parentUuid;
+        if (uuid && (type === "user" || type === "assistant")) {
+          dagEntries.push({
+            uuid,
+            parentUuid: parentUuid ?? "",
+            type,
+            lineIndex: lineIdx,
+            timestampMs: tsMs
+          });
+        }
+        if (!meta && sessionId) {
+          const common = {
+            cliVersion: obj.version,
+            cwd: obj.cwd,
+            startedAtMs: tsMs
+          };
+          if (agentId) {
+            meta = {
+              sessionId: `agent-${agentId}`,
+              parentSessionId: sessionId,
+              relationshipType: "subagent",
+              ...common
+            };
+          } else if (!isSubagentPath && UUID_RE.test(fileUuid) && sessionId !== fileUuid) {
+            meta = {
+              sessionId: fileUuid,
+              parentSessionId: sessionId,
+              relationshipType: "continuation",
+              ...common
+            };
+          } else {
+            meta = { sessionId, ...common };
+          }
+        }
+        const sid = meta?.sessionId ?? sessionId ?? "";
+        if (type === "user") {
+          const msg = obj.message;
+          const content = msg?.content;
+          let preview;
+          const textParts = [];
+          const toolResults = /* @__PURE__ */ new Map();
+          if (typeof content === "string") {
+            preview = content.slice(0, 200);
+            textParts.push(content);
+          } else if (Array.isArray(content)) {
+            for (const block of content) {
+              if (typeof block !== "object" || block === null) continue;
+              const b = block;
+              if (b.type === "text" && typeof b.text === "string") {
+                textParts.push(b.text);
+              } else if (b.type === "tool_result") {
+                const textLen = extractToolResultTextLength(b.content);
+                const raw = typeof b.content === "string" ? b.content : JSON.stringify(b.content ?? "");
+                toolResults.set(b.tool_use_id, {
+                  contentLength: textLen,
+                  contentRaw: raw,
+                  timestampMs: tsMs
+                });
+              }
+            }
+            if (textParts.length > 0) {
+              preview = textParts[0].slice(0, 200);
+            }
+          }
+          if (!firstPrompt && preview) firstPrompt = preview;
+          let fullContent = textParts.join("\n");
+          const isMeta = obj.isMeta === true;
+          const isCompact = obj.isCompactSummary === true;
+          if (isMeta || isCompact) {
+          } else if (fullContent.length === 0 && toolResults.size > 0) {
+            for (const [id, result] of toolResults) {
+              orphanedToolResults.set(id, result);
+            }
+          } else if (fullContent.length > 0) {
+            const [converted, wasCommand] = extractCommandText(fullContent);
+            if (wasCommand) {
+              fullContent = converted;
+            }
+            const isSystem = isSystemMessage(fullContent);
+            messages.push({
+              sessionId: sid,
+              ordinal: ordinal++,
+              role: "user",
+              content: fullContent,
+              timestampMs: tsMs,
+              hasThinking: false,
+              hasToolUse: false,
+              isSystem,
+              contentLength: fullContent.length,
+              hasContextTokens: false,
+              hasOutputTokens: false,
+              uuid,
+              parentUuid: parentUuid ?? void 0,
+              toolCalls: [],
+              toolResults
+            });
+            msgLineIdx.push(lineIdx);
+          }
+          turns.push({
+            sessionId: sid,
+            turnIndex: turnIndex++,
+            timestampMs: tsMs,
+            role: "user",
+            contentPreview: preview,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+            reasoningTokens: 0
+          });
+          turnLineIdx.push(lineIdx);
+        }
+        if (type === "assistant") {
+          const msg = obj.message;
+          const usage = msg?.usage;
+          const model = msg?.model;
+          if (meta && model && !meta.model) meta.model = model;
+          const textParts = [];
+          let hasThinking = false;
+          let hasToolUse = false;
+          const toolCalls = [];
+          const content = msg?.content;
+          if (Array.isArray(content)) {
+            for (const block of content) {
+              if (typeof block !== "object" || block === null) continue;
+              const b = block;
+              if (b.type === "text" && typeof b.text === "string") {
+                textParts.push(b.text);
+              }
+              if (b.type === "thinking") {
+                hasThinking = true;
+                if (typeof b.thinking === "string") {
+                  textParts.push(`[Thinking]
+${b.thinking}
+[/Thinking]`);
+                }
+                events.push({
+                  sessionId: sid,
+                  eventType: "thinking",
+                  timestampMs: tsMs,
+                  content: typeof b.thinking === "string" ? b.thinking.slice(0, 2e3) : void 0,
+                  metadata: {
+                    has_signature: !!b.signature
+                  }
+                });
+              }
+              if (b.type === "tool_use") {
+                hasToolUse = true;
+                const toolName = b.name ?? "";
+                const input = b.input;
+                const inputJson = input ? JSON.stringify(input) : void 0;
+                let skillName;
+                if (toolName === "Skill" && input) {
+                  skillName = input.skill ?? input.name;
+                }
+                toolCalls.push({
+                  toolUseId: b.id ?? "",
+                  toolName,
+                  category: claudeToolCategory(toolName),
+                  inputJson,
+                  skillName,
+                  timestampMs: tsMs
+                });
+                events.push({
+                  sessionId: sid,
+                  eventType: "tool_call",
+                  timestampMs: tsMs,
+                  toolName,
+                  toolInput: inputJson?.slice(0, 1e4),
+                  metadata: { tool_use_id: b.id }
+                });
+              }
+            }
+          }
+          const fullContent = textParts.join("\n");
+          const inputTokens = usage?.input_tokens ?? 0;
+          const outTokens = usage?.output_tokens ?? 0;
+          const cacheRead = usage?.cache_read_input_tokens ?? 0;
+          const cacheCreation = usage?.cache_creation_input_tokens ?? 0;
+          const ctxTokens = inputTokens + cacheRead + cacheCreation;
+          const hasCtx = inputTokens > 0 || cacheRead > 0 || cacheCreation > 0;
+          messages.push({
+            sessionId: sid,
+            ordinal: ordinal++,
+            role: "assistant",
+            content: fullContent,
+            timestampMs: tsMs,
+            hasThinking,
+            hasToolUse,
+            isSystem: false,
+            contentLength: fullContent.length,
+            model,
+            tokenUsage: usage ? JSON.stringify(usage) : void 0,
+            contextTokens: hasCtx ? ctxTokens : void 0,
+            outputTokens: outTokens > 0 ? outTokens : void 0,
+            hasContextTokens: hasCtx,
+            hasOutputTokens: outTokens > 0,
+            uuid,
+            parentUuid: parentUuid ?? void 0,
+            toolCalls,
+            toolResults: /* @__PURE__ */ new Map()
+          });
+          msgLineIdx.push(lineIdx);
+          turns.push({
+            sessionId: sid,
+            turnIndex: turnIndex++,
+            timestampMs: tsMs,
+            model,
+            role: "assistant",
+            inputTokens,
+            outputTokens: outTokens,
+            cacheReadTokens: cacheRead,
+            cacheCreationTokens: cacheCreation,
+            reasoningTokens: 0
+          });
+          turnLineIdx.push(lineIdx);
+        }
+        if (type === "user") {
+          const msg = obj.message;
+          const content = msg?.content;
+          if (Array.isArray(content)) {
+            for (const block of content) {
+              if (typeof block !== "object" || block === null) continue;
+              const b = block;
+              if (b.type === "tool_result") {
+                const resultContent = b.content;
+                events.push({
+                  sessionId: sid,
+                  eventType: "tool_result",
+                  timestampMs: tsMs,
+                  toolOutput: typeof resultContent === "string" ? resultContent.slice(0, 500) : void 0,
+                  metadata: {
+                    tool_use_id: b.tool_use_id,
+                    is_error: b.is_error
+                  }
+                });
+              }
+              if (b.type === "image") {
+                const src = b.source;
+                events.push({
+                  sessionId: sid,
+                  eventType: "image",
+                  timestampMs: tsMs,
+                  metadata: {
+                    media_type: src?.media_type,
+                    source_type: src?.type
+                  }
+                });
+              }
+            }
+          }
+        }
+        if (type === "system") {
+          const data = obj.data;
+          const level = obj.level;
+          const subtype = obj.subtype;
+          if (data?.type === "api_error" || level === "error") {
+            events.push({
+              sessionId: sid,
+              eventType: "error",
+              timestampMs: tsMs,
+              content: typeof data?.message === "string" ? data.message : void 0,
+              metadata: {
+                level,
+                retryAttempt: data?.retryAttempt,
+                maxRetries: data?.maxRetries,
+                retryInMs: data?.retryInMs
+              }
+            });
+          } else if (subtype === "stop_hook_summary" || level === "suggestion") {
+            events.push({
+              sessionId: sid,
+              eventType: subtype ?? "system",
+              timestampMs: tsMs,
+              metadata: {
+                subtype,
+                level,
+                hookCount: obj.hookCount,
+                hookInfos: obj.hookInfos,
+                stopReason: obj.stopReason,
+                preventedContinuation: obj.preventedContinuation
+              }
+            });
+          }
+        }
+        if (type === "file-history-snapshot") {
+          const data = obj.data;
+          const messageId = obj.messageId;
+          events.push({
+            sessionId: sid,
+            eventType: "file_snapshot",
+            timestampMs: tsMs,
+            metadata: { messageId, ...data ?? {} }
+          });
+        }
+        if (type === "progress") {
+          const data = obj.data;
+          const hookEvent = data?.hookEvent;
+          const progressType = data?.type;
+          if (hookEvent || data?.durationMs) {
+            events.push({
+              sessionId: sid,
+              eventType: hookEvent ? `progress:${hookEvent}` : "progress",
+              timestampMs: tsMs,
+              toolName: data?.hookName ?? data?.toolName,
+              metadata: {
+                hookEvent,
+                durationMs: data?.durationMs
+              }
+            });
+          } else if (progressType === "agent_progress") {
+            const tuid = data?.parentToolUseID ?? obj.parentToolUseID;
+            const agentId2 = data?.agentId ?? obj.agentId;
+            if (tuid && agentId2) {
+              subagentMap.set(tuid, `agent-${agentId2}`);
+            }
+            events.push({
+              sessionId: sid,
+              eventType: "agent_progress",
+              timestampMs: tsMs,
+              metadata: {
+                parentToolUseID: tuid,
+                toolUseID: obj.toolUseID
+              }
+            });
+          }
+        }
+        if (type === "queue-operation") {
+          const operation = obj.operation;
+          if (operation === "enqueue" && typeof obj.content === "string") {
+            try {
+              const qc = JSON.parse(obj.content);
+              const tuid = qc.tool_use_id;
+              const taskId = qc.task_id;
+              if (tuid && taskId) {
+                subagentMap.set(tuid, `agent-${taskId}`);
+              }
+            } catch {
+              const tuidMatch = obj.content.match(
+                /<tool-use-id>([^<]+)<\/tool-use-id>/
+              );
+              const taskMatch = obj.content.match(
+                /<task-id>([^<]+)<\/task-id>/
+              );
+              if (tuidMatch?.[1] && taskMatch?.[1]) {
+                subagentMap.set(tuidMatch[1], `agent-${taskMatch[1]}`);
+              }
+            }
+          }
+          events.push({
+            sessionId: sid,
+            eventType: `queue:${operation ?? "unknown"}`,
+            timestampMs: tsMs,
+            content: typeof obj.content === "string" ? obj.content.slice(0, 500) : void 0
+          });
+        }
+        if (type === "last-prompt") {
+          events.push({
+            sessionId: sid,
+            eventType: "last_prompt",
+            timestampMs: tsMs,
+            content: typeof obj.lastPrompt === "string" ? obj.lastPrompt.slice(0, 500) : void 0
+          });
+        }
+      }
+      if (meta && firstPrompt && !meta.firstPrompt)
+        meta.firstPrompt = firstPrompt;
+      if (subagentMap.size > 0) {
+        for (const msg of messages) {
+          for (const tc of msg.toolCalls) {
+            const agentSid = subagentMap.get(tc.toolUseId);
+            if (agentSid && (tc.category === "Task" || tc.toolName === "Agent"))
+              tc.subagentSessionId = agentSid;
+          }
+        }
+      }
+      if (fromByteOffset > 0 && dagEntries.length > 1 && hasDAGFork(dagEntries)) {
+        return {
+          meta,
+          turns: [],
+          events: [],
+          messages: [],
+          newByteOffset: fromByteOffset,
+          // don't advance watermark
+          needsFullReparse: true
+        };
+      }
+      if (fromByteOffset === 0 && meta && dagEntries.length > 1 && hasDAGFork(dagEntries)) {
+        const { mainDagIndices, forkBranches } = detectForks(
+          dagEntries,
+          meta.sessionId
+        );
+        if (forkBranches.length > 0) {
+          const mainLineSet = new Set(
+            mainDagIndices.map((i) => dagEntries[i].lineIndex)
+          );
+          const mainMessages = messages.filter(
+            (_, i) => mainLineSet.has(msgLineIdx[i])
+          );
+          const mainTurns = turns.filter(
+            (_, i) => mainLineSet.has(turnLineIdx[i])
+          );
+          for (let i = 0; i < mainMessages.length; i++) {
+            mainMessages[i] = { ...mainMessages[i], ordinal: i };
+          }
+          for (let i = 0; i < mainTurns.length; i++) {
+            mainTurns[i] = { ...mainTurns[i], turnIndex: i };
+          }
+          const forks = [];
+          for (const branch of forkBranches) {
+            const branchLineSet = new Set(
+              branch.dagIndices.map((i) => dagEntries[i].lineIndex)
+            );
+            const forkUuid = dagEntries[branch.dagIndices[0]].uuid;
+            const forkSessionId = `${meta.sessionId}-${forkUuid}`;
+            const forkStartMs = dagEntries[branch.dagIndices[0]].timestampMs;
+            const forkMessages = messages.filter((_, i) => branchLineSet.has(msgLineIdx[i])).map((m, i) => ({
+              ...m,
+              sessionId: forkSessionId,
+              ordinal: i
+            }));
+            const forkTurns = turns.filter((_, i) => branchLineSet.has(turnLineIdx[i])).map((t, i) => ({
+              ...t,
+              sessionId: forkSessionId,
+              turnIndex: i
+            }));
+            forks.push({
+              meta: {
+                sessionId: forkSessionId,
+                parentSessionId: branch.parentId,
+                relationshipType: "fork",
+                model: meta.model,
+                cwd: meta.cwd,
+                cliVersion: meta.cliVersion,
+                startedAtMs: forkStartMs
+              },
+              turns: forkTurns,
+              events: [],
+              // events stay in main result
+              messages: forkMessages,
+              newByteOffset
+            });
+          }
+          return {
+            meta,
+            turns: mainTurns,
+            events,
+            // all events stay in main
+            messages: mainMessages,
+            newByteOffset,
+            forks,
+            orphanedToolResults: orphanedToolResults.size > 0 ? orphanedToolResults : void 0
+          };
+        }
+      }
+      return {
+        meta,
+        turns,
+        events,
+        messages,
+        newByteOffset,
+        orphanedToolResults: orphanedToolResults.size > 0 ? orphanedToolResults : void 0
+      };
+    }
+  }
+};
+registerTarget(claude);
+
+// src/targets/gemini.ts
+import fs3 from "fs";
+import os2 from "os";
+import path2 from "path";
+var GEMINI_TOOL_CATEGORIES = {
+  read_file: "Read",
+  read_many_files: "Read",
+  write_file: "Write",
+  edit_file: "Edit",
+  run_shell_command: "Bash",
+  shell: "Bash",
+  glob: "Glob",
+  list_directory: "Glob",
+  grep: "Grep",
+  search_files: "Grep",
+  web_search: "Web"
+};
+function geminiToolCategory(toolName) {
+  return GEMINI_TOOL_CATEGORIES[toolName] ?? defaultToolCategory(toolName);
+}
+var GEMINI_DIR = path2.join(os2.homedir(), ".gemini");
+var gemini = {
+  id: "gemini",
+  config: {
+    dir: GEMINI_DIR,
+    configPath: path2.join(GEMINI_DIR, "settings.json"),
+    configFormat: "json"
+  },
+  hooks: {
+    // Gemini's native event names
+    events: ["SessionStart", "BeforeModel", "BeforeTool", "AfterTool"],
+    applyInstallConfig(existing, opts) {
+      const settings = { ...existing };
+      const hookBin = path2.join(opts.pluginRoot, "bin", "hook-handler");
+      const mcpBin = path2.join(opts.pluginRoot, "bin", "mcp-server");
+      const hooks = structuredClone(
+        settings.hooks ?? {}
+      );
+      for (const event of this.events) {
+        hooks[event] = hooks[event] || [];
+        hooks[event] = hooks[event].map((group) => ({
+          ...group,
+          hooks: (group.hooks || []).filter(
+            (h) => !h.command?.includes("panopticon") && !h.path?.includes("panopticon")
+          )
+        })).filter((group) => group.hooks.length > 0);
+        hooks[event].push({
+          hooks: [
+            {
+              type: "command",
+              command: `node ${hookBin} gemini ${opts.port}${opts.proxy ? " --proxy" : ""}`
+            }
+          ]
+        });
+      }
+      settings.hooks = hooks;
+      settings.mcpServers = settings.mcpServers || {};
+      settings.mcpServers.panopticon = {
+        command: "node",
+        args: [mcpBin]
+      };
+      settings.telemetry = settings.telemetry || {};
+      Object.assign(settings.telemetry, {
+        enabled: true,
+        target: "local",
+        otlpProtocol: "http",
+        otlpEndpoint: `http://localhost:${opts.port}`
+      });
+      return settings;
+    },
+    removeInstallConfig(existing) {
+      const settings = { ...existing };
+      const hooks = settings.hooks;
+      if (hooks) {
+        for (const event of Object.keys(hooks)) {
+          hooks[event] = hooks[event].map((group) => ({
+            ...group,
+            hooks: (group.hooks || []).filter(
+              (h) => !h.command?.includes("panopticon") && !h.path?.includes("panopticon")
+            )
+          })).filter((group) => group.hooks.length > 0);
+          if (hooks[event].length === 0) delete hooks[event];
+        }
+        if (Object.keys(hooks).length === 0) delete settings.hooks;
+      }
+      delete settings.hooksConfig;
+      const servers = settings.mcpServers;
+      if (servers) {
+        delete servers.panopticon;
+        if (Object.keys(servers).length === 0) delete settings.mcpServers;
+      }
+      delete settings.telemetry;
+      return settings;
+    }
+  },
+  shellEnv: {
+    envVars(port) {
+      return [
+        ["GEMINI_TELEMETRY_ENABLED", "true"],
+        ["GEMINI_TELEMETRY_TARGET", "local"],
+        ["GEMINI_TELEMETRY_USE_COLLECTOR", "true"],
+        ["GEMINI_TELEMETRY_OTLP_ENDPOINT", `http://localhost:${port}`],
+        ["GEMINI_TELEMETRY_OTLP_PROTOCOL", "http"],
+        ["GEMINI_TELEMETRY_LOG_PROMPTS", "true"]
+      ];
+    }
+  },
+  events: {
+    eventMap: {
+      BeforeTool: "PreToolUse",
+      AfterTool: "PostToolUse",
+      BeforeModel: "UserPromptSubmit"
+    },
+    normalizePayload(data) {
+      const messages = data.llm_request;
+      if (messages?.messages && Array.isArray(messages.messages)) {
+        const lastUser = [...messages.messages].reverse().find((m) => m.role === "user");
+        if (lastUser?.content) {
+          const text = typeof lastUser.content === "string" ? lastUser.content : Array.isArray(lastUser.content) ? lastUser.content.filter((p) => p.type === "text").map((p) => p.text).join("\n") : "";
+          if (text) {
+            data.user_prompt = text;
+          }
+        }
+      }
+      return data;
+    },
+    formatPermissionResponse({ allow, reason }) {
+      return { decision: allow ? "allow" : "deny", reason };
+    }
+  },
+  detect: {
+    displayName: "Gemini CLI",
+    isInstalled: () => fs3.existsSync(GEMINI_DIR),
+    isConfigured() {
+      try {
+        const settings = JSON.parse(
+          fs3.readFileSync(path2.join(GEMINI_DIR, "settings.json"), "utf-8")
+        );
+        return !!settings.telemetry?.enabled;
+      } catch {
+        return false;
+      }
+    }
+  },
+  proxy: {
+    upstreamHost: "generativelanguage.googleapis.com",
+    accumulatorType: "openai"
+  },
+  otel: {
+    serviceName: "gemini-cli",
+    metrics: {
+      metricNames: ["gemini_cli.token.usage", "gen_ai.client.token.usage"],
+      aggregation: "MAX",
+      tokenTypeAttrs: ['$."gen_ai.token.type"'],
+      modelAttrs: ['$."gen_ai.response.model"']
+    }
+  },
+  scanner: {
+    normalizeToolCategory: geminiToolCategory,
+    discover() {
+      const tmpDir = path2.join(GEMINI_DIR, "tmp");
+      const files = [];
+      const safeReaddir = (d) => {
+        try {
+          return fs3.readdirSync(d);
+        } catch {
+          return [];
+        }
+      };
+      for (const project of safeReaddir(tmpDir)) {
+        const chatsDir = path2.join(tmpDir, project, "chats");
+        for (const entry of safeReaddir(chatsDir)) {
+          if (entry.startsWith("session-") && entry.endsWith(".json"))
+            files.push({ filePath: path2.join(chatsDir, entry) });
+        }
+      }
+      return files;
+    },
+    parseFile(filePath, fromByteOffset) {
+      let size;
+      try {
+        size = fs3.statSync(filePath).size;
+      } catch {
+        return null;
+      }
+      if (size <= fromByteOffset) return null;
+      let session;
+      try {
+        session = JSON.parse(fs3.readFileSync(filePath, "utf-8"));
+      } catch {
+        return null;
+      }
+      const sessionId = session.sessionId;
+      if (!sessionId) return null;
+      const messages = session.messages;
+      if (!messages?.length) return null;
+      const meta = {
+        sessionId,
+        startedAtMs: session.startTime ? new Date(session.startTime).getTime() : void 0
+      };
+      const turns = [];
+      const events = [];
+      const parsedMessages = [];
+      let turnIndex = 0;
+      let ordinal = 0;
+      let firstPrompt;
+      for (const msg of messages) {
+        const type = msg.type;
+        const timestamp = msg.timestamp;
+        const timestampMs = timestamp ? new Date(timestamp).getTime() : Date.now();
+        if (type === "user") {
+          const content = msg.content;
+          const textParts = [];
+          if (content) {
+            for (const block of content) {
+              if (block.text) textParts.push(block.text);
+            }
+          }
+          const fullContent = textParts.join("\n");
+          const preview = textParts[0]?.slice(0, 200);
+          if (!firstPrompt && preview) firstPrompt = preview;
+          turns.push({
+            sessionId,
+            turnIndex: turnIndex++,
+            timestampMs,
+            role: "user",
+            contentPreview: preview,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+            reasoningTokens: 0
+          });
+          if (fullContent.length > 0) {
+            parsedMessages.push({
+              sessionId,
+              ordinal: ordinal++,
+              role: "user",
+              content: fullContent,
+              timestampMs,
+              hasThinking: false,
+              hasToolUse: false,
+              isSystem: false,
+              contentLength: fullContent.length,
+              hasContextTokens: false,
+              hasOutputTokens: false,
+              toolCalls: [],
+              toolResults: /* @__PURE__ */ new Map()
+            });
+          }
+        }
+        if (type === "gemini") {
+          const model = msg.model;
+          const tokens = msg.tokens;
+          if (model && !meta.model) meta.model = model;
+          const inputTokens = tokens?.input ?? 0;
+          const outTokens = tokens?.output ?? 0;
+          const cacheRead = tokens?.cached ?? 0;
+          const reasoning = tokens?.thoughts ?? 0;
+          turns.push({
+            sessionId,
+            turnIndex: turnIndex++,
+            timestampMs,
+            model,
+            role: "assistant",
+            contentPreview: typeof msg.content === "string" ? msg.content.slice(0, 200) : void 0,
+            inputTokens,
+            outputTokens: outTokens,
+            cacheReadTokens: cacheRead,
+            cacheCreationTokens: 0,
+            reasoningTokens: reasoning
+          });
+          const textParts = [];
+          if (typeof msg.content === "string") textParts.push(msg.content);
+          const msgToolCalls = msg.toolCalls;
+          const toolCalls = [];
+          const toolResults = /* @__PURE__ */ new Map();
+          if (msgToolCalls) {
+            for (let tcIdx = 0; tcIdx < msgToolCalls.length; tcIdx++) {
+              const tc = msgToolCalls[tcIdx];
+              const toolName = tc.name ?? tc.displayName ?? "";
+              const inputJson = tc.args ? JSON.stringify(tc.args) : void 0;
+              const toolUseId = tc.id || `${toolName}-${timestampMs}-${tcIdx}`;
+              toolCalls.push({
+                toolUseId,
+                toolName,
+                category: geminiToolCategory(toolName),
+                inputJson
+              });
+              const result = tc.result;
+              const fnResponse = result?.[0]?.functionResponse;
+              const responseObj = fnResponse?.response;
+              const output = typeof responseObj?.output === "string" ? responseObj.output : fnResponse ? JSON.stringify(fnResponse) : void 0;
+              if (output) {
+                toolResults.set(toolUseId, {
+                  contentLength: output.length,
+                  contentRaw: output
+                });
+              }
+              events.push({
+                sessionId,
+                eventType: "tool_call",
+                timestampMs,
+                toolName,
+                toolInput: inputJson?.slice(0, 1e3),
+                toolOutput: output?.slice(0, 1e3)
+              });
+            }
+          }
+          let hasThinking = false;
+          const thoughts = msg.thoughts;
+          if (thoughts) {
+            hasThinking = true;
+            for (const t of thoughts) {
+              const text = t.description ?? t.subject;
+              if (text) textParts.push(`[Thinking]
+${text}
+[/Thinking]`);
+              events.push({
+                sessionId,
+                eventType: "reasoning",
+                timestampMs,
+                content: text?.slice(0, 500)
+              });
+            }
+          }
+          const fullContent = textParts.join("\n");
+          const ctxTokens = inputTokens + cacheRead;
+          const hasCtx = inputTokens > 0 || cacheRead > 0;
+          parsedMessages.push({
+            sessionId,
+            ordinal: ordinal++,
+            role: "assistant",
+            content: fullContent,
+            timestampMs,
+            hasThinking,
+            hasToolUse: toolCalls.length > 0,
+            isSystem: false,
+            contentLength: fullContent.length,
+            model,
+            tokenUsage: tokens ? JSON.stringify(tokens) : void 0,
+            contextTokens: hasCtx ? ctxTokens : void 0,
+            outputTokens: outTokens > 0 ? outTokens : void 0,
+            hasContextTokens: hasCtx,
+            hasOutputTokens: outTokens > 0,
+            toolCalls,
+            toolResults
+          });
+        }
+        if (type === "info") {
+          events.push({
+            sessionId,
+            eventType: "info",
+            timestampMs,
+            content: typeof msg.content === "string" ? msg.content.slice(0, 500) : void 0
+          });
+        }
+      }
+      if (firstPrompt) meta.firstPrompt = firstPrompt;
+      return {
+        meta,
+        turns,
+        events,
+        messages: parsedMessages,
+        newByteOffset: size,
+        absoluteIndices: true
+      };
+    }
+  }
+};
+registerTarget(gemini);
+
+// src/targets/codex.ts
+import fs4 from "fs";
+import os3 from "os";
+import path3 from "path";
+var CODEX_TOOL_CATEGORIES = {
+  shell_command: "Bash",
+  shell: "Bash",
+  exec_command: "Bash",
+  write_stdin: "Bash",
+  run_command: "Bash",
+  read_file: "Read",
+  write_file: "Write",
+  create_file: "Write",
+  edit_file: "Edit",
+  list_dir: "Glob",
+  grep_search: "Grep",
+  finder: "Grep",
+  spawn_agent: "Task"
+};
+function codexToolCategory(toolName) {
+  return CODEX_TOOL_CATEGORIES[toolName] ?? defaultToolCategory(toolName);
+}
+var CODEX_SYSTEM_PREFIXES = [
+  "# AGENTS.md",
+  "<environment_context>",
+  "<INSTRUCTIONS>",
+  "<subagent_notification>"
+];
+function isCodexSystemMessage(content) {
+  return CODEX_SYSTEM_PREFIXES.some((p) => content.startsWith(p));
+}
+var CODEX_DIR = path3.join(os3.homedir(), ".codex");
+var CODEX_HOOKS_JSON = path3.join(CODEX_DIR, "hooks.json");
+var HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "Stop"
+];
+function readHooksJson() {
+  try {
+    return JSON.parse(fs4.readFileSync(CODEX_HOOKS_JSON, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeHooksJson(data) {
+  fs4.mkdirSync(CODEX_DIR, { recursive: true });
+  fs4.writeFileSync(CODEX_HOOKS_JSON, `${JSON.stringify(data, null, 2)}
+`);
+}
+var codex = {
+  id: "codex",
+  config: {
+    dir: CODEX_DIR,
+    configPath: path3.join(CODEX_DIR, "config.toml"),
+    configFormat: "toml"
+  },
+  hooks: {
+    events: HOOK_EVENTS,
+    applyInstallConfig(existing, opts) {
+      const codexConfig = { ...existing };
+      const hookBin = path3.join(opts.pluginRoot, "bin", "hook-handler");
+      const mcpBin = path3.join(opts.pluginRoot, "bin", "mcp-server");
+      codexConfig.features = codexConfig.features ?? {};
+      codexConfig.features.codex_hooks = true;
+      codexConfig.suppress_unstable_features_warning = true;
+      delete codexConfig.hooks;
+      const hooksFile = readHooksJson();
+      const hooks = hooksFile.hooks ?? {};
+      const proxyFlag = opts.proxy ? " --proxy" : "";
+      const command = `node ${hookBin} codex ${opts.port}${proxyFlag}`;
+      for (const event of HOOK_EVENTS) {
+        const groups = hooks[event] ?? [];
+        hooks[event] = groups.filter((g) => {
+          const h = g.hooks ?? [];
+          return !h.some(
+            (entry) => entry.command?.includes("panopticon")
+          );
+        });
+        hooks[event].push({
+          hooks: [{ type: "command", command, timeout: 10 }]
+        });
+      }
+      hooksFile.hooks = hooks;
+      writeHooksJson(hooksFile);
+      if (opts.proxy) {
+        codexConfig.openai_base_url = `http://localhost:${opts.port}/proxy/codex`;
+      } else {
+        delete codexConfig.openai_base_url;
+      }
+      delete codexConfig.telemetry;
+      const endpoint = `http://localhost:${opts.port}`;
+      const exporterConfig = { endpoint, protocol: "binary" };
+      codexConfig.otel = {
+        ...codexConfig.otel ?? {},
+        log_user_prompt: true,
+        exporter: { "otlp-http": exporterConfig },
+        trace_exporter: { "otlp-http": exporterConfig },
+        metrics_exporter: { "otlp-http": exporterConfig }
+      };
+      const mcpServers = codexConfig.mcp_servers ?? {};
+      mcpServers.panopticon = { command: "node", args: [mcpBin] };
+      codexConfig.mcp_servers = mcpServers;
+      return codexConfig;
+    },
+    removeInstallConfig(existing) {
+      const cfg = { ...existing };
+      const features = cfg.features;
+      if (features) {
+        delete features.codex_hooks;
+        if (Object.keys(features).length === 0) delete cfg.features;
+      }
+      delete cfg.suppress_unstable_features_warning;
+      delete cfg.hooks;
+      const hooksFile = readHooksJson();
+      const hooks = hooksFile.hooks;
+      if (hooks) {
+        for (const event of Object.keys(hooks)) {
+          hooks[event] = hooks[event].filter((g) => {
+            const h = g.hooks ?? [];
+            return !h.some(
+              (entry) => entry.command?.includes("panopticon")
+            );
+          });
+          if (hooks[event].length === 0) delete hooks[event];
+        }
+        if (Object.keys(hooks).length === 0) {
+          try {
+            fs4.unlinkSync(CODEX_HOOKS_JSON);
+          } catch {
+          }
+        } else {
+          hooksFile.hooks = hooks;
+          writeHooksJson(hooksFile);
+        }
+      }
+      if (typeof cfg.openai_base_url === "string" && cfg.openai_base_url.includes("panopticon")) {
+        delete cfg.openai_base_url;
+      }
+      delete cfg.telemetry;
+      const otel = cfg.otel;
+      if (otel) {
+        delete otel.log_user_prompt;
+        delete otel.exporter;
+        delete otel.trace_exporter;
+        delete otel.metrics_exporter;
+        if (Object.keys(otel).length === 0) delete cfg.otel;
+      }
+      const servers = cfg.mcp_servers;
+      if (servers) {
+        delete servers.panopticon;
+        if (Object.keys(servers).length === 0) delete cfg.mcp_servers;
+      }
+      return cfg;
+    }
+  },
+  shellEnv: {
+    // Codex CLI reads its config from TOML, no shell env vars needed
+    envVars() {
+      return [];
+    }
+  },
+  events: {
+    // Codex uses snake_case but the hook handler already accepts both cases;
+    // no mapping needed since ingest.ts normalizes at storage time
+    eventMap: {},
+    formatPermissionResponse({ allow, reason }) {
+      return {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: allow ? "allow" : "deny",
+          permissionDecisionReason: reason
+        }
+      };
+    }
+  },
+  detect: {
+    displayName: "Codex CLI",
+    isInstalled: () => fs4.existsSync(CODEX_DIR),
+    isConfigured() {
+      try {
+        const content = fs4.readFileSync(CODEX_HOOKS_JSON, "utf-8");
+        return content.includes("panopticon");
+      } catch {
+        return false;
+      }
+    }
+  },
+  otel: {
+    serviceName: "codex_cli_rs",
+    metrics: {
+      metricNames: ["codex.turn.token_usage"],
+      aggregation: "SUM",
+      tokenTypeAttrs: ["$.token_type"],
+      modelAttrs: ["$.model"],
+      tokenTypeMap: {
+        cached_input: "cacheRead",
+        reasoning_output: "output"
+      },
+      excludeTokenTypes: ["total"]
+    },
+    logFields: {
+      eventTypeExprs: ["body", `json_extract(attributes, '$."event.name"')`],
+      timestampMsExprs: [
+        "CAST(timestamp_ns / 1000000 AS INTEGER)",
+        `CAST(strftime('%s', json_extract(attributes, '$."event.timestamp"')) AS INTEGER) * 1000`
+      ]
+    }
+  },
+  ident: {
+    modelPatterns: [/^(gpt-|o[1-9]|chatgpt-)/]
+  },
+  proxy: {
+    upstreamHost(headers) {
+      const auth = headers.authorization ?? "";
+      return auth.startsWith("Bearer eyJ") ? "chatgpt.com" : "api.openai.com";
+    },
+    rewritePath(requestPath, headers) {
+      const auth = headers.authorization ?? "";
+      const isChatGptOAuth = auth.startsWith("Bearer eyJ");
+      return isChatGptOAuth ? `/backend-api/codex${requestPath}` : `/v1${requestPath}`;
+    },
+    accumulatorType: "openai"
+  },
+  scanner: {
+    normalizeToolCategory: codexToolCategory,
+    discover() {
+      const sessionsDir = path3.join(CODEX_DIR, "sessions");
+      const files = [];
+      const safeReaddir = (d) => {
+        try {
+          return fs4.readdirSync(d);
+        } catch {
+          return [];
+        }
+      };
+      for (const year of safeReaddir(sessionsDir)) {
+        for (const month of safeReaddir(path3.join(sessionsDir, year))) {
+          for (const day of safeReaddir(path3.join(sessionsDir, year, month))) {
+            const dayDir = path3.join(sessionsDir, year, month, day);
+            for (const entry of safeReaddir(dayDir)) {
+              if (entry.endsWith(".jsonl"))
+                files.push({ filePath: path3.join(dayDir, entry) });
+            }
+          }
+        }
+      }
+      return files;
+    },
+    parseFile(filePath, fromByteOffset) {
+      const { lines, newByteOffset } = readNewLines(filePath, fromByteOffset);
+      if (lines.length === 0) return null;
+      let meta;
+      const turns = [];
+      const events = [];
+      const messages = [];
+      let turnIndex = 0;
+      let ordinal = 0;
+      let currentModel;
+      let firstPrompt;
+      let pendingToolCalls = [];
+      let pendingAssistantContent = "";
+      const toolResultsByCallId = /* @__PURE__ */ new Map();
+      for (const line of lines) {
+        let obj;
+        try {
+          obj = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const type = obj.type;
+        const timestamp = obj.timestamp;
+        const tsMs = timestamp ? new Date(timestamp).getTime() : Date.now();
+        const payload = obj.payload;
+        if (type === "session_meta" && payload) {
+          meta = {
+            sessionId: payload.id,
+            cwd: payload.cwd,
+            cliVersion: payload.cli_version,
+            startedAtMs: payload.timestamp ? new Date(payload.timestamp).getTime() : tsMs
+          };
+        }
+        if (type === "turn_context" && payload) {
+          currentModel = payload.model;
+          if (meta && currentModel && !meta.model) meta.model = currentModel;
+        }
+        const sid = meta?.sessionId ?? "";
+        if (type === "event_msg" && payload) {
+          const eventType = payload.type;
+          if (eventType === "user_message") {
+            const message = payload.message;
+            if (!firstPrompt && message) firstPrompt = message.slice(0, 200);
+            turns.push({
+              sessionId: sid,
+              turnIndex: turnIndex++,
+              timestampMs: tsMs,
+              model: currentModel,
+              role: "user",
+              contentPreview: message?.slice(0, 200),
+              inputTokens: 0,
+              outputTokens: 0,
+              cacheReadTokens: 0,
+              cacheCreationTokens: 0,
+              reasoningTokens: 0
+            });
+            if (message && !isCodexSystemMessage(message)) {
+              messages.push({
+                sessionId: sid,
+                ordinal: ordinal++,
+                role: "user",
+                content: message,
+                timestampMs: tsMs,
+                hasThinking: false,
+                hasToolUse: false,
+                isSystem: false,
+                contentLength: message.length,
+                hasContextTokens: false,
+                hasOutputTokens: false,
+                toolCalls: [],
+                toolResults: /* @__PURE__ */ new Map()
+              });
+            }
+          }
+          if (eventType === "token_count") {
+            const info = payload.info;
+            if (!info) continue;
+            const lastUsage = info.last_token_usage;
+            if (!lastUsage) continue;
+            const inputTokens = lastUsage.input_tokens ?? 0;
+            const outTokens = lastUsage.output_tokens ?? 0;
+            const cacheRead = lastUsage.cached_input_tokens ?? 0;
+            const reasoning = lastUsage.reasoning_output_tokens ?? 0;
+            const ctxTokens = inputTokens + cacheRead;
+            const hasCtx = inputTokens > 0 || cacheRead > 0;
+            turns.push({
+              sessionId: sid,
+              turnIndex: turnIndex++,
+              timestampMs: tsMs,
+              model: currentModel,
+              role: "assistant",
+              inputTokens,
+              outputTokens: outTokens,
+              cacheReadTokens: cacheRead,
+              cacheCreationTokens: 0,
+              reasoningTokens: reasoning
+            });
+            const toolResults = /* @__PURE__ */ new Map();
+            for (const tc of pendingToolCalls) {
+              const result = toolResultsByCallId.get(tc.toolUseId);
+              if (result) toolResults.set(tc.toolUseId, result);
+            }
+            messages.push({
+              sessionId: sid,
+              ordinal: ordinal++,
+              role: "assistant",
+              content: pendingAssistantContent,
+              timestampMs: tsMs,
+              hasThinking: false,
+              hasToolUse: pendingToolCalls.length > 0,
+              isSystem: false,
+              contentLength: pendingAssistantContent.length,
+              model: currentModel,
+              tokenUsage: JSON.stringify(lastUsage),
+              contextTokens: hasCtx ? ctxTokens : void 0,
+              outputTokens: outTokens > 0 ? outTokens : void 0,
+              hasContextTokens: hasCtx,
+              hasOutputTokens: outTokens > 0,
+              toolCalls: pendingToolCalls,
+              toolResults
+            });
+            pendingToolCalls = [];
+            pendingAssistantContent = "";
+          }
+          if (eventType === "agent_message") {
+            events.push({
+              sessionId: sid,
+              eventType: "agent_message",
+              timestampMs: tsMs,
+              content: payload.message?.slice(0, 500),
+              metadata: { phase: payload.phase }
+            });
+          }
+        }
+        if (type === "response_item") {
+          const p = obj.payload;
+          const itemType = p?.type;
+          if (itemType === "message" || itemType === "text") {
+            const text = p?.text ?? p?.content ?? p?.output_text;
+            if (text) {
+              pendingAssistantContent += (pendingAssistantContent ? "\n" : "") + text;
+            }
+          }
+          if (itemType === "function_call") {
+            const toolName = p?.name ?? "";
+            const callId = p?.call_id ?? "";
+            const inputJson = typeof p?.arguments === "string" ? p.arguments : JSON.stringify(p?.arguments);
+            pendingToolCalls.push({
+              toolUseId: callId,
+              toolName,
+              category: codexToolCategory(toolName),
+              inputJson
+            });
+            events.push({
+              sessionId: sid,
+              eventType: "tool_call",
+              timestampMs: tsMs,
+              toolName,
+              toolInput: inputJson?.slice(0, 1e3),
+              metadata: { call_id: callId }
+            });
+          }
+          if (itemType === "function_call_output") {
+            const callId = p?.call_id ?? "";
+            const output = typeof p?.output === "string" ? p.output : void 0;
+            if (output) {
+              toolResultsByCallId.set(callId, {
+                contentLength: output.length,
+                contentRaw: output
+              });
+            }
+            events.push({
+              sessionId: sid,
+              eventType: "tool_result",
+              timestampMs: tsMs,
+              toolOutput: output?.slice(0, 1e3),
+              metadata: { call_id: callId }
+            });
+          }
+        }
+      }
+      if (meta && firstPrompt && !meta.firstPrompt)
+        meta.firstPrompt = firstPrompt;
+      return { meta, turns, events, messages, newByteOffset };
+    }
+  }
+};
+registerTarget(codex);
+
+export {
+  registerTarget,
+  getTarget,
+  getTargetOrThrow,
+  allTargets,
+  targetIds
+};
+//# sourceMappingURL=chunk-QVK6VGCV.js.map