@shaykec/bridge 0.4.18 → 0.4.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaykec/bridge",
-  "version": "0.4.18",
+  "version": "0.4.19",
   "type": "module",
   "description": "Communication hub — HTTP + WebSocket + SSE server with template engine",
   "main": "src/server.js",

package/src/claude-session.js

@@ -20,6 +20,7 @@ import {
   MSG_CHAT_STATUS,
 } from '@shaykec/shared';
 
+import { randomUUID } from 'crypto';
 import { execSync } from 'child_process';
 import { createRequire } from 'module';
 import { dirname, join } from 'path';
@@ -85,9 +86,18 @@ async function getSDK() {
  * Manages multiple Claude Code SDK sessions.
  */
 export class ClaudeSessionManager {
-  constructor() {
+  /**
+   * @param {object} [sdkOverride] - Injected SDK for testing
+   */
+  constructor(sdkOverride) {
     /** @type {Map<string, SessionEntry>} */
     this._sessions = new Map();
+    this._sdkOverride = sdkOverride || null;
+  }
+
+  /** @private */
+  async _getSDK() {
+    return this._sdkOverride || getSDK();
   }
 
   /**
@@ -96,7 +106,7 @@ export class ClaudeSessionManager {
    */
   async isAvailable() {
     try {
-      await getSDK();
+      await this._getSDK();
       return true;
     } catch {
       return false;
@@ -141,21 +151,24 @@ export class ClaudeSessionManager {
 
   /**
    * Create a new chat session.
+   *
+   * The SDK's sessionId isn't available until after the first message
+   * exchange, so we generate our own UUID to return immediately and
+   * capture the real SDK sessionId lazily during sendMessage().
+   *
    * @param {ChatSessionOptions} options
-   * @returns {Promise<string>} sessionId
+   * @returns {Promise<string>} sessionId (our UUID handle)
    */
   async createSession(options = {}) {
-    const sdk = await getSDK();
+    const sdk = await this._getSDK();
     const onMessage = options.onMessage;
 
     const sessionOpts = {
+      model: options.model || 'claude-sonnet-4-6',
       allowedTools: [
         'Bash(*)', 'Read', 'Write', 'Edit', 'Glob', 'Grep',
       ],
       permissionMode: 'bypassPermissions',
-      allowDangerouslySkipPermissions: true,
-      settingSources: ['user', 'project'],
-      includePartialMessages: true,
     };
 
     if (options.cwd) sessionOpts.cwd = options.cwd;
@@ -166,12 +179,15 @@ export class ClaudeSessionManager {
 
     try {
       const session = sdk.unstable_v2_createSession(sessionOpts);
-      const sessionId = session.sessionId;
+      // session.sessionId throws until after first send()+stream()
+      // so we use our own UUID as the map key
+      const sessionId = randomUUID();
 
       this._sessions.set(sessionId, {
         session,
         streaming: false,
         onMessage,
+        sdkSessionId: null, // captured after first message
       });
 
       this._emit(sessionId, MSG_CHAT_STATUS, { status: 'started', sessionId });
@@ -193,7 +209,7 @@ export class ClaudeSessionManager {
    * @returns {Promise<string>} sessionId
    */
   async resumeSession(sessionId, options = {}) {
-    const sdk = await getSDK();
+    const sdk = await this._getSDK();
 
     // Close existing entry for this ID if present
     await this.closeSession(sessionId);
@@ -201,13 +217,11 @@ export class ClaudeSessionManager {
     const onMessage = options.onMessage;
 
     const sessionOpts = {
+      model: options.model || 'claude-sonnet-4-6',
       allowedTools: [
         'Bash(*)', 'Read', 'Write', 'Edit', 'Glob', 'Grep',
       ],
       permissionMode: 'bypassPermissions',
-      allowDangerouslySkipPermissions: true,
-      settingSources: ['user', 'project'],
-      includePartialMessages: true,
     };
 
     if (options.cwd) sessionOpts.cwd = options.cwd;
@@ -217,12 +231,14 @@ export class ClaudeSessionManager {
     }
 
     try {
+      // For resumed sessions, sessionId is available immediately
       const session = sdk.unstable_v2_resumeSession(sessionId, sessionOpts);
 
       this._sessions.set(sessionId, {
         session,
         streaming: false,
         onMessage,
+        sdkSessionId: sessionId,
       });
 
       this._emit(sessionId, MSG_CHAT_STATUS, { status: 'resumed', sessionId });
@@ -262,6 +278,13 @@ export class ClaudeSessionManager {
       let currentText = '';
 
       for await (const msg of entry.session.stream()) {
+        // Capture the real SDK sessionId once it becomes available
+        if (!entry.sdkSessionId) {
+          try {
+            entry.sdkSessionId = entry.session.sessionId;
+          } catch { /* not ready yet */ }
+        }
+
         if (msg.type === 'assistant') {
           const textBlocks = (msg.message?.content || []).filter(b => b.type === 'text');
           for (const block of textBlocks) {
@@ -305,6 +328,16 @@ export class ClaudeSessionManager {
     }
   }
 
+  /**
+   * Get the real SDK session ID for a session (available after first message).
+   * @param {string} sessionId - Our UUID handle
+   * @returns {string|null}
+   */
+  getSdkSessionId(sessionId) {
+    const entry = this._sessions.get(sessionId);
+    return entry?.sdkSessionId || null;
+  }
+
   /**
    * Stop the current generation for a specific session.
    * @param {string} sessionId
@@ -327,7 +360,7 @@ export class ClaudeSessionManager {
    */
   async listSessions(dir) {
     try {
-      const sdk = await getSDK();
+      const sdk = await this._getSDK();
       const sessions = await sdk.listSessions({ dir, limit: 20 });
       return sessions.map(s => ({
         sessionId: s.sessionId,

package/src/claude-session.test.js

@@ -1,32 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { ClaudeSessionManager } from './claude-session.js';
 
-// Mock the SDK
-vi.mock('@anthropic-ai/claude-agent-sdk', () => ({
-  unstable_v2_createSession: vi.fn(),
-  unstable_v2_resumeSession: vi.fn(),
-  listSessions: vi.fn(),
-}));
-
-import {
-  unstable_v2_createSession,
-  unstable_v2_resumeSession,
-  listSessions,
-} from '@anthropic-ai/claude-agent-sdk';
-
 describe('ClaudeSessionManager', () => {
   let manager;
   let emittedMessages;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    manager = new ClaudeSessionManager();
-    emittedMessages = [];
-  });
-
-  const mockOnMessage = (envelope) => {
-    emittedMessages.push(envelope);
-  };
+  let mockSDK;
 
   function makeMockSession(id) {
     return {
@@ -37,23 +15,40 @@ describe('ClaudeSessionManager', () => {
     };
   }
 
+  beforeEach(() => {
+    vi.clearAllMocks();
+    emittedMessages = [];
+    mockSDK = {
+      unstable_v2_createSession: vi.fn(),
+      unstable_v2_resumeSession: vi.fn(),
+      listSessions: vi.fn(),
+    };
+    manager = new ClaudeSessionManager(mockSDK);
+  });
+
+  const mockOnMessage = (envelope) => {
+    emittedMessages.push(envelope);
+  };
+
   describe('createSession', () => {
     it('creates a session and emits started status', async () => {
-      const mockSession = makeMockSession('test-session-123');
-      unstable_v2_createSession.mockReturnValue(mockSession);
+      const mockSession = makeMockSession('sdk-id-1');
+      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
 
       const sessionId = await manager.createSession({ onMessage: mockOnMessage });
 
-      expect(sessionId).toBe('test-session-123');
-      expect(manager.isActive('test-session-123')).toBe(true);
+      // sessionId is a UUID we generate, not the SDK's
+      expect(sessionId).toMatch(/^[0-9a-f-]{36}$/);
+      expect(manager.isActive(sessionId)).toBe(true);
       expect(emittedMessages).toHaveLength(1);
       expect(emittedMessages[0].type).toBe('chat:status');
       expect(emittedMessages[0].payload.status).toBe('started');
+      expect(emittedMessages[0].payload.sessionId).toBe(sessionId);
     });
 
-    it('passes cwd and pluginDir to the SDK', async () => {
+    it('passes model, cwd and pluginDir to the SDK', async () => {
       const mockSession = makeMockSession('s1');
-      unstable_v2_createSession.mockReturnValue(mockSession);
+      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
 
       await manager.createSession({
         cwd: '/test/dir',
@@ -61,13 +56,14 @@ describe('ClaudeSessionManager', () => {
         onMessage: mockOnMessage,
       });
 
-      const opts = unstable_v2_createSession.mock.calls[0][0];
+      const opts = mockSDK.unstable_v2_createSession.mock.calls[0][0];
+      expect(opts.model).toBe('claude-sonnet-4-6');
       expect(opts.cwd).toBe('/test/dir');
       expect(opts.plugins).toEqual([{ type: 'local', path: '/test/plugin' }]);
     });
 
     it('emits error status on SDK failure', async () => {
-      unstable_v2_createSession.mockImplementation(() => {
+      mockSDK.unstable_v2_createSession.mockImplementation(() => {
         throw new Error('SDK init failed');
       });
 
@@ -83,12 +79,12 @@ describe('ClaudeSessionManager', () => {
   describe('resumeSession', () => {
     it('resumes a session by ID', async () => {
       const mockSession = makeMockSession('existing-session');
-      unstable_v2_resumeSession.mockReturnValue(mockSession);
+      mockSDK.unstable_v2_resumeSession.mockReturnValue(mockSession);
 
       const sessionId = await manager.resumeSession('existing-session', { onMessage: mockOnMessage });
 
       expect(sessionId).toBe('existing-session');
-      expect(unstable_v2_resumeSession).toHaveBeenCalledWith('existing-session', expect.any(Object));
+      expect(mockSDK.unstable_v2_resumeSession).toHaveBeenCalledWith('existing-session', expect.any(Object));
       expect(emittedMessages[0].payload.status).toBe('resumed');
     });
   });
@@ -106,7 +102,7 @@ describe('ClaudeSessionManager', () => {
 
       const mockSession = makeMockSession('stream-test');
       mockSession.stream.mockReturnValue(fakeStream());
-      unstable_v2_createSession.mockReturnValue(mockSession);
+      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
       const sessionId = await manager.createSession({ onMessage: mockOnMessage });
 
       emittedMessages = [];
@@ -121,6 +117,25 @@ describe('ClaudeSessionManager', () => {
       expect(types).toContain('chat:assistant');
     });
 
+    it('captures SDK sessionId during streaming', async () => {
+      async function* fakeStream() {
+        yield { type: 'system' };
+        yield { type: 'assistant', message: { content: [{ type: 'text', text: 'Hi' }] } };
+        yield { type: 'result' };
+      }
+
+      const mockSession = makeMockSession('real-sdk-id');
+      mockSession.stream.mockReturnValue(fakeStream());
+      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
+      const sessionId = await manager.createSession({ onMessage: mockOnMessage });
+
+      expect(manager.getSdkSessionId(sessionId)).toBeNull();
+
+      await manager.sendMessage(sessionId, 'test');
+
+      expect(manager.getSdkSessionId(sessionId)).toBe('real-sdk-id');
+    });
+
     it('emits tool-use and tool-result events', async () => {
       async function* fakeStream() {
         yield { type: 'tool_use', name: 'Bash', id: 'tool-1', input: { command: 'ls' } };
@@ -130,7 +145,7 @@ describe('ClaudeSessionManager', () => {
 
       const mockSession = makeMockSession('tool-test');
       mockSession.stream.mockReturnValue(fakeStream());
-      unstable_v2_createSession.mockReturnValue(mockSession);
+      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
       const sessionId = await manager.createSession({ onMessage: mockOnMessage });
 
       emittedMessages = [];
@@ -148,9 +163,9 @@ describe('ClaudeSessionManager', () => {
 
   describe('multiple sessions', () => {
     it('supports multiple concurrent sessions', async () => {
-      const session1 = makeMockSession('session-1');
-      const session2 = makeMockSession('session-2');
-      unstable_v2_createSession
+      const session1 = makeMockSession('sdk-1');
+      const session2 = makeMockSession('sdk-2');
+      mockSDK.unstable_v2_createSession
         .mockReturnValueOnce(session1)
         .mockReturnValueOnce(session2);
 
@@ -160,37 +175,36 @@ describe('ClaudeSessionManager', () => {
       const id1 = await manager.createSession({ onMessage: (e) => messages1.push(e) });
       const id2 = await manager.createSession({ onMessage: (e) => messages2.push(e) });
 
-      expect(id1).toBe('session-1');
-      expect(id2).toBe('session-2');
-      expect(manager.isActive('session-1')).toBe(true);
-      expect(manager.isActive('session-2')).toBe(true);
+      expect(id1).not.toBe(id2);
+      expect(manager.isActive(id1)).toBe(true);
+      expect(manager.isActive(id2)).toBe(true);
       expect(manager.getActiveSessionIds()).toHaveLength(2);
 
       // Status messages go to the right callback
-      expect(messages1[0].payload.sessionId).toBe('session-1');
-      expect(messages2[0].payload.sessionId).toBe('session-2');
+      expect(messages1[0].payload.sessionId).toBe(id1);
+      expect(messages2[0].payload.sessionId).toBe(id2);
     });
 
     it('closing one session does not affect others', async () => {
-      const session1 = makeMockSession('session-1');
-      const session2 = makeMockSession('session-2');
-      unstable_v2_createSession
+      const session1 = makeMockSession('sdk-1');
+      const session2 = makeMockSession('sdk-2');
+      mockSDK.unstable_v2_createSession
         .mockReturnValueOnce(session1)
         .mockReturnValueOnce(session2);
 
-      await manager.createSession({ onMessage: mockOnMessage });
-      await manager.createSession({ onMessage: mockOnMessage });
+      const id1 = await manager.createSession({ onMessage: mockOnMessage });
+      const id2 = await manager.createSession({ onMessage: mockOnMessage });
 
-      await manager.closeSession('session-1');
+      await manager.closeSession(id1);
 
-      expect(manager.isActive('session-1')).toBe(false);
-      expect(manager.isActive('session-2')).toBe(true);
+      expect(manager.isActive(id1)).toBe(false);
+      expect(manager.isActive(id2)).toBe(true);
     });
 
     it('closeAll closes all sessions', async () => {
-      const session1 = makeMockSession('session-1');
-      const session2 = makeMockSession('session-2');
-      unstable_v2_createSession
+      const session1 = makeMockSession('sdk-1');
+      const session2 = makeMockSession('sdk-2');
+      mockSDK.unstable_v2_createSession
         .mockReturnValueOnce(session1)
         .mockReturnValueOnce(session2);
 
@@ -208,7 +222,7 @@ describe('ClaudeSessionManager', () => {
   describe('stop', () => {
     it('is a no-op when not streaming', async () => {
       const mockSession = makeMockSession('s1');
-      unstable_v2_createSession.mockReturnValue(mockSession);
+      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
       const sessionId = await manager.createSession({ onMessage: mockOnMessage });
 
       emittedMessages = [];
@@ -222,7 +236,7 @@ describe('ClaudeSessionManager', () => {
 
   describe('listSessions', () => {
     it('returns mapped session list', async () => {
-      listSessions.mockResolvedValue([
+      mockSDK.listSessions.mockResolvedValue([
         { sessionId: 's1', summary: 'Test', lastModified: 12345 },
         { sessionId: 's2', summary: 'Other', lastModified: 67890 },
       ]);
@@ -233,7 +247,7 @@ describe('ClaudeSessionManager', () => {
     });
 
     it('returns empty array on error', async () => {
-      listSessions.mockRejectedValue(new Error('fail'));
+      mockSDK.listSessions.mockRejectedValue(new Error('fail'));
       const sessions = await manager.listSessions('/test');
       expect(sessions).toEqual([]);
     });
@@ -242,7 +256,7 @@ describe('ClaudeSessionManager', () => {
   describe('closeSession', () => {
     it('closes active session and removes from map', async () => {
       const mockSession = makeMockSession('s1');
-      unstable_v2_createSession.mockReturnValue(mockSession);
+      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
       const sessionId = await manager.createSession({ onMessage: mockOnMessage });
 
       expect(manager.isActive(sessionId)).toBe(true);
@@ -252,7 +266,7 @@ describe('ClaudeSessionManager', () => {
   });
 
   describe('isAvailable', () => {
-    it('returns true when SDK is loadable', async () => {
+    it('returns true when SDK is available', async () => {
       const available = await manager.isAvailable();
       expect(available).toBe(true);
     });
@@ -268,7 +282,7 @@ describe('ClaudeSessionManager', () => {
 
       const mockSession = makeMockSession('busy');
       mockSession.stream.mockReturnValue(slowStream());
-      unstable_v2_createSession.mockReturnValue(mockSession);
+      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
       const sessionId = await manager.createSession({ onMessage: mockOnMessage });
 
       // Start streaming (don't await — it won't finish)
@@ -290,7 +304,7 @@ describe('ClaudeSessionManager', () => {
 
       const mockSession = makeMockSession('fail-stream');
       mockSession.stream.mockReturnValue(failStream());
-      unstable_v2_createSession.mockReturnValue(mockSession);
+      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
       const sessionId = await manager.createSession({ onMessage: mockOnMessage });
 
       emittedMessages = [];

package/src/server.e2e.test.js

@@ -787,10 +787,15 @@ describe('Bridge E2E: Chat message routing', () => {
     expect(data.ok).toBe(true);
   });
 
-  it('POST /api/chat/start fails without SDK but returns structured error', async () => {
+  it('POST /api/chat/start returns 200 with sessionId (SDK available) or 500 with error', async () => {
     const { status, data } = await postJson('/api/chat/start', { clientId: 'test-client-123' });
-    expect(status).toBe(500);
-    expect(data.error).toBeDefined();
+    expect([200, 500]).toContain(status);
+    if (status === 200) {
+      expect(data.sessionId).toBeDefined();
+      expect(data.ok).toBe(true);
+    } else {
+      expect(data.error).toBeDefined();
+    }
   });
 
   it('POST /api/chat/message requires sessionId', async () => {