@tonyclaw/agent-inspector 4.0.1 → 4.0.3

package/src/proxy/sessionArchive.ts

@@ -1,479 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync } from "node:fs";
-import { readdir, rm } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { CapturedLogSchema, type CapturedLog } from "./schemas";
-import { logger, resolveLogDir } from "./logger";
-import { ensurePrivateDirectorySync, securePrivateFileSync } from "./privateDataPath";
-
-type SqliteConstructorResult = {
-  constructor: ((path: string) => unknown) | null;
-  reason: string | null;
-};
-
-const SESSION_ARCHIVE_DIR = "sessions";
-const SESSION_ARCHIVE_FILE = "session.sqlite";
-const SQLITE_PACKAGE_NAME = "better-sqlite3";
-const BUN_SQLITE_MODULE_NAME = "bun:sqlite";
-
-const CREATE_SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS session_logs (
-  id INTEGER PRIMARY KEY,
-  session_id TEXT NOT NULL,
-  log_json TEXT NOT NULL,
-  updated_at TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_session_logs_session_id_id ON session_logs(session_id, id);
-`;
-
-const UPSERT_SQL = `
-INSERT INTO session_logs (
-  id,
-  session_id,
-  log_json,
-  updated_at
-) VALUES (?, ?, ?, ?)
-ON CONFLICT(id) DO UPDATE SET
-  session_id = excluded.session_id,
-  log_json = excluded.log_json,
-  updated_at = excluded.updated_at
-`;
-
-let didLogUnavailable = false;
-let cachedArchiveMax: { root: string; maxId: number } | null = null;
-
-export function getSessionArchiveRoot(): string {
-  return join(resolveLogDir(), SESSION_ARCHIVE_DIR);
-}
-
-function hashSessionId(sessionId: string): string {
-  return createHash("sha256").update(sessionId).digest("hex").slice(0, 16);
-}
-
-function sanitizeSessionPrefix(sessionId: string): string {
-  const trimmed = sessionId.trim();
-  if (trimmed.length === 0) return "session";
-  const normalized = trimmed.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-  if (normalized.length === 0) return "session";
-  return normalized.slice(0, 48);
-}
-
-function sessionArchiveKey(sessionId: string): string {
-  return `${sanitizeSessionPrefix(sessionId)}--${hashSessionId(sessionId)}`;
-}
-
-export function getSessionArchivePath(sessionId: string): string {
-  return join(getSessionArchiveRoot(), sessionArchiveKey(sessionId), SESSION_ARCHIVE_FILE);
-}
-
-function objectFromUnknown(value: unknown): object | null {
-  if (value === null) return null;
-  if (typeof value === "object" || typeof value === "function") return value;
-  return null;
-}
-
-function readProperty(value: unknown, name: string): unknown {
-  let current = objectFromUnknown(value);
-  while (current !== null) {
-    const desc = Object.getOwnPropertyDescriptor(current, name);
-    if (desc !== undefined) {
-      const propertyValue: unknown = Reflect.get(current, name);
-      return propertyValue;
-    }
-    const nextPrototype: unknown = Object.getPrototypeOf(current);
-    current = objectFromUnknown(nextPrototype);
-  }
-  return undefined;
-}
-
-function readFunction(value: unknown, name: string): Function | null {
-  const property = readProperty(value, name);
-  return typeof property === "function" ? property : null;
-}
-
-function callMethod(target: unknown, methodName: string, args: readonly unknown[]): unknown {
-  const method = readFunction(target, methodName);
-  if (method === null) return undefined;
-  try {
-    return Reflect.apply(method, target, [...args]);
-  } catch (err) {
-    logger.warn("[sessionArchive] SQLite method failed:", methodName, String(err));
-    return undefined;
-  }
-}
-
-function prepareStatement(db: unknown, sql: string): unknown {
-  return callMethod(db, "prepare", [sql]);
-}
-
-function runPrepared(db: unknown, sql: string, params: readonly unknown[] = []): boolean {
-  const statement = prepareStatement(db, sql);
-  if (statement === undefined) return false;
-  const result = callMethod(statement, "run", params);
-  callMethod(statement, "finalize", []);
-  return result !== undefined;
-}
-
-function allPrepared(db: unknown, sql: string, params: readonly unknown[] = []): unknown[] {
-  const statement = prepareStatement(db, sql);
-  if (statement === undefined) return [];
-  const result = callMethod(statement, "all", params);
-  callMethod(statement, "finalize", []);
-  return Array.isArray(result) ? result : [];
-}
-
-function execSql(db: unknown, sql: string): boolean {
-  const result = callMethod(db, "exec", [sql]);
-  return result !== undefined;
-}
-
-function closeDatabase(db: unknown): void {
-  callMethod(db, "close", []);
-}
-
-function sqliteConstructorFromModule(
-  moduleValue: unknown,
-  exportName: "default" | "Database",
-): ((path: string) => unknown) | null {
-  const exportedValue = readProperty(moduleValue, exportName);
-  if (typeof exportedValue === "function") {
-    return (path: string): unknown => Reflect.construct(exportedValue, [path]);
-  }
-  return null;
-}
-
-async function loadSqliteModuleConstructor(
-  moduleName: string,
-  exportName: "default" | "Database",
-): Promise<SqliteConstructorResult> {
-  try {
-    const importedModule: unknown = await import(/* @vite-ignore */ moduleName);
-    const exportedConstructor = sqliteConstructorFromModule(importedModule, exportName);
-    if (exportedConstructor !== null) return { constructor: exportedConstructor, reason: null };
-    if (exportName === "default" && typeof importedModule === "function") {
-      return {
-        constructor: (path: string): unknown => Reflect.construct(importedModule, [path]),
-        reason: null,
-      };
-    }
-    return { constructor: null, reason: `${moduleName} did not expose ${exportName}` };
-  } catch (err) {
-    return { constructor: null, reason: String(err) };
-  }
-}
-
-async function loadSqliteConstructor(): Promise<SqliteConstructorResult> {
-  const bunRuntimeDesc = Object.getOwnPropertyDescriptor(process.versions, "bun");
-  if (bunRuntimeDesc !== undefined) {
-    const bunSqlite = await loadSqliteModuleConstructor(BUN_SQLITE_MODULE_NAME, "Database");
-    if (bunSqlite.constructor !== null) return bunSqlite;
-
-    const betterSqlite = await loadSqliteModuleConstructor(SQLITE_PACKAGE_NAME, "default");
-    if (betterSqlite.constructor !== null) return betterSqlite;
-
-    return {
-      constructor: null,
-      reason: [bunSqlite.reason, betterSqlite.reason]
-        .filter((item): item is string => item !== null)
-        .join("; "),
-    };
-  }
-
-  const betterSqlite = await loadSqliteModuleConstructor(SQLITE_PACKAGE_NAME, "default");
-  if (betterSqlite.constructor !== null) return betterSqlite;
-
-  const bunSqlite = await loadSqliteModuleConstructor(BUN_SQLITE_MODULE_NAME, "Database");
-  if (bunSqlite.constructor !== null) return bunSqlite;
-
-  return {
-    constructor: null,
-    reason: [betterSqlite.reason, bunSqlite.reason]
-      .filter((item): item is string => item !== null)
-      .join("; "),
-  };
-}
-
-function logUnavailableOnce(reason: string): void {
-  if (didLogUnavailable) return;
-  didLogUnavailable = true;
-  logger.warn("[sessionArchive] Optional session archive unavailable:", reason);
-}
-
-async function openSessionArchiveDb(filePath: string, create: boolean): Promise<unknown | null> {
-  if (!create && !existsSync(filePath)) return null;
-
-  const sqliteConstructor = await loadSqliteConstructor();
-  if (sqliteConstructor.constructor === null) {
-    logUnavailableOnce(sqliteConstructor.reason ?? "SQLite runtime is not available");
-    return null;
-  }
-
-  try {
-    if (!create && !existsSync(filePath)) return null;
-    if (!ensurePrivateDirectorySync(dirname(filePath))) {
-      logger.warn("[sessionArchive] Failed to secure archive directory:", dirname(filePath));
-      return null;
-    }
-    const db = sqliteConstructor.constructor(filePath);
-    execSql(db, "PRAGMA journal_mode = WAL");
-    execSql(db, "PRAGMA synchronous = NORMAL");
-    if (!securePrivateFileSync(filePath, true)) {
-      closeDatabase(db);
-      logger.warn("[sessionArchive] Failed to secure archive database:", filePath);
-      return null;
-    }
-    for (const sidecarPath of [`${filePath}-wal`, `${filePath}-shm`]) {
-      if (existsSync(sidecarPath)) void securePrivateFileSync(sidecarPath);
-    }
-    if (!execSql(db, CREATE_SCHEMA_SQL)) {
-      closeDatabase(db);
-      logger.warn("[sessionArchive] Failed to initialize schema:", filePath);
-      return null;
-    }
-    return db;
-  } catch (err) {
-    logger.warn("[sessionArchive] Failed to open session archive:", filePath, String(err));
-    return null;
-  }
-}
-
-export async function archiveSessionLogs(logs: readonly CapturedLog[]): Promise<number> {
-  const bySession = new Map<string, CapturedLog[]>();
-  for (const log of logs) {
-    const sessionId = log.sessionId;
-    if (sessionId === null || sessionId.trim().length === 0) continue;
-    const existing = bySession.get(sessionId);
-    if (existing === undefined) bySession.set(sessionId, [log]);
-    else existing.push(log);
-  }
-
-  let archivedCount = 0;
-  for (const [sessionId, sessionLogs] of bySession) {
-    const db = await openSessionArchiveDb(getSessionArchivePath(sessionId), true);
-    if (db === null || !execSql(db, "BEGIN IMMEDIATE")) {
-      if (db !== null) closeDatabase(db);
-      continue;
-    }
-
-    let committed = false;
-    try {
-      const updatedAt = new Date().toISOString();
-      const archived = sessionLogs.every((log) =>
-        runPrepared(db, UPSERT_SQL, [log.id, sessionId, JSON.stringify(log), updatedAt]),
-      );
-      if (archived && execSql(db, "COMMIT")) {
-        committed = true;
-        archivedCount += sessionLogs.length;
-        if (cachedArchiveMax?.root === getSessionArchiveRoot()) {
-          for (const log of sessionLogs) {
-            cachedArchiveMax.maxId = Math.max(cachedArchiveMax.maxId, log.id);
-          }
-        }
-      }
-    } finally {
-      if (!committed) void execSql(db, "ROLLBACK");
-      closeDatabase(db);
-    }
-  }
-  return archivedCount;
-}
-
-function readString(row: unknown, name: string): string | null {
-  const value = readProperty(row, name);
-  return typeof value === "string" ? value : null;
-}
-
-function readNumber(row: unknown, name: string): number | null {
-  const value = readProperty(row, name);
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-
-function logFromJson(value: string | null): CapturedLog | null {
-  if (value === null) return null;
-  try {
-    const parsed: unknown = JSON.parse(value);
-    const result = CapturedLogSchema.safeParse(parsed);
-    return result.success ? result.data : null;
-  } catch {
-    return null;
-  }
-}
-
-function logsFromRows(rows: readonly unknown[]): CapturedLog[] {
-  const logs: CapturedLog[] = [];
-  for (const row of rows) {
-    const log = logFromJson(readString(row, "log_json"));
-    if (log !== null) logs.push(log);
-  }
-  return logs;
-}
-
-export async function listArchivedSessionLogs(sessionId: string): Promise<CapturedLog[]> {
-  const db = await openSessionArchiveDb(getSessionArchivePath(sessionId), false);
-  if (db === null) return [];
-
-  try {
-    const rows = allPrepared(
-      db,
-      "SELECT log_json FROM session_logs WHERE session_id = ? ORDER BY id ASC",
-      [sessionId],
-    );
-    return logsFromRows(rows);
-  } finally {
-    closeDatabase(db);
-  }
-}
-
-export async function listArchivedSessionIds(): Promise<string[]> {
-  const archivePaths = await listArchiveDatabasePaths();
-  const sessionIds = new Set<string>();
-  for (const archivePath of archivePaths) {
-    const db = await openSessionArchiveDb(archivePath, false);
-    if (db === null) continue;
-
-    try {
-      const rows = allPrepared(
-        db,
-        "SELECT DISTINCT session_id FROM session_logs ORDER BY session_id ASC",
-      );
-      for (const row of rows) {
-        const sessionId = readString(row, "session_id");
-        if (sessionId !== null && sessionId.length > 0) sessionIds.add(sessionId);
-      }
-    } finally {
-      closeDatabase(db);
-    }
-  }
-  return [...sessionIds].sort();
-}
-
-async function listArchiveDatabasePaths(): Promise<string[]> {
-  const root = getSessionArchiveRoot();
-  if (!existsSync(root)) return [];
-
-  try {
-    const entries = await readdir(root, { withFileTypes: true });
-    const paths: string[] = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const candidate = join(root, entry.name, SESSION_ARCHIVE_FILE);
-      if (existsSync(candidate)) paths.push(candidate);
-    }
-    return paths;
-  } catch (err) {
-    logger.warn("[sessionArchive] Failed to list session archives:", String(err));
-    return [];
-  }
-}
-
-/**
- * Return the highest ID retained by an authoritative session archive. The global SQLite index is a
- * rebuildable projection and must never influence ID allocation, while archive IDs must remain
- * reserved even after their corresponding global JSONL records have aged out.
- */
-export async function getSessionArchiveMaxLogId(): Promise<number> {
-  const root = getSessionArchiveRoot();
-  if (cachedArchiveMax?.root === root) return cachedArchiveMax.maxId;
-
-  let maxId = 0;
-  const archivePaths = await listArchiveDatabasePaths();
-  for (const archivePath of archivePaths) {
-    const db = await openSessionArchiveDb(archivePath, false);
-    if (db === null) continue;
-
-    try {
-      const rows = allPrepared(db, "SELECT MAX(id) AS max_id FROM session_logs");
-      const archiveMax = readNumber(rows[0], "max_id");
-      if (archiveMax !== null && Number.isSafeInteger(archiveMax) && archiveMax >= 0) {
-        maxId = Math.max(maxId, archiveMax);
-      }
-    } finally {
-      closeDatabase(db);
-    }
-  }
-
-  cachedArchiveMax = { root, maxId };
-  return maxId;
-}
-
-export async function findArchivedLogById(id: number): Promise<CapturedLog | null> {
-  const archivePaths = await listArchiveDatabasePaths();
-  for (const archivePath of archivePaths) {
-    const db = await openSessionArchiveDb(archivePath, false);
-    if (db === null) continue;
-
-    try {
-      const rows = allPrepared(db, "SELECT log_json FROM session_logs WHERE id = ? LIMIT 1", [id]);
-      const first = logsFromRows(rows)[0];
-      if (first !== undefined) return first;
-    } finally {
-      closeDatabase(db);
-    }
-  }
-
-  return null;
-}
-
-function placeholders(count: number): string {
-  return Array.from({ length: count }, () => "?").join(", ");
-}
-
-function idsFromRows(rows: readonly unknown[]): Set<number> {
-  const ids = new Set<number>();
-  for (const row of rows) {
-    const id = readNumber(row, "id");
-    if (id !== null && Number.isInteger(id)) ids.add(id);
-  }
-  return ids;
-}
-
-export async function deleteArchivedLogsByIds(ids: ReadonlySet<number>): Promise<Set<number>> {
-  if (ids.size === 0) return new Set();
-
-  const removedIds = new Set<number>();
-  const idValues = [...ids];
-  const sqlPlaceholders = placeholders(idValues.length);
-  const archivePaths = await listArchiveDatabasePaths();
-
-  for (const archivePath of archivePaths) {
-    const db = await openSessionArchiveDb(archivePath, false);
-    if (db === null) continue;
-
-    try {
-      const matchingRows = allPrepared(
-        db,
-        `SELECT id FROM session_logs WHERE id IN (${sqlPlaceholders})`,
-        idValues,
-      );
-      const matchingIds = idsFromRows(matchingRows);
-      if (matchingIds.size === 0) continue;
-
-      if (runPrepared(db, `DELETE FROM session_logs WHERE id IN (${sqlPlaceholders})`, idValues)) {
-        for (const id of matchingIds) {
-          removedIds.add(id);
-        }
-      }
-    } finally {
-      closeDatabase(db);
-    }
-  }
-
-  if (removedIds.size > 0) cachedArchiveMax = null;
-
-  return removedIds;
-}
-
-export async function clearSessionArchives(): Promise<number> {
-  const root = getSessionArchiveRoot();
-  if (!existsSync(root)) return 0;
-
-  const archivePaths = await listArchiveDatabasePaths();
-  try {
-    await rm(root, { recursive: true, force: true });
-    cachedArchiveMax = null;
-    return archivePaths.length;
-  } catch (err) {
-    logger.warn("[sessionArchive] Failed to clear session archives:", String(err));
-    return 0;
-  }
-}