@traice/codex-collector 0.1.0

package/collector.mjs

@@ -0,0 +1,932 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { createServer } from 'node:http';
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { gunzipSync } from 'node:zlib';
+
+const DEFAULT_OUT_DIR = '~/.traice/internal-spend-codex';
+const LEGACY_OUT_DIR = '.traice-internal-spend';
+const DEFAULT_INSTALL_CONFIG = `${DEFAULT_OUT_DIR}/install.json`;
+const LEGACY_INSTALL_CONFIG = `${LEGACY_OUT_DIR}/install.json`;
+const DEFAULT_MAX_BATCH_SIZE = 50;
+const MAX_SENT_IDS = 20_000;
+
+const args = parseArgs(process.argv.slice(2));
+loadEnvFile(resolve('apps/web/.env'));
+
+const configPath = args.get('config') ? resolveHome(args.get('config')) : findDefaultInstallConfigPath();
+const outDir = resolveHome(args.get('out') ?? dirname(configPath));
+const installConfig = readJsonIfExists(configPath) ?? {};
+const config = {
+  serverUrl: normalizeUrl(args.get('server-url') ?? installConfig.serverUrl ?? process.env.TRAICE_API_URL ?? 'http://127.0.0.1:3003'),
+  apiKey: readApiKey() ?? installConfig.apiKey ?? process.env.TRAICE_API_KEY,
+  workspaceSlug: args.get('workspace-slug') ?? installConfig.workspaceSlug ?? 'internal-spend-poc',
+  sourceKey: args.get('source-key') ?? installConfig.sourceKey ?? 'codex-local',
+  sourceName: args.get('source-name') ?? installConfig.sourceName ?? 'Codex local collector',
+  sourceKind: args.get('source-kind') ?? installConfig.sourceKind ?? 'codex_otel',
+  tool: args.get('tool') ?? installConfig.tool ?? 'codex',
+  category: args.get('category') ?? installConfig.category ?? 'coding_agent',
+  employeeEmail: args.get('employee-email') ?? installConfig.employeeEmail ?? process.env.TRAICE_EMPLOYEE_EMAIL,
+  employeeName: args.get('employee-name') ?? installConfig.employeeName ?? process.env.TRAICE_EMPLOYEE_NAME,
+  employeeExternalId: args.get('employee-external-id') ?? installConfig.employeeExternalId,
+  teamName: args.get('team-name') ?? installConfig.teamName ?? process.env.TRAICE_TEAM_NAME,
+  teamExternalId: args.get('team-external-id') ?? installConfig.teamExternalId,
+  sourcePrincipal: args.get('source-principal') ?? installConfig.sourcePrincipal,
+  seatMonthlyUsd: parseOptionalMoney(
+    args.get('seat-monthly-usd') ?? installConfig.seatMonthlyUsd ?? process.env.TRAICE_SEAT_MONTHLY_USD,
+  ),
+  codexHome: resolveHome(args.get('codex-home') ?? installConfig.codexHome ?? process.env.CODEX_HOME ?? '~/.codex'),
+  listenHost: args.get('listen-host') ?? installConfig.listenHost ?? '127.0.0.1',
+  listenPort: parsePort(args.get('listen-port') ?? installConfig.listenPort ?? '4318'),
+  pollIntervalMs: parsePositiveInt(args.get('poll-interval-ms') ?? installConfig.pollIntervalMs ?? '3000'),
+  backfillHours: Number(args.get('backfill-hours') ?? installConfig.backfillHours ?? 6),
+  includeZeroOutput: boolArg(args.get('include-zero-output') ?? installConfig.includeZeroOutput, false),
+  maxBatchSize: parsePositiveInt(args.get('max-batch-size') ?? installConfig.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE),
+};
+
+if (!config.apiKey) {
+  console.error(
+    [
+      'Missing collector API key.',
+      'Run: npx @traice/codex-collector@latest install',
+      'Provide the key with TRAICE_API_KEY or --api-key-stdin.',
+    ].join('\n'),
+  );
+  process.exit(2);
+}
+
+mkdirSync(outDir, { recursive: true });
+const rawFile = resolve(outDir, 'requests.ndjson');
+const eventsFile = resolve(outDir, 'events.ndjson');
+const statePath = resolve(outDir, 'collector-state.json');
+const state = loadState(statePath);
+
+const shouldRunOnce = args.get('once') === 'true';
+const sessionTailEnabled = args.get('session-tail') !== 'false';
+const otelListenerEnabled = args.get('otel-listener') !== 'false' && !shouldRunOnce;
+
+if (shouldRunOnce) {
+  const result = sessionTailEnabled ? await scanCodexSessions() : { candidates: 0, sent: 0, files: 0 };
+  saveState(statePath, state);
+  console.log(JSON.stringify({ ok: true, mode: 'once', ...result }, null, 2));
+  process.exit(0);
+}
+
+if (sessionTailEnabled) {
+  scanCodexSessions().catch((error) => {
+    console.error(`[codex-otel] session scan failed: ${error.message}`);
+  });
+  setInterval(() => {
+    scanCodexSessions().catch((error) => {
+      console.error(`[codex-otel] session scan failed: ${error.message}`);
+    });
+  }, config.pollIntervalMs);
+}
+
+if (otelListenerEnabled) {
+  startOtelServer();
+} else if (!sessionTailEnabled) {
+  console.error('Nothing to run: both OTel listener and session tail are disabled.');
+  process.exit(2);
+}
+
+process.on('SIGINT', () => {
+  saveState(statePath, state);
+  process.exit(0);
+});
+process.on('SIGTERM', () => {
+  saveState(statePath, state);
+  process.exit(0);
+});
+
+function startOtelServer() {
+  const server = createServer(async (req, res) => {
+    if (req.method === 'GET') {
+      res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8' });
+      res.end(
+        [
+          'trAIce Internal Spend Codex collector is running.',
+          '',
+          `OTLP endpoint: http://${config.listenHost}:${config.listenPort}/v1/logs`,
+          `Internal usage ingest: ${config.serverUrl}/api/v1/internal-usage`,
+          `Internal Spend view: ${config.serverUrl}/dashboard?tab=internal`,
+          '',
+          'New Codex agents send OTel here when user-level [otel] config is active.',
+          'Already-open Codex agents are covered by tailing ~/.codex/sessions token_count events.',
+        ].join('\n'),
+      );
+      return;
+    }
+
+    if (req.method !== 'POST') {
+      res.writeHead(404).end();
+      return;
+    }
+
+    const receivedAt = new Date().toISOString();
+    let body;
+    try {
+      body = await readRequestBody(req);
+    } catch (error) {
+      res.writeHead(400).end(`failed to read body: ${error.message}`);
+      return;
+    }
+
+    const contentType = req.headers['content-type'] ?? '';
+    const rawEnvelope = {
+      received_at: receivedAt,
+      method: req.method,
+      url: req.url,
+      content_type: contentType,
+      content_encoding: req.headers['content-encoding'],
+      body_base64: contentType.includes('json') ? undefined : body.toString('base64'),
+    };
+
+    let normalized = [];
+    if (contentType.includes('json')) {
+      try {
+        const payload = JSON.parse(body.toString('utf8'));
+        rawEnvelope.body = redactSensitive(payload);
+        normalized = normalizeOtlpLogs(payload);
+      } catch (error) {
+        rawEnvelope.parse_error = error.message;
+        rawEnvelope.body_text = redactSensitive(body.toString('utf8'));
+      }
+    }
+
+    appendFileSync(rawFile, `${JSON.stringify(rawEnvelope)}\n`);
+    appendNormalizedEvents(normalized);
+
+    const ingestEvents = normalized.flatMap(otelRecordToIngestEvent).filter(Boolean);
+    try {
+      const sent = await forwardEvents(ingestEvents);
+      if (normalized.length > 0 || sent > 0) {
+        console.log(
+          JSON.stringify({
+            received_at: receivedAt,
+            source: 'otel',
+            records: normalized.length,
+            ingest_candidates: ingestEvents.length,
+            sent,
+          }),
+        );
+      }
+    } catch (error) {
+      console.error(`[codex-otel] internal usage ingest failed: ${error.message}`);
+    }
+
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end('{}');
+  });
+
+  server.listen(config.listenPort, config.listenHost, () => {
+    console.log(`trAIce Internal Spend Codex collector listening on http://${config.listenHost}:${config.listenPort}/v1/logs`);
+    console.log(`Forwarding Codex internal usage to ${config.serverUrl}/api/v1/internal-usage`);
+    if (config.seatMonthlyUsd > 0) {
+      console.log(`Recording seat subscription commitment: $${config.seatMonthlyUsd}/mo`);
+    }
+    console.log(`Tailing Codex sessions under ${config.codexHome}/sessions`);
+  });
+}
+
+async function scanCodexSessions() {
+  const sessionsDir = resolve(config.codexHome, 'sessions');
+  if (!existsSync(sessionsDir)) return { candidates: 0, sent: 0, files: 0 };
+
+  const cutoffMs = Date.now() - Math.max(0, config.backfillHours) * 60 * 60 * 1000;
+  const threadMetadata = loadThreadMetadata(config.codexHome);
+  const files = findSessionFiles(sessionsDir)
+    .map((file) => ({ file, stat: statSync(file) }))
+    .filter(({ file, stat }) => state.files[file] || stat.mtimeMs >= cutoffMs)
+    .sort((a, b) => a.stat.mtimeMs - b.stat.mtimeMs);
+
+  let candidates = 0;
+  let sent = 0;
+  let touchedFiles = 0;
+
+  for (const { file, stat } of files) {
+    const parsed = readNewSessionTokenEvents(file, stat, cutoffMs, threadMetadata);
+    if (!parsed) continue;
+    touchedFiles += 1;
+    candidates += parsed.events.length;
+    if (parsed.events.length > 0) {
+      sent += await forwardEvents(parsed.events);
+    }
+    state.files[file] = {
+      offset: parsed.nextOffset,
+      size: stat.size,
+      mtimeMs: stat.mtimeMs,
+      updatedAt: new Date().toISOString(),
+    };
+  }
+
+  if (touchedFiles > 0 || sent > 0) {
+    state.lastSessionScanAt = new Date().toISOString();
+    saveState(statePath, state);
+  }
+
+  if (sent > 0) {
+    console.log(JSON.stringify({ source: 'codex_session_jsonl', candidates, sent, files: touchedFiles }));
+  }
+
+  return { candidates, sent, files: touchedFiles };
+}
+
+function readNewSessionTokenEvents(file, stat, cutoffMs, threadMetadata) {
+  const prior = state.files[file];
+  if (!prior && stat.size === 0) return null;
+
+  let startOffset = Number(prior?.offset ?? 0);
+  if (!Number.isFinite(startOffset) || startOffset < 0 || startOffset > stat.size) {
+    startOffset = 0;
+  }
+  if (startOffset === stat.size && prior) return null;
+
+  const buffer = readFileSync(file);
+  const chunk = buffer.subarray(startOffset);
+  const text = chunk.toString('utf8');
+  if (!text) return { events: [], nextOffset: startOffset };
+
+  const completeChars = text.endsWith('\n') ? text.length : text.lastIndexOf('\n') + 1;
+  if (completeChars <= 0) return { events: [], nextOffset: startOffset };
+
+  const completeText = text.slice(0, completeChars);
+  const nextOffset = startOffset + Buffer.byteLength(completeText);
+  const threadId = extractThreadId(file);
+  const metadata = (threadId && threadMetadata.get(threadId)) || threadMetadata.get(file) || null;
+  const isInitialBackfill = !prior;
+  const events = [];
+
+  for (const line of completeText.split('\n')) {
+    if (!line) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry?.type !== 'event_msg' || entry?.payload?.type !== 'token_count') continue;
+
+    const tsMs = new Date(entry.timestamp).getTime();
+    if (isInitialBackfill && Number.isFinite(tsMs) && tsMs < cutoffMs) continue;
+
+    const event = sessionTokenCountToIngestEvent({ entry, file, threadId, metadata });
+    if (event) events.push(event);
+  }
+
+  return { events, nextOffset };
+}
+
+function sessionTokenCountToIngestEvent({ entry, file, threadId, metadata }) {
+  const usage = entry?.payload?.info?.last_token_usage;
+  if (!usage || typeof usage !== 'object') return null;
+
+  const inputTokens = getNumber(usage, 'input_tokens');
+  const cachedInputTokens = getNumber(usage, 'cached_input_tokens');
+  const outputTokens = getNumber(usage, 'output_tokens');
+  const reasoningOutputTokens = getNumber(usage, 'reasoning_output_tokens');
+  const nonCachedInputTokens = Math.max(inputTokens - cachedInputTokens, 0);
+  const billableTokenEstimate = nonCachedInputTokens + outputTokens;
+  if (!config.includeZeroOutput && outputTokens === 0 && reasoningOutputTokens === 0) return null;
+
+  const timestamp = normalizeTimestamp(entry.timestamp);
+  const model = metadata?.model ?? 'unknown';
+  const eventId = hashObject({
+    source: 'codex_session_jsonl',
+    file,
+    timestamp,
+    inputTokens,
+    cachedInputTokens,
+    outputTokens,
+    reasoningOutputTokens,
+  });
+
+  return {
+    ts: timestamp,
+    sourceKey: config.sourceKey,
+    sourceName: config.sourceName,
+    sourceKind: config.sourceKind,
+    tool: config.tool,
+    category: config.category,
+    provider: metadata?.modelProvider ?? 'openai',
+    model,
+    employeeEmail: config.employeeEmail,
+    employeeName: config.employeeName,
+    employeeExternalId: config.employeeExternalId,
+    teamName: config.teamName,
+    teamExternalId: config.teamExternalId,
+    sourcePrincipal: config.sourcePrincipal,
+    sourcePrincipalType: 'device_user',
+    runId: threadId ?? basename(file, '.jsonl').slice(-36),
+    stepId: eventId.slice(0, 32),
+    sourceEventId: eventId,
+    inputTokens,
+    cachedInputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens,
+    costUsd: 0,
+    costBasis: config.seatMonthlyUsd > 0 ? 'seat_subscription' : 'usage_only',
+    status: 'ok',
+    metadata: compactMetadata({
+      usageDomain: 'developer_agent',
+      sourceAgent: 'codex',
+      sourceTransport: 'codex_session_jsonl',
+      sourceEventName: 'codex.session_token_count',
+      workspaceSlug: config.workspaceSlug,
+      tokenAccounting: {
+        rawInputTokens: inputTokens,
+        cachedInputTokens,
+        nonCachedInputTokens,
+        outputTokens,
+        reasoningOutputTokens,
+        billableTokenEstimate,
+        rawTotalTokens: getNumber(usage, 'total_tokens'),
+        cumulative: entry?.payload?.info?.total_token_usage ?? null,
+      },
+      subscription: subscriptionMetadata(),
+      codex: {
+        conversationId: threadId,
+        sessionFile: compactPath(file),
+        eventKind: 'token_count',
+        modelContextWindow: getNumber(entry?.payload?.info, 'model_context_window'),
+        rateLimits: rateLimitSummary(entry?.payload?.rate_limits),
+      },
+      thread: metadata
+        ? {
+            title: metadata.title,
+            cwd: metadata.cwd,
+            source: metadata.source,
+            sandboxPolicy: metadata.sandboxPolicy,
+            approvalMode: metadata.approvalMode,
+            reasoningEffort: metadata.reasoningEffort,
+            tokensUsed: metadata.tokensUsed,
+          }
+        : null,
+    }),
+  };
+}
+
+function otelRecordToIngestEvent(record) {
+  const attributes = record.attributes ?? {};
+  if (record.event_name !== 'codex.sse_event') return [];
+  if (getString(attributes, 'event.kind') !== 'response.completed') return [];
+  if (getString(attributes, 'error.message')) return [];
+
+  const inputTokens = getNumber(attributes, 'input_token_count');
+  const cachedInputTokens = getNumber(attributes, 'cached_token_count');
+  const outputTokens = getNumber(attributes, 'output_token_count');
+  const reasoningOutputTokens = getNumber(attributes, 'reasoning_token_count');
+  const nonCachedInputTokens = Math.max(inputTokens - cachedInputTokens, 0);
+  const zeroOutputRecord = outputTokens === 0 && reasoningOutputTokens === 0;
+  if (!config.includeZeroOutput && zeroOutputRecord) return [];
+
+  const timestamp = normalizeTimestamp(getString(attributes, 'event.timestamp') ?? record.received_at);
+  const conversationId = getString(attributes, 'conversation.id') ?? 'unknown';
+  const model = getString(attributes, 'model') ?? 'unknown';
+  const eventId = hashObject({
+    source: 'otel',
+    conversationId,
+    timestamp,
+    model,
+    inputTokens,
+    cachedInputTokens,
+    outputTokens,
+    reasoningOutputTokens,
+  });
+
+  return [
+    {
+      ts: timestamp,
+      sourceKey: config.sourceKey,
+      sourceName: config.sourceName,
+      sourceKind: config.sourceKind,
+      tool: config.tool,
+      category: config.category,
+      provider: 'openai',
+      model,
+      employeeEmail: config.employeeEmail,
+      employeeName: config.employeeName,
+      employeeExternalId: config.employeeExternalId,
+      teamName: config.teamName,
+      teamExternalId: config.teamExternalId,
+      sourcePrincipal: config.sourcePrincipal,
+      sourcePrincipalType: 'device_user',
+      runId: conversationId,
+      stepId: eventId.slice(0, 32),
+      sourceEventId: eventId,
+      inputTokens,
+      cachedInputTokens,
+      outputTokens,
+      totalTokens: inputTokens + outputTokens,
+      costUsd: 0,
+      costBasis: config.seatMonthlyUsd > 0 ? 'seat_subscription' : 'usage_only',
+      latencyMs: getNullableNumber(attributes, 'duration_ms') ?? undefined,
+      status: 'ok',
+      metadata: compactMetadata({
+        usageDomain: 'developer_agent',
+        sourceAgent: 'codex',
+        sourceTransport: 'otel',
+        sourceEventName: record.event_name,
+        workspaceSlug: config.workspaceSlug,
+        tokenAccounting: {
+          rawInputTokens: inputTokens,
+          cachedInputTokens,
+          nonCachedInputTokens,
+          outputTokens,
+          reasoningOutputTokens,
+          billableTokenEstimate: nonCachedInputTokens + outputTokens,
+          zeroOutputRecord,
+        },
+        subscription: subscriptionMetadata(),
+        service: {
+          name: getString(record.resource, 'service.name'),
+          version: getString(record.resource, 'service.version'),
+          environment: getString(record.resource, 'env'),
+        },
+        codex: {
+          conversationId,
+          eventKind: getString(attributes, 'event.kind'),
+          authMode: getString(attributes, 'auth_mode'),
+          sandboxPolicy: getString(attributes, 'sandbox_policy'),
+          approvalPolicy: getString(attributes, 'approval_policy'),
+        },
+      }),
+    },
+  ];
+}
+
+async function forwardEvents(events) {
+  const pending = events.filter((event) => {
+    const sourceEventId = event?.sourceEventId;
+    return sourceEventId && !state.sent[sourceEventId];
+  });
+  if (pending.length === 0) return 0;
+
+  let sent = 0;
+  for (let i = 0; i < pending.length; i += config.maxBatchSize) {
+    const batch = pending.slice(i, i + config.maxBatchSize);
+    const response = await fetch(`${config.serverUrl}/api/v1/internal-usage`, {
+      method: 'POST',
+      headers: {
+        authorization: `Bearer ${config.apiKey}`,
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify({ events: batch }),
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => '');
+      throw new Error(`POST /api/v1/internal-usage returned ${response.status}: ${text.slice(0, 500)}`);
+    }
+
+    const body = await response.json().catch(() => ({}));
+    const accepted = Number(body.accepted ?? batch.length);
+    for (const event of batch.slice(0, accepted)) {
+      state.sent[event.sourceEventId] = new Date().toISOString();
+    }
+    sent += accepted;
+    pruneSentIds();
+    saveState(statePath, state);
+  }
+
+  return sent;
+}
+
+function normalizeOtlpLogs(payload) {
+  const normalized = [];
+  const resourceLogs = payload.resourceLogs ?? payload.resource_logs ?? [];
+
+  for (const resourceLog of resourceLogs) {
+    const resource = keyValuesToObject(resourceLog.resource?.attributes ?? []);
+    const scopeLogs = resourceLog.scopeLogs ?? resourceLog.scope_logs ?? [];
+
+    for (const scopeLog of scopeLogs) {
+      const scope = {
+        name: scopeLog.scope?.name,
+        version: scopeLog.scope?.version,
+        attributes: keyValuesToObject(scopeLog.scope?.attributes ?? []),
+      };
+      const logRecords = scopeLog.logRecords ?? scopeLog.log_records ?? [];
+
+      for (const logRecord of logRecords) {
+        const attributes = keyValuesToObject(logRecord.attributes ?? []);
+        const body = maybeParseJsonString(otlpValueToJs(logRecord.body));
+        normalized.push({
+          received_at: new Date().toISOString(),
+          time_unix_nano: logRecord.timeUnixNano ?? logRecord.time_unix_nano,
+          severity_text: logRecord.severityText ?? logRecord.severity_text,
+          event_name: extractEventName(body, attributes),
+          resource: redactSensitive(resource),
+          scope: redactSensitive(scope),
+          attributes: redactSensitive(attributes),
+          body: redactSensitive(body),
+        });
+      }
+    }
+  }
+
+  return normalized;
+}
+
+function appendNormalizedEvents(records) {
+  for (const record of records) {
+    appendFileSync(eventsFile, `${JSON.stringify(record)}\n`);
+  }
+}
+
+function loadThreadMetadata(codexHome) {
+  const byId = new Map();
+  const dbPath = resolve(codexHome, 'state_5.sqlite');
+  if (!existsSync(dbPath)) return byId;
+
+  try {
+    const query = [
+      'select id, rollout_path, source, model_provider, cwd, title, sandbox_policy,',
+      'approval_mode, tokens_used, model, reasoning_effort, created_at, updated_at',
+      'from threads',
+    ].join(' ');
+    const output = execFileSync('sqlite3', ['-json', dbPath, query], {
+      encoding: 'utf8',
+      timeout: 3000,
+      maxBuffer: 8 * 1024 * 1024,
+    });
+    const rows = JSON.parse(output || '[]');
+    for (const row of rows) {
+      const metadata = {
+        id: row.id,
+        rolloutPath: row.rollout_path,
+        source: row.source,
+        modelProvider: row.model_provider,
+        cwd: row.cwd,
+        title: row.title,
+        sandboxPolicy: row.sandbox_policy,
+        approvalMode: row.approval_mode,
+        tokensUsed: row.tokens_used,
+        model: row.model,
+        reasoningEffort: row.reasoning_effort,
+        createdAt: epochToIso(row.created_at),
+        updatedAt: epochToIso(row.updated_at),
+      };
+      if (row.id) byId.set(row.id, metadata);
+      if (row.rollout_path) byId.set(row.rollout_path, metadata);
+    }
+  } catch (error) {
+    console.error(`[codex-otel] could not read Codex thread metadata: ${error.message}`);
+  }
+
+  return byId;
+}
+
+function findSessionFiles(dir) {
+  const files = [];
+  const visit = (current) => {
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const fullPath = join(current, entry.name);
+      if (entry.isDirectory()) {
+        visit(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+        files.push(fullPath);
+      }
+    }
+  };
+  visit(dir);
+  return files;
+}
+
+function readRequestBody(req) {
+  return new Promise((resolveBody, rejectBody) => {
+    const chunks = [];
+    req.on('data', (chunk) => chunks.push(chunk));
+    req.on('end', () => {
+      const body = Buffer.concat(chunks);
+      if (req.headers['content-encoding'] === 'gzip') {
+        try {
+          resolveBody(gunzipSync(body));
+        } catch (error) {
+          rejectBody(error);
+        }
+        return;
+      }
+      resolveBody(body);
+    });
+    req.on('error', rejectBody);
+  });
+}
+
+function otlpValueToJs(value) {
+  if (!value || typeof value !== 'object') return value;
+  if ('stringValue' in value) return value.stringValue;
+  if ('intValue' in value) return Number(value.intValue);
+  if ('doubleValue' in value) return Number(value.doubleValue);
+  if ('boolValue' in value) return Boolean(value.boolValue);
+  if ('bytesValue' in value) return value.bytesValue;
+  if ('arrayValue' in value) return (value.arrayValue?.values ?? []).map(otlpValueToJs);
+  if ('kvlistValue' in value) return keyValuesToObject(value.kvlistValue?.values ?? []);
+  return value;
+}
+
+function keyValuesToObject(values) {
+  const out = {};
+  for (const item of values ?? []) {
+    if (!item?.key) continue;
+    out[item.key] = otlpValueToJs(item.value);
+  }
+  return out;
+}
+
+function maybeParseJsonString(value) {
+  if (typeof value !== 'string') return value;
+  const trimmed = value.trim();
+  if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) return value;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return value;
+  }
+}
+
+function extractEventName(body, attributes) {
+  if (typeof body === 'string') return body;
+  if (body && typeof body === 'object') {
+    return (
+      body.event_name ??
+      body.eventName ??
+      body.event ??
+      body.name ??
+      body.type ??
+      body.message ??
+      attributes['event.name'] ??
+      attributes.event_name ??
+      attributes.name ??
+      'unknown'
+    );
+  }
+  return attributes['event.name'] ?? attributes.event_name ?? attributes.name ?? 'unknown';
+}
+
+function redactSensitive(value, path = '') {
+  if (value === null || value === undefined) return value;
+  if (Array.isArray(value)) return value.map((item, index) => redactSensitive(item, `${path}.${index}`));
+  if (typeof value === 'object') {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      const childPath = path ? `${path}.${key}` : key;
+      out[key] = isSensitiveKey(childPath) || isSensitiveKey(key) ? '[REDACTED]' : redactSensitive(child, childPath);
+    }
+    return out;
+  }
+  if (typeof value === 'string' && /\b[^@\s]+@[^@\s]+\.[^@\s]+\b/.test(value)) return '[REDACTED]';
+  return value;
+}
+
+function isSensitiveKey(key) {
+  return /(^|\.|_)(authorization|cookie|api[_-]?key|secret|bearer|access[_-]?token|refresh[_-]?token|id[_-]?token|user\.email|user\.account_id|email|account_id|host\.name)$/i.test(
+    key,
+  );
+}
+
+function compactMetadata(metadata) {
+  return pruneNullish(metadata);
+}
+
+function subscriptionMetadata() {
+  if (config.seatMonthlyUsd <= 0) return null;
+  return {
+    monthlySeatUsd: config.seatMonthlyUsd,
+    allocation: 'monthly_seat_commitment',
+    note: 'Subscription commitment is shown separately from per-request usage cost.',
+  };
+}
+
+function pruneNullish(value) {
+  if (Array.isArray(value)) {
+    return value.map(pruneNullish).filter((item) => item !== undefined);
+  }
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      const pruned = pruneNullish(child);
+      if (pruned !== undefined) out[key] = pruned;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+  }
+  return value === null || value === undefined || value === '' ? undefined : value;
+}
+
+function rateLimitSummary(rateLimits) {
+  if (!rateLimits || typeof rateLimits !== 'object') return null;
+  return {
+    limitId: rateLimits.limit_id,
+    planType: rateLimits.plan_type,
+    rateLimitReachedType: rateLimits.rate_limit_reached_type,
+    primary: rateLimits.primary
+      ? {
+          usedPercent: rateLimits.primary.used_percent,
+          windowMinutes: rateLimits.primary.window_minutes,
+          resetsAt: epochToIso(rateLimits.primary.resets_at),
+        }
+      : null,
+    secondary: rateLimits.secondary
+      ? {
+          usedPercent: rateLimits.secondary.used_percent,
+          windowMinutes: rateLimits.secondary.window_minutes,
+          resetsAt: epochToIso(rateLimits.secondary.resets_at),
+        }
+      : null,
+  };
+}
+
+function loadState(path) {
+  const fallback = { version: 1, files: {}, sent: {} };
+  if (!existsSync(path)) return fallback;
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    return {
+      version: 1,
+      files: parsed.files && typeof parsed.files === 'object' ? parsed.files : {},
+      sent: parsed.sent && typeof parsed.sent === 'object' ? parsed.sent : {},
+      lastSessionScanAt: parsed.lastSessionScanAt,
+    };
+  } catch {
+    return fallback;
+  }
+}
+
+function saveState(path, nextState) {
+  writeFileSync(path, `${JSON.stringify(nextState, null, 2)}\n`);
+}
+
+function pruneSentIds() {
+  const entries = Object.entries(state.sent);
+  if (entries.length <= MAX_SENT_IDS) return;
+  entries
+    .sort((a, b) => String(b[1]).localeCompare(String(a[1])))
+    .slice(MAX_SENT_IDS)
+    .forEach(([id]) => {
+      delete state.sent[id];
+    });
+}
+
+function parseArgs(argv) {
+  const parsed = new Map();
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg.startsWith('--')) continue;
+    const key = arg.slice(2);
+    const next = argv[i + 1];
+    if (next && !next.startsWith('--')) {
+      parsed.set(key, next);
+      i += 1;
+    } else {
+      parsed.set(key, 'true');
+    }
+  }
+  return parsed;
+}
+
+function loadEnvFile(path) {
+  if (!existsSync(path)) return;
+  for (const line of readFileSync(path, 'utf8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (!match) continue;
+    const [, key, rawValue] = match;
+    if (process.env[key] != null) continue;
+    process.env[key] = unquoteEnvValue(rawValue.trim());
+  }
+}
+
+function unquoteEnvValue(value) {
+  if (
+    (value.startsWith('"') && value.endsWith('"')) ||
+    (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+function readJsonIfExists(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function normalizeUrl(value) {
+  return String(value).replace(/\/+$/, '');
+}
+
+function findDefaultInstallConfigPath() {
+  const primaryPath = resolveHome(DEFAULT_INSTALL_CONFIG);
+  if (existsSync(primaryPath)) return primaryPath;
+
+  const legacyPath = resolve(LEGACY_INSTALL_CONFIG);
+  if (existsSync(legacyPath)) return legacyPath;
+
+  return primaryPath;
+}
+
+function resolveHome(value) {
+  if (value === '~') return homedir();
+  if (String(value).startsWith('~/')) return resolve(homedir(), String(value).slice(2));
+  return resolve(String(value));
+}
+
+function parsePort(value) {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+    console.error(`Invalid listen port: ${value}`);
+    process.exit(2);
+  }
+  return port;
+}
+
+function parsePositiveInt(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    console.error(`Invalid positive integer: ${value}`);
+    process.exit(2);
+  }
+  return parsed;
+}
+
+function parseOptionalMoney(value) {
+  if (value === undefined || value === null || value === '') return 0;
+  const parsed = Number(String(value).replace(/[$,]/g, ''));
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    console.error(`Invalid USD amount: ${value}`);
+    process.exit(2);
+  }
+  return parsed;
+}
+
+function boolArg(value, fallback) {
+  if (value === undefined || value === null || value === '') return fallback;
+  if (typeof value === 'boolean') return value;
+  return String(value) === 'true';
+}
+
+function readApiKey() {
+  if (args.get('api-key-stdin') !== 'true') return args.get('api-key');
+  return readFileSync(0, 'utf8').trim();
+}
+
+function getString(source, key) {
+  const value = source?.[key];
+  return typeof value === 'string' && value.length > 0 ? value : null;
+}
+
+function getNumber(source, key) {
+  return getNullableNumber(source, key) ?? 0;
+}
+
+function getNullableNumber(source, key) {
+  const value = source?.[key];
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'string') {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+
+function normalizeTimestamp(value) {
+  const date = value ? new Date(value) : new Date();
+  return Number.isNaN(date.getTime()) ? new Date().toISOString() : date.toISOString();
+}
+
+function epochToIso(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return null;
+  const ms = parsed > 10_000_000_000 ? parsed : parsed * 1000;
+  const date = new Date(ms);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+
+function extractThreadId(file) {
+  const match = basename(file).match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i);
+  return match?.[1] ?? null;
+}
+
+function compactPath(file) {
+  const home = homedir();
+  return file.startsWith(home) ? `~${file.slice(home.length)}` : file;
+}
+
+function hashObject(value) {
+  return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}