@fml-inc/panopticon 0.1.0

package/dist/chunk-4SM2H22C.js

@@ -0,0 +1,169 @@
+import {
+  config
+} from "./chunk-K7YUPLES.js";
+
+// src/api/client.ts
+import http from "http";
+function post(path, body, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const json = JSON.stringify(body);
+    const req = http.request(
+      {
+        hostname: config.host,
+        port: config.port,
+        path,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(json)
+        },
+        timeout: timeoutMs
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          const text = Buffer.concat(chunks).toString("utf-8");
+          let parsed;
+          try {
+            parsed = JSON.parse(text);
+          } catch {
+            reject(
+              new Error(
+                `Invalid JSON response from server: ${text.slice(0, 200)}`
+              )
+            );
+            return;
+          }
+          if (res.statusCode && res.statusCode >= 400 && typeof parsed === "object" && parsed !== null && "error" in parsed) {
+            reject(new Error(parsed.error));
+            return;
+          }
+          resolve(parsed);
+        });
+      }
+    );
+    req.on("error", (err) => {
+      if (err.code === "ECONNREFUSED") {
+        reject(
+          new Error(
+            "Panopticon server is not running. Start with: panopticon start"
+          )
+        );
+        return;
+      }
+      reject(err);
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request to panopticon server timed out"));
+    });
+    req.write(json);
+    req.end();
+  });
+}
+var TOOL_TIMEOUT = 3e4;
+function callTool(name, params) {
+  return post("/api/tool", { name, params }, TOOL_TIMEOUT);
+}
+function listSessions(opts) {
+  return callTool(
+    "sessions",
+    opts
+  );
+}
+function sessionTimeline(opts) {
+  return callTool(
+    "timeline",
+    opts
+  );
+}
+function costBreakdown(opts) {
+  return callTool(
+    "costs",
+    opts
+  );
+}
+function activitySummary(opts) {
+  return callTool(
+    "summary",
+    opts
+  );
+}
+function listPlans(opts) {
+  return callTool("plans", opts);
+}
+function search(opts) {
+  return callTool(
+    "search",
+    opts
+  );
+}
+function print(opts) {
+  return callTool("get", opts);
+}
+function rawQuery(sql) {
+  return callTool("query", { sql });
+}
+function dbStats() {
+  return callTool("status");
+}
+var EXEC_TIMEOUT = 6e4;
+function callExec(command, params) {
+  return post("/api/exec", { command, params }, EXEC_TIMEOUT);
+}
+function pruneEstimate(cutoffMs) {
+  return callExec("prune", { cutoffMs, dryRun: true });
+}
+function pruneExecute(cutoffMs, opts) {
+  return callExec("prune", { cutoffMs, ...opts });
+}
+function refreshPricing() {
+  return callExec("refresh-pricing");
+}
+function syncReset(target) {
+  return callExec("sync-reset", target ? { target } : {});
+}
+function syncWatermarkGet(target, table) {
+  return callExec("sync-watermark-get", { target, table });
+}
+function syncWatermarkSet(target, table, value) {
+  return callExec("sync-watermark-set", { target, table, value });
+}
+function syncPending(target) {
+  return callExec("sync-pending", { target });
+}
+function syncTargetList() {
+  return callExec("sync-target-list");
+}
+function syncTargetAdd(target) {
+  return callExec("sync-target-add", target);
+}
+function syncTargetRemove(name) {
+  return callExec("sync-target-remove", { name });
+}
+
+export {
+  callTool,
+  listSessions,
+  sessionTimeline,
+  costBreakdown,
+  activitySummary,
+  listPlans,
+  search,
+  print,
+  rawQuery,
+  dbStats,
+  callExec,
+  pruneEstimate,
+  pruneExecute,
+  refreshPricing,
+  syncReset,
+  syncWatermarkGet,
+  syncWatermarkSet,
+  syncPending,
+  syncTargetList,
+  syncTargetAdd,
+  syncTargetRemove
+};
+//# sourceMappingURL=chunk-4SM2H22C.js.map

