@larose/pi-web 0.3.0

package/src/server/session-repository.ts

@@ -0,0 +1,488 @@
+import { type FileHandle, open, realpath, stat, unlink } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+
+import {
+  CURRENT_SESSION_VERSION,
+  SessionManager,
+  sessionEntryToContextMessages,
+  type SessionHeader,
+  type SessionInfo,
+} from "@earendil-works/pi-coding-agent";
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+
+import { AppError } from "./errors.js";
+
+export interface SessionSummary {
+  id: string;
+  cwd: string;
+  name?: string;
+  created: string;
+  modified: string;
+  messageCount: number;
+  firstMessage: string;
+}
+
+export interface PersistedMessage {
+  entryId: string;
+  message: AgentMessage;
+}
+
+export interface PersistedCustomEntry {
+  entryId: string;
+  customType: string;
+  data: unknown;
+}
+
+export type PersistedTranscriptEntry =
+  | ({ kind: "message" } & PersistedMessage)
+  | ({ kind: "custom" } & PersistedCustomEntry);
+
+export interface PersistedSession extends SessionSummary {
+  transcriptEntries: PersistedTranscriptEntry[];
+  model: { provider: string; modelId: string } | null;
+  thinkingLevel: string;
+}
+
+export interface SessionListing {
+  groups: Array<{ cwd: string; sessions: SessionSummary[] }>;
+  knownCwds: string[];
+}
+
+export interface SessionRepositoryOptions {
+  sessionDir?: string;
+}
+
+const MAX_SESSION_HEADER_BYTES = 1024 * 1024;
+
+function isCurrentSessionHeader(value: unknown): value is SessionHeader & { version: number } {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+
+  const header = value as Record<string, unknown>;
+  return (
+    header.type === "session" &&
+    header.version === CURRENT_SESSION_VERSION &&
+    typeof header.id === "string" &&
+    header.id.trim() !== "" &&
+    typeof header.timestamp === "string" &&
+    header.timestamp.trim() !== "" &&
+    !Number.isNaN(new Date(header.timestamp).getTime()) &&
+    typeof header.cwd === "string" &&
+    header.cwd.trim() !== "" &&
+    (header.parentSession === undefined || typeof header.parentSession === "string")
+  );
+}
+
+async function readCurrentSessionHeader(path: string): Promise<SessionHeader | null> {
+  let file: FileHandle | undefined;
+
+  try {
+    file = await open(path, "r");
+    const buffer = Buffer.allocUnsafe(MAX_SESSION_HEADER_BYTES + 1);
+    let bytesRead = 0;
+    let newline = -1;
+
+    while (bytesRead < buffer.length && newline === -1) {
+      const result = await file.read(buffer, bytesRead, buffer.length - bytesRead, bytesRead);
+      if (result.bytesRead === 0) {
+        break;
+      }
+
+      newline = buffer.indexOf(0x0a, bytesRead);
+      bytesRead += result.bytesRead;
+      if (newline >= bytesRead) {
+        newline = -1;
+      }
+    }
+
+    const bounded = buffer.subarray(0, Math.min(bytesRead, MAX_SESSION_HEADER_BYTES));
+    if (newline === -1 && bytesRead > MAX_SESSION_HEADER_BYTES) {
+      return null;
+    }
+
+    const line = bounded.subarray(0, newline === -1 ? bounded.length : newline).toString("utf8");
+    const parsed: unknown = JSON.parse(line);
+    return isCurrentSessionHeader(parsed) ? parsed : null;
+  } catch {
+    return null;
+  } finally {
+    if (file) {
+      await file.close().catch(() => undefined);
+    }
+  }
+}
+
+function toSummary(info: SessionInfo, header: SessionHeader): SessionSummary {
+  return {
+    id: header.id,
+    cwd: header.cwd,
+    ...(info.name ? { name: info.name } : {}),
+    created: header.timestamp,
+    modified: info.modified.toISOString(),
+    messageCount: info.messageCount,
+    firstMessage: info.firstMessage,
+  };
+}
+
+async function canonicalFile(path: string): Promise<string> {
+  try {
+    const file = await stat(path);
+    if (!file.isFile()) {
+      throw new AppError("stale_session", "The session path is no longer a file", 410);
+    }
+
+    return await realpath(path);
+  } catch (error) {
+    if (error instanceof AppError) {
+      throw error;
+    }
+
+    throw new AppError("stale_session", "The session file no longer exists or is inaccessible", 410, {
+      cause: error,
+    });
+  }
+}
+
+export async function validateCwd(input: unknown): Promise<string> {
+  if (typeof input !== "string" || input.trim() === "") {
+    throw new AppError("invalid_cwd", "A working directory is required");
+  }
+
+  const candidate = input.trim();
+  if (!isAbsolute(candidate)) {
+    throw new AppError("invalid_cwd", "The working directory must be an absolute path");
+  }
+
+  try {
+    const canonical = await realpath(resolve(candidate));
+    const directory = await stat(canonical);
+    if (!directory.isDirectory()) {
+      throw new AppError("invalid_cwd", "The working directory is not a directory");
+    }
+
+    return canonical;
+  } catch (error) {
+    if (error instanceof AppError) {
+      throw error;
+    }
+
+    throw new AppError("invalid_cwd", "The working directory does not exist or is inaccessible", 400, {
+      cause: error,
+    });
+  }
+}
+
+export class SessionRepository {
+  readonly startupCwd: string;
+
+  private readonly sessionDir: string | undefined;
+  private pathsById = new Map<string, string>();
+  private readonly pendingManagers = new Map<string, SessionManager>();
+
+  private constructor(startupCwd: string, sessionDir: string | undefined) {
+    this.startupCwd = startupCwd;
+    this.sessionDir = sessionDir;
+  }
+
+  static async create(startupCwd: string, options: SessionRepositoryOptions = {}): Promise<SessionRepository> {
+    const configuredSessionDir = options.sessionDir ?? process.env.PI_CODING_AGENT_SESSION_DIR;
+    const sessionDir = configuredSessionDir ? resolve(configuredSessionDir) : undefined;
+
+    return new SessionRepository(await validateCwd(startupCwd), sessionDir);
+  }
+
+  async list(): Promise<SessionListing> {
+    const infos = this.sessionDir ? await SessionManager.listAll(this.sessionDir) : await SessionManager.listAll();
+    const nextPaths = new Map<string, string>();
+    const groups = new Map<string, SessionSummary[]>();
+
+    for (const info of infos) {
+      const header = await readCurrentSessionHeader(info.path);
+      if (!header || header.id !== info.id || nextPaths.has(header.id)) {
+        continue;
+      }
+
+      nextPaths.set(header.id, info.path);
+      const sessions = groups.get(header.cwd) ?? [];
+      sessions.push(toSummary(info, header));
+      groups.set(header.cwd, sessions);
+    }
+
+    for (const [id, pending] of [...this.pendingManagers]) {
+      if (nextPaths.has(id)) {
+        continue;
+      }
+
+      let session: PersistedSession;
+      try {
+        session = await this.get(id);
+      } catch (error) {
+        if (!(error instanceof AppError) || error.code !== "invalid_session") {
+          throw error;
+        }
+
+        this.pendingManagers.delete(id);
+        this.pathsById.delete(id);
+        continue;
+      }
+
+      const sessions = groups.get(session.cwd) ?? [];
+      sessions.unshift({
+        id: session.id,
+        cwd: session.cwd,
+        ...(session.name ? { name: session.name } : {}),
+        created: session.created,
+        modified: session.modified,
+        messageCount: session.messageCount,
+        firstMessage: session.firstMessage,
+      });
+      groups.set(session.cwd, sessions);
+
+      const file = pending.getSessionFile();
+      if (file) {
+        nextPaths.set(id, file);
+      }
+    }
+
+    this.pathsById = nextPaths;
+
+    const knownCwds = [this.startupCwd];
+    for (const sessions of groups.values()) {
+      const cwd = sessions[0]?.cwd;
+      if (cwd && !knownCwds.includes(cwd)) {
+        knownCwds.push(cwd);
+      }
+    }
+
+    return {
+      groups: [...groups].map(([cwd, sessions]) => ({ cwd, sessions })),
+      knownCwds,
+    };
+  }
+
+  async resolvePath(id: string): Promise<string> {
+    if (!id) {
+      throw new AppError("unknown_session", "A session id is required", 404);
+    }
+
+    let path = this.pathsById.get(id);
+    if (!path) {
+      await this.list();
+      path = this.pathsById.get(id);
+    }
+    if (!path) {
+      throw new AppError("unknown_session", `Unknown session: ${id}`, 404);
+    }
+
+    return canonicalFile(path);
+  }
+
+  async delete(id: string): Promise<void> {
+    if (!id) {
+      throw new AppError("unknown_session", "A session id is required", 404);
+    }
+
+    const pending = this.pendingManagers.get(id);
+    let path: string;
+
+    if (pending) {
+      const pendingFile = pending.getSessionFile();
+      if (!pendingFile) {
+        throw new AppError("invalid_session", "The session is not persisted", 422);
+      }
+
+      try {
+        await stat(pendingFile);
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+          throw new AppError("session_delete_failed", "Could not inspect the session file", 500, {
+            cause: error,
+          });
+        }
+
+        this.pendingManagers.delete(id);
+        this.pathsById.delete(id);
+        return;
+      }
+
+      path = await canonicalFile(pendingFile);
+    } else {
+      path = await this.resolvePath(id);
+    }
+
+    const header = await readCurrentSessionHeader(path);
+    if (!header || header.id !== id) {
+      throw new AppError("invalid_session", "The session file is not in the current format", 422);
+    }
+
+    try {
+      await unlink(path);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        throw new AppError("stale_session", "The session file no longer exists", 410, { cause: error });
+      }
+
+      throw new AppError("session_delete_failed", "Could not delete the session file", 500, {
+        cause: error,
+      });
+    }
+
+    this.pendingManagers.delete(id);
+    this.pathsById.delete(id);
+  }
+
+  adoptManager(manager: SessionManager): void {
+    const id = manager.getSessionId();
+    this.pendingManagers.set(id, manager);
+
+    const file = manager.getSessionFile();
+    if (file) {
+      this.pathsById.set(id, file);
+    }
+  }
+
+  async openManager(id: string): Promise<SessionManager> {
+    const pending = this.pendingManagers.get(id);
+    if (pending) {
+      const pendingFile = pending.getSessionFile();
+      if (!pendingFile) {
+        return pending;
+      }
+
+      try {
+        await stat(pendingFile);
+      } catch {
+        return pending;
+      }
+
+      const header = await readCurrentSessionHeader(pendingFile);
+      if (!header || header.id !== id) {
+        throw new AppError("invalid_session", "The session file is not in the current format", 422);
+      }
+
+      this.pendingManagers.delete(id);
+      this.pathsById.set(id, pendingFile);
+    }
+
+    const path = await this.resolvePath(id);
+    const header = await readCurrentSessionHeader(path);
+    if (!header || header.id !== id) {
+      throw new AppError("invalid_session", "The session file is not in the current format", 422);
+    }
+
+    try {
+      const manager = SessionManager.open(path);
+      if (manager.getSessionId() !== id) {
+        throw new AppError("stale_session", "The session file id no longer matches", 410);
+      }
+
+      await validateCwd(manager.getCwd());
+      return manager;
+    } catch (error) {
+      if (error instanceof AppError) {
+        throw error;
+      }
+
+      throw new AppError("invalid_session", "The session file could not be opened", 422, { cause: error });
+    }
+  }
+
+  async get(id: string): Promise<PersistedSession> {
+    const manager = await this.openManager(id);
+    const context = manager.buildSessionContext();
+    const branch = manager.getBranch();
+    const transcriptEntries: PersistedTranscriptEntry[] = [];
+
+    for (const entry of branch) {
+      if (entry.type === "message") {
+        const persisted = { entryId: entry.id, message: entry.message };
+        transcriptEntries.push({ kind: "message", ...persisted });
+        continue;
+      }
+
+      if (entry.type === "custom_message") {
+        for (const message of sessionEntryToContextMessages(entry)) {
+          const persisted = { entryId: entry.id, message };
+          transcriptEntries.push({ kind: "message", ...persisted });
+        }
+        continue;
+      }
+
+      if (entry.type === "custom") {
+        const persisted = { entryId: entry.id, customType: entry.customType, data: entry.data };
+        transcriptEntries.push({ kind: "custom", ...persisted });
+      }
+    }
+
+    const file = manager.getSessionFile();
+    if (!file) {
+      throw new AppError("invalid_session", "The session is not persisted", 422);
+    }
+
+    const details = await stat(file).catch(() => undefined);
+    const header = manager.getHeader();
+    if (!isCurrentSessionHeader(header)) {
+      throw new AppError("invalid_session", "The session file is not in the current format", 422);
+    }
+
+    const name = manager.getSessionName();
+    const created = header.timestamp;
+
+    return {
+      id: manager.getSessionId(),
+      cwd: manager.getCwd(),
+      ...(name ? { name } : {}),
+      created,
+      modified: details?.mtime.toISOString() ?? created,
+      messageCount: transcriptEntries.reduce((count, entry) => count + (entry.kind === "message" ? 1 : 0), 0),
+      firstMessage: this.firstUserText(transcriptEntries),
+      transcriptEntries,
+      model: context.model,
+      thinkingLevel: context.thinkingLevel,
+    };
+  }
+
+  async createSession(cwdInput: unknown): Promise<{ manager: SessionManager; session: PersistedSession }> {
+    const cwd = await validateCwd(cwdInput);
+
+    let manager: SessionManager;
+    try {
+      manager = SessionManager.create(cwd, this.sessionDir);
+    } catch (error) {
+      throw new AppError("session_create_failed", "Could not create the session file", 500, { cause: error });
+    }
+
+    const file = manager.getSessionFile();
+    if (!file) {
+      throw new AppError("session_create_failed", "Pi did not create a persistent session", 500);
+    }
+
+    this.adoptManager(manager);
+
+    return {
+      manager,
+      session: await this.get(manager.getSessionId()),
+    };
+  }
+
+  private firstUserText(entries: PersistedTranscriptEntry[]): string {
+    for (const entry of entries) {
+      if (entry.kind !== "message" || entry.message.role !== "user") {
+        continue;
+      }
+
+      const { message } = entry;
+      if (typeof message.content === "string") {
+        return message.content;
+      }
+
+      return message.content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("");
+    }
+
+    return "";
+  }
+}