@blackbelt-technology/pi-agent-dashboard 0.2.0

package/packages/server/src/memory-event-store.ts

@@ -0,0 +1,193 @@
+/**
+ * In-memory event store with LRU eviction.
+ * Replaces SQLite-backed event-store.ts.
+ */
+import type { DashboardEvent } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+
+export interface StoredEvent {
+  seq: number;
+  event: DashboardEvent;
+}
+
+export interface EventStore {
+  /** Insert an event, returns assigned sequence number */
+  insertEvent(sessionId: string, event: DashboardEvent): number;
+  /** Get events for a session starting from minSeq (inclusive) */
+  getEvents(sessionId: string, minSeq: number): StoredEvent[];
+  /** Get a single event by sessionId and seq */
+  getEvent(sessionId: string, seq: number): DashboardEvent | undefined;
+  /** Delete all events for a specific session */
+  deleteEventsForSession(sessionId: string): number;
+  /** Check if session has events in memory */
+  hasEvents(sessionId: string): boolean;
+  /** Return the highest seq for a session, or 0 if no events */
+  getMaxSeq(sessionId: string): number;
+  /** Number of cached sessions */
+  sessionCount(): number;
+}
+
+interface SessionBuffer {
+  events: StoredEvent[];
+  nextSeq: number;
+  lastAccess: number;
+}
+
+export const DEFAULT_MAX_CACHED_SESSIONS = 100;
+export const DEFAULT_MAX_EVENTS_PER_SESSION = 5000;
+
+/** Default max size for any string field within event data */
+const DEFAULT_MAX_STRING_SIZE = 4_000;
+/** Max total serialized size for an individual event's data */
+const MAX_EVENT_DATA_SIZE = 20_000;
+
+/**
+ * Recursively truncate large string fields in an object.
+ * Returns a new object if any truncation occurred, otherwise the original.
+ */
+function truncateStrings(obj: unknown, maxSize: number, depth = 0): unknown {
+  if (depth > 4) return obj;
+  if (typeof obj === "string") {
+    return obj.length > maxSize ? obj.slice(0, maxSize) + "\n…[truncated]" : obj;
+  }
+  if (Array.isArray(obj)) {
+    // Skip large arrays (e.g., edits arrays)
+    if (obj.length > 20) return "[array truncated]";
+    let changed = false;
+    const result = obj.map((item) => {
+      const t = truncateStrings(item, maxSize, depth + 1);
+      if (t !== item) changed = true;
+      return t;
+    });
+    return changed ? result : obj;
+  }
+  if (obj && typeof obj === "object") {
+    let changed = false;
+    const result: Record<string, unknown> = {};
+    for (const [key, val] of Object.entries(obj)) {
+      // Preserve base64 image data — skip truncation when sibling mimeType exists
+      if (key === "data" && typeof val === "string" && "mimeType" in obj) {
+        result[key] = val;
+        continue;
+      }
+      // Skip 'thinking' blocks entirely — large and not shown in chat
+      if (key === "thinking" && typeof val === "string" && val.length > maxSize) {
+        result[key] = (val as string).slice(0, 500) + "\n…[truncated]";
+        changed = true;
+        continue;
+      }
+      const t = truncateStrings(val, maxSize, depth + 1);
+      if (t !== val) changed = true;
+      result[key] = t;
+    }
+    return changed ? result : obj;
+  }
+  return obj;
+}
+
+/**
+ * Truncate large event data to bound memory usage per event.
+ */
+function createTruncator(maxStringSize: number) {
+  if (maxStringSize <= 0) return (event: DashboardEvent) => event; // disabled
+  return (event: DashboardEvent): DashboardEvent => {
+    const data = event.data;
+    if (!data || typeof data !== "object") return event;
+    const truncated = truncateStrings(data, maxStringSize) as Record<string, unknown>;
+    return truncated !== data ? { ...event, data: truncated } : event;
+  };
+}
+
+export function createMemoryEventStore(
+  isSessionPinned: (sessionId: string) => boolean,
+  maxCachedSessions: number = DEFAULT_MAX_CACHED_SESSIONS,
+  maxEventsPerSession: number = DEFAULT_MAX_EVENTS_PER_SESSION,
+  maxStringFieldSize: number = DEFAULT_MAX_STRING_SIZE,
+): EventStore {
+  const truncateEventData = createTruncator(maxStringFieldSize);
+  const buffers = new Map<string, SessionBuffer>();
+
+  function getOrCreate(sessionId: string): SessionBuffer {
+    let buf = buffers.get(sessionId);
+    if (!buf) {
+      buf = { events: [], nextSeq: 1, lastAccess: Date.now() };
+      buffers.set(sessionId, buf);
+    }
+    buf.lastAccess = Date.now();
+    return buf;
+  }
+
+  function evictIfNeeded(): void {
+    if (buffers.size <= maxCachedSessions) return;
+
+    // Collect evictable sessions sorted by lastAccess ascending
+    const evictable: Array<[string, number]> = [];
+    for (const [id, buf] of buffers) {
+      if (!isSessionPinned(id)) {
+        evictable.push([id, buf.lastAccess]);
+      }
+    }
+    evictable.sort((a, b) => a[1] - b[1]);
+
+    // Evict until we're at or below the limit
+    let toEvict = buffers.size - maxCachedSessions;
+    for (const [id] of evictable) {
+      if (toEvict <= 0) break;
+      buffers.delete(id);
+      toEvict--;
+    }
+  }
+
+  return {
+    insertEvent(sessionId: string, event: DashboardEvent): number {
+      const buf = getOrCreate(sessionId);
+      const seq = buf.nextSeq++;
+      buf.events.push({ seq, event: truncateEventData(event) });
+      // Trim oldest events when over the per-session limit (0 = unlimited)
+      if (maxEventsPerSession > 0 && buf.events.length > maxEventsPerSession) {
+        const excess = buf.events.length - maxEventsPerSession;
+        buf.events.splice(0, excess);
+      }
+      evictIfNeeded();
+      return seq;
+    },
+
+    getEvents(sessionId: string, minSeq: number): StoredEvent[] {
+      const buf = buffers.get(sessionId);
+      if (!buf) return [];
+      buf.lastAccess = Date.now();
+      const effectiveMin = minSeq > 0 ? minSeq : 1;
+      return buf.events.filter((e) => e.seq >= effectiveMin);
+    },
+
+    getEvent(sessionId: string, seq: number): DashboardEvent | undefined {
+      const buf = buffers.get(sessionId);
+      if (!buf) return undefined;
+      buf.lastAccess = Date.now();
+      const entry = buf.events.find((e) => e.seq === seq);
+      return entry?.event;
+    },
+
+    deleteEventsForSession(sessionId: string): number {
+      const buf = buffers.get(sessionId);
+      if (!buf) return 0;
+      const count = buf.events.length;
+      buffers.delete(sessionId);
+      return count;
+    },
+
+    hasEvents(sessionId: string): boolean {
+      const buf = buffers.get(sessionId);
+      return buf !== undefined && buf.events.length > 0;
+    },
+
+    getMaxSeq(sessionId: string): number {
+      const buf = buffers.get(sessionId);
+      if (!buf || buf.events.length === 0) return 0;
+      return buf.events[buf.events.length - 1].seq;
+    },
+
+    sessionCount(): number {
+      return buffers.size;
+    },
+  };
+}

