nlm-memory 0.5.0 → 0.5.2

package/src/core/sources/source-registry.ts

@@ -1,278 +0,0 @@
-/**
- * SourceRegistry — CRUD over the `sources` table.
- *
- * A "source" is any transcript origin the daemon scans (Claude Code's
- * projects dir, Hermes's sessions dir, pi.dev, a user-defined JSONL
- * directory, or a webhook).
- *
- * The three legacy adapters (claude-code, hermes, pi) seed as preset rows
- * pointing at fixed `path_or_url` values. The generic JSONL adapter and
- * webhook ingest piggy-back on this same table — the scheduler chooses
- * which adapter to dispatch by reading `kind`.
- *
- * See docs/plans/desktop-product.md (Phase 0).
- */
-
-import { randomBytes } from "node:crypto";
-import { existsSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import type Database from "better-sqlite3";
-import { defaultHistoryFile as defaultAiderHistoryFile } from "../adapters/aider.js";
-import { defaultDbPath as defaultCursorDbPath } from "../adapters/cursor.js";
-import { defaultDbPath as defaultHermesAgentDbPath } from "../adapters/hermes-agent.js";
-import { defaultDbPath as defaultOpenCodeDbPath } from "../adapters/opencode.js";
-import { defaultUserDir as defaultWindsurfUserDir } from "../adapters/windsurf.js";
-
-export type SourceKind = "claude-code" | "hermes" | "hermes-agent" | "aider" | "cursor" | "windsurf" | "opencode" | "pi" | "jsonl-generic" | "webhook";
-
-export interface SourceRow {
-  readonly id: number;
-  readonly kind: SourceKind;
-  readonly name: string;
-  readonly pathOrUrl: string | null;
-  readonly runtimeLabel: string;
-  readonly parseConfig: Record<string, unknown>;
-  readonly enabled: boolean;
-  /** Only populated on the response from `insert()` for webhook sources.
-   *  Always `null` from `list()` / `get()`. Use `getToken()` inside the daemon. */
-  readonly token: string | null;
-  readonly hasToken: boolean;
-  readonly createdAt: string;
-  readonly updatedAt: string;
-}
-
-export interface SourceInsert {
-  readonly kind: SourceKind;
-  readonly name: string;
-  readonly pathOrUrl?: string | null;
-  readonly runtimeLabel: string;
-  readonly parseConfig?: Record<string, unknown>;
-  readonly enabled?: boolean;
-}
-
-export interface SourceUpdate {
-  readonly name?: string;
-  readonly pathOrUrl?: string | null;
-  readonly runtimeLabel?: string;
-  readonly parseConfig?: Record<string, unknown>;
-  readonly enabled?: boolean;
-}
-
-interface SourceDbRow {
-  id: number;
-  kind: string;
-  name: string;
-  path_or_url: string | null;
-  runtime_label: string;
-  parse_config: string;
-  enabled: number;
-  token: string | null;
-  created_at: string;
-  updated_at: string;
-}
-
-function rowFromDb(r: SourceDbRow, revealedToken: string | null = null): SourceRow {
-  let parsed: Record<string, unknown> = {};
-  try {
-    parsed = r.parse_config ? (JSON.parse(r.parse_config) as Record<string, unknown>) : {};
-  } catch {
-    parsed = {};
-  }
-  return {
-    id: r.id,
-    kind: r.kind as SourceKind,
-    name: r.name,
-    pathOrUrl: r.path_or_url,
-    runtimeLabel: r.runtime_label,
-    parseConfig: parsed,
-    enabled: r.enabled === 1,
-    token: revealedToken,
-    hasToken: r.token !== null && r.token.length > 0,
-    createdAt: r.created_at,
-    updatedAt: r.updated_at,
-  };
-}
-
-function mintToken(): string {
-  return `nlm_${randomBytes(24).toString("hex")}`;
-}
-
-export class SourceRegistry {
-  constructor(private readonly db: Database.Database) {}
-
-  list(): SourceRow[] {
-    const rows = this.db.prepare<[], SourceDbRow>(
-      `SELECT * FROM sources ORDER BY id ASC`,
-    ).all();
-    return rows.map((r) => rowFromDb(r));
-  }
-
-  get(id: number): SourceRow | null {
-    const row = this.db.prepare<[number], SourceDbRow>(
-      `SELECT * FROM sources WHERE id = ?`,
-    ).get(id);
-    return row ? rowFromDb(row) : null;
-  }
-
-  getByName(name: string): SourceRow | null {
-    const row = this.db.prepare<[string], SourceDbRow>(
-      `SELECT * FROM sources WHERE name = ?`,
-    ).get(name);
-    return row ? rowFromDb(row) : null;
-  }
-
-  insert(input: SourceInsert): SourceRow {
-    const token = input.kind === "webhook" ? mintToken() : null;
-    const stmt = this.db.prepare(`
-      INSERT INTO sources (kind, name, path_or_url, runtime_label, parse_config, enabled, token)
-      VALUES (@kind, @name, @path_or_url, @runtime_label, @parse_config, @enabled, @token)
-    `);
-    const result = stmt.run({
-      kind: input.kind,
-      name: input.name,
-      path_or_url: input.pathOrUrl ?? null,
-      runtime_label: input.runtimeLabel,
-      parse_config: JSON.stringify(input.parseConfig ?? {}),
-      enabled: input.enabled === false ? 0 : 1,
-      token,
-    });
-    const id = Number(result.lastInsertRowid);
-    const dbRow = this.db.prepare<[number], SourceDbRow>(
-      `SELECT * FROM sources WHERE id = ?`,
-    ).get(id);
-    if (!dbRow) throw new Error(`SourceRegistry.insert: row ${id} not found after insert`);
-    // Reveal the token on the insert response only — this is the user's
-    // one chance to copy it. Subsequent list/get redact.
-    return rowFromDb(dbRow, token);
-  }
-
-  /** Daemon-internal: resolve a bearer token to its owning source. */
-  findByToken(token: string): SourceRow | null {
-    if (!token) return null;
-    const row = this.db.prepare<[string], SourceDbRow>(
-      `SELECT * FROM sources WHERE token = ?`,
-    ).get(token);
-    return row ? rowFromDb(row) : null;
-  }
-
-  /** Daemon-internal: returns the raw token. Never echo to HTTP responses. */
-  getToken(id: number): string | null {
-    const row = this.db.prepare<[number], SourceDbRow>(
-      `SELECT token FROM sources WHERE id = ?`,
-    ).get(id);
-    return row?.token ?? null;
-  }
-
-  /** Mint a fresh token, invalidating any previous one. */
-  regenerateToken(id: number): string | null {
-    const current = this.get(id);
-    if (!current || current.kind !== "webhook") return null;
-    const token = mintToken();
-    this.db.prepare(`UPDATE sources SET token = ?, updated_at = datetime('now') WHERE id = ?`)
-      .run(token, id);
-    return token;
-  }
-
-  update(id: number, patch: SourceUpdate): SourceRow | null {
-    const fields: string[] = [];
-    const params: Record<string, unknown> = { id };
-    if (patch.name !== undefined) { fields.push("name = @name"); params["name"] = patch.name; }
-    if (patch.pathOrUrl !== undefined) { fields.push("path_or_url = @path"); params["path"] = patch.pathOrUrl; }
-    if (patch.runtimeLabel !== undefined) { fields.push("runtime_label = @rt"); params["rt"] = patch.runtimeLabel; }
-    if (patch.parseConfig !== undefined) { fields.push("parse_config = @cfg"); params["cfg"] = JSON.stringify(patch.parseConfig); }
-    if (patch.enabled !== undefined) { fields.push("enabled = @en"); params["en"] = patch.enabled ? 1 : 0; }
-    if (fields.length === 0) return this.get(id);
-    fields.push("updated_at = datetime('now')");
-    this.db.prepare(`UPDATE sources SET ${fields.join(", ")} WHERE id = @id`).run(params);
-    return this.get(id);
-  }
-
-  delete(id: number): boolean {
-    const result = this.db.prepare(`DELETE FROM sources WHERE id = ?`).run(id);
-    return result.changes > 0;
-  }
-
-  /**
-   * Seed the three legacy adapter presets on first boot of an empty
-   * registry. Subsequent boots are no-ops. Respects per-runtime env
-   * overrides so existing installs don't lose their custom paths.
-   */
-  seedDefaults(): void {
-    const count = this.db.prepare<[], { c: number }>(`SELECT COUNT(*) AS c FROM sources`).get();
-    if ((count?.c ?? 0) > 0) return;
-
-    const claudePath = process.env["NLM_CLAUDE_PROJECTS_PATH"]
-      ?? join(homedir(), ".claude", "projects");
-    const hermesPath = process.env["NLM_HERMES_SESSIONS_PATH"]
-      ?? join(homedir(), ".hermes", "sessions");
-    const piPath = process.env["PI_SESSIONS_PATH"]
-      ?? join(homedir(), ".pi", "agent", "sessions");
-
-    const openCodeDbPath = defaultOpenCodeDbPath();
-    const hermesAgentDbPath = defaultHermesAgentDbPath();
-    const aiderHistoryFile = defaultAiderHistoryFile();
-    const cursorDbPath = defaultCursorDbPath();
-    const windsurfUserDir = defaultWindsurfUserDir();
-
-    const presets: SourceInsert[] = [
-      {
-        kind: "claude-code",
-        name: "Claude Code",
-        pathOrUrl: claudePath,
-        runtimeLabel: "claude-code/1.0",
-        enabled: existsSync(claudePath),
-      },
-      {
-        kind: "hermes",
-        name: "Hermes",
-        pathOrUrl: hermesPath,
-        runtimeLabel: "hermes/1.0",
-        enabled: existsSync(hermesPath),
-      },
-      {
-        kind: "hermes-agent",
-        name: "Hermes Agent",
-        pathOrUrl: hermesAgentDbPath,
-        runtimeLabel: "hermes-agent/1.0",
-        enabled: existsSync(hermesAgentDbPath),
-      },
-      {
-        kind: "aider",
-        name: "Aider",
-        pathOrUrl: aiderHistoryFile,
-        runtimeLabel: "aider/1.0",
-        enabled: existsSync(aiderHistoryFile),
-      },
-      {
-        kind: "cursor",
-        name: "Cursor",
-        pathOrUrl: cursorDbPath,
-        runtimeLabel: "cursor/1.0",
-        enabled: existsSync(cursorDbPath),
-      },
-      {
-        kind: "windsurf",
-        name: "Windsurf",
-        pathOrUrl: windsurfUserDir,
-        runtimeLabel: "windsurf/1.0",
-        enabled: existsSync(windsurfUserDir),
-      },
-      {
-        kind: "opencode",
-        name: "OpenCode",
-        pathOrUrl: openCodeDbPath,
-        runtimeLabel: "opencode/1.0",
-        enabled: existsSync(openCodeDbPath),
-      },
-      {
-        kind: "pi",
-        name: "pi.dev",
-        pathOrUrl: piPath,
-        runtimeLabel: "pi/1.0",
-        enabled: existsSync(piPath),
-      },
-    ];
-    for (const p of presets) this.insert(p);
-  }
-}

package/src/core/storage/db-restore.ts

@@ -1,133 +0,0 @@
-/**
- * Backup + restore for the canonical SQLite store.
- *
- * Backup is live-safe: `VACUUM INTO` takes a read lock and writes a clean,
- * defragmented, single-file snapshot — no WAL sidecars, consistent even
- * while the daemon is ingesting.
- *
- * Restore cannot swap a file the daemon holds open. Instead the uploaded
- * DB is validated and parked at `<dbPath>.restore-pending`; the next daemon
- * boot calls `applyPendingRestore()` before opening the store, moving the
- * current DB aside to `<dbPath>.pre-restore-<ts>` and promoting the pending
- * file. The desktop shell turns "restart required" into one click.
- */
-
-import Database from "better-sqlite3";
-import { existsSync, renameSync, rmSync, statSync } from "node:fs";
-import { dirname, join } from "node:path";
-
-export const PENDING_SUFFIX = ".restore-pending";
-
-export interface RestoreValidation {
-  ok: boolean;
-  error?: string;
-  sessions?: number;
-  schemaVersion?: number;
-}
-
-/**
- * Validate that `filePath` is a usable canonical store: passes integrity
- * check and carries the `sessions` + `schema_migrations` tables. Opened
- * read-only and without the sqlite-vec extension — we never touch the
- * vec virtual tables here, so the extension isn't needed.
- */
-export function validateRestoreCandidate(filePath: string): RestoreValidation {
-  let db: Database.Database | null = null;
-  try {
-    db = new Database(filePath, { readonly: true, fileMustExist: true });
-    const integrity = db.pragma("integrity_check", { simple: true });
-    if (integrity !== "ok") {
-      return { ok: false, error: `integrity check failed: ${String(integrity)}` };
-    }
-    const tables = db
-      .prepare<[], { name: string }>(
-        "SELECT name FROM sqlite_master WHERE type='table' AND name IN ('sessions','schema_migrations')",
-      )
-      .all()
-      .map((r) => r.name);
-    if (!tables.includes("sessions") || !tables.includes("schema_migrations")) {
-      return { ok: false, error: "not an nlm-memory database (missing sessions/schema_migrations)" };
-    }
-    const sessions = db
-      .prepare<[], { n: number }>("SELECT COUNT(*) AS n FROM sessions")
-      .get();
-    const version = db
-      .prepare<[], { v: number | null }>("SELECT MAX(version) AS v FROM schema_migrations")
-      .get();
-    return {
-      ok: true,
-      sessions: sessions?.n ?? 0,
-      schemaVersion: version?.v ?? 0,
-    };
-  } catch (e) {
-    return { ok: false, error: e instanceof Error ? e.message : String(e) };
-  } finally {
-    db?.close();
-  }
-}
-
-/**
- * Park an already-written candidate file as the pending restore for
- * `dbPath`. Validates first; on failure the candidate is removed and the
- * validation error returned. On success the candidate is renamed to
- * `<dbPath>.restore-pending` (same directory, so the rename is atomic).
- */
-export function stageRestore(dbPath: string, candidatePath: string): RestoreValidation {
-  const validation = validateRestoreCandidate(candidatePath);
-  if (!validation.ok) {
-    rmSync(candidatePath, { force: true });
-    return validation;
-  }
-  const pending = dbPath + PENDING_SUFFIX;
-  rmSync(pending, { force: true });
-  renameSync(candidatePath, pending);
-  return validation;
-}
-
-export interface PendingRestoreResult {
-  applied: boolean;
-  archivedTo?: string;
-}
-
-/**
- * If a pending restore exists for `dbPath`, promote it: move the current
- * DB (and its WAL/SHM sidecars) aside, then rename the pending file into
- * place. Call once at boot, before the store is opened.
- */
-export function applyPendingRestore(dbPath: string): PendingRestoreResult {
-  const pending = dbPath + PENDING_SUFFIX;
-  if (!existsSync(pending)) return { applied: false };
-
-  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const archived = `${dbPath}.pre-restore-${stamp}`;
-
-  if (existsSync(dbPath)) {
-    renameSync(dbPath, archived);
-  }
-  // The archived DB's WAL/SHM belong to it — drop the live sidecars so the
-  // promoted file isn't paired with a stale WAL.
-  for (const sidecar of [`${dbPath}-wal`, `${dbPath}-shm`]) {
-    rmSync(sidecar, { force: true });
-  }
-  renameSync(pending, dbPath);
-
-  return existsSync(archived)
-    ? { applied: true, archivedTo: archived }
-    : { applied: true };
-}
-
-/**
- * Write a live-consistent snapshot of `db` to a fresh file via
- * `VACUUM INTO`. The destination must not already exist. Returns the
- * snapshot's size in bytes.
- */
-export function vacuumSnapshot(db: Database.Database, destPath: string): number {
-  rmSync(destPath, { force: true });
-  db.prepare("VACUUM INTO ?").run(destPath);
-  return statSync(destPath).size;
-}
-
-/** Scratch path for a backup snapshot, alongside the DB so rename stays atomic. */
-export function snapshotScratchPath(dbPath: string): string {
-  return join(dirname(dbPath), `.backup-${process.pid}-${Date.now()}.sqlite`);
-}

package/src/core/storage/live-status.ts

@@ -1,45 +0,0 @@
-/**
- * live-status — derive the three-tier session status (active / idle / closed)
- * from a transcript file's mtime. Mirrors the Python daemon's
- * live_session_status(): explicit supersedence wins; missing file → closed;
- * otherwise bucketed by age.
- *
- * Thresholds match Python exactly:
- *   < 15 min       → active
- *   15 min – 24 h  → idle
- *   ≥ 24 h         → closed
- *
- * Pure function over filesystem mtime. Tested with synthetic file ages.
- */
-
-import { statSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-import type { SessionStatus } from "@shared/types.js";
-
-const ACTIVE_THRESHOLD_MS = 15 * 60 * 1000;
-const IDLE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
-
-function expandHome(path: string): string {
-  if (path.startsWith("~/")) return join(homedir(), path.slice(2));
-  return path;
-}
-
-export function liveSessionStatus(
-  transcriptPath: string | null,
-  persistedStatus: SessionStatus | "active" | "closed" | "superseded",
-  now: number = Date.now(),
-): SessionStatus {
-  if (persistedStatus === "superseded") return "superseded";
-  if (!transcriptPath) return "closed";
-  try {
-    const expanded = expandHome(transcriptPath);
-    const st = statSync(expanded);
-    const ageMs = now - st.mtimeMs;
-    if (ageMs < ACTIVE_THRESHOLD_MS) return "active";
-    if (ageMs < IDLE_THRESHOLD_MS) return "idle";
-    return "closed";
-  } catch {
-    return "closed";
-  }
-}

package/src/core/storage/migrate.ts

@@ -1,72 +0,0 @@
-/**
- * Migration runner. Reads versioned *.sql files from a directory, applies any
- * whose integer prefix is not yet in schema_migrations, and returns the list
- * of newly applied versions. Idempotent: re-running on an up-to-date database
- * is a no-op. Each migration file is expected to end with its own
- * `INSERT OR IGNORE INTO schema_migrations (...) VALUES (...)`; the runner
- * also defensively upserts the row in case a file forgets.
- */
-
-import { readFileSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import type Database from "better-sqlite3";
-
-export interface AppliedMigration {
-  readonly version: number;
-  readonly name: string;
-}
-
-const FILE_PATTERN = /^(\d+)_([a-z0-9_-]+)\.sql$/i;
-
-export function runMigrations(
-  db: Database.Database,
-  migrationsDir: string,
-): ReadonlyArray<AppliedMigration> {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS schema_migrations (
-      version    INTEGER PRIMARY KEY,
-      name       TEXT NOT NULL,
-      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-  `);
-
-  const applied = new Set<number>(
-    db
-      .prepare<[], { version: number }>("SELECT version FROM schema_migrations")
-      .all()
-      .map((r) => r.version),
-  );
-
-  const files = readdirSync(migrationsDir)
-    .filter((f) => FILE_PATTERN.test(f))
-    .sort();
-
-  const newlyApplied: AppliedMigration[] = [];
-  const upsert = db.prepare(
-    "INSERT OR IGNORE INTO schema_migrations (version, name) VALUES (?, ?)",
-  );
-
-  for (const file of files) {
-    const match = FILE_PATTERN.exec(file);
-    if (!match) continue;
-    const version = Number(match[1]);
-    const name = match[2] ?? file;
-    if (applied.has(version)) continue;
-
-    const sql = readFileSync(join(migrationsDir, file), "utf8");
-    db.exec("BEGIN");
-    try {
-      db.exec(sql);
-      upsert.run(version, name);
-      db.exec("COMMIT");
-    } catch (err) {
-      db.exec("ROLLBACK");
-      throw new Error(
-        `Migration ${file} failed: ${err instanceof Error ? err.message : String(err)}`,
-      );
-    }
-    newlyApplied.push({ version, name });
-  }
-
-  return newlyApplied;
-}