package/dist/chunk-4SM2H22C.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/api/client.ts"],"sourcesContent":["/**\n * HTTP client for the panopticon server API.\n *\n * Provides typed wrappers around POST /api/tool and POST /api/exec\n * so that CLI and MCP can query the server instead of opening the\n * database directly.\n */\nimport http from \"node:http\";\nimport { config } from \"../config.js\";\nimport type {\n  ActivitySummaryResult,\n  SearchResult,\n  SessionListResult,\n  SessionTimelineResult,\n  SpendingResult,\n} from \"../types.js\";\n\n// ── Core transport ───────────────────────────────────────────────────────────\n\nfunction post(\n  path: string,\n  body: unknown,\n  timeoutMs: number,\n): Promise<unknown> {\n  return new Promise((resolve, reject) => {\n    const json = JSON.stringify(body);\n    const req = http.request(\n      {\n        hostname: config.host,\n        port: config.port,\n        path,\n        method: \"POST\",\n        headers: {\n          \"Content-Type\": \"application/json\",\n          \"Content-Length\": Buffer.byteLength(json),\n        },\n        timeout: timeoutMs,\n      },\n      (res) => {\n        const chunks: Buffer[] = [];\n        res.on(\"data\", (chunk: Buffer) => chunks.push(chunk));\n        res.on(\"end\", () => {\n          const text = Buffer.concat(chunks).toString(\"utf-8\");\n          let parsed: unknown;\n          try {\n            parsed = JSON.parse(text);\n          } catch {\n            reject(\n              new Error(\n                `Invalid JSON response from server: ${text.slice(0, 200)}`,\n              ),\n            );\n            return;\n          }\n          if (\n            res.statusCode &&\n            res.statusCode >= 400 &&\n            typeof parsed === \"object\" &&\n            parsed !== null &&\n            \"error\" in parsed\n          ) {\n            reject(new Error((parsed as { error: string }).error));\n            return;\n          }\n          resolve(parsed);\n        });\n      },\n    );\n    req.on(\"error\", (err: NodeJS.ErrnoException) => {\n      if (err.code === \"ECONNREFUSED\") {\n        reject(\n          new Error(\n            \"Panopticon server is not running. Start with: panopticon start\",\n          ),\n        );\n        return;\n      }\n      reject(err);\n    });\n    req.on(\"timeout\", () => {\n      req.destroy();\n      reject(new Error(\"Request to panopticon server timed out\"));\n    });\n    req.write(json);\n    req.end();\n  });\n}\n\n// ── Tool calls (read-only) ──────────────────────────────────────────────────\n\nconst TOOL_TIMEOUT = 30_000;\n\nexport function callTool(\n  name: string,\n  params?: Record<string, unknown>,\n): Promise<unknown> {\n  return post(\"/api/tool\", { name, params }, TOOL_TIMEOUT);\n}\n\nexport function listSessions(opts?: {\n  limit?: number;\n  since?: string;\n}): Promise<SessionListResult> {\n  return callTool(\n    \"sessions\",\n    opts as Record<string, unknown>,\n  ) as Promise<SessionListResult>;\n}\n\nexport function sessionTimeline(opts: {\n  sessionId: string;\n  limit?: number;\n  offset?: number;\n  fullPayloads?: boolean;\n}): Promise<SessionTimelineResult> {\n  return callTool(\n    \"timeline\",\n    opts as Record<string, unknown>,\n  ) as Promise<SessionTimelineResult>;\n}\n\nexport function costBreakdown(opts?: {\n  since?: string;\n  groupBy?: \"session\" | \"model\" | \"day\";\n}): Promise<SpendingResult> {\n  return callTool(\n    \"costs\",\n    opts as Record<string, unknown>,\n  ) as Promise<SpendingResult>;\n}\n\nexport function activitySummary(opts?: {\n  since?: string;\n}): Promise<ActivitySummaryResult> {\n  return callTool(\n    \"summary\",\n    opts as Record<string, unknown>,\n  ) as Promise<ActivitySummaryResult>;\n}\n\nexport function listPlans(opts?: {\n  session_id?: string;\n  since?: string;\n  limit?: number;\n}): Promise<unknown> {\n  return callTool(\"plans\", opts as Record<string, unknown>);\n}\n\nexport function search(opts: {\n  query: string;\n  eventTypes?: string[];\n  since?: string;\n  limit?: number;\n  offset?: number;\n  fullPayloads?: boolean;\n}): Promise<SearchResult> {\n  return callTool(\n    \"search\",\n    opts as Record<string, unknown>,\n  ) as Promise<SearchResult>;\n}\n\nexport function print(opts: {\n  source: \"hook\" | \"otel\" | \"message\";\n  id: number;\n}): Promise<unknown> {\n  return callTool(\"get\", opts as Record<string, unknown>);\n}\n\nexport function rawQuery(sql: string): Promise<unknown> {\n  return callTool(\"query\", { sql });\n}\n\nexport function dbStats(): Promise<unknown> {\n  return callTool(\"status\");\n}\n\n// ── Exec calls (write operations, CLI only) ─────────────────────────────────\n\nconst EXEC_TIMEOUT = 60_000;\n\nexport function callExec(\n  command: string,\n  params?: Record<string, unknown>,\n): Promise<unknown> {\n  return post(\"/api/exec\", { command, params }, EXEC_TIMEOUT);\n}\n\nexport function pruneEstimate(cutoffMs: number): Promise<unknown> {\n  return callExec(\"prune\", { cutoffMs, dryRun: true });\n}\n\nexport function pruneExecute(\n  cutoffMs: number,\n  opts?: { vacuum?: boolean },\n): Promise<unknown> {\n  return callExec(\"prune\", { cutoffMs, ...opts });\n}\n\nexport function refreshPricing(): Promise<unknown> {\n  return callExec(\"refresh-pricing\");\n}\n\nexport function syncReset(target?: string): Promise<unknown> {\n  return callExec(\"sync-reset\", target ? { target } : {});\n}\n\nexport function syncWatermarkGet(\n  target: string,\n  table?: string,\n): Promise<unknown> {\n  return callExec(\"sync-watermark-get\", { target, table });\n}\n\nexport function syncWatermarkSet(\n  target: string,\n  table: string,\n  value: number,\n): Promise<unknown> {\n  return callExec(\"sync-watermark-set\", { target, table, value });\n}\n\nexport function syncPending(target: string): Promise<{\n  target: string;\n  totalPending: number;\n  tables: Record<string, { maxId: number; watermark: number; pending: number }>;\n}> {\n  return callExec(\"sync-pending\", { target }) as Promise<{\n    target: string;\n    totalPending: number;\n    tables: Record<\n      string,\n      { maxId: number; watermark: number; pending: number }\n    >;\n  }>;\n}\n\nexport function syncTargetList(): Promise<unknown> {\n  return callExec(\"sync-target-list\");\n}\n\nexport function syncTargetAdd(target: {\n  name: string;\n  url: string;\n  token?: string;\n  tokenCommand?: string;\n}): Promise<unknown> {\n  return callExec(\"sync-target-add\", target as Record<string, unknown>);\n}\n\nexport function syncTargetRemove(name: string): Promise<unknown> {\n  return callExec(\"sync-target-remove\", { name });\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-7Q3BJMLG.js