package/packages/server/src/memory-session-manager.ts

@@ -0,0 +1,123 @@
+/**
+ * Pure in-memory session registry.
+ * Replaces SQLite-backed session-manager.ts.
+ */
+import type { DashboardSession, SessionSource, SessionStatus } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+
+export interface RegisterSessionParams {
+  id: string;
+  cwd: string;
+  name?: string;
+  source: SessionSource;
+  model?: string;
+  thinkingLevel?: string;
+  sessionFile?: string;
+  sessionDir?: string;
+  firstMessage?: string;
+  startedAt?: number;
+  pid?: number;
+}
+
+export interface SessionManager {
+  register(params: RegisterSessionParams): DashboardSession;
+  /** Restore a previously persisted session (e.g. on startup). Does not trigger onChange. */
+  restore(session: DashboardSession): void;
+  unregister(sessionId: string): void;
+  update(sessionId: string, updates: Partial<DashboardSession>): void;
+  get(sessionId: string): DashboardSession | undefined;
+  listActive(): DashboardSession[];
+  listAll(): DashboardSession[];
+  /** Called after any mutation (register, unregister, update). Receives the affected session ID. */
+  onChange?: (sessionId: string) => void;
+  /** Called after a session is unregistered (status set to ended). */
+  onUnregister?: (sessionId: string) => void;
+}
+
+export function createMemorySessionManager(): SessionManager {
+  const sessions = new Map<string, DashboardSession>();
+
+  const mgr: SessionManager = {
+    register(params: RegisterSessionParams): DashboardSession {
+      // Preserve accumulated data (tokens, cost) from a prior session with the
+      // same ID (e.g. restored after server restart). Git and openspec data are
+      // polled by the bridge extension shortly after reconnect, so they don't
+      // need to be carried over.
+      const existing = sessions.get(params.id);
+
+      const session: DashboardSession = {
+        // Carry over accumulated data from the existing session (e.g. restored after restart)
+        ...(existing ? {
+          tokensIn: existing.tokensIn,
+          tokensOut: existing.tokensOut,
+          cacheRead: existing.cacheRead,
+          cacheWrite: existing.cacheWrite,
+          cost: existing.cost,
+          // Preserve user-set openspec assignment (not polled, set via dashboard UI)
+          attachedProposal: existing.attachedProposal,
+          // Preserve context usage until bridge sends fresh data
+          contextTokens: existing.contextTokens,
+          contextWindow: existing.contextWindow,
+        } : {
+          tokensIn: 0,
+          tokensOut: 0,
+          cost: 0,
+        }),
+        // Apply registration params (always override)
+        id: params.id,
+        cwd: params.cwd,
+        name: params.name ?? existing?.name,
+        source: params.source,
+        status: "active",
+        model: params.model,
+        thinkingLevel: params.thinkingLevel,
+        startedAt: params.startedAt ?? existing?.startedAt ?? Date.now(),
+        endedAt: undefined,
+        sessionFile: params.sessionFile,
+        sessionDir: params.sessionDir,
+        hidden: false,
+        firstMessage: params.firstMessage ?? existing?.firstMessage,
+        dataUnavailable: false,
+        pid: params.pid,
+      };
+      sessions.set(params.id, session);
+      mgr.onChange?.(params.id);
+      return session;
+    },
+
+    restore(session: DashboardSession): void {
+      sessions.set(session.id, session);
+    },
+
+    unregister(sessionId: string): void {
+      const session = sessions.get(sessionId);
+      if (session) {
+        session.status = "ended";
+        session.endedAt = Date.now();
+        mgr.onChange?.(sessionId);
+        mgr.onUnregister?.(sessionId);
+      }
+    },
+
+    update(sessionId: string, updates: Partial<DashboardSession>): void {
+      const session = sessions.get(sessionId);
+      if (session) {
+        Object.assign(session, updates);
+        mgr.onChange?.(sessionId);
+      }
+    },
+
+    get(sessionId: string): DashboardSession | undefined {
+      return sessions.get(sessionId);
+    },
+
+    listActive(): DashboardSession[] {
+      return Array.from(sessions.values()).filter((s) => s.status !== "ended");
+    },
+
+    listAll(): DashboardSession[] {
+      return Array.from(sessions.values());
+    },
+  };
+
+  return mgr;
+}

