@pi-chamber/web 0.2.0 → 0.2.2

package/server/lib/pi/session-daemon/session-jsonl.js

@@ -1,5 +1,5 @@
 import { createReadStream } from 'node:fs';
-import { mkdir, readdir } from 'node:fs/promises';
+import { mkdir, open, readdir, stat } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { createInterface } from 'node:readline';
 
@@ -33,11 +33,132 @@ class SessionJsonlError extends Error {
 const malformed = () => new SessionJsonlError('MALFORMED_SESSION_JSONL');
 const unreadable = () => new SessionJsonlError('SESSION_JSONL_UNREADABLE');
 
+/** Stop looking for the first user prompt after this many leading bytes. */
+const LIST_HEAD_SCAN_BYTES = 512 * 1024;
+/** Latest `session_info` (rename) is appended; read a tail instead of the whole log. */
+const LIST_TAIL_SCAN_BYTES = 128 * 1024;
+const LIST_PREVIEW_CHARS = 500;
+
+const isSessionHeader = (entry) => (
+  Boolean(entry)
+  && !Array.isArray(entry)
+  && typeof entry === 'object'
+  && entry.type === 'session'
+  && typeof entry.id === 'string'
+  && entry.id.length > 0
+  && typeof entry.cwd === 'string'
+);
+
+const extractUserPreview = (message) => {
+  const content = message?.content;
+  if (typeof content === 'string') return content.trim();
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((block) => block && block.type === 'text' && typeof block.text === 'string')
+    .map((block) => block.text)
+    .join(' ')
+    .trim();
+};
+
+const trimPreview = (text) => {
+  if (!text) return undefined;
+  return text.length > LIST_PREVIEW_CHARS ? text.slice(0, LIST_PREVIEW_CHARS) : text;
+};
+
+const sessionInfoName = (entry) => {
+  if (!entry || entry.type !== 'session_info') return undefined;
+  if (typeof entry.name !== 'string') return undefined;
+  const name = entry.name.trim();
+  return name.length > 0 ? name : undefined;
+};
+
 /**
  * Validates the JSONL files Pi discovers for a cwd before granting that
  * discovery result authority. Pi's discovery intentionally skips malformed
  * files; the daemon must instead surface them as an explicit failure.
+ * List/startup/create only require a valid session header. Full-file
+ * validation stays on open of a chosen transcript so a 16MB log cannot
+ * block every `sessions.list`.
+ */
+export const matchesPiSessionJsonlName = (fileName, sessionId) => (
+  typeof fileName === 'string'
+  && typeof sessionId === 'string'
+  && sessionId.length > 0
+  && fileName.endsWith('.jsonl')
+  && (fileName === `${sessionId}.jsonl` || fileName.endsWith(`_${sessionId}.jsonl`))
+);
+
+/**
+ * Read only the session header. Callers that are looking up an id must
+ * not scan the rest of a multi-megabyte transcript.
  */
+async function readPiSessionJsonlHeader(filePath) {
+  const input = createReadStream(filePath, { encoding: 'utf8' });
+  const lines = createInterface({ input, crlfDelay: Infinity });
+  try {
+    for await (const line of lines) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        throw malformed();
+      }
+      if (!isSessionHeader(entry)) throw malformed();
+      return entry;
+    }
+    throw malformed();
+  } catch (error) {
+    if (error instanceof SessionJsonlError) throw error;
+    throw unreadable();
+  } finally {
+    lines.close();
+    input.destroy();
+  }
+}
+
+/**
+ * Locate a persisted Pi session by the SDK filename (`<timestamp>_<id>.jsonl`
+ * or `<id>.jsonl`) without listing or fully reading every transcript. A miss
+ * is `null`, not an empty success.
+ */
+export async function findPiSessionJsonlById({ sessionId, agentDir, resolvePath = resolve }) {
+  if (typeof sessionId !== 'string' || sessionId.length === 0 || typeof agentDir !== 'string') {
+    return null;
+  }
+  const sessionsRoot = join(resolvePath(agentDir), 'sessions');
+  let dirEntries;
+  try {
+    dirEntries = await readdir(sessionsRoot, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const dirEntry of dirEntries) {
+    if (!dirEntry.isDirectory()) continue;
+    const dirPath = join(sessionsRoot, dirEntry.name);
+    let files;
+    try {
+      files = await readdir(dirPath, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (file.isDirectory()) continue;
+      if (!matchesPiSessionJsonlName(file.name, sessionId)) continue;
+      const fullPath = join(dirPath, file.name);
+      try {
+        const header = await readPiSessionJsonlHeader(fullPath);
+        if (header.id === sessionId) {
+          return { id: sessionId, path: fullPath, cwd: header.cwd };
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+
 export async function validatePiSessionJsonlFile(filePath) {
   let sawHeader = false;
   try {
@@ -53,9 +174,7 @@ export async function validatePiSessionJsonlFile(filePath) {
       }
       if (!entry || Array.isArray(entry) || typeof entry !== 'object') throw malformed();
       if (!sawHeader) {
-        if (entry.type !== 'session' || typeof entry.id !== 'string' || entry.id.length === 0 || typeof entry.cwd !== 'string') {
-          throw malformed();
-        }
+        if (!isSessionHeader(entry)) throw malformed();
         sawHeader = true;
       }
     }
@@ -66,6 +185,139 @@ export async function validatePiSessionJsonlFile(filePath) {
   if (!sawHeader) throw malformed();
 }
 
+async function readLatestSessionInfoFromTail(filePath, fileSize) {
+  const tailSize = Math.min(fileSize, LIST_TAIL_SCAN_BYTES);
+  if (tailSize <= 0) return null;
+  let handle;
+  try {
+    handle = await open(filePath, 'r');
+    const buffer = Buffer.alloc(tailSize);
+    const { bytesRead } = await handle.read(buffer, 0, tailSize, fileSize - tailSize);
+    const text = buffer.subarray(0, bytesRead).toString('utf8');
+    const lines = text.split('\n');
+    let seen = false;
+    let name;
+    for (const line of lines.slice(fileSize > tailSize ? 1 : 0)) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry?.type === 'session_info') {
+          seen = true;
+          name = sessionInfoName(entry);
+        }
+      } catch {
+        continue;
+      }
+    }
+    return seen ? { name } : null;
+  } catch {
+    return null;
+  } finally {
+    await handle?.close().catch(() => {});
+  }
+}
+
+async function readPiSessionJsonlListFields(filePath, fileSize) {
+  const input = createReadStream(filePath, { encoding: 'utf8' });
+  const lines = createInterface({ input, crlfDelay: Infinity });
+  let header;
+  let name;
+  let firstMessage;
+  let bytes = 0;
+  const scanWholePrefix = fileSize <= LIST_HEAD_SCAN_BYTES;
+  try {
+    for await (const line of lines) {
+      bytes += Buffer.byteLength(line) + 1;
+      if (!line.trim()) {
+        if (!scanWholePrefix && bytes >= LIST_HEAD_SCAN_BYTES) break;
+        continue;
+      }
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        if (!header) throw malformed();
+        if (!scanWholePrefix && bytes >= LIST_HEAD_SCAN_BYTES) break;
+        continue;
+      }
+      if (!header) {
+        if (!isSessionHeader(entry)) throw malformed();
+        header = entry;
+      } else if (entry?.type === 'session_info') {
+        name = sessionInfoName(entry);
+      } else if (!firstMessage && entry?.type === 'message' && entry.message?.role === 'user') {
+        const preview = extractUserPreview(entry.message);
+        if (preview) firstMessage = trimPreview(preview);
+      }
+      if (!scanWholePrefix && header && firstMessage) break;
+      if (!scanWholePrefix && bytes >= LIST_HEAD_SCAN_BYTES) break;
+    }
+  } catch (error) {
+    if (error instanceof SessionJsonlError) throw error;
+    throw unreadable();
+  } finally {
+    lines.close();
+    input.destroy();
+  }
+  if (!header) throw malformed();
+  return { header, name, firstMessage };
+}
+
+/**
+ * Sidebar/list metadata for one cwd. Reads a header, a bounded prefix for
+ * the first user prompt, and a tail for the latest rename. It does not
+ * load whole transcripts.
+ */
+export async function listPiSessionJsonlDirectory({
+  cwd,
+  agentDir,
+  platform = process.platform,
+  resolvePath = resolve,
+} = {}) {
+  let sessionDirectory;
+  let entries;
+  try {
+    sessionDirectory = getPiSessionDirectory({ cwd, agentDir, platform, resolvePath });
+    await mkdir(sessionDirectory, { recursive: true, mode: 0o700 });
+    entries = await readdir(sessionDirectory, { withFileTypes: true });
+  } catch {
+    throw unreadable();
+  }
+
+  const sessions = [];
+  for (const entry of entries) {
+    if (!entry.name.endsWith('.jsonl') || entry.isDirectory()) continue;
+    const filePath = join(sessionDirectory, entry.name);
+    let fileStat;
+    try {
+      fileStat = await stat(filePath);
+    } catch {
+      throw unreadable();
+    }
+    const fields = await readPiSessionJsonlListFields(filePath, fileStat.size);
+    const tail = fileStat.size > LIST_HEAD_SCAN_BYTES
+      ? await readLatestSessionInfoFromTail(filePath, fileStat.size)
+      : null;
+    const name = tail?.name ?? fields.name;
+    const headerTime = typeof fields.header.timestamp === 'string'
+      ? Date.parse(fields.header.timestamp)
+      : NaN;
+    const created = Number.isFinite(headerTime) ? new Date(headerTime) : fileStat.mtime;
+    sessions.push({
+      path: filePath,
+      id: fields.header.id,
+      cwd: fields.header.cwd,
+      ...(name ? { name } : {}),
+      ...(typeof fields.header.parentSession === 'string' ? { parentSessionPath: fields.header.parentSession } : {}),
+      created,
+      modified: fileStat.mtime,
+      ...(fields.firstMessage ? { firstMessage: fields.firstMessage } : {}),
+    });
+  }
+  sessions.sort((left, right) => right.modified.getTime() - left.modified.getTime());
+  return sessions;
+}
+
 export const getPiSessionDirectory = ({
   cwd,
   agentDir,
@@ -88,7 +340,7 @@ export async function validatePiSessionJsonlDirectory({ cwd, agentDir }) {
   }
 
   for (const entry of entries) {
-    if (!entry.name.endsWith('.jsonl')) continue;
-    await validatePiSessionJsonlFile(join(sessionDirectory, entry.name));
+    if (!entry.name.endsWith('.jsonl') || entry.isDirectory()) continue;
+    await readPiSessionJsonlHeader(join(sessionDirectory, entry.name));
   }
 }

package/server/lib/pi/session-daemon/session-jsonl.test.js

@@ -6,7 +6,10 @@ import { describe, expect, it } from 'vitest';
 
 import {
   encodePiSessionCwd,
+  findPiSessionJsonlById,
   getPiSessionDirectory,
+  listPiSessionJsonlDirectory,
+  matchesPiSessionJsonlName,
   normalizeWindowsShellPath,
   validatePiSessionJsonlDirectory,
   validatePiSessionJsonlFile,
@@ -58,9 +61,15 @@ describe('Pi session JSONL validation', () => {
     await mkdir(sessionDirectory, { recursive: true });
     await writeFile(join(sessionDirectory, 'corrupt.jsonl'), `${validHeader(cwd)}\nnot-json\n`);
 
-    await expect(validatePiSessionJsonlDirectory({ cwd, agentDir })).rejects.toMatchObject({
+    await expect(validatePiSessionJsonlFile(join(sessionDirectory, 'corrupt.jsonl'))).rejects.toMatchObject({
       code: 'MALFORMED_SESSION_JSONL',
     });
+    // Directory list/startup only require a valid header so a later corrupt
+    // line cannot make every sessions.list read 16MB transcripts.
+    await expect(validatePiSessionJsonlDirectory({ cwd, agentDir })).resolves.toBeUndefined();
+    await expect(listPiSessionJsonlDirectory({ cwd, agentDir })).resolves.toEqual([
+      expect.objectContaining({ id: 'session-one', cwd }),
+    ]);
   });
 
   it('reports unreadable session files explicitly', async () => {
@@ -70,4 +79,63 @@ describe('Pi session JSONL validation', () => {
       code: 'SESSION_JSONL_UNREADABLE',
     });
   });
+
+  it('matches Pi SessionManager filenames without treating session-1 as session-10', () => {
+    expect(matchesPiSessionJsonlName('2026-01-01T00-00-00-000Z_session-one.jsonl', 'session-one')).toBe(true);
+    expect(matchesPiSessionJsonlName('session-one.jsonl', 'session-one')).toBe(true);
+    expect(matchesPiSessionJsonlName('2026-01-01T00-00-00-000Z_session-10.jsonl', 'session-1')).toBe(false);
+    expect(matchesPiSessionJsonlName('other.jsonl', 'session-one')).toBe(false);
+  });
+
+  it('finds a session by filename without reading unrelated transcripts', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-jsonl-'));
+    const cwd = join(root, 'project');
+    const agentDir = join(root, 'agent');
+    const sessionDirectory = getPiSessionDirectory({ cwd, agentDir });
+    await mkdir(sessionDirectory, { recursive: true });
+    const targetId = '01a019b7-ce87-7be9-8fdd-4ed2ce979f5f';
+    await writeFile(
+      join(sessionDirectory, `2026-08-19T11-13-31-038Z_${targetId}.jsonl`),
+      `${JSON.stringify({ type: 'session', version: 3, id: targetId, timestamp: '2026-08-19T11:13:31.038Z', cwd })}\n`,
+    );
+    await writeFile(join(sessionDirectory, 'unrelated.jsonl'), `${validHeader(cwd)}\n`);
+
+    await expect(findPiSessionJsonlById({ sessionId: targetId, agentDir })).resolves.toMatchObject({
+      id: targetId,
+      cwd,
+    });
+    await expect(findPiSessionJsonlById({ sessionId: '01a019b7-ce87-7be9-8fdd-missing', agentDir })).resolves.toBeNull();
+  });
+
+  it('lists session metadata without reading a padded transcript body', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-jsonl-'));
+    const cwd = join(root, 'project');
+    const agentDir = join(root, 'agent');
+    const sessionDirectory = getPiSessionDirectory({ cwd, agentDir });
+    await mkdir(sessionDirectory, { recursive: true });
+    const padding = `${JSON.stringify({ type: 'message', message: { role: 'assistant', content: 'x'.repeat(1024) } })}\n`.repeat(800);
+    await writeFile(
+      join(sessionDirectory, '2026-01-01T00-00-00-000Z_session-one.jsonl'),
+      [
+        validHeader(cwd),
+        JSON.stringify({ type: 'message', message: { role: 'user', content: [{ type: 'text', text: 'First prompt about listing' }] } }),
+        padding.trimEnd(),
+        JSON.stringify({ type: 'session_info', name: 'Renamed from tail' }),
+        '',
+      ].join('\n'),
+    );
+
+    const started = Date.now();
+    const listed = await listPiSessionJsonlDirectory({ cwd, agentDir });
+    expect(Date.now() - started).toBeLessThan(1000);
+    expect(listed).toEqual([
+      expect.objectContaining({
+        id: 'session-one',
+        cwd,
+        name: 'Renamed from tail',
+        firstMessage: 'First prompt about listing',
+      }),
+    ]);
+    expect(listed[0].path).toContain('session-one.jsonl');
+  });
 });

package/server/lib/pi/session-daemon/supervisor.js

@@ -42,6 +42,10 @@ const hasValidStateIdentity = (state) => (
 
 const isValidState = (state) => hasValidStateIdentity(state) && typeof state.startedAt === 'string';
 
+const daemonEntrypointMatches = (state) => (
+  typeof state?.entrypoint === 'string' && state.entrypoint === DAEMON_ENTRYPOINT
+);
+
 const isValidFailureState = (state) => hasValidStateIdentity(state)
   && state.state === 'failed'
   && typeof state.error?.code === 'string';
@@ -306,6 +310,26 @@ export const createPiSessionDaemonSupervisor = ({
     return true;
   };
 
+  const requestDaemonExit = async (state) => {
+    if (!state || !Number.isInteger(state.pid) || state.pid <= 0) return;
+    try {
+      processLike.kill(state.pid, 'SIGTERM');
+    } catch {
+      if (isPidAlive(processLike, state.pid)) throw new PiSessionDaemonUnavailableError('DAEMON_STOP_FAILED');
+      await removeStaleState(state);
+      return;
+    }
+    const deadline = Date.now() + startupTimeoutMs;
+    while (Date.now() < deadline) {
+      if (!isPidAlive(processLike, state.pid)) {
+        await removeStaleState(state);
+        return;
+      }
+      await wait(RETRY_DELAY_MS);
+    }
+    throw new PiSessionDaemonUnavailableError('DAEMON_STOP_TIMEOUT');
+  };
+
   const start = async () => {
     intentionallyStopped = false;
     if (startPromise) return startPromise;
@@ -313,9 +337,15 @@ export const createPiSessionDaemonSupervisor = ({
       const credential = await ensureCredential();
       try {
         const existing = await probe(credential);
-        return { state: 'ready', reused: true, protocolVersion: PROTOCOL_VERSION, capabilities: existing.health.capabilities ?? [] };
+        if (daemonEntrypointMatches(existing.state)) {
+          return { state: 'ready', reused: true, protocolVersion: PROTOCOL_VERSION, capabilities: existing.health.capabilities ?? [] };
+        }
+        // A healthy daemon from another install (global npm vs this checkout)
+        // must not keep answering getSession without the live-turn overlay.
+        await requestDaemonExit(existing.state);
       } catch (error) {
         if (!(error instanceof PiSessionDaemonUnavailableError)) throw error;
+        if (error.code === 'DAEMON_STOP_FAILED' || error.code === 'DAEMON_STOP_TIMEOUT') throw error;
       }
 
       const staleState = await readState() ?? await readFailureState();
@@ -386,16 +416,19 @@ export const createPiSessionDaemonSupervisor = ({
     let credential = await readCredential();
     try {
       const ready = await probe(credential);
-      return { credential, ready };
+      if (daemonEntrypointMatches(ready.state)) {
+        return { credential, ready };
+      }
     } catch (probeError) {
       if (intentionallyStopped) throw new PiSessionDaemonUnavailableError('DAEMON_UNAVAILABLE');
       if (probeError instanceof PiSessionDaemonUnavailableError && isPermanentStartupFailure(probeError.code)) {
         throw probeError;
       }
-      await start();
-      credential = await readCredential();
-      return { credential, ready: await probe(credential) };
     }
+    if (intentionallyStopped) throw new PiSessionDaemonUnavailableError('DAEMON_UNAVAILABLE');
+    await start();
+    credential = await readCredential();
+    return { credential, ready: await probe(credential) };
   };
 
   const requestDaemon = async (command, payload) => {
@@ -435,22 +468,9 @@ export const createPiSessionDaemonSupervisor = ({
     return withOperationLock(async () => {
       const credential = await readCredential();
       const { state } = await probe(credential);
-      try {
-        processLike.kill(state.pid, 'SIGTERM');
-      } catch {
-        throw new PiSessionDaemonUnavailableError('DAEMON_STOP_FAILED');
-      }
-
-      const deadline = Date.now() + startupTimeoutMs;
-      while (Date.now() < deadline) {
-        if (!isPidAlive(processLike, state.pid)) {
-          await removeStaleState(state);
-          intentionallyStopped = true;
-          return { state: 'stopped' };
-        }
-        await wait(RETRY_DELAY_MS);
-      }
-      throw new PiSessionDaemonUnavailableError('DAEMON_STOP_TIMEOUT');
+      await requestDaemonExit(state);
+      intentionallyStopped = true;
+      return { state: 'stopped' };
     });
   };
 

package/server/lib/pi/session-daemon/supervisor.test.js

@@ -110,6 +110,34 @@ describe('Pi session daemon supervisor', () => {
     });
   }, 20_000);
 
+  it('replaces a healthy daemon that predates entrypoint identity', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-supervisor-entrypoint-'));
+    const cwd = join(root, 'project');
+    const agentDir = join(root, 'agent');
+    await Promise.all([mkdir(cwd), mkdir(agentDir)]);
+    const env = {
+      ...process.env,
+      PI_OFFLINE: '1',
+      PICHAMBER_DATA_DIR: join(root, 'data'),
+      PICHAMBER_PI_AGENT_DIR: agentDir,
+      XDG_RUNTIME_DIR: join(root, 'runtime'),
+    };
+
+    supervisor = createPiSessionDaemonSupervisor({ env, cwd });
+    await expect(supervisor.start()).resolves.toMatchObject({ state: 'ready', reused: false });
+    const first = JSON.parse(await readFile(supervisor.paths.stateFile, 'utf8'));
+    expect(typeof first.entrypoint).toBe('string');
+    const firstPid = first.pid;
+    const { entrypoint: _entrypoint, ...legacyState } = first;
+    await writeFile(supervisor.paths.stateFile, JSON.stringify(legacyState));
+
+    await expect(supervisor.start()).resolves.toMatchObject({ state: 'ready', reused: false });
+    await waitForExit(firstPid);
+    const second = JSON.parse(await readFile(supervisor.paths.stateFile, 'utf8'));
+    expect(second.pid).not.toBe(firstPid);
+    expect(second.entrypoint).toBe(first.entrypoint);
+  }, 20_000);
+
   it('spawns the daemon as Node when the parent process is Electron', async () => {
     const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-supervisor-electron-'));
     const cwd = join(root, 'project');