@@ -0,0 +1,62 @@
+// src/log.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { Logger } from "tslog";
+function getLogDir() {
+  switch (process.platform) {
+    case "darwin":
+      return path.join(os.homedir(), "Library", "Logs", "panopticon");
+    case "win32":
+      return path.join(
+        process.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local"),
+        "panopticon",
+        "logs"
+      );
+    default:
+      return path.join(
+        process.env.XDG_STATE_HOME ?? path.join(os.homedir(), ".local", "state"),
+        "panopticon",
+        "logs"
+      );
+  }
+}
+var LOG_DIR = getLogDir();
+var logPaths = {
+  server: path.join(LOG_DIR, "server.log"),
+  otlp: path.join(LOG_DIR, "otlp-receiver.log"),
+  mcp: path.join(LOG_DIR, "mcp-server.log"),
+  proxy: path.join(LOG_DIR, "proxy.log"),
+  hook: path.join(LOG_DIR, "hook-handler.log")
+};
+var DAEMON_NAMES = Object.keys(logPaths);
+function openLogFd(daemon) {
+  fs.mkdirSync(LOG_DIR, { recursive: true });
+  return fs.openSync(logPaths[daemon], "a");
+}
+var root = new Logger({
+  name: "panopticon",
+  type: "pretty",
+  prettyLogTimeZone: "UTC",
+  stylePrettyLogs: false,
+  prettyLogTemplate: "{{dateIsoStr}} [{{name}}] {{logLevelName}}	"
+});
+var log = {
+  server: root.getSubLogger({ name: "server" }),
+  scanner: root.getSubLogger({ name: "scanner" }),
+  sync: root.getSubLogger({ name: "sync" }),
+  proxy: root.getSubLogger({ name: "proxy" }),
+  llm: root.getSubLogger({ name: "llm" }),
+  mcp: root.getSubLogger({ name: "mcp" }),
+  otlp: root.getSubLogger({ name: "otlp" }),
+  hooks: root.getSubLogger({ name: "hooks" })
+};
+
+export {
+  LOG_DIR,
+  logPaths,
+  DAEMON_NAMES,
+  openLogFd,
+  log
+};
+//# sourceMappingURL=chunk-7Q3BJMLG.js.map

