@fml-inc/panopticon 0.1.0

package/dist/chunk-LWXF7YRG.js

@@ -0,0 +1,626 @@
+import {
+  allTargets
+} from "./chunk-QVK6VGCV.js";
+import {
+  getDb
+} from "./chunk-DZ5HJFB4.js";
+
+// src/db/query.ts
+function parseSince(since) {
+  if (!since) return null;
+  const match = since.match(/^(\d+)(h|d|m)$/);
+  if (match) {
+    const [, num, unit] = match;
+    const ms = unit === "h" ? 36e5 : unit === "d" ? 864e5 : 6e4;
+    return Date.now() - parseInt(num, 10) * ms;
+  }
+  const date = new Date(since);
+  return Number.isNaN(date.getTime()) ? null : date.getTime();
+}
+function toIso(ms) {
+  return new Date(ms).toISOString();
+}
+function buildOtelLogExprs() {
+  const defaultTs = "CAST(timestamp_ns / 1000000 AS INTEGER)";
+  const eventExprs = /* @__PURE__ */ new Set(["body"]);
+  const extraTsExprs = /* @__PURE__ */ new Set();
+  for (const target of allTargets()) {
+    const lf = target.otel?.logFields;
+    if (!lf) continue;
+    for (const expr of lf.eventTypeExprs ?? []) {
+      eventExprs.add(expr);
+    }
+    for (const expr of lf.timestampMsExprs ?? []) {
+      if (expr !== defaultTs) extraTsExprs.add(expr);
+    }
+  }
+  const eventExprArr = [...eventExprs];
+  const eventType = eventExprArr.length === 1 ? eventExprArr[0] : `COALESCE(${eventExprArr.join(", ")})`;
+  let timestampMs = defaultTs;
+  if (extraTsExprs.size > 0) {
+    const fallbackArr = [...extraTsExprs];
+    const fallbackExpr = fallbackArr.length === 1 ? fallbackArr[0] : `COALESCE(${fallbackArr.join(", ")})`;
+    timestampMs = `CASE WHEN timestamp_ns > 0 THEN ${defaultTs} ELSE ${fallbackExpr} END`;
+  }
+  return { eventType, timestampMs };
+}
+var _otelLogExprs = null;
+function otelLogExprs() {
+  if (!_otelLogExprs) _otelLogExprs = buildOtelLogExprs();
+  return _otelLogExprs;
+}
+var SESSION_COST_SQL = `
+  COALESCE((
+    SELECT s.total_input_tokens * COALESCE(mp.input_per_m, 0) / 1000000.0
+         + s.total_output_tokens * COALESCE(mp.output_per_m, 0) / 1000000.0
+         + s.total_cache_read_tokens * COALESCE(mp.cache_read_per_m, 0) / 1000000.0
+         + s.total_cache_creation_tokens * COALESCE(mp.cache_write_per_m, 0) / 1000000.0
+    FROM model_pricing mp
+    WHERE s.model LIKE mp.model_id || '%'
+    ORDER BY LENGTH(mp.model_id) DESC, mp.updated_ms DESC
+    LIMIT 1
+  ), 0)`;
+function listSessions(opts = {}) {
+  const db = getDb();
+  const limit = opts.limit ?? 20;
+  const sinceMs = parseSince(opts.since);
+  const conditions = [];
+  const params = [];
+  if (sinceMs) {
+    conditions.push("s.started_at_ms >= ?");
+    params.push(sinceMs);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const sql = `
+    SELECT s.session_id, s.target, s.model, s.project,
+           s.started_at_ms, s.ended_at_ms, s.first_prompt, s.summary,
+           COALESCE(s.turn_count, 0) as turn_count,
+           COALESCE(s.message_count, 0) as message_count,
+           COALESCE(s.total_input_tokens, 0) as total_input_tokens,
+           COALESCE(s.total_output_tokens, 0) as total_output_tokens,
+           s.parent_session_id, s.relationship_type,
+           ${SESSION_COST_SQL} as total_cost
+    FROM sessions s
+    ${where}
+    ORDER BY s.started_at_ms DESC
+    LIMIT ?
+  `;
+  params.push(limit);
+  const rows = db.prepare(sql).all(...params);
+  const sessionIds = rows.map((r) => r.session_id);
+  const repoRows = sessionIds.length > 0 ? db.prepare(
+    `SELECT session_id, repository, git_user_name, git_user_email
+             FROM session_repositories
+             WHERE session_id IN (${sessionIds.map(() => "?").join(",")})`
+  ).all(...sessionIds) : [];
+  const reposBySession = /* @__PURE__ */ new Map();
+  for (const r of repoRows) {
+    const list = reposBySession.get(r.session_id) ?? [];
+    list.push(r);
+    reposBySession.set(r.session_id, list);
+  }
+  const sessions = rows.map((row) => ({
+    sessionId: row.session_id,
+    target: row.target,
+    model: row.model,
+    project: row.project,
+    startedAt: row.started_at_ms ? toIso(row.started_at_ms) : null,
+    endedAt: row.ended_at_ms ? toIso(row.ended_at_ms) : null,
+    firstPrompt: row.first_prompt,
+    turnCount: row.turn_count,
+    messageCount: row.message_count,
+    totalInputTokens: row.total_input_tokens,
+    totalOutputTokens: row.total_output_tokens,
+    totalCost: row.total_cost,
+    repositories: (reposBySession.get(row.session_id) ?? []).map((r) => ({
+      name: r.repository,
+      gitUserName: r.git_user_name,
+      gitUserEmail: r.git_user_email
+    })),
+    parentSessionId: row.parent_session_id,
+    relationshipType: row.relationship_type,
+    summary: row.summary
+  }));
+  return {
+    sessions,
+    totalCount: sessions.length,
+    source: "local"
+  };
+}
+function sessionTimeline(opts) {
+  const db = getDb();
+  const limit = opts.limit ?? 50;
+  const offset = opts.offset ?? 0;
+  const truncate = !opts.fullPayloads;
+  const sessionRow = db.prepare(
+    "SELECT session_id, target, model, project, parent_session_id, relationship_type FROM sessions WHERE session_id = ?"
+  ).get(opts.sessionId);
+  if (!sessionRow) {
+    return {
+      session: null,
+      messages: [],
+      totalMessages: 0,
+      hasMore: false,
+      source: "local"
+    };
+  }
+  const repoRows = db.prepare(
+    "SELECT repository, git_user_name, git_user_email FROM session_repositories WHERE session_id = ?"
+  ).all(opts.sessionId);
+  const childRows = db.prepare(
+    "SELECT session_id, relationship_type, model, COALESCE(turn_count, 0) as turn_count, first_prompt, started_at_ms FROM sessions WHERE parent_session_id = ?"
+  ).all(opts.sessionId);
+  const childSessions = childRows.map((r) => ({
+    sessionId: r.session_id,
+    relationshipType: r.relationship_type,
+    model: r.model,
+    turnCount: r.turn_count,
+    firstPrompt: r.first_prompt,
+    startedAtMs: r.started_at_ms
+  }));
+  const totalMessages = db.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ?").get(opts.sessionId).c;
+  const contentCol = truncate ? "SUBSTR(m.content, 1, 500)" : "m.content";
+  const msgRows = db.prepare(
+    `SELECT m.id, m.ordinal, m.role, ${contentCol} as content, m.timestamp_ms,
+              m.model, m.is_system, m.has_thinking, m.has_tool_use,
+              m.content_length, m.uuid, m.parent_uuid,
+              m.token_usage, m.context_tokens, m.output_tokens
+       FROM messages m
+       WHERE m.session_id = ?
+       ORDER BY m.ordinal ASC
+       LIMIT ? OFFSET ?`
+  ).all(opts.sessionId, limit, offset);
+  const msgIds = msgRows.map((m) => m.id);
+  const tcRows = msgIds.length > 0 ? db.prepare(
+    `SELECT tc.message_id, tc.tool_name, tc.category, tc.tool_use_id,
+                    tc.input_json, tc.skill_name, tc.result_content_length,
+                    tc.duration_ms, tc.subagent_session_id
+             FROM tool_calls tc
+             WHERE tc.message_id IN (${msgIds.map(() => "?").join(",")})
+             ORDER BY tc.id ASC`
+  ).all(...msgIds) : [];
+  const subagentIds = [
+    ...new Set(
+      tcRows.map((tc) => tc.subagent_session_id).filter(Boolean)
+    )
+  ];
+  const subagentMap = /* @__PURE__ */ new Map();
+  if (subagentIds.length > 0) {
+    const subRows = db.prepare(
+      `SELECT session_id, model, COALESCE(turn_count, 0) as turn_count, first_prompt
+         FROM sessions WHERE session_id IN (${subagentIds.map(() => "?").join(",")})`
+    ).all(...subagentIds);
+    for (const r of subRows) {
+      subagentMap.set(r.session_id, {
+        model: r.model,
+        turn_count: r.turn_count,
+        first_prompt: r.first_prompt
+      });
+    }
+  }
+  const tcByMessage = /* @__PURE__ */ new Map();
+  for (const tc of tcRows) {
+    const list = tcByMessage.get(tc.message_id) ?? [];
+    list.push(tc);
+    tcByMessage.set(tc.message_id, list);
+  }
+  const messages = msgRows.map((m) => {
+    const tcs = tcByMessage.get(m.id) ?? [];
+    return {
+      id: m.id,
+      ordinal: m.ordinal,
+      role: m.role,
+      content: m.content,
+      timestampMs: m.timestamp_ms,
+      model: m.model,
+      isSystem: m.is_system === 1,
+      hasThinking: m.has_thinking === 1,
+      hasToolUse: m.has_tool_use === 1,
+      contentLength: m.content_length,
+      uuid: m.uuid,
+      parentUuid: m.parent_uuid,
+      tokenUsage: m.token_usage,
+      contextTokens: m.context_tokens,
+      outputTokens: m.output_tokens,
+      toolCalls: tcs.map((tc) => {
+        const sub = tc.subagent_session_id ? subagentMap.get(tc.subagent_session_id) : void 0;
+        return {
+          toolName: tc.tool_name,
+          category: tc.category,
+          toolUseId: tc.tool_use_id,
+          inputJson: truncate ? tc.input_json?.slice(0, 500) ?? null : tc.input_json,
+          skillName: tc.skill_name,
+          resultContentLength: tc.result_content_length,
+          durationMs: tc.duration_ms,
+          subagentSessionId: tc.subagent_session_id,
+          subagent: sub ? {
+            sessionId: tc.subagent_session_id,
+            model: sub.model,
+            turnCount: sub.turn_count,
+            firstPrompt: sub.first_prompt
+          } : null
+        };
+      })
+    };
+  });
+  return {
+    session: {
+      sessionId: opts.sessionId,
+      target: sessionRow.target,
+      model: sessionRow.model,
+      project: sessionRow.project,
+      parentSessionId: sessionRow.parent_session_id,
+      relationshipType: sessionRow.relationship_type,
+      repositories: repoRows.map((r) => ({
+        name: r.repository,
+        gitUserName: r.git_user_name,
+        gitUserEmail: r.git_user_email
+      })),
+      childSessions
+    },
+    messages,
+    totalMessages,
+    hasMore: offset + limit < totalMessages,
+    source: "local"
+  };
+}
+function costBreakdown(opts = {}) {
+  const db = getDb();
+  const sinceMs = parseSince(opts.since);
+  const groupBy = opts.groupBy ?? "session";
+  const conditions = [];
+  const params = [];
+  if (sinceMs) {
+    conditions.push("s.started_at_ms >= ?");
+    params.push(sinceMs);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  let groupExpr;
+  let selectExpr;
+  if (groupBy === "day") {
+    groupExpr = "date(s.started_at_ms / 1000, 'unixepoch')";
+    selectExpr = `${groupExpr} as group_key`;
+  } else if (groupBy === "model") {
+    groupExpr = "COALESCE(s.model, 'unknown')";
+    selectExpr = `${groupExpr} as group_key`;
+  } else {
+    groupExpr = "s.session_id";
+    selectExpr = "s.session_id as group_key";
+  }
+  const sql = `
+    SELECT ${selectExpr},
+           SUM(COALESCE(s.total_input_tokens, 0) + COALESCE(s.total_cache_read_tokens, 0) + COALESCE(s.total_cache_creation_tokens, 0)) as input_tokens,
+           SUM(COALESCE(s.total_output_tokens, 0)) as output_tokens,
+           SUM(COALESCE(s.total_input_tokens, 0) + COALESCE(s.total_output_tokens, 0) + COALESCE(s.total_cache_read_tokens, 0) + COALESCE(s.total_cache_creation_tokens, 0)) as total_tokens,
+           SUM(${SESSION_COST_SQL}) as total_cost,
+           COUNT(DISTINCT s.session_id) as session_count
+    FROM sessions s
+    ${where}
+    GROUP BY ${groupExpr}
+    ORDER BY ${groupBy === "day" ? "group_key DESC" : "total_tokens DESC"}
+  `;
+  const rows = db.prepare(sql).all(...params);
+  const groups = rows.map((row) => ({
+    key: row.group_key,
+    inputTokens: row.input_tokens,
+    outputTokens: row.output_tokens,
+    totalTokens: row.total_tokens,
+    totalCost: row.total_cost,
+    sessionCount: row.session_count
+  }));
+  const totals = {
+    inputTokens: groups.reduce((sum, g) => sum + g.inputTokens, 0),
+    outputTokens: groups.reduce((sum, g) => sum + g.outputTokens, 0),
+    totalTokens: groups.reduce((sum, g) => sum + g.totalTokens, 0),
+    totalCost: groups.reduce((sum, g) => sum + g.totalCost, 0)
+  };
+  return { groups, totals, groupBy, source: "local" };
+}
+function search(opts) {
+  const db = getDb();
+  const limit = opts.limit ?? 20;
+  const offset = opts.offset ?? 0;
+  const sinceMs = parseSince(opts.since);
+  const pattern = `%${opts.query}%`;
+  const truncate = !opts.fullPayloads;
+  const hookPayloadCol = truncate ? "SUBSTR(decompress(h.payload), 1, 500)" : "decompress(h.payload)";
+  const hookConditions = [];
+  const hookParams = [];
+  hookConditions.push(
+    "(h.id IN (SELECT rowid FROM hook_events_fts WHERE hook_events_fts MATCH ?) OR h.tool_name LIKE ? OR h.event_type LIKE ?)"
+  );
+  hookParams.push(opts.query, pattern, pattern);
+  if (opts.eventTypes?.length) {
+    hookConditions.push(
+      `h.event_type IN (${opts.eventTypes.map(() => "?").join(",")})`
+    );
+    hookParams.push(...opts.eventTypes);
+  }
+  if (sinceMs) {
+    hookConditions.push("h.timestamp_ms >= ?");
+    hookParams.push(sinceMs);
+  }
+  const hookSql = `
+    SELECT 'hook' as source, h.id, h.session_id, h.event_type, h.timestamp_ms,
+           h.tool_name, h.cwd, ${hookPayloadCol} as payload
+    FROM hook_events h
+    WHERE ${hookConditions.join(" AND ")}
+  `;
+  const otelConditions = ["(o.body LIKE ? OR o.attributes LIKE ?)"];
+  const otelParams = [pattern, pattern];
+  if (sinceMs) {
+    otelConditions.push("CAST(o.timestamp_ns / 1000000 AS INTEGER) >= ?");
+    otelParams.push(sinceMs);
+  }
+  const otelAttrsCol = truncate ? "SUBSTR(o.attributes, 1, 500)" : "o.attributes";
+  const otelEventTypeQ = otelLogExprs().eventType.replace(
+    /\b(body|timestamp_ns|attributes)\b/g,
+    "o.$1"
+  );
+  const otelTimestampMsQ = otelLogExprs().timestampMs.replace(
+    /\b(body|timestamp_ns|attributes)\b/g,
+    "o.$1"
+  );
+  const otelSql = `
+    SELECT 'otel' as source, o.id, o.session_id,
+           ${otelEventTypeQ} as event_type,
+           ${otelTimestampMsQ} as timestamp_ms,
+           NULL as tool_name, NULL as cwd, ${otelAttrsCol} as payload
+    FROM otel_logs o
+    WHERE ${otelConditions.join(" AND ")}
+  `;
+  const msgContentCol = truncate ? "SUBSTR(m.content, 1, 500)" : "m.content";
+  const msgConditions = [
+    "m.id IN (SELECT rowid FROM messages_fts WHERE messages_fts MATCH ?)"
+  ];
+  const msgParams = [opts.query];
+  if (sinceMs) {
+    msgConditions.push("m.timestamp_ms >= ?");
+    msgParams.push(sinceMs);
+  }
+  const msgSql = `
+    SELECT 'message' as source, m.id, m.session_id,
+           m.role as event_type, m.timestamp_ms,
+           NULL as tool_name, NULL as cwd, ${msgContentCol} as payload
+    FROM messages m
+    WHERE ${msgConditions.join(" AND ")}
+  `;
+  const summaryConditions = [
+    "s.summary IS NOT NULL",
+    "s.summary LIKE ?"
+  ];
+  const summaryParams = [pattern];
+  if (sinceMs) {
+    summaryConditions.push("s.started_at_ms >= ?");
+    summaryParams.push(sinceMs);
+  }
+  const summarySql = `
+    SELECT 'summary' as source, s.session_id as id, s.session_id,
+           'summary' as event_type, s.started_at_ms as timestamp_ms,
+           NULL as tool_name, NULL as cwd, SUBSTR(s.summary, 1, 500) as payload
+    FROM sessions s
+    WHERE ${summaryConditions.join(" AND ")}
+  `;
+  const countSql = `SELECT COUNT(*) as total FROM (${hookSql} UNION ALL ${otelSql} UNION ALL ${msgSql} UNION ALL ${summarySql})`;
+  const total = db.prepare(countSql).get(...hookParams, ...otelParams, ...msgParams, ...summaryParams).total;
+  const sql = `
+    SELECT * FROM (${hookSql} UNION ALL ${otelSql} UNION ALL ${msgSql} UNION ALL ${summarySql})
+    ORDER BY timestamp_ms DESC
+    LIMIT ? OFFSET ?
+  `;
+  const rows = db.prepare(sql).all(
+    ...hookParams,
+    ...otelParams,
+    ...msgParams,
+    ...summaryParams,
+    limit,
+    offset
+  );
+  const results = rows.map((row) => {
+    const snippet = row.payload ?? row.event_type ?? "";
+    const matchType = row.source === "summary" ? "summary" : row.source === "message" ? "message" : row.event_type === "UserPromptSubmit" ? "prompt" : row.tool_name ? "tool_use" : "event";
+    return {
+      sessionId: row.session_id,
+      timestamp: toIso(row.timestamp_ms),
+      matchType,
+      matchSnippet: typeof snippet === "string" ? snippet.slice(0, 300) : String(snippet).slice(0, 300),
+      eventType: row.event_type,
+      toolName: row.tool_name
+    };
+  });
+  return {
+    results,
+    totalMatches: total,
+    query: opts.query,
+    source: "local"
+  };
+}
+function activitySummary(opts = {}) {
+  const db = getDb();
+  const sinceMs = parseSince(opts.since ?? "24h") ?? Date.now() - 864e5;
+  const now = Date.now();
+  const rawSessions = db.prepare(
+    `SELECT s.session_id, s.model, s.project,
+              s.started_at_ms, s.ended_at_ms,
+              COALESCE(s.total_input_tokens, 0) + COALESCE(s.total_output_tokens, 0) +
+              COALESCE(s.total_cache_read_tokens, 0) + COALESCE(s.total_cache_creation_tokens, 0) as total_tokens,
+              ${SESSION_COST_SQL} as total_cost
+       FROM sessions s
+       WHERE s.started_at_ms >= ?
+       ORDER BY s.started_at_ms ASC`
+  ).all(sinceMs);
+  let totalCost = 0;
+  let totalTokens = 0;
+  const sessions = [];
+  for (const s of rawSessions) {
+    totalCost += s.total_cost;
+    totalTokens += s.total_tokens;
+    const prompts = db.prepare(
+      "SELECT SUBSTR(content, 1, 100) as prompt FROM messages WHERE session_id = ? AND role = 'user' AND is_system = 0 ORDER BY ordinal ASC LIMIT 10"
+    ).all(s.session_id);
+    const tools = db.prepare(
+      "SELECT tool_name, COUNT(*) as count FROM tool_calls WHERE session_id = ? GROUP BY tool_name ORDER BY count DESC"
+    ).all(s.session_id);
+    const fileRows = db.prepare(
+      "SELECT DISTINCT json_extract(input_json, '$.file_path') as file_path FROM tool_calls WHERE session_id = ? AND tool_name IN ('Write', 'Edit') AND input_json IS NOT NULL"
+    ).all(s.session_id);
+    const repos = db.prepare(
+      "SELECT repository, git_user_name, git_user_email FROM session_repositories WHERE session_id = ?"
+    ).all(s.session_id);
+    const durationMs = s.started_at_ms && s.ended_at_ms ? s.ended_at_ms - s.started_at_ms : 0;
+    sessions.push({
+      sessionId: s.session_id,
+      startedAt: s.started_at_ms ? toIso(s.started_at_ms) : null,
+      durationMinutes: Math.round(durationMs / 6e4),
+      model: s.model,
+      project: s.project,
+      repositories: repos.map((r) => ({
+        name: r.repository,
+        gitUserName: r.git_user_name,
+        gitUserEmail: r.git_user_email
+      })),
+      userPrompts: prompts.map((p) => p.prompt),
+      toolsUsed: tools.map((t) => ({ tool: t.tool_name, count: t.count })),
+      filesModified: fileRows.map((f) => f.file_path).filter(Boolean),
+      totalCost: s.total_cost
+    });
+  }
+  const topTools = db.prepare(
+    `SELECT tc.tool_name, COUNT(*) as count
+       FROM tool_calls tc
+       INNER JOIN sessions s ON tc.session_id = s.session_id
+       WHERE s.started_at_ms >= ?
+       GROUP BY tc.tool_name ORDER BY count DESC LIMIT 10`
+  ).all(sinceMs);
+  return {
+    period: {
+      since: toIso(sinceMs),
+      until: toIso(now)
+    },
+    totalSessions: rawSessions.length,
+    totalTokens,
+    totalCost,
+    topTools: topTools.map((t) => ({ tool: t.tool_name, count: t.count })),
+    sessions,
+    source: "local"
+  };
+}
+function listPlans(opts = {}) {
+  const db = getDb();
+  const limit = opts.limit ?? 20;
+  const sinceMs = parseSince(opts.since);
+  const conditions = [
+    "tool_name = 'ExitPlanMode'",
+    "event_type = 'PreToolUse'"
+  ];
+  const params = [];
+  if (opts.session_id) {
+    conditions.push("session_id = ?");
+    params.push(opts.session_id);
+  }
+  if (sinceMs) {
+    conditions.push("timestamp_ms >= ?");
+    params.push(sinceMs);
+  }
+  const sql = `
+    SELECT id, session_id, timestamp_ms, plan, allowed_prompts
+    FROM hook_events
+    WHERE ${conditions.join(" AND ")}
+    ORDER BY timestamp_ms DESC
+    LIMIT ?
+  `;
+  params.push(limit);
+  const rows = db.prepare(sql).all(...params);
+  return rows.map((r) => ({
+    id: r.id,
+    session_id: r.session_id,
+    timestamp: toIso(r.timestamp_ms),
+    plan: r.plan,
+    allowed_prompts: r.allowed_prompts ? JSON.parse(r.allowed_prompts) : null
+  }));
+}
+function print(opts) {
+  const db = getDb();
+  if (opts.source === "hook") {
+    const sql2 = `
+      SELECT 'hook' as source, id, session_id, event_type, timestamp_ms,
+             tool_name, cwd, user_prompt, file_path, command, plan,
+             tool_result, allowed_prompts, decompress(payload) as payload
+      FROM hook_events
+      WHERE id = ?
+    `;
+    return db.prepare(sql2).get(opts.id) ?? null;
+  }
+  if (opts.source === "message") {
+    const msg = db.prepare(
+      `SELECT m.id, m.session_id, m.ordinal, m.role, m.content, m.timestamp_ms,
+              m.has_thinking, m.has_tool_use, m.content_length, m.is_system,
+              m.model, m.token_usage, m.context_tokens, m.output_tokens,
+              m.uuid, m.parent_uuid
+       FROM messages m WHERE m.id = ?`
+    ).get(opts.id);
+    if (!msg) return null;
+    const toolCalls = db.prepare(
+      `SELECT tool_name, category, tool_use_id, input_json, skill_name,
+              result_content_length, duration_ms, subagent_session_id
+       FROM tool_calls WHERE message_id = ?`
+    ).all(opts.id);
+    return { source: "message", ...msg, tool_calls: toolCalls };
+  }
+  const sql = `
+    SELECT 'otel' as source, id, session_id, ${otelLogExprs().eventType} as event_type,
+           ${otelLogExprs().timestampMs} as timestamp_ms,
+           NULL as tool_name, NULL as cwd, attributes, severity_text,
+           ${otelLogExprs().eventType} as body
+    FROM otel_logs
+    WHERE id = ?
+  `;
+  return db.prepare(sql).get(opts.id) ?? null;
+}
+function rawQuery(sql) {
+  const db = getDb();
+  const trimmed = sql.trim().toUpperCase();
+  if (!trimmed.startsWith("SELECT") && !trimmed.startsWith("WITH") && !trimmed.startsWith("PRAGMA")) {
+    throw new Error("Only SELECT, WITH, and PRAGMA statements are allowed");
+  }
+  if (!trimmed.startsWith("PRAGMA") && !trimmed.includes("LIMIT")) {
+    sql = `${sql.trimEnd().replace(/;$/, "")} LIMIT 1000`;
+  }
+  return db.prepare(sql).all();
+}
+function dbStats() {
+  const db = getDb();
+  const logs = db.prepare("SELECT COUNT(*) as count FROM otel_logs").get();
+  const metrics = db.prepare("SELECT COUNT(*) as count FROM otel_metrics").get();
+  const hooks = db.prepare("SELECT COUNT(*) as count FROM hook_events").get();
+  const spans = db.prepare("SELECT COUNT(*) as count FROM otel_spans").get();
+  const sessions = db.prepare("SELECT COUNT(*) as count FROM sessions").get();
+  const scannerTurns = db.prepare("SELECT COUNT(*) as count FROM scanner_turns").get();
+  const scannerEvents = db.prepare("SELECT COUNT(*) as count FROM scanner_events").get();
+  const messages = db.prepare("SELECT COUNT(*) as count FROM messages").get();
+  const toolCalls = db.prepare("SELECT COUNT(*) as count FROM tool_calls").get();
+  return {
+    sessions: sessions.count,
+    messages: messages.count,
+    tool_calls: toolCalls.count,
+    scanner_turns: scannerTurns.count,
+    scanner_events: scannerEvents.count,
+    hook_events: hooks.count,
+    otel_logs: logs.count,
+    otel_metrics: metrics.count,
+    otel_spans: spans.count
+  };
+}
+
+export {
+  listSessions,
+  sessionTimeline,
+  costBreakdown,
+  search,
+  activitySummary,
+  listPlans,
+  print,
+  rawQuery,
+  dbStats
+};
+//# sourceMappingURL=chunk-LWXF7YRG.js.map