ompchamber 0.3.0

package/src/server/lib/omp/session/files.ts

@@ -0,0 +1,282 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Read-only session-file scanner for oh-my-pi (format v3).
+ *
+ * Faithful, trimmed port of omp-web/lib/omp/session-files.ts (itself a port of
+ * oh-my-pi packages/coding-agent/src/session/session-listing.ts): it lists the
+ * per-project session directories under ~/.omp/agent/sessions and derives a
+ * compact summary per session from a small 4 KiB prefix window of each file —
+ * enough for a sidebar list without ever loading a full session into memory.
+ *
+ * File layout: optional fixed-width 256-byte title-slot line, then the
+ * {"type":"session"} header line, then message entries. Legacy pi v1/v2
+ * shapes parse leniently (raw-text scans); nothing here mutates on-disk data.
+ * The lenient JSONL + header parsing lives in ./session-jsonl.ts.
+ */
+
+import fs from 'fs';
+import * as path from 'path';
+import { getSessionsDir } from '@/server/lib/omp/core/paths';
+import { countMessageMarkers, extractFirstDisplayMessageFromPrefix, extractTextFromContent, parseJsonlLenient, parseSessionListHeader } from '@/shared/lib/omp/session/jsonl';
+import { isRecord } from '@/shared/lib/util/guards';
+
+export const SESSION_TITLE_SLOT_BYTES = 256;
+
+/** Compact summary of one session file — the sidebar list row. */
+export interface OmpSessionInfo {
+  /** Absolute path of the .jsonl file. */
+  path: string;
+  id: string;
+  /** Working directory the session ran in (from the header). */
+  cwd: string;
+  /** User-facing title (title slot wins; falls back to header title). */
+  title?: string;
+  parentSessionPath?: string;
+  created: Date;
+  modified: Date;
+  messageCount: number;
+  size: number;
+  firstMessage: string;
+}
+
+// ============================================================================
+// Per-file scan (4 KiB prefix window)
+// ============================================================================
+
+const SESSION_LIST_PREFIX_BYTES = 4096;
+
+async function readTextPrefix(filePath: string, prefixBytes: number): Promise<[string, number, Date]> {
+  const file = Bun.file(filePath);
+  const stat = await file.stat();
+  const prefixLength = Math.min(prefixBytes, stat.size);
+  const prefix = prefixLength > 0 ? await file.slice(0, prefixLength).text() : '';
+  return [prefix, stat.size, new Date(stat.mtimeMs)];
+}
+
+/**
+ * Scan a single session file into an OmpSessionInfo using only a 4 KiB prefix
+ * window. Faithful port of omp's scanSessionFile — messageCount is a
+ * prefix-derived lower bound. Missing/unreadable/header-less files yield
+ * undefined instead of throwing.
+ */
+export async function scanSessionInfo(filePath: string): Promise<OmpSessionInfo | undefined> {
+  try {
+    const [content, size, mtime] = await readTextPrefix(filePath, SESSION_LIST_PREFIX_BYTES);
+    const entries = parseJsonlLenient<Record<string, unknown>>(content);
+    const header = parseSessionListHeader(content, entries);
+    if (!header) return undefined;
+
+    let parsedMessageCount = 0;
+    let firstMessage = '';
+    let shortSummary: string | undefined;
+    for (let i = 1; i < entries.length; i++) {
+      const entry = entries[i] as {
+        type?: string;
+        message?: { role?: string; content?: unknown };
+        shortSummary?: string;
+      };
+      if (entry.type === 'compaction' && typeof entry.shortSummary === 'string') {
+        shortSummary = entry.shortSummary;
+      }
+      if (entry.type === 'message' && entry.message) {
+        parsedMessageCount++;
+        if (entry.message.role === 'user' && !firstMessage) {
+          firstMessage = extractTextFromContent(entry.message.content);
+        }
+      }
+    }
+
+    firstMessage ||= extractFirstDisplayMessageFromPrefix(content) ?? '';
+    return {
+      path: filePath,
+      id: header.id,
+      cwd: header.cwd ?? '',
+      title: header.title ?? shortSummary,
+      parentSessionPath: header.parentSession,
+      created: new Date(header.timestamp ?? ''),
+      modified: mtime,
+      messageCount: Math.max(parsedMessageCount, countMessageMarkers(content)),
+      size,
+      firstMessage: firstMessage || '(no messages)',
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+// ============================================================================
+// File-list walk + per-file memo, both mtime-keyed
+// ============================================================================
+
+interface SessionFileListCacheEntry {
+  /** mtimeMs of every project subdirectory, keyed by directory name. A new
+   *  session file bumps its project dir's mtime, so the cache invalidates for
+   *  free on add/remove even though the sessions root itself never changes. */
+  dirMtimes: Map<string, number>;
+  files: string[];
+}
+
+declare global {
+  var __ompChamberSessionFileListCache: Map<string, SessionFileListCacheEntry> | undefined;
+  var __ompChamberSessionScanCache: Map<string, OmpSessionInfo> | undefined;
+}
+
+const MAX_SESSION_SCAN_CACHE_ENTRIES = 2048;
+
+/**
+ * Walk `<sessionsRoot>/<project>/*.jsonl`, caching on the root directory's
+ * mtimeMs: creating/deleting a session bumps the parent directory's mtime, so
+ * the cache invalidates for free on every add/remove. A directory that no
+ * longer exists yields [] rather than throwing.
+ */
+export async function listSessionFiles(sessionsRoot: string = getSessionsDir()): Promise<string[]> {
+  try {
+    await Bun.file(sessionsRoot).stat();
+  } catch {
+    return [];
+  }
+  if (!globalThis.__ompChamberSessionFileListCache) {
+    globalThis.__ompChamberSessionFileListCache = new Map();
+  }
+  const cache = globalThis.__ompChamberSessionFileListCache;
+  const cached = cache.get(sessionsRoot);
+  if (cached) {
+    let fresh = true;
+    for (const dirent of await fs.promises.readdir(sessionsRoot, { withFileTypes: true })) {
+      if (!dirent.isDirectory()) continue;
+      try {
+        const stat = await Bun.file(path.join(sessionsRoot, dirent.name)).stat();
+        if (cached.dirMtimes.get(dirent.name) !== stat.mtimeMs) {
+          fresh = false;
+          break;
+        }
+      } catch {
+        fresh = false;
+        break;
+      }
+    }
+    if (fresh && cached.dirMtimes.size > 0) return cached.files;
+  }
+
+  const files: string[] = [];
+  const dirMtimes = new Map<string, number>();
+  let dirents: fs.Dirent[] = [];
+  try {
+    dirents = await fs.promises.readdir(sessionsRoot, { withFileTypes: true });
+  } catch {
+    // Unreadable sessions root — treat as empty.
+  }
+  for (const dirent of dirents) {
+    if (!dirent.isDirectory()) continue;
+    const projectDir = path.join(sessionsRoot, dirent.name);
+    try {
+      dirMtimes.set(dirent.name, (await Bun.file(projectDir).stat()).mtimeMs);
+    } catch {
+      continue;
+    }
+    let entries: fs.Dirent[] = [];
+    try {
+      entries = await fs.promises.readdir(projectDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      // Skip per-session artifacts directories (file name minus .jsonl) —
+      // only regular files ending in .jsonl are accepted.
+      if (!entry.isFile() || !entry.name.endsWith('.jsonl')) continue;
+      files.push(path.join(projectDir, entry.name));
+    }
+  }
+
+  cache.set(sessionsRoot, { dirMtimes, files });
+  return files;
+}
+
+function getSessionScanCache(): Map<string, OmpSessionInfo> {
+  if (!globalThis.__ompChamberSessionScanCache) {
+    globalThis.__ompChamberSessionScanCache = new Map();
+  }
+  return globalThis.__ompChamberSessionScanCache;
+}
+
+/** scanSessionInfo memoized on (path, size, mtimeMs) — an unchanged file costs
+ *  a single stat. Cache hits share one object; callers must treat results as
+ *  immutable. */
+async function scanSessionInfoCached(filePath: string): Promise<OmpSessionInfo | undefined> {
+  let stat: { size: number; mtimeMs: number };
+  try {
+    stat = await Bun.file(filePath).stat();
+  } catch {
+    return undefined;
+  }
+  const cache = getSessionScanCache();
+  const cached = cache.get(filePath);
+  if (cached) {
+    const info = cached;
+    // Re-scan when size or mtime changed.
+    if (info.size === stat.size && info.modified.getTime() === stat.mtimeMs) {
+      cache.delete(filePath);
+      cache.set(filePath, info);
+      return info;
+    }
+    cache.delete(filePath);
+  }
+  const info = await scanSessionInfo(filePath);
+  // Failed scans are not negatively cached: a transient read error must not
+  // hide a session until its next mtime bump.
+  if (info) {
+    cache.set(filePath, info);
+    while (cache.size > MAX_SESSION_SCAN_CACHE_ENTRIES) {
+      const oldestKey = cache.keys().next().value;
+      if (oldestKey === undefined) break;
+      cache.delete(oldestKey);
+    }
+  }
+  return info;
+}
+
+/**
+ * List every session across all project subdirectories of the sessions root,
+ * newest-modified first. Invalidates are automatic via mtime keys; callers
+ * that mutate sessions may clear caches via clearSessionFileCaches().
+ */
+export async function listAllSessionInfos(sessionsRoot: string = getSessionsDir()): Promise<OmpSessionInfo[]> {
+  const files = await listSessionFiles(sessionsRoot);
+  const sessions: OmpSessionInfo[] = [];
+  for (const file of files) {
+    const info = await scanSessionInfoCached(file);
+    if (info) sessions.push(info);
+  }
+  sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+  return sessions;
+}
+
+/** Clear in-memory file-list and per-file scan caches (e.g. after a mutation
+ *  that mtime keys cannot detect). */
+export function clearSessionFileCaches(): void {
+  globalThis.__ompChamberSessionFileListCache?.clear();
+  globalThis.__ompChamberSessionScanCache?.clear();
+}
+
+/** Exported for tests/spot-checks: read a raw JSONL session header directly. */
+export async function readRawHeaderLine(filePath: string): Promise<Record<string, unknown> | undefined> {
+  try {
+    const head = (await Bun.file(filePath).text()).slice(0, SESSION_TITLE_SLOT_BYTES + 4096);
+    const lines = head.split('\n').filter(Boolean);
+    for (const line of lines) {
+      try {
+        const parsed: unknown = JSON.parse(line);
+        if (isRecord(parsed) && parsed.type === 'session') return parsed;
+      } catch {
+        // Keep scanning lines.
+      }
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}

package/src/server/lib/omp/session/locator.ts

@@ -0,0 +1,60 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Locate an oh-my-pi session file by its session UUID. Uses the same mtime
+ * cached scan as the sidebar list (no extra directory walks), then returns
+ * the file path when an id matches.
+ */
+
+import { json } from '@/server/lib/remix-compat';
+import { getSessionsDir } from '@/server/lib/omp/core/paths';
+import { listSessionFiles, readRawHeaderLine, scanSessionInfo } from '@/server/lib/omp/session/files';
+
+/** Find the absolute path of the .jsonl whose header id matches. */
+export async function findSessionFileById(
+  sessionId: string,
+  sessionsRoot: string = getSessionsDir(),
+): Promise<string | undefined> {
+  const files = await listSessionFiles(sessionsRoot);
+  for (const file of files) {
+    const info = await scanSessionInfo(file);
+    if (info?.id === sessionId) return file;
+  }
+  return undefined;
+}
+
+/** The JSON 404 envelope every session-resolve guard answers with. */
+export function sessionNotFoundResponse(): Response {
+  return json({ error: 'Session not found' }, { status: 404 });
+}
+
+/**
+ * Resolve a session id to its on-disk JSONL path, or the shared 404 response.
+ * The union keeps the guard explicit at each call site: `if ('response' in
+ * resolved) return resolved.response;`.
+ */
+export async function resolveSessionFileOr404(
+  sessionId: string,
+): Promise<{ filePath: string } | { response: Response }> {
+  const filePath = await findSessionFileById(sessionId);
+  if (!filePath) return { response: sessionNotFoundResponse() };
+  return { filePath };
+}
+
+/**
+ * Resolve the session file path and its recorded cwd (used to respawn the
+ * agent in the directory the session was created in), or the shared 404.
+ */
+export async function resolveSessionPathOr404(
+  sessionId: string,
+): Promise<{ filePath: string; recordedCwd: string | null } | { response: Response }> {
+  const filePath = await findSessionFileById(sessionId);
+  if (!filePath) return { response: sessionNotFoundResponse() };
+  let recordedCwd: string | null = null;
+  const header = await readRawHeaderLine(filePath);
+  if (header && typeof header.cwd === 'string') recordedCwd = header.cwd;
+  return { filePath, recordedCwd };
+}

package/src/server/lib/omp/session/messages.ts

@@ -0,0 +1,222 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Read-only full-JSONL loader for a single oh-my-pi session file, mapping the
+ * omp message stream to the chamber ChatMessageData shape so the chat timeline
+ * renders faithfully (thinking accordions, tool calls with their results,
+ * assistant text, user turns).
+ *
+ * omp writes one JSONL entry per message turn, but a single assistant entry
+ * may hold several blocks: thinking, toolCall, toolResult and text. The
+ * mapping below:
+ *   - turns each omp "message" entry into one ChatMessageData
+ *   - lifts `thinking` blocks into msg.thinking
+ *   - lifts `toolCall` blocks into msg.toolCalls (ToolCallData)
+ *   - pairs toolResult blocks with the toolCallId of their tool call and folds
+ *     their text into that tool's `output` (skipping image/refusal payloads)
+ *   - joins text blocks into msg.content
+ */
+
+import { parseJsonlLenient } from '@/shared/lib/omp/session/jsonl';
+import { normalizeNoticePositions } from '@/shared/lib/chat/order';
+import { normalizeThinkingLevel } from '@/shared/lib/models/thinking-levels';
+import type { ChatMessageData } from '@/shared/types/chat';
+import { collectToolOutputs, noticeFromCustomMessage, toChatMessage, type SequenceState } from '@/shared/lib/omp/session/messages-map';
+import type { OmpMessageEntry } from '@/shared/lib/omp/session/messages-parse';
+
+const MAX_SESSION_LOAD_BYTES = 512 * 1024 * 1024;
+
+/** omp expands `/skill:<name>` into a `custom_message` record and stores no
+ *  user message for it, so the chamber reconstructs the bubble from it. */
+function skillUserMessageFromRecord(record: Record<string, unknown>): ChatMessageData | null {
+  const details = record.details as { name?: unknown } | undefined;
+  const fromDetails = typeof details?.name === 'string' ? details.name : undefined;
+  const fromContent = typeof record.content === 'string'
+    ? /User invoked the "([^"]+)" skill/.exec(record.content)?.[1]
+    : undefined;
+  const skillName = fromDetails ?? fromContent;
+  if (!skillName) return null;
+  const parsed = typeof record.timestamp === 'string' ? new Date(record.timestamp) : undefined;
+  const time = parsed && !Number.isNaN(parsed.getTime())
+    ? parsed.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' })
+    : undefined;
+  return {
+    id: typeof record.id === 'string' ? record.id : `skill-${Date.now()}`,
+    role: 'user',
+    content: `/skill:${skillName}`,
+    date: time ? `Today, ${time}` : undefined,
+    timestamp: time,
+  };
+}
+
+/**
+ * Load a session file and return the chat timeline in chronological order.
+ * Assistant messages carry thinking accordion + tool calls (with outputs
+ * paired from their toolResult entries); tool plumbing rows are folded in.
+ */
+export async function loadSessionMessages(filePath: string): Promise<ChatMessageData[]> {
+  try {
+    const file = Bun.file(filePath);
+    if ((await file.stat()).size > MAX_SESSION_LOAD_BYTES) return [];
+  } catch {
+    return [];
+  }
+
+  let body: string;
+  try {
+    body = await Bun.file(filePath).text();
+  } catch {
+    return [];
+  }
+
+  const records = parseJsonlLenient<Record<string, unknown>>(body);
+  const state: SequenceState = { messages: [], outputsByCall: collectToolOutputs(records) };
+  // omp records the thinking level as separate `thinking_level_change` entries
+  // (session state), not as a per-message field. Walk the records in order and
+  // stamp the level in effect onto each assistant turn so the footer shows the
+  // level that actually served it — not the last level used in the session.
+  let currentLevel: string | undefined;
+  const levelFor = (record: Record<string, unknown>): string | undefined => {
+    if (record?.type === 'thinking_level_change') {
+      currentLevel = normalizeThinkingLevel(record.thinkingLevel);
+    }
+    return currentLevel;
+  };
+
+  for (const record of records) {
+    const level = levelFor(record);
+    if (record?.type === 'custom_message' && record.customType === 'skill-prompt') {
+      const skillMsg = skillUserMessageFromRecord(record);
+      if (skillMsg) {
+        state.messages.push(skillMsg);
+        continue;
+      }
+    }
+    if (record?.type === 'custom_message' || record?.type === 'custom') {
+      const notice = noticeFromCustomMessage(record);
+      if (notice) state.messages.push(notice);
+      continue;
+    }
+    if (record?.type !== 'message') continue;
+    const mapped = toChatMessage(record as unknown as OmpMessageEntry);
+    if (!mapped) continue;
+    if (level !== undefined && mapped.role !== 'user') {
+      mapped.thinkingLevel = level;
+    }
+    // Fold the collected outputs into this message's tool calls.
+    if (mapped.toolCalls?.length) {
+      mapped.toolCalls = mapped.toolCalls.map((call) => {
+        const collected = state.outputsByCall.get(call.id);
+        return {
+          ...call,
+          output: call.output || collected?.output || undefined,
+          details: (call.details || collected?.details || undefined) as Record<string, any> | undefined,
+          status: collected?.isError ? 'error' : call.status,
+        };
+      });
+    }
+    state.messages.push(mapped);
+  }
+  return normalizeNoticePositions(state.messages);
+}
+
+/** Derive the display title from the JSONL header/title slot (cheap read). */
+export async function loadSessionTitle(filePath: string): Promise<string | undefined> {
+  try {
+    const file = Bun.file(filePath);
+    if ((await file.stat()).size > 10 * 1024 * 1024) return undefined; // only need the head
+  } catch {
+    return undefined;
+  }
+  try {
+    const head = (await Bun.file(filePath).text()).slice(0, 32 * 1024);
+    const records = parseJsonlLenient<Record<string, unknown>>(head);
+    const first = records[0];
+    if (first?.type === 'title' && typeof first.title === 'string' && first.title.trim()) {
+      return first.title.trim();
+    }
+    const header = records.find((r) => r?.type === 'session');
+    if (typeof header?.title === 'string' && header.title.trim()) {
+      return header.title.trim();
+    }
+    // Fallback: extract from session_init task
+    const init = records.find((r) => r?.type === 'session_init');
+    if (init && typeof init.task === 'string' && init.task.trim()) {
+      const taskLines = init.task.trim().split('\n').map((l) => l.trim()).filter((l) => l && !l.startsWith('#') && !l.startsWith('Complete assignment'));
+      if (taskLines.length > 0) {
+        return taskLines[0].slice(0, 60);
+      }
+    }
+    // Fallback: extract from first user message
+    const userMsg = records.find((r) => r?.type === 'message' && (r as Record<string, unknown>).message != null
+      && ((r as Record<string, unknown>).message as Record<string, unknown>).role === 'user');
+    if (userMsg) {
+      const message = (userMsg as Record<string, unknown>).message as Record<string, unknown>;
+      const text = message.content;
+      const str = typeof text === 'string' ? text : Array.isArray(text) ? text.map((c) => (c as Record<string, unknown>).text || '').join('') : '';
+      const lines = str.trim().split('\n').map((l) => l.trim()).filter((l) => l && !l.startsWith('#') && !l.startsWith('Complete assignment'));
+      if (lines.length > 0) {
+        return lines[0].slice(0, 60);
+      }
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Resolve the model last used by a session from its `model_change` entries
+ *  (omp records `"provider/model-id"`). Returns undefined when the file has
+ *  no model_change entry or the value is malformed. */
+export async function loadSessionModel(filePath: string): Promise<{ provider: string; modelId: string } | undefined> {
+  try {
+    const file = Bun.file(filePath);
+    if ((await file.stat()).size > MAX_SESSION_LOAD_BYTES) return undefined;
+  } catch {
+    return undefined;
+  }
+  try {
+    const body = await Bun.file(filePath).text();
+    const records = parseJsonlLenient<Record<string, unknown>>(body);
+    let last: { provider: string; modelId: string } | undefined;
+    for (const record of records) {
+      if (record?.type !== 'model_change') continue;
+      const model = typeof record.model === 'string' ? record.model : undefined;
+      if (!model) continue;
+      const slash = model.indexOf('/');
+      if (slash <= 0 || slash === model.length - 1) continue;
+      last = { provider: model.slice(0, slash), modelId: model.slice(slash + 1) };
+    }
+    return last;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Resolve the thinking level last used by a session from its
+ *  `thinking_level_change` entries (omp records the level string, e.g.
+ *  "off" | "minimal" | "low" | "medium" | "high" | "max"). */
+export async function loadSessionThinkingLevel(filePath: string): Promise<string | undefined> {
+  try {
+    const file = Bun.file(filePath);
+    if ((await file.stat()).size > MAX_SESSION_LOAD_BYTES) return undefined;
+  } catch {
+    return undefined;
+  }
+  try {
+    const body = await Bun.file(filePath).text();
+    const records = parseJsonlLenient<Record<string, unknown>>(body);
+    let last: string | undefined;
+    for (const record of records) {
+      if (record?.type !== 'thinking_level_change') continue;
+      // A change entry always yields a display level: null/unset → "off".
+      last = normalizeThinkingLevel(record.thinkingLevel);
+    }
+    return last;
+  } catch {
+    return undefined;
+  }
+}