package/dist/chunk-7Q3BJMLG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/log.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport os from \"node:os\";\nimport path from \"node:path\";\nimport { Logger } from \"tslog\";\n\nfunction getLogDir(): string {\n  switch (process.platform) {\n    case \"darwin\":\n      return path.join(os.homedir(), \"Library\", \"Logs\", \"panopticon\");\n    case \"win32\":\n      return path.join(\n        process.env.LOCALAPPDATA ?? path.join(os.homedir(), \"AppData\", \"Local\"),\n        \"panopticon\",\n        \"logs\",\n      );\n    default:\n      // Linux and other Unix-like\n      return path.join(\n        process.env.XDG_STATE_HOME ??\n          path.join(os.homedir(), \".local\", \"state\"),\n        \"panopticon\",\n        \"logs\",\n      );\n  }\n}\n\nexport const LOG_DIR = getLogDir();\n\nexport const logPaths = {\n  server: path.join(LOG_DIR, \"server.log\"),\n  otlp: path.join(LOG_DIR, \"otlp-receiver.log\"),\n  mcp: path.join(LOG_DIR, \"mcp-server.log\"),\n  proxy: path.join(LOG_DIR, \"proxy.log\"),\n  hook: path.join(LOG_DIR, \"hook-handler.log\"),\n} as const;\n\nexport type DaemonName = keyof typeof logPaths;\n\nexport const DAEMON_NAMES = Object.keys(logPaths) as DaemonName[];\n\n/**\n * Open a log file in append mode, returning the fd.\n * Pass the fd to spawn's stdio array: [\"ignore\", fd, fd]\n * Close the fd after spawn — the child inherits its own copy.\n */\nexport function openLogFd(daemon: DaemonName): number {\n  fs.mkdirSync(LOG_DIR, { recursive: true });\n  return fs.openSync(logPaths[daemon], \"a\");\n}\n\nconst root = new Logger({\n  name: \"panopticon\",\n  type: \"pretty\",\n  prettyLogTimeZone: \"UTC\",\n  stylePrettyLogs: false,\n  prettyLogTemplate: \"{{dateIsoStr}} [{{name}}] {{logLevelName}}\\t\",\n});\n\nexport const log = {\n  server: root.getSubLogger({ name: \"server\" }),\n  scanner: root.getSubLogger({ name: \"scanner\" }),\n  sync: root.getSubLogger({ name: \"sync\" }),\n  proxy: root.getSubLogger({ name: \"proxy\" }),\n  llm: root.getSubLogger({ name: \"llm\" }),\n  mcp: root.getSubLogger({ name: \"mcp\" }),\n  otlp: root.getSubLogger({ name: \"otlp\" }),\n  hooks: root.getSubLogger({ name: \"hooks\" }),\n};\n"],"mappings":";AAAA,OAAO,QAAQ;AACf,OAAO,QAAQ;AACf,OAAO,UAAU;AACjB,SAAS,cAAc;AAEvB,SAAS,YAAoB;AAC3B,UAAQ,QAAQ,UAAU;AAAA,IACxB,KAAK;AACH,aAAO,KAAK,KAAK,GAAG,QAAQ,GAAG,WAAW,QAAQ,YAAY;AAAA,IAChE,KAAK;AACH,aAAO,KAAK;AAAA,QACV,QAAQ,IAAI,gBAAgB,KAAK,KAAK,GAAG,QAAQ,GAAG,WAAW,OAAO;AAAA,QACtE;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEE,aAAO,KAAK;AAAA,QACV,QAAQ,IAAI,kBACV,KAAK,KAAK,GAAG,QAAQ,GAAG,UAAU,OAAO;AAAA,QAC3C;AAAA,QACA;AAAA,MACF;AAAA,EACJ;AACF;AAEO,IAAM,UAAU,UAAU;AAE1B,IAAM,WAAW;AAAA,EACtB,QAAQ,KAAK,KAAK,SAAS,YAAY;AAAA,EACvC,MAAM,KAAK,KAAK,SAAS,mBAAmB;AAAA,EAC5C,KAAK,KAAK,KAAK,SAAS,gBAAgB;AAAA,EACxC,OAAO,KAAK,KAAK,SAAS,WAAW;AAAA,EACrC,MAAM,KAAK,KAAK,SAAS,kBAAkB;AAC7C;AAIO,IAAM,eAAe,OAAO,KAAK,QAAQ;AAOzC,SAAS,UAAU,QAA4B;AACpD,KAAG,UAAU,SAAS,EAAE,WAAW,KAAK,CAAC;AACzC,SAAO,GAAG,SAAS,SAAS,MAAM,GAAG,GAAG;AAC1C;AAEA,IAAM,OAAO,IAAI,OAAO;AAAA,EACtB,MAAM;AAAA,EACN,MAAM;AAAA,EACN,mBAAmB;AAAA,EACnB,iBAAiB;AAAA,EACjB,mBAAmB;AACrB,CAAC;AAEM,IAAM,MAAM;AAAA,EACjB,QAAQ,KAAK,aAAa,EAAE,MAAM,SAAS,CAAC;AAAA,EAC5C,SAAS,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAAA,EAC9C,MAAM,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAAA,EACxC,OAAO,KAAK,aAAa,EAAE,MAAM,QAAQ,CAAC;AAAA,EAC1C,KAAK,KAAK,aAAa,EAAE,MAAM,MAAM,CAAC;AAAA,EACtC,KAAK,KAAK,aAAa,EAAE,MAAM,MAAM,CAAC;AAAA,EACtC,MAAM,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAAA,EACxC,OAAO,KAAK,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC5C;","names":[]}

package/dist/chunk-BVOE7A2Z.js

