@shaykec/bridge 0.4.19 → 0.4.20

package/src/claude-session.test.js

@@ -1,326 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ClaudeSessionManager } from './claude-session.js';
-
-describe('ClaudeSessionManager', () => {
-  let manager;
-  let emittedMessages;
-  let mockSDK;
-
-  function makeMockSession(id) {
-    return {
-      sessionId: id,
-      send: vi.fn(),
-      stream: vi.fn(),
-      close: vi.fn(),
-    };
-  }
-
-  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('sdk-id-1');
-      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
-
-      const sessionId = await manager.createSession({ onMessage: mockOnMessage });
-
-      // 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 model, cwd and pluginDir to the SDK', async () => {
-      const mockSession = makeMockSession('s1');
-      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
-
-      await manager.createSession({
-        cwd: '/test/dir',
-        pluginDir: '/test/plugin',
-        onMessage: mockOnMessage,
-      });
-
-      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 () => {
-      mockSDK.unstable_v2_createSession.mockImplementation(() => {
-        throw new Error('SDK init failed');
-      });
-
-      await expect(
-        manager.createSession({ onMessage: mockOnMessage })
-      ).rejects.toThrow('SDK init failed');
-
-      expect(emittedMessages[0].type).toBe('chat:status');
-      expect(emittedMessages[0].payload.status).toBe('error');
-    });
-  });
-
-  describe('resumeSession', () => {
-    it('resumes a session by ID', async () => {
-      const mockSession = makeMockSession('existing-session');
-      mockSDK.unstable_v2_resumeSession.mockReturnValue(mockSession);
-
-      const sessionId = await manager.resumeSession('existing-session', { onMessage: mockOnMessage });
-
-      expect(sessionId).toBe('existing-session');
-      expect(mockSDK.unstable_v2_resumeSession).toHaveBeenCalledWith('existing-session', expect.any(Object));
-      expect(emittedMessages[0].payload.status).toBe('resumed');
-    });
-  });
-
-  describe('sendMessage', () => {
-    it('throws if no active session', async () => {
-      await expect(manager.sendMessage('nonexistent', 'hello')).rejects.toThrow('No active session');
-    });
-
-    it('sends a message and streams response', async () => {
-      async function* fakeStream() {
-        yield { type: 'assistant', message: { content: [{ type: 'text', text: 'Hello' }] } };
-        yield { type: 'result' };
-      }
-
-      const mockSession = makeMockSession('stream-test');
-      mockSession.stream.mockReturnValue(fakeStream());
-      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
-      const sessionId = await manager.createSession({ onMessage: mockOnMessage });
-
-      emittedMessages = [];
-      await manager.sendMessage(sessionId, 'test message');
-
-      expect(mockSession.send).toHaveBeenCalledWith('test message');
-      expect(mockSession.stream).toHaveBeenCalled();
-
-      const types = emittedMessages.map(m => m.type);
-      expect(types).toContain('chat:status');
-      expect(types).toContain('chat:stream');
-      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' } };
-        yield { type: 'tool_result', tool_use_id: 'tool-1', content: 'file1\nfile2' };
-        yield { type: 'result' };
-      }
-
-      const mockSession = makeMockSession('tool-test');
-      mockSession.stream.mockReturnValue(fakeStream());
-      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
-      const sessionId = await manager.createSession({ onMessage: mockOnMessage });
-
-      emittedMessages = [];
-      await manager.sendMessage(sessionId, 'list files');
-
-      const toolUse = emittedMessages.find(m => m.type === 'chat:tool-use');
-      expect(toolUse).toBeDefined();
-      expect(toolUse.payload.toolName).toBe('Bash');
-
-      const toolResult = emittedMessages.find(m => m.type === 'chat:tool-result');
-      expect(toolResult).toBeDefined();
-      expect(toolResult.payload.toolId).toBe('tool-1');
-    });
-  });
-
-  describe('multiple sessions', () => {
-    it('supports multiple concurrent sessions', async () => {
-      const session1 = makeMockSession('sdk-1');
-      const session2 = makeMockSession('sdk-2');
-      mockSDK.unstable_v2_createSession
-        .mockReturnValueOnce(session1)
-        .mockReturnValueOnce(session2);
-
-      const messages1 = [];
-      const messages2 = [];
-
-      const id1 = await manager.createSession({ onMessage: (e) => messages1.push(e) });
-      const id2 = await manager.createSession({ onMessage: (e) => messages2.push(e) });
-
-      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(id1);
-      expect(messages2[0].payload.sessionId).toBe(id2);
-    });
-
-    it('closing one session does not affect others', async () => {
-      const session1 = makeMockSession('sdk-1');
-      const session2 = makeMockSession('sdk-2');
-      mockSDK.unstable_v2_createSession
-        .mockReturnValueOnce(session1)
-        .mockReturnValueOnce(session2);
-
-      const id1 = await manager.createSession({ onMessage: mockOnMessage });
-      const id2 = await manager.createSession({ onMessage: mockOnMessage });
-
-      await manager.closeSession(id1);
-
-      expect(manager.isActive(id1)).toBe(false);
-      expect(manager.isActive(id2)).toBe(true);
-    });
-
-    it('closeAll closes all sessions', async () => {
-      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 });
-
-      await manager.closeAll();
-
-      expect(manager.getActiveSessionIds()).toHaveLength(0);
-      expect(session1.close).toHaveBeenCalled();
-      expect(session2.close).toHaveBeenCalled();
-    });
-  });
-
-  describe('stop', () => {
-    it('is a no-op when not streaming', async () => {
-      const mockSession = makeMockSession('s1');
-      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
-      const sessionId = await manager.createSession({ onMessage: mockOnMessage });
-
-      emittedMessages = [];
-      await manager.stop(sessionId);
-
-      // Session is still active since it wasn't streaming
-      expect(manager.isActive(sessionId)).toBe(true);
-      expect(emittedMessages).toHaveLength(0);
-    });
-  });
-
-  describe('listSessions', () => {
-    it('returns mapped session list', async () => {
-      mockSDK.listSessions.mockResolvedValue([
-        { sessionId: 's1', summary: 'Test', lastModified: 12345 },
-        { sessionId: 's2', summary: 'Other', lastModified: 67890 },
-      ]);
-
-      const sessions = await manager.listSessions('/test');
-      expect(sessions).toHaveLength(2);
-      expect(sessions[0].sessionId).toBe('s1');
-    });
-
-    it('returns empty array on error', async () => {
-      mockSDK.listSessions.mockRejectedValue(new Error('fail'));
-      const sessions = await manager.listSessions('/test');
-      expect(sessions).toEqual([]);
-    });
-  });
-
-  describe('closeSession', () => {
-    it('closes active session and removes from map', async () => {
-      const mockSession = makeMockSession('s1');
-      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
-      const sessionId = await manager.createSession({ onMessage: mockOnMessage });
-
-      expect(manager.isActive(sessionId)).toBe(true);
-      await manager.closeSession(sessionId);
-      expect(manager.isActive(sessionId)).toBe(false);
-    });
-  });
-
-  describe('isAvailable', () => {
-    it('returns true when SDK is available', async () => {
-      const available = await manager.isAvailable();
-      expect(available).toBe(true);
-    });
-  });
-
-  describe('sendMessage edge cases', () => {
-    it('throws if already streaming', async () => {
-      async function* slowStream() {
-        yield { type: 'assistant', message: { content: [{ type: 'text', text: 'Hi' }] } };
-        // never yields 'result' — hangs forever
-        await new Promise(() => {});
-      }
-
-      const mockSession = makeMockSession('busy');
-      mockSession.stream.mockReturnValue(slowStream());
-      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
-      const sessionId = await manager.createSession({ onMessage: mockOnMessage });
-
-      // Start streaming (don't await — it won't finish)
-      const streamPromise = manager.sendMessage(sessionId, 'first');
-
-      // Wait a tick for streaming flag to be set
-      await new Promise(r => setTimeout(r, 10));
-
-      await expect(manager.sendMessage(sessionId, 'second')).rejects.toThrow('Already streaming');
-
-      // Clean up
-      await manager.closeSession(sessionId);
-    });
-
-    it('emits error status on stream failure', async () => {
-      async function* failStream() {
-        throw new Error('stream broke');
-      }
-
-      const mockSession = makeMockSession('fail-stream');
-      mockSession.stream.mockReturnValue(failStream());
-      mockSDK.unstable_v2_createSession.mockReturnValue(mockSession);
-      const sessionId = await manager.createSession({ onMessage: mockOnMessage });
-
-      emittedMessages = [];
-      await manager.sendMessage(sessionId, 'test');
-
-      const errorStatus = emittedMessages.find(
-        m => m.type === 'chat:status' && m.payload.status === 'error'
-      );
-      expect(errorStatus).toBeDefined();
-      expect(errorStatus.payload.message).toBe('stream broke');
-
-      // Should return to idle after error
-      const idleStatus = emittedMessages.find(
-        m => m.type === 'chat:status' && m.payload.status === 'idle'
-      );
-      expect(idleStatus).toBeDefined();
-    });
-  });
-});