@hoverlover/cc-discord 0.1.0

package/scripts/orchestrator.sh

@@ -0,0 +1,325 @@
+#!/bin/bash
+# orchestrator.sh — Discover Discord channels and manage one channel-agent per channel.
+#
+# This is a pure shell script (no Claude instance). It:
+# 1. Queries the relay API for active channels
+# 2. Spawns one channel-agent.sh per channel as a child process
+# 3. Monitors children and restarts any that exit
+# 4. On SIGTERM/SIGINT, kills all children and exits cleanly
+#
+# Usage: orchestrator.sh
+#
+# Environment:
+#   RELAY_HOST, RELAY_PORT, RELAY_API_TOKEN — relay server coordinates
+#   HEALTH_CHECK_INTERVAL — seconds between health checks (default: 30)
+#   AGENT_RESTART_DELAY — seconds to wait before restarting a dead agent (default: 5)
+#   STUCK_AGENT_THRESHOLD — seconds without heartbeat + unread msgs = stuck (default: 900)
+
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+source "$ROOT_DIR/scripts/load-env.sh"
+
+# Load relay connection env vars
+load_env_file "$ROOT_DIR/.env.worker"
+load_env_file "${CC_DISCORD_CONFIG_DIR:-$HOME/.config/cc-discord}/.env.worker"
+load_env_file "$ROOT_DIR/.env"
+load_env_file "${CC_DISCORD_CONFIG_DIR:-$HOME/.config/cc-discord}/.env"
+
+# Ensure bun/curl are findable
+export PATH="$HOME/.bun/bin:/opt/homebrew/bin:/usr/local/bin:$PATH"
+
+RELAY_HOST="${RELAY_HOST:-127.0.0.1}"
+RELAY_PORT="${RELAY_PORT:-3199}"
+RELAY_API_TOKEN="${RELAY_API_TOKEN:-}"
+HEALTH_CHECK_INTERVAL="${HEALTH_CHECK_INTERVAL:-30}"
+AGENT_RESTART_DELAY="${AGENT_RESTART_DELAY:-5}"
+
+RELAY_URL="http://${RELAY_HOST}:${RELAY_PORT}"
+
+# Track child PIDs and names using parallel indexed arrays.
+# (Associative arrays lose state inside piped subshells.)
+KNOWN_CHANNEL_IDS=()
+KNOWN_CHANNEL_NAMES=()
+KNOWN_CHANNEL_PIDS=()
+
+log() {
+  echo "[orchestrator] $(date '+%H:%M:%S') $*"
+}
+
+# Return the array index for a channel_id, or -1 if not found
+find_channel_index() {
+  local target="$1"
+  for i in "${!KNOWN_CHANNEL_IDS[@]}"; do
+    if [ "${KNOWN_CHANNEL_IDS[$i]}" = "$target" ]; then
+      echo "$i"
+      return
+    fi
+  done
+  echo "-1"
+}
+
+# Clean shutdown: kill all channel agents
+cleanup() {
+  log "Shutting down -- killing all channel agents..."
+  for i in "${!KNOWN_CHANNEL_PIDS[@]}"; do
+    local pid="${KNOWN_CHANNEL_PIDS[$i]}"
+    local name="${KNOWN_CHANNEL_NAMES[$i]:-unknown}"
+    if [ "$pid" -gt 0 ] && kill -0 "$pid" 2>/dev/null; then
+      log "  Killing #${name} (PID $pid)"
+      kill -TERM "$pid" 2>/dev/null || true
+    fi
+  done
+
+  # Wait briefly for graceful shutdown, then force-kill stragglers
+  sleep 2
+  for i in "${!KNOWN_CHANNEL_PIDS[@]}"; do
+    local pid="${KNOWN_CHANNEL_PIDS[$i]}"
+    if [ "$pid" -gt 0 ] && kill -0 "$pid" 2>/dev/null; then
+      kill -9 "$pid" 2>/dev/null || true
+    fi
+  done
+
+  log "All channel agents stopped."
+  exit 0
+}
+
+trap cleanup SIGTERM SIGINT
+
+# Query relay API and output "id name" lines
+discover_channels_lines() {
+  local response
+  response=$(curl -s --max-time 10 \
+    -H "x-api-token: ${RELAY_API_TOKEN}" \
+    "${RELAY_URL}/api/channels" 2>/dev/null) || {
+    log "WARNING: Failed to reach relay at ${RELAY_URL}"
+    return
+  }
+
+  echo "$response" | bun -e "
+    const input = await Bun.stdin.text();
+    try {
+      const data = JSON.parse(input);
+      if (data.success && Array.isArray(data.channels)) {
+        for (const ch of data.channels) {
+          console.log(ch.id + ' ' + (ch.name || 'channel-' + ch.id));
+        }
+      }
+    } catch {}
+  "
+}
+
+# Start a channel agent as a child process
+start_channel_agent() {
+  local channel_id="$1"
+  local channel_name="$2"
+
+  log "Starting agent for #${channel_name} (${channel_id})"
+  bash "$ROOT_DIR/scripts/channel-agent.sh" "$channel_id" "$channel_name" &
+  local pid=$!
+
+  local idx
+  idx=$(find_channel_index "$channel_id")
+  if [ "$idx" -ge 0 ]; then
+    KNOWN_CHANNEL_PIDS[$idx]=$pid
+  else
+    KNOWN_CHANNEL_IDS+=("$channel_id")
+    KNOWN_CHANNEL_NAMES+=("$channel_name")
+    KNOWN_CHANNEL_PIDS+=("$pid")
+  fi
+
+  log "  Agent #${channel_name} started (PID $pid)"
+}
+
+# Check if a channel agent PID is still running
+is_agent_alive() {
+  local pid="$1"
+  [ "$pid" -gt 0 ] && kill -0 "$pid" 2>/dev/null
+}
+
+# Kill and restart a stuck agent
+kill_stuck_agent() {
+  local channel_id="$1"
+  local idx
+  idx=$(find_channel_index "$channel_id")
+  if [ "$idx" -lt 0 ]; then
+    log "WARNING: stuck agent $channel_id not in known list — skipping"
+    return
+  fi
+
+  local pid="${KNOWN_CHANNEL_PIDS[$idx]}"
+  local name="${KNOWN_CHANNEL_NAMES[$idx]}"
+
+  if is_agent_alive "$pid"; then
+    log "Killing stuck agent #${name} (${channel_id}, PID $pid)"
+    kill -TERM "$pid" 2>/dev/null || true
+    sleep 2
+    if is_agent_alive "$pid"; then
+      kill -9 "$pid" 2>/dev/null || true
+    fi
+    wait "$pid" 2>/dev/null || true
+  fi
+
+  log "Restarting stuck agent #${name} in ${AGENT_RESTART_DELAY}s..."
+  sleep "$AGENT_RESTART_DELAY"
+  start_channel_agent "$channel_id" "$name"
+}
+
+# Query /api/agent-health for stuck agents and restart them.
+# An agent is truly stuck ONLY if ALL THREE conditions are met:
+#   1. Heartbeat stale (>threshold) — agent isn't polling
+#   2. Unread messages waiting — someone is expecting a response
+#   3. Log file stale (>threshold) — agent isn't producing output either
+# This avoids false kills during long-running tasks that are still producing output.
+STUCK_THRESHOLD="${STUCK_AGENT_THRESHOLD:-900}"  # default 15 min
+
+# Check how many seconds since a file was last modified.
+# Returns 999999 if file doesn't exist.
+file_age_seconds() {
+  local filepath="$1"
+  if [ ! -f "$filepath" ]; then
+    echo 999999
+    return
+  fi
+  # macOS stat: -f %m gives mtime as epoch seconds
+  # Linux stat: -c %Y gives mtime as epoch seconds
+  local mtime
+  if stat -f %m "$filepath" >/dev/null 2>&1; then
+    mtime=$(stat -f %m "$filepath")
+  else
+    mtime=$(stat -c %Y "$filepath" 2>/dev/null || echo 0)
+  fi
+  local now
+  now=$(date +%s)
+  echo $(( now - mtime ))
+}
+
+# Map channel_id to its log file path
+channel_log_file() {
+  local channel_id="$1"
+  local idx
+  idx=$(find_channel_index "$channel_id")
+  if [ "$idx" -lt 0 ]; then
+    echo ""
+    return
+  fi
+  local name="${KNOWN_CHANNEL_NAMES[$idx]}"
+  local cid="${KNOWN_CHANNEL_IDS[$idx]}"
+  echo "${LOG_DIR}/channel-${name}-${cid}.log"
+}
+
+check_stuck_agents() {
+  local response
+  response=$(curl -s --max-time 10 \
+    -H "x-api-token: ${RELAY_API_TOKEN}" \
+    "${RELAY_URL}/api/agent-health?stale_threshold=${STUCK_THRESHOLD}" 2>/dev/null) || {
+    log "WARNING: Failed to reach /api/agent-health"
+    return
+  }
+
+  # Extract stuck agent IDs using bun (jq-like)
+  local stuck_ids
+  stuck_ids=$(echo "$response" | bun -e "
+    const input = await Bun.stdin.text();
+    try {
+      const data = JSON.parse(input);
+      if (data.success && Array.isArray(data.stuckAgents)) {
+        for (const id of data.stuckAgents) {
+          console.log(id);
+        }
+      }
+    } catch {}
+  " 2>/dev/null) || return
+
+  if [ -z "$stuck_ids" ]; then
+    return
+  fi
+
+  while IFS= read -r stuck_id; do
+    [ -z "$stuck_id" ] && continue
+
+    # Condition 3: check log file freshness
+    local log_path
+    log_path=$(channel_log_file "$stuck_id")
+    if [ -n "$log_path" ]; then
+      local log_age
+      log_age=$(file_age_seconds "$log_path")
+      if [ "$log_age" -lt "$STUCK_THRESHOLD" ]; then
+        log "Agent ${stuck_id}: heartbeat stale + unread msgs, but log updated ${log_age}s ago — NOT stuck (working)"
+        continue
+      fi
+      log "Stuck agent detected: ${stuck_id} (heartbeat stale, unread msgs, log stale ${log_age}s)"
+    else
+      log "Stuck agent detected: ${stuck_id} (heartbeat stale, unread msgs, no log file found)"
+    fi
+
+    kill_stuck_agent "$stuck_id"
+  done <<< "$stuck_ids"
+}
+
+# ---- Main ----
+
+# Set up logging
+LOG_DIR="${CC_DISCORD_LOG_DIR:-/tmp/cc-discord/logs}"
+mkdir -p "$LOG_DIR"
+LOG_FILE="${LOG_DIR}/orchestrator.log"
+
+# Redirect all orchestrator output to log file
+exec >> "$LOG_FILE" 2>&1
+
+log "Starting (relay=${RELAY_URL}, health_check=${HEALTH_CHECK_INTERVAL}s)"
+log "Logging to $LOG_FILE"
+
+# Wait for relay to be reachable
+MAX_WAIT=60
+WAITED=0
+while ! curl -s --max-time 3 -H "x-api-token: ${RELAY_API_TOKEN}" "${RELAY_URL}/api/channels" >/dev/null 2>&1; do
+  if [ "$WAITED" -ge "$MAX_WAIT" ]; then
+    log "ERROR: Relay not reachable after ${MAX_WAIT}s. Exiting."
+    exit 1
+  fi
+  log "Waiting for relay server at ${RELAY_URL}..."
+  sleep 3
+  WAITED=$((WAITED + 3))
+done
+
+log "Relay is up. Discovering channels..."
+
+# Initial channel discovery — read lines into the current shell (no subshell)
+while IFS=' ' read -r channel_id channel_name; do
+  [ -z "$channel_id" ] && continue
+  start_channel_agent "$channel_id" "$channel_name"
+done < <(discover_channels_lines)
+
+log "Initial spawn complete (${#KNOWN_CHANNEL_IDS[@]} channels). Entering health check loop."
+
+# Health check loop
+while true; do
+  sleep "$HEALTH_CHECK_INTERVAL"
+
+  # Check for dead agents and restart them
+  for i in "${!KNOWN_CHANNEL_IDS[@]}"; do
+    _pid="${KNOWN_CHANNEL_PIDS[$i]}"
+    if ! is_agent_alive "$_pid"; then
+      _name="${KNOWN_CHANNEL_NAMES[$i]}"
+      _cid="${KNOWN_CHANNEL_IDS[$i]}"
+      wait "$_pid" 2>/dev/null || true
+      log "Agent #${_name} (${_cid}) exited. Restarting in ${AGENT_RESTART_DELAY}s..."
+      sleep "$AGENT_RESTART_DELAY"
+      start_channel_agent "$_cid" "$_name"
+    fi
+  done
+
+  # Check for stuck agents (alive but not polling)
+  check_stuck_agents
+
+  # Check for new channels
+  while IFS=' ' read -r channel_id channel_name; do
+    [ -z "$channel_id" ] && continue
+    _idx=$(find_channel_index "$channel_id")
+    if [ "$_idx" -lt 0 ]; then
+      log "New channel discovered: #${channel_name} (${channel_id})"
+      start_channel_agent "$channel_id" "$channel_name"
+    fi
+  done < <(discover_channels_lines)
+done

package/scripts/parse-claude-stream.ts

@@ -0,0 +1,349 @@
+#!/usr/bin/env bun
+/**
+ * parse-claude-stream.ts — Transform Claude CLI stream-json output into
+ * human-readable log lines.
+ *
+ * Reads NDJSON from stdin (as produced by `claude -p --output-format stream-json --verbose`),
+ * extracts the interesting events (assistant text, tool use, tool results, errors,
+ * thinking/reasoning), and writes concise, timestamped log lines to stdout.
+ *
+ * Claude CLI stream-json event types (v2.x):
+ *   type:"system"    subtype:"init"|"hook_started"|"hook_response"
+ *   type:"assistant"  message:{content:[...], usage:{...}}
+ *   type:"user"       message:{content:[...]} (tool results)
+ *   type:"result"     subtype:"success"|"error"
+ *   type:"rate_limit_event"
+ *   type:"error"
+ *
+ * Usage:
+ *   claude -p --output-format stream-json --verbose ... | bun scripts/parse-claude-stream.ts
+ *
+ * Environment:
+ *   LOG_LEVEL=debug|info|warn  (default: info)
+ *   SHOW_THINKING=1            (show extended-thinking blocks, default: 0)
+ */
+
+import { Database as DatabaseSync } from "bun:sqlite";
+import { join } from "node:path";
+
+const LOG_LEVEL = (process.env.LOG_LEVEL ?? "info").toLowerCase();
+const SHOW_THINKING = process.env.SHOW_THINKING === "1";
+
+// ---- Trace thread integration ----
+// Write reasoning/thinking blocks to the trace_events DB table so
+// the relay server can post them to the channel's live Agent Trace thread.
+
+const TRACE_ENABLED = String(process.env.TRACE_THREAD_ENABLED || "true").toLowerCase() !== "false";
+const TRACE_SESSION_ID = process.env.DISCORD_SESSION_ID || process.env.SESSION_ID || "default";
+const TRACE_AGENT_ID = process.env.AGENT_ID || process.env.CLAUDE_AGENT_ID || "claude";
+const TRACE_CHANNEL_ID = TRACE_AGENT_ID; // In channel routing mode, agent_id IS the channel ID
+const ORCHESTRATOR_DIR = process.env.ORCHESTRATOR_DIR || "";
+
+let traceDb: InstanceType<typeof DatabaseSync> | null = null;
+
+function getTraceDb(): InstanceType<typeof DatabaseSync> | null {
+  if (!TRACE_ENABLED || !ORCHESTRATOR_DIR) return null;
+  if (traceDb) return traceDb;
+  try {
+    const dbPath = join(ORCHESTRATOR_DIR, "data", "messages.db");
+    traceDb = new DatabaseSync(dbPath);
+    traceDb.exec(`
+      CREATE TABLE IF NOT EXISTS trace_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        session_id TEXT NOT NULL,
+        agent_id TEXT NOT NULL,
+        channel_id TEXT,
+        event_type TEXT NOT NULL,
+        tool_name TEXT,
+        summary TEXT,
+        posted INTEGER DEFAULT 0
+      );
+      CREATE INDEX IF NOT EXISTS idx_trace_events_pending
+        ON trace_events(posted, created_at);
+    `);
+    return traceDb;
+  } catch {
+    return null;
+  }
+}
+
+function writeTraceEvent(eventType: string, toolName: string | null, summary: string) {
+  try {
+    const db = getTraceDb();
+    if (!db) return;
+    db.prepare(`
+      INSERT INTO trace_events (session_id, agent_id, channel_id, event_type, tool_name, summary)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(TRACE_SESSION_ID, TRACE_AGENT_ID, TRACE_CHANNEL_ID, eventType, toolName, summary);
+  } catch {
+    // fail-open — never break the parser for trace
+  }
+}
+
+// ---- Helpers ----
+
+function ts(): string {
+  return new Date().toISOString().slice(11, 19); // HH:MM:SS
+}
+
+function log(tag: string, msg: string) {
+  const line = `[${ts()}] [${tag}] ${msg}`;
+  process.stdout.write(`${line}\n`);
+}
+
+function debug(tag: string, msg: string) {
+  if (LOG_LEVEL === "debug") log(tag, msg);
+}
+
+/** Truncate long strings for log display */
+function trunc(s: string, max = 200): string {
+  s = s.replace(/\n/g, "\\n");
+  return s.length > max ? `${s.slice(0, max)}…` : s;
+}
+
+// ---- Event handling ----
+
+/**
+ * Handle a top-level NDJSON event from the Claude CLI stream-json output.
+ */
+function handleEvent(evt: any) {
+  if (!evt || typeof evt !== "object") return;
+
+  const type: string = evt.type ?? "";
+
+  // -- system events: init, hooks --
+  if (type === "system") {
+    const subtype: string = evt.subtype ?? "";
+
+    if (subtype === "init") {
+      const model = evt.model ?? "?";
+      const sid = evt.session_id ?? "?";
+      const mode = evt.permissionMode ?? "?";
+      log("init", `model=${model} session=${sid} mode=${mode}`);
+      return;
+    }
+
+    if (subtype === "hook_started") {
+      debug("hook", `started ${evt.hook_name ?? "?"}`);
+      return;
+    }
+
+    if (subtype === "hook_response") {
+      const code = evt.exit_code ?? "?";
+      const outcome = evt.outcome ?? "?";
+      if (outcome !== "success" || code !== 0) {
+        log("hook", `${evt.hook_name ?? "?"} exit=${code} outcome=${outcome}`);
+        if (evt.stderr) log("hook:stderr", trunc(String(evt.stderr), 300));
+      } else {
+        debug("hook", `${evt.hook_name ?? "?"} ok`);
+      }
+      return;
+    }
+
+    // Other system subtypes
+    debug("system", `subtype=${subtype} ${trunc(JSON.stringify(evt), 200)}`);
+    return;
+  }
+
+  // -- assistant turn: contains message with content blocks --
+  if (type === "assistant") {
+    const msg = evt.message;
+    if (!msg) {
+      debug("assistant", "empty message");
+      return;
+    }
+
+    const content = msg.content;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block.type === "text" && block.text) {
+          log("assistant", trunc(block.text, 500));
+        } else if (block.type === "tool_use") {
+          const name = block.name ?? "?";
+          const input = block.input ?? {};
+          // Format tool inputs concisely
+          if (name === "Bash") {
+            const cmd = input.command ?? "";
+            const desc = input.description ?? "";
+            log("tool_use", `Bash: ${trunc(desc || cmd, 400)}`);
+          } else if (name === "Read") {
+            log("tool_use", `Read: ${input.file_path ?? "?"}`);
+          } else if (name === "Edit" || name === "Write") {
+            log("tool_use", `${name}: ${input.file_path ?? "?"}`);
+          } else {
+            log("tool_use", `${name} ${trunc(JSON.stringify(input), 300)}`);
+          }
+        } else if (block.type === "thinking" && block.thinking) {
+          if (SHOW_THINKING) {
+            log("thinking", trunc(block.thinking, 300));
+          } else {
+            debug("thinking", trunc(block.thinking, 300));
+          }
+          // Write full reasoning to trace thread (no truncation)
+          writeTraceEvent("thinking", null, block.thinking);
+        }
+      }
+    }
+
+    // Log usage summary
+    const usage = msg.usage;
+    if (usage) {
+      const input_tokens = usage.input_tokens ?? 0;
+      const cache_read = usage.cache_read_input_tokens ?? 0;
+      const output_tokens = usage.output_tokens ?? 0;
+      debug("usage", `in=${input_tokens} cache=${cache_read} out=${output_tokens}`);
+    }
+    return;
+  }
+
+  // -- user turn: typically tool results --
+  if (type === "user") {
+    const msg = evt.message;
+    if (!msg) return;
+
+    const content = msg.content;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block.type === "tool_result") {
+          const output = block.output ?? block.content ?? "";
+          const str = typeof output === "string" ? output : JSON.stringify(output);
+          debug("tool_result", trunc(str, 300));
+        }
+      }
+    }
+    return;
+  }
+
+  // -- result: session complete --
+  if (type === "result") {
+    const subtype = evt.subtype ?? "?";
+    const duration = evt.duration_ms ? `${(evt.duration_ms / 1000).toFixed(1)}s` : "?";
+    const cost = evt.total_cost_usd ? `$${evt.total_cost_usd.toFixed(4)}` : "";
+    const turns = evt.num_turns ?? "?";
+    log("result", `${subtype} duration=${duration} turns=${turns} ${cost}`.trim());
+    return;
+  }
+
+  // -- rate limit --
+  if (type === "rate_limit_event") {
+    const info = evt.rate_limit_info ?? {};
+    if (info.status !== "allowed") {
+      log("rate_limit", `status=${info.status} resets=${info.resetsAt ?? "?"}`);
+    } else {
+      debug("rate_limit", `allowed`);
+    }
+    return;
+  }
+
+  // -- error --
+  if (type === "error") {
+    const errMsg = typeof evt.error === "string" ? evt.error : JSON.stringify(evt.error ?? evt);
+    log("ERROR", trunc(errMsg, 500));
+    return;
+  }
+
+  // ---- Legacy / raw Anthropic streaming API format (fallback) ----
+
+  if (
+    type === "content_block_start" ||
+    type === "content_block_delta" ||
+    type === "content_block_stop" ||
+    type === "message_start" ||
+    type === "message_delta" ||
+    type === "message_stop"
+  ) {
+    // Legacy streaming format — log at debug
+    debug("legacy_stream", `type=${type}`);
+    return;
+  }
+
+  // -- init (legacy format) --
+  if (type === "init") {
+    const sid = evt.session_id ?? "unknown";
+    log("init", `session=${sid}`);
+    return;
+  }
+
+  // -- message (legacy format) --
+  if (type === "message") {
+    const role = evt.role ?? "?";
+    if (Array.isArray(evt.content)) {
+      for (const block of evt.content) {
+        if (block.type === "text" && block.text) {
+          log(role, trunc(block.text, 500));
+        } else if (block.type === "tool_use") {
+          log("tool_use", `${block.name ?? "?"} ${trunc(JSON.stringify(block.input ?? {}), 300)}`);
+        }
+      }
+    }
+    return;
+  }
+
+  // Unknown event — log at info so we catch new event types
+  log("unknown_event", `type=${type} ${trunc(JSON.stringify(evt), 300)}`);
+}
+
+function processLine(line: string) {
+  line = line.trim();
+  if (!line) return;
+
+  let parsed: any;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    // Not JSON — pass through as-is (e.g. stderr leaking into stdout)
+    log("raw", trunc(line, 300));
+    return;
+  }
+
+  // stream_event wrapper (some versions wrap events)
+  if (parsed.type === "stream_event" && parsed.event) {
+    handleEvent(parsed.event);
+  } else {
+    handleEvent(parsed);
+  }
+}
+
+// ---- Main: read stdin line by line ----
+
+async function main() {
+  log("parser", "Claude stream parser started");
+
+  const reader = Bun.stdin.stream().getReader();
+  const decoder = new TextDecoder();
+  let leftover = "";
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const chunk = leftover + decoder.decode(value, { stream: true });
+      const lines = chunk.split("\n");
+      // Last element might be incomplete — save for next chunk
+      leftover = lines.pop() ?? "";
+
+      for (const line of lines) {
+        processLine(line);
+      }
+    }
+
+    // Process any remaining data
+    if (leftover.trim()) {
+      processLine(leftover);
+    }
+  } finally {
+    // no-op — buffers removed since CLI sends complete messages
+  }
+
+  log("parser", "Stream ended");
+
+  // Clean up trace DB connection
+  try { traceDb?.close(); } catch { /* ignore */ }
+}
+
+main().catch((err) => {
+  log("FATAL", String(err));
+  process.exit(1);
+});