#!/usr/bin/env node

// handler.ts
import { randomUUID as randomUUID2 } from "node:crypto";
import { hostname, homedir } from "node:os";
import { readFileSync, writeFileSync, mkdirSync, unlinkSync } from "node:fs";
import { join } from "node:path";

// ../shared/lib.ts
import { randomUUID } from "node:crypto";
function isRecord(value) {
  return value !== null && typeof value === "object" && !Array.isArray(value);
}
function pickString(...values) {
  for (const value of values) {
    if (typeof value === "string" && value.trim() !== "") {
      return value;
    }
  }
  return void 0;
}
function pickNumber(...values) {
  for (const value of values) {
    if (typeof value === "number" && Number.isFinite(value)) {
      return value;
    }
  }
  return void 0;
}
function truncate(value, limit) {
  if (value === void 0 || value === null) {
    return void 0;
  }
  const text = typeof value === "string" ? value : safeJSONStringify(value);
  if (!text) {
    return void 0;
  }
  if (text.length <= limit) {
    return text;
  }
  return text.slice(0, limit) + "...";
}
function safeJSONStringify(value) {
  try {
    return JSON.stringify(value);
  } catch {
    return String(value);
  }
}
function buildEnvelope(framework, host, type, sessionKey, opts = {}) {
  const correlation = {};
  if (sessionKey) {
    correlation.session_id = sessionKey;
  }
  if (opts.runId) {
    correlation.run_id = opts.runId;
  }
  if (opts.spanId) {
    correlation.span_id = opts.spanId;
  }
  if (opts.parentSpanId) {
    correlation.parent_span_id = opts.parentSpanId;
  }
  const envelope = {
    schema: { name: "agentmon.event", version: 1 },
    event: {
      id: randomUUID(),
      type,
      ts: (/* @__PURE__ */ new Date()).toISOString(),
      source: {
        framework,
        client_id: host,
        host
      }
    }
  };
  if (Object.keys(correlation).length > 0) {
    envelope.correlation = correlation;
  }
  if (opts.attributes && Object.keys(opts.attributes).length > 0) {
    envelope.attributes = opts.attributes;
  }
  if (opts.payload && Object.keys(opts.payload).length > 0) {
    envelope.payload = opts.payload;
  }
  return envelope;
}
function createTransport(ingestUrl, opts) {
  const batchSize = opts?.batchSize ?? 10;
  const flushMs = opts?.flushMs ?? 2e3;
  const fetchTimeoutMs = opts?.fetchTimeoutMs ?? 500;
  let buffer = [];
  let flushTimer = null;
  let isFlushing = false;
  async function postBatch(batch) {
    const controller = new AbortController();
    const timeout = setTimeout(() => controller.abort(), fetchTimeoutMs);
    try {
      await fetch(`${ingestUrl}/v1/events`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(batch),
        signal: controller.signal
      });
    } finally {
      clearTimeout(timeout);
    }
  }
  function scheduleFlush() {
    if (!flushTimer) {
      flushTimer = setTimeout(() => {
        void flush2();
      }, flushMs);
    }
  }
  async function flush2() {
    if (flushTimer) {
      clearTimeout(flushTimer);
      flushTimer = null;
    }
    if (isFlushing || buffer.length === 0) {
      return;
    }
    isFlushing = true;
    const batch = buffer.splice(0, batchSize);
    try {
      await postBatch(batch);
    } catch {
      console.debug(`[agentmon] failed to flush ${batch.length} events`);
    } finally {
      isFlushing = false;
      if (buffer.length > 0) {
        if (buffer.length >= batchSize) {
          void flush2();
        } else {
          scheduleFlush();
        }
      }
    }
  }
  function enqueue2(event) {
    buffer.push(event);
    if (buffer.length >= batchSize) {
      void flush2();
    } else {
      scheduleFlush();
    }
  }
  return { enqueue: enqueue2, flush: flush2 };
}
async function readStdin() {
  return new Promise((resolve) => {
    let data = "";
    let done = false;
    const timer = setTimeout(() => finish(data), 100);
    const finish = (value) => {
      if (done)
        return;
      done = true;
      clearTimeout(timer);
      resolve(value);
    };
    process.stdin.on("data", (chunk) => {
      data += chunk;
    });
    process.stdin.on("end", () => finish(data));
    process.stdin.on("error", () => finish(""));
  });
}