@@ -0,0 +1,412 @@
+import {
+  getDb
+} from "./chunk-DZ5HJFB4.js";
+
+// src/db/store.ts
+import { createHash } from "crypto";
+import { gzipSync } from "zlib";
+var INSERT_LOG_SQL = `
+  INSERT INTO otel_logs (timestamp_ns, observed_timestamp_ns, severity_number, severity_text, body, attributes, resource_attributes, session_id, prompt_id, trace_id, span_id)
+  VALUES (@timestamp_ns, @observed_timestamp_ns, @severity_number, @severity_text, @body, @attributes, @resource_attributes, @session_id, @prompt_id, @trace_id, @span_id)
+`;
+var INSERT_METRIC_SQL = `
+  INSERT INTO otel_metrics (timestamp_ns, name, value, metric_type, unit, attributes, resource_attributes, session_id)
+  VALUES (@timestamp_ns, @name, @value, @metric_type, @unit, @attributes, @resource_attributes, @session_id)
+`;
+var INSERT_SPAN_SQL = `
+  INSERT OR IGNORE INTO otel_spans (trace_id, span_id, parent_span_id, name, kind, start_time_ns, end_time_ns, status_code, status_message, attributes, resource_attributes, session_id)
+  VALUES (@trace_id, @span_id, @parent_span_id, @name, @kind, @start_time_ns, @end_time_ns, @status_code, @status_message, @attributes, @resource_attributes, @session_id)
+`;
+var INSERT_HOOK_SQL = `
+  INSERT INTO hook_events (session_id, event_type, timestamp_ms, cwd, repository, tool_name,
+                           target, user_prompt, file_path, command, tool_result, plan, allowed_prompts, payload)
+  VALUES (@session_id, @event_type, @timestamp_ms, @cwd, @repository, @tool_name,
+          @target, @user_prompt, @file_path, @command, @tool_result, @plan, @allowed_prompts, @payload)
+`;
+function insertOtelLogs(rows) {
+  const db = getDb();
+  const stmt = db.prepare(INSERT_LOG_SQL);
+  const insertMany = db.transaction((rows2) => {
+    for (const row of rows2) {
+      stmt.run({
+        timestamp_ns: row.timestamp_ns,
+        observed_timestamp_ns: row.observed_timestamp_ns ?? null,
+        severity_number: row.severity_number ?? null,
+        severity_text: row.severity_text ?? null,
+        body: row.body ?? null,
+        attributes: row.attributes ? JSON.stringify(row.attributes) : null,
+        resource_attributes: row.resource_attributes ? JSON.stringify(row.resource_attributes) : null,
+        session_id: row.session_id ?? null,
+        prompt_id: row.prompt_id ?? null,
+        trace_id: row.trace_id ?? null,
+        span_id: row.span_id ?? null
+      });
+    }
+  });
+  insertMany(rows);
+}
+function insertOtelMetrics(rows) {
+  const db = getDb();
+  const stmt = db.prepare(INSERT_METRIC_SQL);
+  const insertMany = db.transaction((rows2) => {
+    for (const row of rows2) {
+      const sessionId = row.session_id ?? null;
+      stmt.run({
+        timestamp_ns: row.timestamp_ns,
+        name: row.name,
+        value: row.value,
+        metric_type: row.metric_type ?? null,
+        unit: row.unit ?? null,
+        attributes: row.attributes ? JSON.stringify(row.attributes) : null,
+        resource_attributes: row.resource_attributes ? JSON.stringify(row.resource_attributes) : null,
+        session_id: sessionId
+      });
+    }
+  });
+  insertMany(rows);
+}
+function insertOtelSpans(rows) {
+  const db = getDb();
+  const stmt = db.prepare(INSERT_SPAN_SQL);
+  const insertMany = db.transaction((rows2) => {
+    for (const row of rows2) {
+      stmt.run({
+        trace_id: row.trace_id,
+        span_id: row.span_id,
+        parent_span_id: row.parent_span_id ?? null,
+        name: row.name,
+        kind: row.kind ?? null,
+        start_time_ns: row.start_time_ns,
+        end_time_ns: row.end_time_ns,
+        status_code: row.status_code ?? null,
+        status_message: row.status_message ?? null,
+        attributes: row.attributes ? JSON.stringify(row.attributes) : null,
+        resource_attributes: row.resource_attributes ? JSON.stringify(row.resource_attributes) : null,
+        session_id: row.session_id ?? null
+      });
+    }
+  });
+  insertMany(rows);
+}
+function upsertSessionRepository(sessionId, repository, timestampMs, gitIdentity, branch) {
+  const db = getDb();
+  const existing = db.prepare(
+    `SELECT 1 FROM session_repositories WHERE session_id = ? AND repository = ?`
+  ).get(sessionId, repository);
+  db.prepare(
+    `INSERT INTO session_repositories (session_id, repository, first_seen_ms, git_user_name, git_user_email, branch)
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(session_id, repository) DO UPDATE SET
+       git_user_name = COALESCE(session_repositories.git_user_name, excluded.git_user_name),
+       git_user_email = COALESCE(session_repositories.git_user_email, excluded.git_user_email),
+       branch = COALESCE(excluded.branch, session_repositories.branch)`
+  ).run(
+    sessionId,
+    repository,
+    timestampMs,
+    gitIdentity?.name ?? null,
+    gitIdentity?.email ?? null,
+    branch ?? null
+  );
+  if (!existing) {
+    db.prepare(
+      `UPDATE sessions SET sync_seq = COALESCE(sync_seq, 0) + 1 WHERE session_id = ?`
+    ).run(sessionId);
+  }
+}
+function upsertSessionCwd(sessionId, cwd, timestampMs) {
+  const db = getDb();
+  db.prepare(
+    "INSERT INTO session_cwds (session_id, cwd, first_seen_ms) VALUES (?, ?, ?) ON CONFLICT DO NOTHING"
+  ).run(sessionId, cwd, timestampMs);
+}
+function contentHash(obj) {
+  return createHash("sha256").update(JSON.stringify(obj, Object.keys(obj).sort())).digest("hex");
+}
+function insertUserConfigSnapshot(snap) {
+  const db = getDb();
+  const hash = contentHash({
+    permissions: snap.permissions,
+    enabledPlugins: snap.enabledPlugins,
+    hooks: snap.hooks,
+    commands: snap.commands,
+    rules: snap.rules,
+    skills: snap.skills
+  });
+  const existing = db.prepare(
+    "SELECT content_hash FROM user_config_snapshots WHERE device_name = ? ORDER BY snapshot_at_ms DESC LIMIT 1"
+  ).get(snap.deviceName);
+  if (existing?.content_hash === hash) return false;
+  db.prepare(
+    `INSERT INTO user_config_snapshots
+       (device_name, snapshot_at_ms, content_hash, permissions, enabled_plugins, hooks, commands, rules, skills)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    snap.deviceName,
+    Date.now(),
+    hash,
+    JSON.stringify(snap.permissions),
+    JSON.stringify(snap.enabledPlugins),
+    JSON.stringify(snap.hooks),
+    JSON.stringify(snap.commands),
+    JSON.stringify(snap.rules),
+    JSON.stringify(snap.skills)
+  );
+  return true;
+}
+function insertRepoConfigSnapshot(snap) {
+  const db = getDb();
+  const hash = contentHash({
+    hooks: snap.hooks,
+    mcpServers: snap.mcpServers,
+    commands: snap.commands,
+    agents: snap.agents,
+    rules: snap.rules,
+    localHooks: snap.localHooks,
+    localMcpServers: snap.localMcpServers,
+    localPermissions: snap.localPermissions,
+    localIsGitignored: snap.localIsGitignored,
+    instructions: snap.instructions
+  });
+  const existing = db.prepare(
+    "SELECT content_hash FROM repo_config_snapshots WHERE repository = ? ORDER BY snapshot_at_ms DESC LIMIT 1"
+  ).get(snap.repository);
+  if (existing?.content_hash === hash) return false;
+  db.prepare(
+    `INSERT INTO repo_config_snapshots
+       (repository, cwd, session_id, snapshot_at_ms, content_hash,
+        hooks, mcp_servers, commands, agents, rules,
+        local_hooks, local_mcp_servers, local_permissions, local_is_gitignored,
+        instructions)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    snap.repository,
+    snap.cwd,
+    snap.sessionId ?? null,
+    Date.now(),
+    hash,
+    JSON.stringify(snap.hooks),
+    JSON.stringify(snap.mcpServers),
+    JSON.stringify(snap.commands),
+    JSON.stringify(snap.agents),
+    JSON.stringify(snap.rules),
+    JSON.stringify(snap.localHooks),
+    JSON.stringify(snap.localMcpServers),
+    JSON.stringify(snap.localPermissions),
+    snap.localIsGitignored ? 1 : 0,
+    JSON.stringify(snap.instructions)
+  );
+  return true;
+}
+function upsertSession(row) {
+  const db = getDb();
+  db.prepare(
+    `INSERT INTO sessions (session_id, target, started_at_ms, ended_at_ms, first_prompt,
+       permission_mode, agent_version, model, cli_version, scanner_file_path,
+       total_input_tokens, total_output_tokens, total_cache_read_tokens,
+       total_cache_creation_tokens, total_reasoning_tokens, turn_count,
+       otel_input_tokens, otel_output_tokens, otel_cache_read_tokens, otel_cache_creation_tokens,
+       models, project, created_at, parent_session_id, relationship_type, is_automated,
+       has_hooks, has_otel, has_scanner)
+     VALUES (@session_id, @target, @started_at_ms, @ended_at_ms, @first_prompt,
+       @permission_mode, @agent_version, @model, @cli_version, @scanner_file_path,
+       @total_input_tokens, @total_output_tokens, @total_cache_read_tokens,
+       @total_cache_creation_tokens, @total_reasoning_tokens, @turn_count,
+       @otel_input_tokens, @otel_output_tokens, @otel_cache_read_tokens, @otel_cache_creation_tokens,
+       @model, @project, @created_at, @parent_session_id, @relationship_type, @is_automated,
+       @has_hooks, @has_otel, @has_scanner)
+     ON CONFLICT(session_id) DO UPDATE SET
+       target = COALESCE(excluded.target, sessions.target),
+       started_at_ms = COALESCE(excluded.started_at_ms, sessions.started_at_ms),
+       ended_at_ms = COALESCE(excluded.ended_at_ms, sessions.ended_at_ms),
+       first_prompt = COALESCE(sessions.first_prompt, excluded.first_prompt),
+       permission_mode = COALESCE(excluded.permission_mode, sessions.permission_mode),
+       agent_version = COALESCE(excluded.agent_version, sessions.agent_version),
+       model = COALESCE(excluded.model, sessions.model),
+       cli_version = COALESCE(excluded.cli_version, sessions.cli_version),
+       scanner_file_path = COALESCE(excluded.scanner_file_path, sessions.scanner_file_path),
+       total_input_tokens = COALESCE(excluded.total_input_tokens, sessions.total_input_tokens),
+       total_output_tokens = COALESCE(excluded.total_output_tokens, sessions.total_output_tokens),
+       total_cache_read_tokens = COALESCE(excluded.total_cache_read_tokens, sessions.total_cache_read_tokens),
+       total_cache_creation_tokens = COALESCE(excluded.total_cache_creation_tokens, sessions.total_cache_creation_tokens),
+       total_reasoning_tokens = COALESCE(excluded.total_reasoning_tokens, sessions.total_reasoning_tokens),
+       turn_count = COALESCE(excluded.turn_count, sessions.turn_count),
+       otel_input_tokens = COALESCE(excluded.otel_input_tokens, sessions.otel_input_tokens),
+       otel_output_tokens = COALESCE(excluded.otel_output_tokens, sessions.otel_output_tokens),
+       otel_cache_read_tokens = COALESCE(excluded.otel_cache_read_tokens, sessions.otel_cache_read_tokens),
+       otel_cache_creation_tokens = COALESCE(excluded.otel_cache_creation_tokens, sessions.otel_cache_creation_tokens),
+       models = CASE
+         WHEN excluded.model IS NULL THEN sessions.models
+         WHEN sessions.models IS NULL THEN excluded.model
+         WHEN sessions.models LIKE '%' || excluded.model || '%' THEN sessions.models
+         ELSE sessions.models || ',' || excluded.model
+       END,
+       project = COALESCE(sessions.project, excluded.project),
+       parent_session_id = COALESCE(excluded.parent_session_id, sessions.parent_session_id),
+       relationship_type = COALESCE(excluded.relationship_type, sessions.relationship_type),
+       is_automated = COALESCE(excluded.is_automated, sessions.is_automated),
+       has_hooks = MAX(COALESCE(sessions.has_hooks, 0), COALESCE(excluded.has_hooks, 0)),
+       has_otel = MAX(COALESCE(sessions.has_otel, 0), COALESCE(excluded.has_otel, 0)),
+       has_scanner = MAX(COALESCE(sessions.has_scanner, 0), COALESCE(excluded.has_scanner, 0)),
+       sync_dirty = 1,
+       sync_seq = COALESCE(sessions.sync_seq, 0) + 1`
+  ).run({
+    session_id: row.session_id,
+    target: row.target ?? null,
+    started_at_ms: row.started_at_ms ?? null,
+    ended_at_ms: row.ended_at_ms ?? null,
+    first_prompt: row.first_prompt ?? null,
+    permission_mode: row.permission_mode ?? null,
+    agent_version: row.agent_version ?? null,
+    model: row.model ?? null,
+    cli_version: row.cli_version ?? null,
+    scanner_file_path: row.scanner_file_path ?? null,
+    total_input_tokens: row.total_input_tokens ?? null,
+    total_output_tokens: row.total_output_tokens ?? null,
+    total_cache_read_tokens: row.total_cache_read_tokens ?? null,
+    total_cache_creation_tokens: row.total_cache_creation_tokens ?? null,
+    total_reasoning_tokens: row.total_reasoning_tokens ?? null,
+    turn_count: row.turn_count ?? null,
+    otel_input_tokens: row.otel_input_tokens ?? null,
+    otel_output_tokens: row.otel_output_tokens ?? null,
+    otel_cache_read_tokens: row.otel_cache_read_tokens ?? null,
+    otel_cache_creation_tokens: row.otel_cache_creation_tokens ?? null,
+    project: row.project ?? null,
+    created_at: row.created_at ?? null,
+    parent_session_id: row.parent_session_id ?? null,
+    relationship_type: row.relationship_type ?? null,
+    is_automated: row.is_automated ?? null,
+    has_hooks: row.has_hooks ?? null,
+    has_otel: row.has_otel ?? null,
+    has_scanner: row.has_scanner ?? null
+  });
+}
+var AUTOMATED_PREFIXES = [
+  "You are a code reviewer.",
+  "You are a security code reviewer.",
+  "You are a design reviewer.",
+  "You are a code assistant. Your task is to address",
+  "You are a code review insights analyst.",
+  "You are reviewing whether an implementation matches",
+  "You are a plan document reviewer.",
+  "You are a spec document reviewer.",
+  "You are summarizing a day of AI agent activity.",
+  "You are analyzing AI agent sessions.",
+  "## Analysis Request",
+  "# Fix Request"
+];
+var AUTOMATED_SUBSTRINGS = ["invoked by roborev to perform this review"];
+function isAutomatedPrompt(firstPrompt) {
+  for (const p of AUTOMATED_PREFIXES) {
+    if (firstPrompt.startsWith(p)) return true;
+  }
+  for (const s of AUTOMATED_SUBSTRINGS) {
+    if (firstPrompt.includes(s)) return true;
+  }
+  return false;
+}
+function updateSessionMessageCounts(sessionId) {
+  const db = getDb();
+  const counts = db.prepare(
+    `SELECT
+         (SELECT COUNT(*) FROM messages WHERE session_id = ?) as msg_count,
+         (SELECT COUNT(*) FROM messages WHERE session_id = ? AND role = 'user' AND is_system = 0) as user_count,
+         (SELECT first_prompt FROM sessions WHERE session_id = ?) as first_prompt`
+  ).get(sessionId, sessionId, sessionId);
+  const isAutomated = counts.user_count <= 1 && counts.first_prompt != null && isAutomatedPrompt(counts.first_prompt) ? 1 : 0;
+  db.prepare(
+    `UPDATE sessions SET
+       message_count = ?,
+       user_message_count = ?,
+       is_automated = CASE WHEN ? > 1 THEN 0 ELSE ? END,
+       sync_seq = COALESCE(sync_seq, 0) + 1
+     WHERE session_id = ?`
+  ).run(
+    counts.msg_count,
+    counts.user_count,
+    counts.user_count,
+    isAutomated,
+    sessionId
+  );
+}
+function incrementToolCount(sessionId, toolName) {
+  const db = getDb();
+  db.prepare(
+    `UPDATE sessions
+     SET hook_tool_counts = JSON_SET(
+           COALESCE(hook_tool_counts, '{}'),
+           '$.' || @tool,
+           COALESCE(JSON_EXTRACT(hook_tool_counts, '$.' || @tool), 0) + 1
+         )
+     WHERE session_id = @session_id`
+  ).run({ session_id: sessionId, tool: toolName });
+}
+function incrementEventTypeCount(sessionId, eventType) {
+  const db = getDb();
+  db.prepare(
+    `UPDATE sessions
+     SET hook_event_type_counts = JSON_SET(
+           COALESCE(hook_event_type_counts, '{}'),
+           '$.' || @event_type,
+           COALESCE(JSON_EXTRACT(hook_event_type_counts, '$.' || @event_type), 0) + 1
+         )
+     WHERE session_id = @session_id`
+  ).run({ session_id: sessionId, event_type: eventType });
+}
+function extractStr(obj, key) {
+  const v = obj?.[key];
+  return typeof v === "string" ? v : void 0;
+}
+function insertHookEvent(row) {
+  const db = getDb();
+  const data = row.payload;
+  const toolInput = data.tool_input;
+  const userPrompt = extractStr(data, "prompt") ?? extractStr(data, "user_prompt");
+  const filePath = extractStr(toolInput, "file_path");
+  const command = extractStr(toolInput, "command");
+  const plan = extractStr(toolInput, "plan");
+  const toolResultRaw = data.tool_result ?? data.tool_response;
+  const toolResult = toolResultRaw ? typeof toolResultRaw === "string" ? toolResultRaw : JSON.stringify(toolResultRaw) : void 0;
+  const allowedPrompts = toolInput?.allowedPrompts ? JSON.stringify(toolInput.allowedPrompts) : void 0;
+  const fullJson = JSON.stringify(data);
+  const insertWithFts = db.transaction(() => {
+    db.prepare(INSERT_HOOK_SQL).run({
+      session_id: row.session_id,
+      event_type: row.event_type,
+      timestamp_ms: row.timestamp_ms,
+      cwd: row.cwd ?? null,
+      repository: row.repository ?? null,
+      tool_name: row.tool_name ?? null,
+      target: row.target ?? null,
+      user_prompt: userPrompt ?? null,
+      file_path: filePath ?? null,
+      command: command ?? null,
+      tool_result: toolResult ?? null,
+      plan: plan ?? null,
+      allowed_prompts: allowedPrompts ?? null,
+      payload: gzipSync(Buffer.from(fullJson))
+    });
+    const { id } = db.prepare("SELECT last_insert_rowid() as id").get();
+    db.prepare("INSERT INTO hook_events_fts(rowid, payload) VALUES (?, ?)").run(
+      id,
+      fullJson
+    );
+  });
+  insertWithFts();
+}
+
+export {
+  insertOtelLogs,
+  insertOtelMetrics,
+  insertOtelSpans,
+  upsertSessionRepository,
+  upsertSessionCwd,
+  insertUserConfigSnapshot,
+  insertRepoConfigSnapshot,
+  upsertSession,
+  updateSessionMessageCounts,
+  incrementToolCount,
+  incrementEventTypeCount,
+  insertHookEvent
+};
+//# sourceMappingURL=chunk-BVOE7A2Z.js.map