@tonyclaw/agent-inspector 2.1.6 → 2.1.7

package/src/proxy/sessionArchive.ts

@@ -0,0 +1,410 @@
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readdir, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { CapturedLogSchema, type CapturedLog } from "./schemas";
+import { logger, resolveLogDir } from "./logger";
+
+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;
+
+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) await mkdir(dirname(filePath), { recursive: true });
+    const db = sqliteConstructor.constructor(filePath);
+    execSql(db, "PRAGMA journal_mode = WAL");
+    execSql(db, "PRAGMA synchronous = NORMAL");
+    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 archiveSessionLog(log: CapturedLog): Promise<boolean> {
+  const sessionId = log.sessionId;
+  if (sessionId === null || sessionId.trim().length === 0) return false;
+
+  const db = await openSessionArchiveDb(getSessionArchivePath(sessionId), true);
+  if (db === null) return false;
+
+  try {
+    return runPrepared(db, UPSERT_SQL, [
+      log.id,
+      sessionId,
+      JSON.stringify(log),
+      new Date().toISOString(),
+    ]);
+  } finally {
+    closeDatabase(db);
+  }
+}
+
+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 [];
+  }
+}
+
+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);
+    }
+  }
+
+  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 });
+    return archivePaths.length;
+  } catch (err) {
+    logger.warn("[sessionArchive] Failed to clear session archives:", String(err));
+    return 0;
+  }
+}