@pi-chamber/web 0.2.0 → 0.2.2

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

@@ -1,8 +1,10 @@
 import { readFile, chmod, rename, rm, writeFile } from 'node:fs/promises';
-import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 import { createSessionDaemon } from './session-daemon.js';
 
+const DAEMON_ENTRYPOINT = fileURLToPath(import.meta.url);
+
 const argument = (name) => {
   const index = process.argv.indexOf(name);
   return index === -1 ? undefined : process.argv[index + 1];
@@ -41,6 +43,7 @@ const writeReadyState = () => writeState({
   protocolVersion: 1,
   pid: process.pid,
   endpoint,
+  entrypoint: DAEMON_ENTRYPOINT,
   startedAt: new Date().toISOString(),
 });
 

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

@@ -19,7 +19,13 @@ import {
 import { createPiModelConfigStore } from '../model-config-store.js';
 import { clampThinkingLevel, getSupportedThinkingLevels, isPiThinkingLevel } from '../thinking-levels.js';
 import { createSessionRuntimeRegistry } from './runtime-registry.js';
-import { getPiSessionDirectory, validatePiSessionJsonlDirectory, validatePiSessionJsonlFile } from './session-jsonl.js';
+import {
+  findPiSessionJsonlById,
+  getPiSessionDirectory,
+  listPiSessionJsonlDirectory,
+  validatePiSessionJsonlDirectory,
+  validatePiSessionJsonlFile,
+} from './session-jsonl.js';
 
 const PROTOCOL_VERSION = 1;
 const MAX_FRAME_BYTES = 16 * 1024 * 1024;
@@ -80,10 +86,10 @@ export function createSessionDaemon({
   createRuntime = createPiSessionRuntime,
   healthMetadata = {},
   idleTimeoutMs = 5 * 60 * 1_000,
-  listSessions = ({ cwd: sessionCwd, agentDir: sessionAgentDir = agentDir }) => SessionManager.list(
-    sessionCwd,
-    getPiSessionDirectory({ cwd: sessionCwd, agentDir: sessionAgentDir }),
-  ),
+  listSessions = ({ cwd: sessionCwd, agentDir: sessionAgentDir = agentDir }) => listPiSessionJsonlDirectory({
+    cwd: sessionCwd,
+    agentDir: sessionAgentDir,
+  }),
   createSettingsManager = ({ cwd: settingsCwd, agentDir: settingsAgentDir = agentDir, projectTrusted }) => SettingsManager.create(
     settingsCwd,
     settingsAgentDir,
@@ -335,9 +341,8 @@ export function createSessionDaemon({
     idleDisposeTimers.set(sessionId, timer);
   };
 
-  const listSessionItems = async (requestedDirectory) => {
-    const targetDir = requestedDirectory ? await resolveDirectory(requestedDirectory) : (activeDirectory || cwd);
-    await validatePiSessionJsonlDirectory({ cwd: targetDir, agentDir });
+  const listInflightByDirectory = new Map();
+  const listSessionItemsUnshared = async (targetDir) => {
     const sessions = await listSessions({ cwd: targetDir, agentDir });
     if (!Array.isArray(sessions)) {
       throw new SessionDaemonProtocolError('INVALID_SESSION', 'Pi returned an invalid session collection.');
@@ -392,6 +397,17 @@ export function createSessionDaemon({
     });
   };
 
+  const listSessionItems = async (requestedDirectory) => {
+    const targetDir = requestedDirectory ? await resolveDirectory(requestedDirectory) : (activeDirectory || cwd);
+    const inflight = listInflightByDirectory.get(targetDir);
+    if (inflight) return inflight;
+    const pending = listSessionItemsUnshared(targetDir).finally(() => {
+      if (listInflightByDirectory.get(targetDir) === pending) listInflightByDirectory.delete(targetDir);
+    });
+    listInflightByDirectory.set(targetDir, pending);
+    return pending;
+  };
+
   const renameSession = async (payload) => {
     if (!payload || typeof payload !== 'object' || typeof payload.sessionId !== 'string' || payload.sessionId.length === 0
       || typeof payload.title !== 'string' || payload.title.trim().length === 0 || payload.title.length > 256) {
@@ -428,6 +444,21 @@ export function createSessionDaemon({
     if (typeof sessionId !== 'string' || sessionId.length === 0) {
       throw new SessionDaemonProtocolError('INVALID_SESSION', 'The Pi session does not exist.');
     }
+    // Filename identity is enough to 404 a missing id without listing or
+    // fully reading every transcript in every cwd. Deep-linking a stale
+    // `?session=` used to hang here while `validatePiSessionJsonlDirectory`
+    // scanned multi-megabyte JSONL files that cannot be the target.
+    try {
+      const named = await findPiSessionJsonlById({ sessionId, agentDir });
+      if (named?.path && named.cwd) {
+        await validatePiSessionJsonlFile(named.path);
+        const directory = await resolveDirectory(named.cwd);
+        knownDirectories.add(directory);
+        return { target: { id: sessionId, path: named.path }, directory };
+      }
+    } catch {
+      // Fall through to SDK list / header scan for non-standard filenames.
+    }
     const candidateDirs = new Set();
     if (requestedDirectory) {
       try {
@@ -440,7 +471,6 @@ export function createSessionDaemon({
 
     for (const dir of candidateDirs) {
       try {
-        await validatePiSessionJsonlDirectory({ cwd: dir, agentDir });
         const sessions = await listSessions({ cwd: dir, agentDir });
         const target = Array.isArray(sessions) ? sessions.find((session) => session?.id === sessionId) : undefined;
         if (target && typeof target.path === 'string' && target.path.length > 0) {
@@ -492,7 +522,8 @@ export function createSessionDaemon({
     throw new SessionDaemonProtocolError('INVALID_SESSION', 'The Pi session does not exist.');
   };
 
-  const activateSession = async (sessionId, requestedDirectory) => {
+  const activateInflightBySessionId = new Map();
+  const activateSessionUnshared = async (sessionId, requestedDirectory) => {
     if (!runtimeRegistry) {
       runtimeRegistry = createSessionRuntimeRegistry({
         onSessionEvent: ({ cwd: eventCwd, sessionId: eventSessionId }, event) => publishSessionEvent(eventSessionId, event, eventCwd),
@@ -521,16 +552,89 @@ export function createSessionDaemon({
     if (newRuntime.session?.sessionId !== sessionId && typeof newRuntime.switchSession === 'function') {
       await newRuntime.switchSession(target.path);
     }
-    runtimeRegistry.register(newRuntime, { cwd: directory });
+    const raced = runtimeRegistry.findBySessionId(sessionId);
+    if (raced) {
+      try { await newRuntime.dispose?.(); } catch { /* keep the winner */ }
+      runtime = raced;
+      if (raced.cwd) activeDirectory = raced.cwd;
+      return raced;
+    }
+    try {
+      runtimeRegistry.register(newRuntime, { cwd: directory });
+    } catch (error) {
+      if (error?.code === 'SESSION_RUNTIME_CONFLICT') {
+        try { await newRuntime.dispose?.(); } catch { /* keep the winner */ }
+        const winner = runtimeRegistry.findBySessionId(sessionId)
+          || runtimeRegistry.get({ cwd: directory, sessionId });
+        if (winner) {
+          runtime = winner;
+          if (winner.cwd) activeDirectory = winner.cwd;
+          return winner;
+        }
+      }
+      throw error;
+    }
     runtime = newRuntime;
     activeDirectory = directory;
     rememberRuntimeSession();
     return newRuntime;
   };
 
+  const activateSession = async (sessionId, requestedDirectory) => {
+    const inflight = activateInflightBySessionId.get(sessionId);
+    if (inflight) return inflight;
+    const pending = activateSessionUnshared(sessionId, requestedDirectory).finally(() => {
+      if (activateInflightBySessionId.get(sessionId) === pending) activateInflightBySessionId.delete(sessionId);
+    });
+    activateInflightBySessionId.set(sessionId, pending);
+    return pending;
+  };
+
+  const liveProjectionEntries = (session, persisted) => {
+    if (!session?.isStreaming) return persisted;
+    const liveMessages = [];
+    if (Array.isArray(session.messages)) liveMessages.push(...session.messages);
+    const streamingMessage = session.state?.streamingMessage;
+    if (streamingMessage && liveMessages[liveMessages.length - 1] !== streamingMessage) {
+      liveMessages.push(streamingMessage);
+    }
+    if (liveMessages.length === 0) return persisted;
+
+    const persistedKeys = new Set();
+    for (const entry of persisted) {
+      if (entry?.type !== 'message' || !entry.message) continue;
+      const timestamp = typeof entry.message.timestamp === 'number' ? entry.message.timestamp : Date.parse(entry.timestamp);
+      persistedKeys.add(`${entry.message.role}:${Number.isFinite(timestamp) ? timestamp : ''}`);
+    }
+
+    const entries = [...persisted];
+    let liveIndex = 0;
+    const liveAssistantId = streamingMessageIds.get(session.sessionId);
+    for (const message of liveMessages) {
+      if (!message || (message.role !== 'user' && message.role !== 'assistant' && message.role !== 'toolResult')) continue;
+      const timestamp = typeof message.timestamp === 'number' ? message.timestamp : undefined;
+      const key = `${message.role}:${timestamp ?? ''}`;
+      if (timestamp !== undefined && persistedKeys.has(key)) continue;
+      persistedKeys.add(key);
+      const id = message.role === 'assistant' && liveAssistantId
+        ? liveAssistantId
+        : `live-${session.sessionId}-${liveIndex}`;
+      liveIndex += 1;
+      entries.push({
+        type: 'message',
+        id,
+        timestamp: new Date(timestamp || Date.now()).toISOString(),
+        message,
+      });
+    }
+    return entries;
+  };
+
   const projectMessageEntries = (session, targetDir = activeDirectory || cwd) => {
-    const entries = session?.sessionManager?.getEntries?.();
-    if (!Array.isArray(entries)) return [];
+    const persisted = session?.sessionManager?.getEntries?.();
+    const entries = liveProjectionEntries(session, Array.isArray(persisted) ? persisted : []);
+    if (entries.length === 0) return [];
+    const streaming = session?.isStreaming === true;
     const toolResults = new Map();
     for (const entry of entries) {
       if (entry?.type !== 'message' || !entry.message || entry.message.role !== 'toolResult' || typeof entry.message.toolCallId !== 'string') continue;
@@ -563,6 +667,8 @@ export function createSessionDaemon({
         if (part?.type === 'thinking') return [{ type: 'thinking', id: `${entry.id}:thinking:${index}`, index, text: redactAttachmentPaths(part.thinking) }];
         if (part?.type === 'toolCall') {
           const result = toolResults.get(part.id);
+          const running = streaming && !result;
+          const interrupted = !running && !result;
           return [{
             type: 'tool',
             id: `${entry.id}:tool:${part.id}`,
@@ -570,12 +676,20 @@ export function createSessionDaemon({
             toolCallId: part.id,
             name: part.name,
             input: redactAttachmentValues(part.arguments),
-            state: result?.isError ? 'error' : 'completed',
+            state: result?.isError || interrupted ? 'error' : running ? 'running' : 'completed',
             ...(result?.output ? { output: result.output } : {}),
-            ...(result?.error ? { error: result.error } : {}),
-            ...(result?.isError ? { isError: true } : {}),
+            ...(result?.error
+              ? { error: result.error }
+              : interrupted
+                ? { error: 'Tool was interrupted before completion.' }
+                : {}),
+            ...(result?.isError || interrupted ? { isError: true } : {}),
             ...(result?.metadata ? { metadata: result.metadata } : {}),
-            ...(Number.isFinite(result?.endedAt) ? { endedAt: result.endedAt } : {}),
+            ...(Number.isFinite(result?.endedAt)
+              ? { endedAt: result.endedAt }
+              : interrupted
+                ? { endedAt: createdAt }
+                : {}),
           }];
         }
         return [];
@@ -608,6 +722,7 @@ export function createSessionDaemon({
     const sessionModel = lastAssistant?.model
       ?? (model?.provider && model?.id ? { providerId: model.provider, modelId: model.id } : undefined);
     const sessionThinking = lastAssistant?.thinkingLevel || session.thinkingLevel;
+    const isStreaming = session.isStreaming === true;
     return {
       session: {
         id: session.sessionId, directory: targetDir, createdAt, updatedAt: createdAt,
@@ -618,6 +733,8 @@ export function createSessionDaemon({
       },
       messages,
       lastSequence: sequence,
+      isStreaming,
+      lifecycle: isStreaming ? 'busy' : 'idle',
     };
   };
 
@@ -1378,17 +1495,18 @@ export function createSessionDaemon({
   const deleteSession = async (sessionId, requestedDirectory) => {
     const active = runtimeRegistry?.findBySessionId(sessionId);
     let targetDir = requestedDirectory ? await resolveDirectory(requestedDirectory) : active?.cwd || activeDirectory || cwd;
+    const activeSessionFile = active?.session?.sessionManager?.getSessionFile?.();
     if (active) {
       if (active.session?.isStreaming) await active.session.abort();
       await runtimeRegistry?.dispose(active);
       if (runtime === active) runtime = undefined;
     }
-    try {
+    if (active && typeof activeSessionFile === 'string' && activeSessionFile.length > 0) {
+      await rm(activeSessionFile, { force: true });
+    } else if (!active) {
       const { target, directory } = await findPersistedSession(sessionId, targetDir);
       targetDir = directory;
       await rm(target.path, { force: false });
-    } catch (error) {
-      if (!active || error?.code !== 'INVALID_SESSION') throw error;
     }
     publish('session.lifecycle', { state: 'idle', deleted: true }, sessionId, targetDir);
   };

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

@@ -390,6 +390,93 @@ describe('Pi session daemon spike', () => {
     await client.close();
   });
 
+  it('shares an in-flight sessions.list for the same directory', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-share-'));
+    const endpoint = testDaemonEndpoint(root);
+    const agentDir = join(root, 'agent');
+    await mkdir(agentDir, { recursive: true });
+    let calls = 0;
+    daemon = createSessionDaemon({
+      endpoint,
+      credential,
+      cwd: root,
+      agentDir,
+      createRuntime: async () => ({ session: new FakeSession(), async dispose() {} }),
+      listSessions: async () => {
+        calls += 1;
+        await new Promise((resolve) => setTimeout(resolve, 80));
+        return [{
+          path: join(root, 'session.jsonl'),
+          id: 'pi-session-1',
+          cwd: root,
+          created: new Date('2026-01-01T00:00:00.000Z'),
+          modified: new Date('2026-01-02T00:00:00.000Z'),
+        }];
+      },
+    });
+    await daemon.start();
+
+    const first = connectClient(endpoint);
+    await first.authenticate();
+    const second = connectClient(endpoint);
+    await second.authenticate();
+    const [left, right] = await Promise.all([
+      first.request('sessions.list', { directory: root }),
+      second.request('sessions.list', { directory: root }),
+    ]);
+    expect(calls).toBe(1);
+    expect(left.result.sessions[0].session.id).toBe('pi-session-1');
+    expect(right.result.sessions[0].session.id).toBe('pi-session-1');
+    await first.close();
+    await second.close();
+  });
+
+  it('shares an in-flight sessions.open for the same session id', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-open-share-'));
+    const endpoint = testDaemonEndpoint(root);
+    const agentDir = join(root, 'agent');
+    await mkdir(agentDir, { recursive: true });
+    const sessionFile = join(root, 'session.jsonl');
+    await writeFile(sessionFile, `{"type":"session","id":"pi-session-1","cwd":${JSON.stringify(root)}}\n`);
+    let calls = 0;
+    daemon = createSessionDaemon({
+      endpoint,
+      credential,
+      cwd: root,
+      agentDir,
+      listSessions: async () => [{
+        path: sessionFile,
+        id: 'pi-session-1',
+        cwd: root,
+        created: new Date('2026-01-01T00:00:00.000Z'),
+        modified: new Date('2026-01-02T00:00:00.000Z'),
+      }],
+      createRuntime: async (options) => {
+        calls += 1;
+        await new Promise((resolve) => setTimeout(resolve, 80));
+        return new FakeRuntime({
+          cwd: options.cwd,
+          session: new FakeSession('pi-session-1', options.sessionFile),
+        });
+      },
+    });
+    await daemon.start();
+
+    const first = connectClient(endpoint);
+    await first.authenticate();
+    const second = connectClient(endpoint);
+    await second.authenticate();
+    const [left, right] = await Promise.all([
+      first.request('sessions.open', { sessionId: 'pi-session-1', directory: root }),
+      second.request('sessions.open', { sessionId: 'pi-session-1', directory: root }),
+    ]);
+    expect(calls).toBe(1);
+    expect(left.result.session.id).toBe('pi-session-1');
+    expect(right.result.session.id).toBe('pi-session-1');
+    await first.close();
+    await second.close();
+  });
+
   it('does not include in-memory sessions from another directory when listing a newly selected project directory', async () => {
     const rootA = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-a-'));
     const rootB = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-b-'));
@@ -1198,6 +1285,127 @@ describe('Pi session daemon spike', () => {
     await client.close();
   });
 
+  it('projects unmatched tools as running only while the session is authoritative-busy', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-live-hydrate-'));
+    const endpoint = testDaemonEndpoint(root);
+    const projectDir = join(root, 'project');
+    const agentDir = join(root, 'agent');
+    await mkdir(projectDir, { recursive: true });
+    await mkdir(agentDir, { recursive: true });
+    const session = new FakeSession('pi-session-live');
+    session.isStreaming = true;
+    session.entries = [
+      {
+        type: 'message',
+        id: 'user-1',
+        timestamp: '2026-01-01T00:00:01.000Z',
+        message: { role: 'user', content: 'run it', timestamp: 1_000 },
+      },
+      {
+        type: 'message',
+        id: 'assistant-1',
+        timestamp: '2026-01-01T00:00:01.100Z',
+        message: {
+          role: 'assistant',
+          content: [
+            { type: 'text', text: 'calling bash' },
+            { type: 'toolCall', id: 'tool-live', name: 'bash', arguments: { command: 'ls' } },
+          ],
+          provider: 'test',
+          model: 'model',
+          timestamp: 1_100,
+        },
+      },
+    ];
+    session.messages = [
+      { role: 'user', content: 'run it', timestamp: 1_000 },
+      {
+        role: 'assistant',
+        content: [
+          { type: 'text', text: 'calling bash' },
+          { type: 'toolCall', id: 'tool-live', name: 'bash', arguments: { command: 'ls' } },
+        ],
+        provider: 'test',
+        model: 'model',
+        timestamp: 1_100,
+      },
+    ];
+
+    daemon = createSessionDaemon({
+      endpoint,
+      credential,
+      cwd: projectDir,
+      agentDir,
+      createRuntime: async () => ({ session, async dispose() {} }),
+      listSessions: async () => [],
+    });
+    await daemon.start();
+
+    const client = connectClient(endpoint);
+    await client.authenticate();
+    const detail = await client.request('sessions.create', { cwd: projectDir });
+    expect(detail.result.isStreaming).toBe(true);
+    expect(detail.result.lifecycle).toBe('busy');
+    expect(detail.result.messages).toHaveLength(2);
+    expect(detail.result.messages[1].parts).toEqual(expect.arrayContaining([
+      expect.objectContaining({ type: 'text', text: 'calling bash' }),
+      expect.objectContaining({ type: 'tool', name: 'bash', state: 'running', toolCallId: 'tool-live' }),
+    ]));
+
+    session.isStreaming = false;
+    const settled = await client.request('sessions.open', { sessionId: session.sessionId, cwd: projectDir });
+    expect(settled.result.lifecycle).toBe('idle');
+    expect(settled.result.messages[1].parts).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: 'tool',
+        name: 'bash',
+        state: 'error',
+        toolCallId: 'tool-live',
+        isError: true,
+        error: 'Tool was interrupted before completion.',
+        endedAt: expect.any(Number),
+      }),
+    ]));
+    await client.close();
+  });
+
+  it('overlays an unpersisted live user prompt onto getSession while streaming', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-live-user-'));
+    const endpoint = testDaemonEndpoint(root);
+    const projectDir = join(root, 'project');
+    const agentDir = join(root, 'agent');
+    await mkdir(projectDir, { recursive: true });
+    await mkdir(agentDir, { recursive: true });
+    const session = new FakeSession('pi-session-live-user');
+    session.isStreaming = true;
+    session.entries = [];
+    session.messages = [
+      { role: 'user', content: 'just sent', timestamp: 2_000 },
+    ];
+
+    daemon = createSessionDaemon({
+      endpoint,
+      credential,
+      cwd: projectDir,
+      agentDir,
+      createRuntime: async () => ({ session, async dispose() {} }),
+      listSessions: async () => [],
+    });
+    await daemon.start();
+
+    const client = connectClient(endpoint);
+    await client.authenticate();
+    const detail = await client.request('sessions.create', { cwd: projectDir });
+    expect(detail.result.isStreaming).toBe(true);
+    expect(detail.result.lifecycle).toBe('busy');
+    expect(detail.result.messages).toEqual([
+      expect.objectContaining({
+        message: expect.objectContaining({ role: 'user', text: 'just sent' }),
+      }),
+    ]);
+    await client.close();
+  });
+
   it('projects Pi usage in getSession messages and message_end events, omitting malformed payloads', async () => {
     const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-usage-'));
     const endpoint = testDaemonEndpoint(root);