package/packages/server/src/meta-persistence.ts

@@ -0,0 +1,64 @@
+/**
+ * Per-session debounced `.meta.json` writer.
+ * Each session gets its own debounce timer — updating session A
+ * does not trigger a write for session B.
+ */
+import { type SessionMeta, metaPath, readSessionMeta, writeSessionMeta } from "@blackbelt-technology/pi-dashboard-shared/session-meta.js";
+
+const DEBOUNCE_MS = 1000;
+
+export interface MetaPersistence {
+  /** Schedule a debounced write of the session's `.meta.json`. */
+  save(sessionFile: string, meta: SessionMeta): void;
+  /** Flush all pending writes immediately. */
+  flushAll(): void;
+  /** Stop all debounce timers. */
+  dispose(): void;
+}
+
+interface PendingWrite {
+  sessionFile: string;
+  meta: SessionMeta;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+export function createMetaPersistence(): MetaPersistence {
+  // Keyed by sessionFile path
+  const pending = new Map<string, PendingWrite>();
+
+  function writeNow(sessionFile: string): void {
+    const entry = pending.get(sessionFile);
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    pending.delete(sessionFile);
+    writeSessionMeta(sessionFile, entry.meta);
+  }
+
+  return {
+    save(sessionFile: string, meta: SessionMeta): void {
+      const existing = pending.get(sessionFile);
+      if (existing) {
+        // Update meta and reset timer
+        clearTimeout(existing.timer);
+        existing.meta = meta;
+        existing.timer = setTimeout(() => writeNow(sessionFile), DEBOUNCE_MS);
+      } else {
+        const timer = setTimeout(() => writeNow(sessionFile), DEBOUNCE_MS);
+        pending.set(sessionFile, { sessionFile, meta, timer });
+      }
+    },
+
+    flushAll(): void {
+      for (const sessionFile of [...pending.keys()]) {
+        writeNow(sessionFile);
+      }
+    },
+
+    dispose(): void {
+      for (const entry of pending.values()) {
+        clearTimeout(entry.timer);
+      }
+      pending.clear();
+    },
+  };
+}

package/packages/server/src/migrate-persistence.ts

@@ -0,0 +1,195 @@
+/**
+ * Migration utility: converts sessions.json + state.json → per-session .meta.json + preferences.json.
+ * Runs automatically on first startup when old files are detected.
+ * Idempotent — safe to run multiple times.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { CONFIG_DIR } from "@blackbelt-technology/pi-dashboard-shared/config.js";
+import { type SessionMeta, readSessionMeta, writeSessionMeta } from "@blackbelt-technology/pi-dashboard-shared/session-meta.js";
+import { readJsonFile, writeJsonFile } from "./json-store.js";
+import { PREFERENCES_FILE } from "./preferences-store.js";
+
+const DEFAULT_SESSIONS_FILE = path.join(CONFIG_DIR, "sessions.json");
+const DEFAULT_STATE_FILE = path.join(CONFIG_DIR, "state.json");
+
+interface OldSession {
+  id: string;
+  sessionFile?: string;
+  cwd?: string;
+  name?: string;
+  source?: string;
+  status?: string;
+  model?: string;
+  thinkingLevel?: string;
+  startedAt?: number;
+  endedAt?: number;
+  tokensIn?: number;
+  tokensOut?: number;
+  cacheRead?: number;
+  cacheWrite?: number;
+  cost?: number;
+  contextTokens?: number;
+  contextWindow?: number;
+  firstMessage?: string;
+  hidden?: boolean;
+  attachedProposal?: string | null;
+}
+
+interface OldState {
+  hiddenSessions?: string[];
+  sessionOrder?: Record<string, string[]>;
+  pinnedDirectories?: string[];
+}
+
+export interface MigrationResult {
+  sessionsWritten: number;
+  hiddenApplied: number;
+  hiddenOrphaned: number;
+  preferencesWritten: boolean;
+  oldFilesRenamed: string[];
+}
+
+export interface MigrationPaths {
+  sessionsFile?: string;
+  stateFile?: string;
+  preferencesFile?: string;
+  sessionsDir?: string;
+}
+
+/** Check if migration is needed (old files exist without .bak) */
+export function needsMigration(paths?: MigrationPaths): boolean {
+  const sessionsFile = paths?.sessionsFile ?? DEFAULT_SESSIONS_FILE;
+  const stateFile = paths?.stateFile ?? DEFAULT_STATE_FILE;
+  return fs.existsSync(sessionsFile) || fs.existsSync(stateFile);
+}
+
+/**
+ * Run the full migration:
+ * 1. Read sessions.json → write .meta.json for each session
+ * 2. Read state.json → apply hiddenSessions to .meta.json, write preferences.json
+ * 3. Rename old files to .bak
+ */
+export function runMigration(paths?: MigrationPaths): MigrationResult {
+  const sessionsFile = paths?.sessionsFile ?? DEFAULT_SESSIONS_FILE;
+  const stateFile = paths?.stateFile ?? DEFAULT_STATE_FILE;
+  const preferencesFile = paths?.preferencesFile ?? PREFERENCES_FILE;
+  const sessionsScanDir = paths?.sessionsDir ?? path.join(os.homedir(), ".pi", "agent", "sessions");
+
+  const result: MigrationResult = {
+    sessionsWritten: 0,
+    hiddenApplied: 0,
+    hiddenOrphaned: 0,
+    preferencesWritten: false,
+    oldFilesRenamed: [],
+  };
+
+  // --- Step 1: Migrate sessions.json → per-session .meta.json ---
+  const sessions = readJsonFile<OldSession[]>(sessionsFile, []);
+  const sessionFileById = new Map<string, string>();
+
+  for (const session of sessions) {
+    if (!session.sessionFile || !fs.existsSync(session.sessionFile)) continue;
+
+    sessionFileById.set(session.id, session.sessionFile);
+
+    // Build meta from session data
+    const newMeta: SessionMeta = {
+      source: session.source,
+      name: session.name,
+      attachedProposal: session.attachedProposal,
+      hidden: session.hidden ?? false,
+      cwd: session.cwd,
+      status: session.status,
+      startedAt: session.startedAt,
+      endedAt: session.endedAt,
+      model: session.model,
+      thinkingLevel: session.thinkingLevel,
+      tokensIn: session.tokensIn,
+      tokensOut: session.tokensOut,
+      cacheRead: session.cacheRead,
+      cacheWrite: session.cacheWrite,
+      cost: session.cost,
+      contextTokens: session.contextTokens,
+      contextWindow: session.contextWindow,
+      firstMessage: session.firstMessage,
+      cachedAt: Date.now(),
+    };
+
+    // Merge with existing .meta.json — strip undefined values so they don't overwrite
+    const existing = readSessionMeta(session.sessionFile) ?? {};
+    const cleaned = Object.fromEntries(Object.entries(newMeta).filter(([, v]) => v !== undefined));
+    const merged = { ...existing, ...cleaned };
+    writeSessionMeta(session.sessionFile, merged);
+    result.sessionsWritten++;
+  }
+
+  // --- Step 2: Migrate state.json ---
+  const state = readJsonFile<OldState>(stateFile, {});
+
+  // Apply hidden IDs to .meta.json files
+  if (state.hiddenSessions) {
+    for (const hiddenId of state.hiddenSessions) {
+      // Try to find the session file
+      const sessionFile = sessionFileById.get(hiddenId);
+      if (sessionFile) {
+        // Known session — merge hidden flag
+        const existing = readSessionMeta(sessionFile) ?? {};
+        writeSessionMeta(sessionFile, { ...existing, hidden: true });
+        result.hiddenApplied++;
+        continue;
+      }
+
+      // Try scanning session directories for this UUID
+      const found = findSessionFileByUuid(hiddenId, sessionsScanDir);
+      if (found) {
+        const existing = readSessionMeta(found) ?? {};
+        writeSessionMeta(found, { ...existing, hidden: true });
+        result.hiddenApplied++;
+      } else {
+        result.hiddenOrphaned++;
+      }
+    }
+  }
+
+  // Write preferences.json
+  const preferences = {
+    pinnedDirectories: state.pinnedDirectories ?? [],
+    sessionOrder: state.sessionOrder ?? {},
+  };
+  writeJsonFile(preferencesFile, preferences);
+  result.preferencesWritten = true;
+
+  // --- Step 3: Rename old files to .bak ---
+  for (const file of [sessionsFile, stateFile]) {
+    if (fs.existsSync(file)) {
+      const bakFile = file + ".bak";
+      fs.renameSync(file, bakFile);
+      result.oldFilesRenamed.push(path.basename(file));
+    }
+  }
+
+  return result;
+}
+
+/** Scan session directories for a .jsonl file containing the given UUID */
+function findSessionFileByUuid(uuid: string, scanDir: string): string | null {
+  if (!fs.existsSync(scanDir)) return null;
+
+  try {
+    for (const cwdDir of fs.readdirSync(scanDir)) {
+      const cwdPath = path.join(scanDir, cwdDir);
+      try {
+        if (!fs.statSync(cwdPath).isDirectory()) continue;
+        for (const file of fs.readdirSync(cwdPath)) {
+          if (file.endsWith(".jsonl") && file.includes(uuid)) {
+            return path.join(cwdPath, file);
+          }
+        }
+      } catch { continue; }
+    }
+  } catch { /* ignore */ }
+
+  return null;
+}