// handler.ts
var INGEST_URL = process.env.AGENTMON_INGEST_URL || "http://localhost:8080";
var FRAMEWORK = process.env.AGENTMON_FRAMEWORK || "claude-code";
var HOST = process.env.AGENTMON_HOST || hostname();
var ALLOW_STARTUP_SESSIONS = process.env.AGENTMON_CLAUDE_ALLOW_STARTUP === "1";
var { enqueue, flush } = createTransport(INGEST_URL);
var STATE_DIR = join(homedir(), ".agentmon-state");
function ensureStateDir() {
  try {
    mkdirSync(STATE_DIR, { recursive: true });
  } catch {
  }
}
function loadState(sessionKey) {
  try {
    const raw = readFileSync(join(STATE_DIR, sessionKey + ".json"), "utf8");
    return JSON.parse(raw);
  } catch {
    return { spans: {} };
  }
}
function saveState(sessionKey, state) {
  ensureStateDir();
  try {
    writeFileSync(join(STATE_DIR, sessionKey + ".json"), JSON.stringify(state), "utf8");
  } catch {
  }
}
function clearState(sessionKey) {
  try {
    unlinkSync(join(STATE_DIR, sessionKey + ".json"));
  } catch {
  }
}
function readProcCmdline(pid) {
  try {
    return readFileSync(`/proc/${pid}/cmdline`, "utf8").replace(/\0/g, " ").trim();
  } catch {
    return "";
  }
}
function readProcPPID(pid) {
  try {
    const status = readFileSync(`/proc/${pid}/status`, "utf8");
    const match = status.match(/^PPid:\s+(\d+)$/m);
    return match ? Number(match[1]) : void 0;
  } catch {
    return void 0;
  }
}
function getProcessTree() {
  const tree = [];
  let pid = process.pid;
  for (let i = 0; pid && i < 8; i++) {
    tree.push({ pid, cmd: readProcCmdline(pid) });
    pid = readProcPPID(pid);
  }
  return tree;
}
function isNonPersistentClaudeLaunch() {
  return getProcessTree().some(
    ({ cmd }) => cmd.includes("/claude") && cmd.includes("--no-session-persistence")
  );
}
function hasClaudeProcessAncestor() {
  return getProcessTree().some(({ cmd }) => {
    if (!cmd)
      return false;
    if (cmd.includes("agentmon-handler") || cmd.includes("/hooks/claude-code/handler"))
      return false;
    return /(^|[/\s])claude(\s|$)/.test(cmd) || cmd.includes("@anthropic-ai/claude-code");
  });
}
var activeRuns = /* @__PURE__ */ new Map();
var activeSpans = /* @__PURE__ */ new Map();
var activeSubagents = /* @__PURE__ */ new Map();
function getSessionKey(input) {
  return pickString(
    input.sessionId,
    input.session_id,
    input.conversationId,
    input.conversation_id
  );
}
function getUsage(input) {
  const usage = isRecord(input.usage) ? input.usage : isRecord(input.llm) ? input.llm : void 0;
  if (!usage)
    return void 0;
  const result = {};
  if (usage.input_tokens !== void 0)
    result.input_tokens = usage.input_tokens;
  if (usage.output_tokens !== void 0)
    result.output_tokens = usage.output_tokens;
  if (usage.cache_creation_tokens !== void 0)
    result.cache_creation_tokens = usage.cache_creation_tokens;
  if (usage.cache_read_tokens !== void 0)
    result.cache_read_tokens = usage.cache_read_tokens;
  if (usage.thinking_tokens !== void 0)
    result.thinking_tokens = usage.thinking_tokens;
  if (usage.total_tokens !== void 0)
    result.total_tokens = usage.total_tokens;
  if (usage.total_cost !== void 0)
    result.total_cost = usage.total_cost;
  return Object.keys(result).length > 0 ? result : void 0;
}
function getContextWindow(input) {
  const stats = isRecord(input.context_stats) ? input.context_stats : isRecord(input.stats) ? input.stats : void 0;
  if (!stats)
    return void 0;
  const result = {};
  if (stats.input_tokens !== void 0)
    result.input_tokens = stats.input_tokens;
  if (stats.output_tokens !== void 0)
    result.output_tokens = stats.output_tokens;
  if (stats.used_tokens !== void 0)
    result.used_tokens = stats.used_tokens;
  if (stats.max_tokens !== void 0)
    result.max_tokens = stats.max_tokens;
  if (stats.tokens_remaining !== void 0)
    result.tokens_remaining = stats.tokens_remaining;
  return Object.keys(result).length > 0 ? result : void 0;
}
function emitError(sessionKey, runId, spanId, errorValue) {
  if (errorValue === void 0 || errorValue === null || errorValue === false) {
    return;
  }
  const errorRecord = isRecord(errorValue) ? errorValue : {};
  const message = pickString(errorRecord.message, errorRecord.error, errorValue) || "unknown";
  const errType = pickString(errorRecord.type, errorRecord.code) || FRAMEWORK;
  enqueue(buildEnvelope(FRAMEWORK, HOST, "error", sessionKey, {
    runId,
    spanId,
    payload: {
      error: {
        type: errType,
        message
      }
    }
  }));
}
async function handleSessionStart(input) {
  const sessionKey = getSessionKey(input);
  if (!sessionKey) {
    console.error("[agentmon] ignoring claude-code session.start without session_id");
    return;
  }
  const hookEventName = pickString(input.hook_event_name);
  if (hookEventName !== "SessionStart") {
    console.error(`[agentmon] ignoring claude-code session.start with hook_event_name=${hookEventName || "missing"}`);
    return;
  }
  const cwd = pickString(input.cwd);
  const transcriptPath = pickString(input.transcript_path);
  if (!cwd || !transcriptPath) {
    console.error("[agentmon] ignoring claude-code session.start without cwd or transcript_path");
    return;
  }
  if (pickString(input.source) === "startup" && isNonPersistentClaudeLaunch()) {
    console.error("[agentmon] ignoring claude-code startup from --no-session-persistence launch");
    return;
  }
  if (pickString(input.source) === "startup" && (!ALLOW_STARTUP_SESSIONS || !hasClaudeProcessAncestor())) {
    console.error("[agentmon] ignoring claude-code startup session");
    return;
  }
  const runId = randomUUID2();
  activeRuns.set(sessionKey, runId);
  saveState(sessionKey, { runId, spans: {} });
  const contextWindow = getContextWindow(input);
  enqueue(buildEnvelope(FRAMEWORK, HOST, "session.start", sessionKey, {
    attributes: {
      cwd,
      transcript_path: transcriptPath,
      source: pickString(input.source),
      ...contextWindow && { context_window: contextWindow }
    }
  }));
  enqueue(buildEnvelope(FRAMEWORK, HOST, "run.start", sessionKey, {
    runId,
    attributes: {
      trigger: pickString(input.trigger_type, input.trigger)
    },
    payload: {
      prompt_preview: truncate(input.prompt, 200)
    }
  }));
  await flush();
}
async function handleSessionEnd(input) {
  const sessionKey = getSessionKey(input);
  const state = sessionKey ? loadState(sessionKey) : { spans: {} };
  const runId = sessionKey ? activeRuns.get(sessionKey) || state.runId : void 0;
  const usage = getUsage(input);
  const contextWindow = getContextWindow(input);
  const duration = pickNumber(input.duration_ms, input.elapsed_ms);
  if (runId) {
    enqueue(buildEnvelope(FRAMEWORK, HOST, "run.end", sessionKey, {
      runId,
      payload: {
        status: "success",
        duration_ms: duration,
        model: pickString(input.model),
        ...usage && { usage },
        ...contextWindow && { context_window: contextWindow }
      }
    }));
  }
  enqueue(buildEnvelope(FRAMEWORK, HOST, "session.end", sessionKey, {
    payload: {
      ...usage && { usage },
      ...contextWindow && { context_window: contextWindow }
    }
  }));
  activeRuns.delete(sessionKey || "");
  activeSpans.clear();
  activeSubagents.clear();
  if (sessionKey)
    clearState(sessionKey);
  await flush();
}
async function handlePromptSubmit(input) {
  const sessionKey = getSessionKey(input);
  const state = sessionKey ? loadState(sessionKey) : { spans: {} };
  const runId = sessionKey ? activeRuns.get(sessionKey) || state.runId : void 0;
  const prompt = pickString(input.prompt, input.text, input.message);
  if (runId && prompt) {
    enqueue(buildEnvelope(FRAMEWORK, HOST, "run.end", sessionKey, {
      runId,
      payload: {
        status: "success",
        duration_ms: pickNumber(input.elapsed_ms, input.duration_ms)
      }
    }));
  }
  if (!runId && sessionKey) {
    enqueue(buildEnvelope(FRAMEWORK, HOST, "session.start", sessionKey, {
      attributes: {
        cwd: pickString(input.cwd),
        transcript_path: pickString(input.transcript_path),
        source: pickString(input.source)
      }
    }));
  }
  const newRunId = randomUUID2();
  if (sessionKey) {
    activeRuns.set(sessionKey, newRunId);
    saveState(sessionKey, { runId: newRunId, spans: {} });
  }
  enqueue(buildEnvelope(FRAMEWORK, HOST, "run.start", sessionKey, {
    runId: newRunId,
    attributes: {
      type: "user_prompt"
    },
    payload: {
      prompt_preview: truncate(prompt, 200)
    }
  }));
  await flush();
}
async function handleToolStart(input) {
  const sessionKey = getSessionKey(input);
  const state = sessionKey ? loadState(sessionKey) : { spans: {} };
  const runId = sessionKey ? activeRuns.get(sessionKey) || state.runId : void 0;
  const toolName = pickString(input.tool, input.tool_name, input.name) || "unknown";
  const toolInput = isRecord(input.input) ? input.input : {};
  const spanId = randomUUID2();
  const spanKey = sessionKey ? sessionKey + ":" + toolName : void 0;
  if (spanKey) {
    activeSpans.set(spanKey, spanId);
    state.spans[spanKey] = spanId;
    state.spanStartTimes = state.spanStartTimes || {};
    state.spanStartTimes[spanId] = Date.now();
    if (runId)
      state.runId = runId;
    if (sessionKey)
      saveState(sessionKey, state);
  }
  enqueue(buildEnvelope(FRAMEWORK, HOST, "span.start", sessionKey, {
    runId,
    spanId,
    attributes: {
      span_kind: "tool",
      name: toolName
    },
    payload: {
      input: truncate(toolInput, 200)
    }
  }));
  await flush();
}
async function handleToolEnd(input) {
  const sessionKey = getSessionKey(input);
  const state = sessionKey ? loadState(sessionKey) : { spans: {} };
  const runId = sessionKey ? activeRuns.get(sessionKey) || state.runId : void 0;
  const toolName = pickString(input.tool, input.tool_name, input.name) || "unknown";
  const spanKey = sessionKey ? sessionKey + ":" + toolName : void 0;
  const spanId = spanKey ? activeSpans.get(spanKey) || state.spans[spanKey] : void 0;
  const result = isRecord(input.result) ? input.result : isRecord(input.output) ? input.output : {};
  const success = !result.error;
  const startTime = spanId ? state.spanStartTimes?.[spanId] : void 0;
  const duration = pickNumber(input.duration_ms, input.elapsed_ms) ?? (startTime ? Date.now() - startTime : void 0);
  if (spanId && state.spanStartTimes) {
    delete state.spanStartTimes[spanId];
    if (sessionKey)
      saveState(sessionKey, state);
  }
  enqueue(buildEnvelope(FRAMEWORK, HOST, "span.end", sessionKey, {
    runId,
    spanId,
    attributes: {
      span_kind: "tool",
      name: toolName
    },
    payload: {
      status: success ? "success" : "error",
      result_preview: truncate(result.output ?? result.error ?? result, 500),
      duration_ms: duration
    }
  }));
  if (!success) {
    emitError(sessionKey, runId, spanId, result.error);
  }
  activeSpans.delete(spanKey || "");
  await flush();
}
async function handleSubagentStart(input) {
  const sessionKey = getSessionKey(input);
  const state = sessionKey ? loadState(sessionKey) : { spans: {} };
  const runId = sessionKey ? activeRuns.get(sessionKey) || state.runId : void 0;
  const agentName = pickString(input.agent, input.agent_name, input.name) || "unknown";
  const spanId = randomUUID2();
  if (sessionKey) {
    activeSubagents.set(sessionKey, { name: agentName, spanId });
    state.subagent = { name: agentName, spanId };
    state.spanStartTimes = state.spanStartTimes || {};
    state.spanStartTimes[spanId] = Date.now();
    if (runId)
      state.runId = runId;
    saveState(sessionKey, state);
  }
  enqueue(buildEnvelope(FRAMEWORK, HOST, "span.start", sessionKey, {
    runId,
    spanId,
    attributes: {
      span_kind: "agent",
      name: agentName,
      type: "subagent"
    },
    payload: {
      prompt_preview: truncate(input.prompt, 200)
    }
  }));
  await flush();
}
async function handleSubagentStop(input) {
  const sessionKey = getSessionKey(input);
  const state = sessionKey ? loadState(sessionKey) : { spans: {} };
  const runId = sessionKey ? activeRuns.get(sessionKey) || state.runId : void 0;
  const subagent = sessionKey ? activeSubagents.get(sessionKey) || state.subagent : void 0;
  const spanId = subagent?.spanId;
  const agentName = subagent?.name || pickString(input.agent, input.agent_name) || "unknown";
  const startTime = spanId ? state.spanStartTimes?.[spanId] : void 0;
  const duration = pickNumber(input.duration_ms, input.elapsed_ms) ?? (startTime ? Date.now() - startTime : void 0);
  const usage = getUsage(input);
  if (spanId && state.spanStartTimes) {
    delete state.spanStartTimes[spanId];
    if (sessionKey)
      saveState(sessionKey, state);
  }
  enqueue(buildEnvelope(FRAMEWORK, HOST, "span.end", sessionKey, {
    runId,
    spanId,
    attributes: {
      span_kind: "agent",
      name: agentName,
      type: "subagent"
    },
    payload: {
      status: "success",
      duration_ms: duration,
      ...usage && { usage }
    }
  }));
  activeSubagents.delete(sessionKey || "");
  await flush();
}
async function handleCompactStart(input) {
  const sessionKey = getSessionKey(input);
  const state = sessionKey ? loadState(sessionKey) : { spans: {} };
  const runId = sessionKey ? activeRuns.get(sessionKey) || state.runId : void 0;
  const spanId = randomUUID2();
  if (sessionKey) {
    activeSpans.set(sessionKey + ":compact", spanId);
    state.compactSpanId = spanId;
    state.spanStartTimes = state.spanStartTimes || {};
    state.spanStartTimes[spanId] = Date.now();
    if (runId)
      state.runId = runId;
    saveState(sessionKey, state);
  }
  enqueue(buildEnvelope(FRAMEWORK, HOST, "span.start", sessionKey, {
    runId,
    spanId,
    attributes: {
      span_kind: "internal",
      name: "context_compaction"
    }
  }));
  await flush();
}
async function handleCompactEnd(input) {
  const sessionKey = getSessionKey(input);
  const state = sessionKey ? loadState(sessionKey) : { spans: {} };
  const runId = sessionKey ? activeRuns.get(sessionKey) || state.runId : void 0;
  const spanKey = sessionKey ? sessionKey + ":compact" : void 0;
  const spanId = spanKey ? activeSpans.get(spanKey) || state.compactSpanId : void 0;
  const startTime = spanId ? state.spanStartTimes?.[spanId] : void 0;
  const duration = pickNumber(input.duration_ms, input.elapsed_ms) ?? (startTime ? Date.now() - startTime : void 0);
  const contextWindow = getContextWindow(input);
  if (spanId && state.spanStartTimes) {
    delete state.spanStartTimes[spanId];
    if (sessionKey)
      saveState(sessionKey, state);
  }
  enqueue(buildEnvelope(FRAMEWORK, HOST, "span.end", sessionKey, {
    runId,
    spanId,
    attributes: {
      span_kind: "internal",
      name: "context_compaction"
    },
    payload: {
      status: "success",
      duration_ms: duration,
      ...contextWindow && { context_window: contextWindow }
    }
  }));
  activeSpans.delete(spanKey || "");
  await flush();
}
async function handleNotification(input) {
  const sessionKey = getSessionKey(input);
  const notificationType = pickString(input.notification_type, input.type);
  const usage = getUsage(input);
  const contextWindow = getContextWindow(input);
  const duration = pickNumber(input.duration_ms, input.elapsed_ms);
  if (notificationType === "Done" || notificationType === "success") {
    const state = sessionKey ? loadState(sessionKey) : { spans: {} };
    const runId = sessionKey ? activeRuns.get(sessionKey) || state.runId : void 0;
    if (runId) {
      enqueue(buildEnvelope(FRAMEWORK, HOST, "run.end", sessionKey, {
        runId,
        payload: {
          status: "success",
          duration_ms: duration,
          model: pickString(input.model),
          ...usage && { usage },
          ...contextWindow && { context_window: contextWindow }
        }
      }));
    }
  }
  await flush();
}
var handler = async () => {
  const args = process.argv.slice(2);
  const hookType = args[0] || "unknown";
  let input = {};
  try {
    const stdin = await readStdin();
    if (stdin) {
      input = JSON.parse(stdin);
    }
  } catch {
    input = {};
  }
  try {
    switch (hookType) {
      case "start":
        await handleSessionStart(input);
        break;
      case "stop":
        await handleSessionEnd(input);
        break;
      case "prompt":
        await handlePromptSubmit(input);
        break;
      case "tool-start":
        await handleToolStart(input);
        break;
      case "tool-end":
        await handleToolEnd(input);
        break;
      case "subagent-start":
        await handleSubagentStart(input);
        break;
      case "subagent-stop":
        await handleSubagentStop(input);
        break;
      case "compact-start":
        await handleCompactStart(input);
        break;
      case "compact-end":
        await handleCompactEnd(input);
        break;
      case "notification":
        await handleNotification(input);
        break;
      default:
        console.debug(`[agentmon] unknown hook type: ${hookType}`);
    }
  } catch (err) {
    console.debug("[agentmon] handler error:", err);
  }
};
handler();