@ken-jo/agent-connector 0.1.0

package/dist/claude-code-W74MNTAC.js

@@ -0,0 +1,652 @@
+#!/usr/bin/env node
+import {
+  fileMtimeMs,
+  readJsonFile,
+  readJsonlLines
+} from "./chunk-RK6VBLXP.js";
+import {
+  firstExistingRoot,
+  isFile,
+  walkFiles
+} from "./chunk-JWNT5KW7.js";
+import {
+  emptyTokens,
+  inferProvider,
+  normalizeWorkspaceKey,
+  workspaceLabelFromKey
+} from "./chunk-XD7MY6HB.js";
+
+// src/usage/readers/claude-code.ts
+import { basename, dirname, sep } from "path";
+var PLATFORM_ID = "claude-code";
+var DEFAULT_MODEL = "unknown";
+var DEFAULT_PROVIDER = "anthropic";
+var SUBAGENT_FALLBACK = "claude-code-subagent";
+function toNonNegInt(v) {
+  const n = typeof v === "number" ? v : typeof v === "string" ? Number(v) : NaN;
+  if (!Number.isFinite(n)) return 0;
+  return Math.max(0, Math.trunc(n));
+}
+function toIntOrNull(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return Math.trunc(v);
+  if (typeof v === "string") {
+    const n = Number(v);
+    if (Number.isFinite(n)) return Math.trunc(n);
+  }
+  return null;
+}
+function asNonEmptyString(v) {
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+function parseTs(v) {
+  if (typeof v === "string") {
+    const ms = Date.parse(v);
+    if (!Number.isNaN(ms)) return ms;
+    const num = Number(v);
+    if (Number.isFinite(num) && num > 0) return num >= 1e12 ? num : num * 1e3;
+    return null;
+  }
+  if (typeof v === "number" && Number.isFinite(v) && v > 0) {
+    return v >= 1e12 ? v : v * 1e3;
+  }
+  return null;
+}
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function resolveProvider(rawModel, hint) {
+  const canonicalHint = canonicalProvider(hint);
+  if (canonicalHint !== void 0) {
+    if (canonicalHint === "anthropic") {
+      const inferred2 = rawModel !== void 0 ? inferProvider(rawModel) : null;
+      if (inferred2 !== null && inferred2 !== "anthropic") return inferred2;
+      return "anthropic";
+    }
+    return canonicalHint;
+  }
+  if (rawModel === void 0) return DEFAULT_PROVIDER;
+  if (rawModel.trim().includes("/")) {
+    const prefixProvider = canonicalProvider(rawModel);
+    if (prefixProvider !== void 0) return prefixProvider;
+  }
+  const inferred = inferProvider(rawModel);
+  if (inferred !== null) return inferred;
+  return DEFAULT_PROVIDER;
+}
+function canonicalProvider(hint) {
+  if (hint === void 0) return void 0;
+  const trimmed = hint.trim();
+  if (trimmed === "") return void 0;
+  const inferred = inferProvider(trimmed);
+  if (inferred !== null) return inferred;
+  const head = trimmed.split("/")[0];
+  if (head !== void 0 && head !== "") return head.toLowerCase();
+  return void 0;
+}
+function workspaceFromPath(path) {
+  const components = path.split(/[\\/]+/).filter((c) => c !== "");
+  for (let i = 0; i + 2 < components.length; i++) {
+    if (components[i] === ".claude" && components[i + 1] === "projects") {
+      return keyAndLabel(components[i + 2]);
+    }
+  }
+  for (let i = 0; i + 4 < components.length; i++) {
+    if (components[i] === ".cc-mirror" && components[i + 2] === "config" && components[i + 3] === "projects") {
+      return keyAndLabel(components[i + 4]);
+    }
+  }
+  for (let i = components.length - 2; i >= 0; i--) {
+    if (components[i] === "projects") {
+      return keyAndLabel(components[i + 1]);
+    }
+  }
+  return {};
+}
+function keyAndLabel(raw) {
+  if (raw === void 0) return {};
+  const key = normalizeWorkspaceKey(raw);
+  if (key === void 0) return {};
+  const label = workspaceLabelFromKey(key);
+  return label === void 0 ? { projectKey: key } : { projectKey: key, projectLabel: label };
+}
+function stripExt(name) {
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(0, dot) : name;
+}
+function resolveSubagentName(path, parentSessionId, entryAgentId, cache) {
+  const stem = stripExt(basename(path));
+  if (stem === "") return SUBAGENT_FALLBACK;
+  const metaPath = `${dirname(path)}${sep}${stem}.meta.json`;
+  const meta = readJsonFile(metaPath);
+  if (isObject(meta)) {
+    const agentType = asNonEmptyString(meta["agentType"]);
+    if (agentType !== void 0 && agentType.trim() !== "") return agentType;
+  }
+  const lookupAgentId = entryAgentId !== void 0 && entryAgentId.trim() !== "" ? entryAgentId : agentIdFromStem(stem);
+  if (parentSessionId !== void 0 && lookupAgentId !== void 0) {
+    const parentPath = findParentSessionPath(path, parentSessionId);
+    if (parentPath !== void 0) {
+      const subagentType = lookupSubagentTypeInParent(parentPath, lookupAgentId, cache);
+      if (subagentType !== void 0) return subagentType;
+    }
+  }
+  return SUBAGENT_FALLBACK;
+}
+function agentIdFromStem(stem) {
+  if (!stem.startsWith("agent-")) return void 0;
+  const agentStem = stem.slice("agent-".length);
+  if (!agentStem.includes("-")) return agentStem;
+  const trailing = agentStem.slice(agentStem.lastIndexOf("-") + 1);
+  if (trailing !== "" && /^[0-9a-fA-F]+$/.test(trailing)) return trailing;
+  return agentStem;
+}
+function findParentSessionPath(sidechainPath, parentSessionId) {
+  const parentFilename = `${parentSessionId}.jsonl`;
+  const dir = dirname(sidechainPath);
+  if (basename(dir) === "subagents") {
+    const projectDir = dirname(dirname(dir));
+    const candidate = `${projectDir}${sep}${parentFilename}`;
+    if (isFile(candidate)) return candidate;
+  }
+  const flat = `${dir}${sep}${parentFilename}`;
+  if (isFile(flat)) return flat;
+  return void 0;
+}
+function lookupSubagentTypeInParent(parentPath, targetAgentId, cache) {
+  let lookup = cache.get(parentPath);
+  if (lookup === void 0) {
+    lookup = buildParentSubagentLookup(parentPath);
+    cache.set(parentPath, lookup);
+  }
+  return lookup.get(targetAgentId);
+}
+function buildParentSubagentLookup(parentPath) {
+  const out = /* @__PURE__ */ new Map();
+  const toolUseTypes = /* @__PURE__ */ new Map();
+  const agentIdLinks = /* @__PURE__ */ new Map();
+  for (const raw of readJsonlLines(parentPath)) {
+    if (!isObject(raw)) continue;
+    const message = raw["message"];
+    if (!isObject(message)) continue;
+    const content = message["content"];
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      if (!isObject(block)) continue;
+      const blockType = block["type"];
+      if (blockType === "tool_use") {
+        const id = asNonEmptyString(block["id"]);
+        const input = block["input"];
+        const subagentType = isObject(input) ? asNonEmptyString(input["subagent_type"]) : void 0;
+        if (id !== void 0 && subagentType !== void 0) {
+          toolUseTypes.set(id, subagentType);
+        }
+      } else if (blockType === "tool_result") {
+        const toolUseId = asNonEmptyString(block["tool_use_id"]);
+        if (toolUseId === void 0) continue;
+        const resultContent = block["content"];
+        if (!Array.isArray(resultContent)) continue;
+        for (const cb of resultContent) {
+          if (!isObject(cb)) continue;
+          const text = cb["text"];
+          if (typeof text === "string") {
+            const aid = extractAgentIdFromText(text);
+            if (aid !== void 0) {
+              agentIdLinks.set(toolUseId, aid);
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  for (const [toolUseId, agentId] of agentIdLinks) {
+    const subagentType = toolUseTypes.get(toolUseId);
+    if (subagentType !== void 0) out.set(agentId, subagentType);
+  }
+  return out;
+}
+function extractAgentIdFromText(text) {
+  const marker = "agentId: ";
+  const pos = text.indexOf(marker);
+  if (pos < 0) return void 0;
+  const rest = text.slice(pos + marker.length);
+  let end = 0;
+  while (end < rest.length && /[0-9a-zA-Z]/.test(rest[end])) end++;
+  return end > 0 ? rest.slice(0, end) : void 0;
+}
+function extractToolResultUsage(value) {
+  let total = 0;
+  let firstDedupId;
+  const seen = /* @__PURE__ */ new Set();
+  for (const toolResult of collectToolResultValues(value)) {
+    const id = extractToolResultId(toolResult);
+    if (id !== void 0) {
+      if (seen.has(id)) continue;
+      seen.add(id);
+    }
+    if (firstDedupId === void 0 && id !== void 0) firstDedupId = `tool_result:${id}`;
+    total += extractToolResultInputTokens(toolResult);
+  }
+  if (total <= 0) return void 0;
+  return firstDedupId === void 0 ? { inputTokens: total } : { inputTokens: total, dedupId: firstDedupId };
+}
+function collectToolResultValues(value) {
+  const results = [];
+  if (value["type"] === "tool_result") results.push(value);
+  const directTr = value["tool_result"];
+  if (isObject(directTr)) results.push(directTr);
+  const message = value["message"];
+  if (isObject(message)) {
+    const msgTr = message["tool_result"];
+    if (isObject(msgTr)) results.push(msgTr);
+  }
+  const content = isObject(message) ? message["content"] : value["content"];
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (isObject(block) && block["type"] === "tool_result") results.push(block);
+    }
+  }
+  return results;
+}
+function extractToolResultId(tr) {
+  return asNonEmptyString(tr["tool_use_id"]) ?? asNonEmptyString(tr["id"]) ?? asNonEmptyString(tr["tool_result_id"]);
+}
+function extractToolResultInputTokens(tr) {
+  const explicit = explicitToolResultInputTokens(tr);
+  if (explicit !== void 0) return explicit;
+  const chars = toolResultOutputCharCount(tr);
+  return chars > 0 ? Math.ceil(chars / 4) : 0;
+}
+function explicitToolResultInputTokens(tr) {
+  const toolOutput = isObject(tr["tool_output"]) ? tr["tool_output"] : void 0;
+  const usage = isObject(tr["usage"]) ? tr["usage"] : void 0;
+  const toolOutputUsage = toolOutput !== void 0 && isObject(toolOutput["usage"]) ? toolOutput["usage"] : void 0;
+  const candidates = [
+    tr["input_tokens"],
+    tr["token_count"],
+    tr["tokens"],
+    usage?.["input_tokens"],
+    toolOutput?.["input_tokens"],
+    toolOutput?.["token_count"],
+    toolOutput?.["tokens"],
+    toolOutputUsage?.["input_tokens"]
+  ];
+  for (const c of candidates) {
+    const n = toIntOrNull(c);
+    if (n !== null) return Math.max(0, n);
+  }
+  return void 0;
+}
+function toolResultOutputCharCount(tr) {
+  let chars = 0;
+  const toolOutput = tr["tool_output"];
+  if (isObject(toolOutput)) {
+    const output = toolOutput["output"];
+    if (typeof output === "string") chars += [...output].length;
+  }
+  const content = tr["content"];
+  if (typeof content === "string") {
+    chars += [...content].length;
+  } else if (Array.isArray(content)) {
+    for (const block of content) {
+      if (!isObject(block)) continue;
+      const blockToolOutput = block["tool_output"];
+      const blockOutput = isObject(blockToolOutput) ? blockToolOutput["output"] : void 0;
+      const text = typeof blockOutput === "string" ? blockOutput : typeof block["text"] === "string" ? block["text"] : void 0;
+      if (text !== void 0) chars += [...text].length;
+    }
+  }
+  return chars;
+}
+var PC_DEFAULT = 1;
+var PC_INFERRED = 2;
+var PC_EXPLICIT = 3;
+function providerConfidence(rawModel, hint) {
+  const canonicalHint = canonicalProvider(hint);
+  if (canonicalHint !== void 0) {
+    if (canonicalHint === "anthropic") {
+      const inferred = rawModel !== void 0 ? inferProvider(rawModel) : null;
+      if (inferred !== null && inferred !== "anthropic") return PC_INFERRED;
+      return PC_DEFAULT;
+    }
+    return PC_EXPLICIT;
+  }
+  if (rawModel !== void 0) {
+    if (rawModel.trim().includes("/") && canonicalProvider(rawModel) !== void 0) return PC_EXPLICIT;
+    if (inferProvider(rawModel) !== null) return PC_INFERRED;
+  }
+  return 0;
+}
+function parseClaudeFile(path, parentCache) {
+  const fallbackTs = fileMtimeMs(path);
+  const { projectKey, projectLabel } = workspaceFromPath(path);
+  if (path.endsWith(".json")) {
+    const headless = parseHeadlessJson(path, fallbackTs, projectKey, projectLabel);
+    if (headless.length > 0) return headless;
+  }
+  const lines = readJsonlLines(path);
+  if (lines.length === 0) return [];
+  let sessionId = stripExt(basename(path)) || "unknown";
+  const byKey = /* @__PURE__ */ new Map();
+  const ordered = [];
+  let lastModel;
+  let lastProviderHint;
+  let sidechainAgent;
+  let sidechainDetected = false;
+  const headlessState = newHeadlessState();
+  const headlessOut = [];
+  for (let li = 0; li < lines.length; li++) {
+    const value = lines[li];
+    if (!isObject(value)) continue;
+    const rawLine = JSON.stringify(value);
+    const entryType = value["type"];
+    const message = isObject(value["message"]) ? value["message"] : void 0;
+    const entryProviderHint = asNonEmptyString(value["providerId"]) ?? asNonEmptyString(value["provider_id"]) ?? asNonEmptyString(value["provider"]);
+    if (!sidechainDetected) {
+      sidechainDetected = true;
+      if (value["isSidechain"] === true) {
+        const parentId = asNonEmptyString(value["sessionId"]);
+        if (parentId !== void 0) sessionId = parentId;
+        sidechainAgent = resolveSubagentName(
+          path,
+          asNonEmptyString(value["sessionId"]),
+          asNonEmptyString(value["agentId"]),
+          parentCache
+        );
+      }
+    }
+    if (entryType === "user" || entryType === "tool_result") {
+      const tr = extractToolResultUsage(value);
+      if (tr !== void 0) {
+        const rawModel = extractModel(value) ?? (message !== void 0 ? asNonEmptyString(message["model"]) : void 0) ?? lastModel;
+        const providerHint = extractProviderHint(value) ?? (message !== void 0 ? messageProviderHint(message) : void 0) ?? entryProviderHint ?? lastProviderHint;
+        const ts = parseTs(value["timestamp"]) ?? extractClaudeTimestamp(value) ?? fallbackTs;
+        const dedupKey = tr.dedupId !== void 0 ? `claude:tool_result:${sessionId}:${tr.dedupId}` : void 0;
+        if (dedupKey !== void 0) {
+          const existing = byKey.get(dedupKey);
+          if (existing !== void 0) {
+            existing.record.tokens.input = Math.max(existing.record.tokens.input, tr.inputTokens);
+            if (ts >= existing.record.ts) existing.record.ts = ts;
+            continue;
+          }
+        }
+        const tokens = emptyTokens();
+        tokens.input = tr.inputTokens;
+        const record = buildRecord({
+          rawModel,
+          providerHint,
+          sessionId,
+          ts,
+          tokens,
+          messageCount: 0,
+          dedupKey,
+          projectKey,
+          projectLabel,
+          agent: sidechainAgent
+        });
+        const accum = { record, providerConfidence: providerConfidence(rawModel, providerHint) };
+        if (dedupKey !== void 0) byKey.set(dedupKey, accum);
+        ordered.push(accum);
+      }
+      continue;
+    }
+    if (entryType === "assistant") {
+      if (message === void 0) continue;
+      const msgModel = asNonEmptyString(message["model"]);
+      if (msgModel !== void 0) {
+        lastModel = msgModel;
+        lastProviderHint = messageProviderHint(message) ?? entryProviderHint;
+      }
+      const usage = message["usage"];
+      if (!isObject(usage)) continue;
+      const u = usage;
+      const msgId = asNonEmptyString(message["id"]);
+      const reqId = asNonEmptyString(value["requestId"]);
+      const providerHint = messageProviderHint(message) ?? entryProviderHint;
+      let dedupKey;
+      if (msgId !== void 0 && reqId !== void 0) dedupKey = `${msgId}:${reqId}`;
+      else if (msgId !== void 0) dedupKey = `message:${msgId}`;
+      const ts = parseTs(value["timestamp"]) ?? fallbackTs;
+      if (dedupKey !== void 0) {
+        const existing = byKey.get(dedupKey);
+        if (existing !== void 0) {
+          mergeUsageMax(existing.record.tokens, u);
+          if (ts >= existing.record.ts) existing.record.ts = ts;
+          const cand = providerConfidence(msgModel, providerHint);
+          if (cand > existing.providerConfidence) {
+            existing.providerConfidence = cand;
+            existing.record.providerId = resolveProvider(msgModel, providerHint);
+          }
+          continue;
+        }
+      }
+      if (msgModel === void 0) continue;
+      const tokens = emptyTokens();
+      tokens.input = toNonNegInt(u.input_tokens);
+      tokens.output = toNonNegInt(u.output_tokens);
+      tokens.cacheRead = toNonNegInt(u.cache_read_input_tokens);
+      tokens.cacheWrite = toNonNegInt(u.cache_creation_input_tokens);
+      const record = buildRecord({
+        rawModel: msgModel,
+        providerHint,
+        sessionId,
+        ts,
+        tokens,
+        messageCount: 1,
+        dedupKey,
+        projectKey,
+        projectLabel,
+        agent: sidechainAgent
+      });
+      const accum = { record, providerConfidence: providerConfidence(msgModel, providerHint) };
+      if (dedupKey !== void 0) byKey.set(dedupKey, accum);
+      ordered.push(accum);
+      continue;
+    }
+    const completed = processHeadlessLine(value, rawLine, sessionId, headlessState, fallbackTs);
+    if (completed !== void 0) {
+      if (projectKey !== void 0) completed.projectKey = projectKey;
+      if (projectLabel !== void 0) completed.projectLabel = projectLabel;
+      headlessOut.push(completed);
+    }
+  }
+  const finalHeadless = finalizeHeadlessState(headlessState, sessionId, fallbackTs);
+  if (finalHeadless !== void 0) {
+    if (projectKey !== void 0) finalHeadless.projectKey = projectKey;
+    if (projectLabel !== void 0) finalHeadless.projectLabel = projectLabel;
+    headlessOut.push(finalHeadless);
+  }
+  return [...ordered.map((a) => a.record), ...headlessOut];
+}
+function mergeUsageMax(tokens, u) {
+  tokens.input = Math.max(tokens.input, toNonNegInt(u.input_tokens));
+  tokens.output = Math.max(tokens.output, toNonNegInt(u.output_tokens));
+  tokens.cacheRead = Math.max(tokens.cacheRead, toNonNegInt(u.cache_read_input_tokens));
+  tokens.cacheWrite = Math.max(tokens.cacheWrite, toNonNegInt(u.cache_creation_input_tokens));
+}
+function buildRecord(a) {
+  const modelId = a.rawModel !== void 0 && a.rawModel !== "" ? a.rawModel : DEFAULT_MODEL;
+  const record = {
+    platformId: PLATFORM_ID,
+    modelId,
+    providerId: resolveProvider(a.rawModel, a.providerHint),
+    sessionId: a.sessionId,
+    tokens: a.tokens,
+    ts: a.ts,
+    messageCount: a.messageCount,
+    confidence: "host-reported"
+  };
+  if (a.dedupKey !== void 0) record.dedupKey = a.dedupKey;
+  if (a.projectKey !== void 0) record.projectKey = a.projectKey;
+  if (a.projectLabel !== void 0) record.projectLabel = a.projectLabel;
+  if (a.agent !== void 0) record.agent = a.agent;
+  return record;
+}
+function extractModel(value) {
+  const top = asNonEmptyString(value["model"]);
+  if (top !== void 0) return top;
+  const message = value["message"];
+  return isObject(message) ? asNonEmptyString(message["model"]) : void 0;
+}
+function messageProviderHint(message) {
+  return asNonEmptyString(message["providerId"]) ?? asNonEmptyString(message["provider_id"]) ?? asNonEmptyString(message["provider"]);
+}
+function extractProviderHint(value) {
+  const top = asNonEmptyString(value["providerId"]) ?? asNonEmptyString(value["provider_id"]) ?? asNonEmptyString(value["provider"]);
+  if (top !== void 0) return top;
+  const message = value["message"];
+  return isObject(message) ? messageProviderHint(message) : void 0;
+}
+function extractClaudeTimestamp(value) {
+  const direct = parseTs(value["timestamp"]) ?? parseTs(value["created_at"]);
+  if (direct !== null) return direct;
+  const message = value["message"];
+  if (isObject(message)) {
+    const m = parseTs(message["created_at"]);
+    if (m !== null) return m;
+  }
+  return null;
+}
+function newHeadlessState() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, ts: null };
+}
+function resetHeadlessState(s) {
+  s.model = void 0;
+  s.providerHint = void 0;
+  s.input = 0;
+  s.output = 0;
+  s.cacheRead = 0;
+  s.cacheWrite = 0;
+  s.ts = null;
+}
+function parseHeadlessJson(path, fallbackTs, projectKey, projectLabel) {
+  const value = readJsonFile(path);
+  if (!isObject(value)) return [];
+  const record = extractHeadlessMessage(value, "unknown-session", fallbackTs);
+  if (record === void 0) return [];
+  record.sessionId = stripExt(basename(path)) || "unknown";
+  if (projectKey !== void 0) record.projectKey = projectKey;
+  if (projectLabel !== void 0) record.projectLabel = projectLabel;
+  return [record];
+}
+function processHeadlessLine(value, _rawLine, sessionId, state, fallbackTs) {
+  const eventType = typeof value["type"] === "string" ? value["type"] : "";
+  switch (eventType) {
+    case "message_start": {
+      const completed = finalizeHeadlessState(state, sessionId, fallbackTs);
+      state.model = extractModel(value);
+      state.providerHint = extractProviderHint(value);
+      const ts = extractClaudeTimestamp(value);
+      if (ts !== null) state.ts = ts;
+      const message = value["message"];
+      const usage = (isObject(message) && isObject(message["usage"]) ? message["usage"] : void 0) ?? (isObject(value["usage"]) ? value["usage"] : void 0);
+      if (usage !== void 0) updateHeadlessUsage(state, usage);
+      return completed;
+    }
+    case "message_delta": {
+      const delta = value["delta"];
+      const usage = (isObject(value["usage"]) ? value["usage"] : void 0) ?? (isObject(delta) && isObject(delta["usage"]) ? delta["usage"] : void 0);
+      if (usage !== void 0) updateHeadlessUsage(state, usage);
+      return void 0;
+    }
+    case "message_stop":
+      return finalizeHeadlessState(state, sessionId, fallbackTs);
+    default:
+      return extractHeadlessMessage(value, sessionId, fallbackTs);
+  }
+}
+function updateHeadlessUsage(state, usage) {
+  const input = toIntOrNull(usage["input_tokens"]);
+  if (input !== null) state.input = Math.max(state.input, input);
+  const output = toIntOrNull(usage["output_tokens"]);
+  if (output !== null) state.output = Math.max(state.output, output);
+  const cacheRead = toIntOrNull(usage["cache_read_input_tokens"]);
+  if (cacheRead !== null) state.cacheRead = Math.max(state.cacheRead, cacheRead);
+  const cacheWrite = toIntOrNull(usage["cache_creation_input_tokens"]);
+  if (cacheWrite !== null) state.cacheWrite = Math.max(state.cacheWrite, cacheWrite);
+}
+function finalizeHeadlessState(state, sessionId, fallbackTs) {
+  const rawModel = state.model;
+  if (rawModel === void 0) return void 0;
+  if (state.input === 0 && state.output === 0 && state.cacheRead === 0 && state.cacheWrite === 0) {
+    resetHeadlessState(state);
+    return void 0;
+  }
+  const tokens = emptyTokens();
+  tokens.input = Math.max(0, state.input);
+  tokens.output = Math.max(0, state.output);
+  tokens.cacheRead = Math.max(0, state.cacheRead);
+  tokens.cacheWrite = Math.max(0, state.cacheWrite);
+  const record = buildRecord({
+    rawModel,
+    providerHint: state.providerHint,
+    sessionId,
+    ts: state.ts ?? fallbackTs,
+    tokens,
+    messageCount: 1,
+    dedupKey: void 0,
+    projectKey: void 0,
+    projectLabel: void 0,
+    agent: void 0
+  });
+  resetHeadlessState(state);
+  return record;
+}
+function extractHeadlessMessage(value, sessionId, fallbackTs) {
+  const message = value["message"];
+  const usage = (isObject(value["usage"]) ? value["usage"] : void 0) ?? (isObject(message) && isObject(message["usage"]) ? message["usage"] : void 0);
+  if (usage === void 0) return void 0;
+  const rawModel = extractModel(value);
+  if (rawModel === void 0) return void 0;
+  const providerHint = extractProviderHint(value);
+  const ts = extractClaudeTimestamp(value) ?? fallbackTs;
+  const tokens = emptyTokens();
+  tokens.input = Math.max(0, toIntOrNull(usage["input_tokens"]) ?? 0);
+  tokens.output = Math.max(0, toIntOrNull(usage["output_tokens"]) ?? 0);
+  tokens.cacheRead = Math.max(0, toIntOrNull(usage["cache_read_input_tokens"]) ?? 0);
+  tokens.cacheWrite = Math.max(0, toIntOrNull(usage["cache_creation_input_tokens"]) ?? 0);
+  return buildRecord({
+    rawModel,
+    providerHint,
+    sessionId,
+    ts,
+    tokens,
+    messageCount: 1,
+    dedupKey: void 0,
+    projectKey: void 0,
+    projectLabel: void 0,
+    agent: void 0
+  });
+}
+var claudeCodeReader = {
+  platformId: PLATFORM_ID,
+  kind: "local",
+  async read({ sinceMs }) {
+    const root = firstExistingRoot(PLATFORM_ID);
+    if (root === void 0) return [];
+    const files = walkFiles(root, (name) => {
+      if (name.endsWith(".meta.json")) return false;
+      return name.endsWith(".jsonl") || name.endsWith(".json");
+    });
+    const parentCache = /* @__PURE__ */ new Map();
+    const records = [];
+    for (const file of files) {
+      let rows;
+      try {
+        rows = parseClaudeFile(file, parentCache);
+      } catch {
+        continue;
+      }
+      for (const row of rows) {
+        if (sinceMs !== void 0 && row.ts < sinceMs) continue;
+        records.push(row);
+      }
+    }
+    return records;
+  }
+};
+var claude_code_default = claudeCodeReader;
+export {
+  claude_code_default as default
+};
+//# sourceMappingURL=claude-code-W74MNTAC.js.map