@shaykec/bridge 0.4.18 → 0.4.20

package/canvas-dist/assets/stateDiagram-v2-4FDKWEC3-MT16RLO4.js

@@ -1 +0,0 @@
-import{s as t,b as r,a,S as s}from"./chunk-DI55MBZ5-DUJCBZzM.js";import{_ as i}from"./index-DYNtb52W.js";import"./chunk-55IACEB6-CTdcUQSV.js";import"./chunk-QN33PNHL-Cu6V1xBU.js";var l={parser:a,get db(){return new s(2)},renderer:r,styles:t,init:i(e=>{e.state||(e.state={}),e.state.arrowMarkerAbsolute=e.arrowMarkerAbsolute},"init")};export{l as diagram};

package/src/claude-session.js

@@ -1,381 +0,0 @@
-/**
- * Claude session manager — wraps the Agent SDK to manage
- * multiple Claude Code session lifecycles for browser chat.
- *
- * Uses the V2 preview interface (unstable_v2_createSession / unstable_v2_resumeSession)
- * for clean send()/stream() multi-turn conversation support.
- *
- * The SDK is an optional dependency — if not installed, chat features
- * are gracefully disabled.
- *
- * Supports multiple concurrent sessions (one per browser tab).
- */
-
-import {
-  createEnvelope,
-  MSG_CHAT_ASSISTANT,
-  MSG_CHAT_STREAM,
-  MSG_CHAT_TOOL_USE,
-  MSG_CHAT_TOOL_RESULT,
-  MSG_CHAT_STATUS,
-} from '@shaykec/shared';
-
-import { execSync } from 'child_process';
-import { createRequire } from 'module';
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-
-// Resolve the package tree root (parent of node_modules/@shaykec/bridge)
-const __filename = fileURLToPath(import.meta.url);
-const BRIDGE_ROOT = join(dirname(__filename), '..');
-// Walk up: bridge/ -> @shaykec/ -> node_modules/ -> prefix/
-const NPM_PREFIX = join(BRIDGE_ROOT, '..', '..', '..');
-
-// Lazy-load the Agent SDK — auto-installs on first use if missing
-let _sdk = null;
-let _sdkLoadError = null;
-
-function tryRequireSDK() {
-  const require = createRequire(import.meta.url);
-  return require('@anthropic-ai/claude-agent-sdk');
-}
-
-async function getSDK() {
-  if (_sdk) return _sdk;
-  if (_sdkLoadError) throw _sdkLoadError;
-  try {
-    _sdk = tryRequireSDK();
-    return _sdk;
-  } catch {
-    // SDK not installed — install it into the same node_modules tree
-    console.log('[chat] Agent SDK not found, installing @anthropic-ai/claude-agent-sdk...');
-    try {
-      execSync(
-        `npm install @anthropic-ai/claude-agent-sdk --registry https://registry.npmjs.org/ --prefix "${NPM_PREFIX}" --no-save`,
-        { stdio: 'inherit', timeout: 60000 }
-      );
-      _sdk = tryRequireSDK();
-      console.log('[chat] Agent SDK installed successfully.');
-      return _sdk;
-    } catch (installErr) {
-      _sdkLoadError = new Error(
-        'Failed to install Claude Agent SDK. Chat features require @anthropic-ai/claude-agent-sdk. ' +
-        'Install manually: npm install @anthropic-ai/claude-agent-sdk --registry https://registry.npmjs.org/'
-      );
-      throw _sdkLoadError;
-    }
-  }
-}
-
-/**
- * @typedef {object} ChatSessionOptions
- * @property {string} [cwd] - Working directory for Claude Code
- * @property {string} [pluginDir] - Path to the ClaudeTeach plugin
- * @property {function} onMessage - Callback receiving protocol envelopes to broadcast
- */
-
-/**
- * @typedef {object} SessionEntry
- * @property {import('@anthropic-ai/claude-agent-sdk').SDKSession} session
- * @property {boolean} streaming
- * @property {function} onMessage
- */
-
-/**
- * Manages multiple Claude Code SDK sessions.
- */
-export class ClaudeSessionManager {
-  constructor() {
-    /** @type {Map<string, SessionEntry>} */
-    this._sessions = new Map();
-  }
-
-  /**
-   * Check if the Agent SDK is available.
-   * @returns {Promise<boolean>}
-   */
-  async isAvailable() {
-    try {
-      await getSDK();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Get a session entry by ID.
-   * @param {string} sessionId
-   * @returns {SessionEntry|undefined}
-   */
-  getSession(sessionId) {
-    return this._sessions.get(sessionId);
-  }
-
-  /**
-   * Check if a session exists and is active.
-   * @param {string} sessionId
-   * @returns {boolean}
-   */
-  isActive(sessionId) {
-    return this._sessions.has(sessionId);
-  }
-
-  /**
-   * Check if a specific session is currently streaming.
-   * @param {string} sessionId
-   * @returns {boolean}
-   */
-  isStreaming(sessionId) {
-    const entry = this._sessions.get(sessionId);
-    return entry ? entry.streaming : false;
-  }
-
-  /**
-   * Get all active session IDs.
-   * @returns {string[]}
-   */
-  getActiveSessionIds() {
-    return [...this._sessions.keys()];
-  }
-
-  /**
-   * Create a new chat session.
-   * @param {ChatSessionOptions} options
-   * @returns {Promise<string>} sessionId
-   */
-  async createSession(options = {}) {
-    const sdk = await getSDK();
-    const onMessage = options.onMessage;
-
-    const sessionOpts = {
-      allowedTools: [
-        'Bash(*)', 'Read', 'Write', 'Edit', 'Glob', 'Grep',
-      ],
-      permissionMode: 'bypassPermissions',
-      allowDangerouslySkipPermissions: true,
-      settingSources: ['user', 'project'],
-      includePartialMessages: true,
-    };
-
-    if (options.cwd) sessionOpts.cwd = options.cwd;
-
-    if (options.pluginDir) {
-      sessionOpts.plugins = [{ type: 'local', path: options.pluginDir }];
-    }
-
-    try {
-      const session = sdk.unstable_v2_createSession(sessionOpts);
-      const sessionId = session.sessionId;
-
-      this._sessions.set(sessionId, {
-        session,
-        streaming: false,
-        onMessage,
-      });
-
-      this._emit(sessionId, MSG_CHAT_STATUS, { status: 'started', sessionId });
-
-      return sessionId;
-    } catch (err) {
-      if (onMessage) {
-        const envelope = createEnvelope(MSG_CHAT_STATUS, { status: 'error', message: err.message }, 'bridge');
-        onMessage(envelope);
-      }
-      throw err;
-    }
-  }
-
-  /**
-   * Resume a previous session by ID.
-   * @param {string} sessionId
-   * @param {ChatSessionOptions} options
-   * @returns {Promise<string>} sessionId
-   */
-  async resumeSession(sessionId, options = {}) {
-    const sdk = await getSDK();
-
-    // Close existing entry for this ID if present
-    await this.closeSession(sessionId);
-
-    const onMessage = options.onMessage;
-
-    const sessionOpts = {
-      allowedTools: [
-        'Bash(*)', 'Read', 'Write', 'Edit', 'Glob', 'Grep',
-      ],
-      permissionMode: 'bypassPermissions',
-      allowDangerouslySkipPermissions: true,
-      settingSources: ['user', 'project'],
-      includePartialMessages: true,
-    };
-
-    if (options.cwd) sessionOpts.cwd = options.cwd;
-
-    if (options.pluginDir) {
-      sessionOpts.plugins = [{ type: 'local', path: options.pluginDir }];
-    }
-
-    try {
-      const session = sdk.unstable_v2_resumeSession(sessionId, sessionOpts);
-
-      this._sessions.set(sessionId, {
-        session,
-        streaming: false,
-        onMessage,
-      });
-
-      this._emit(sessionId, MSG_CHAT_STATUS, { status: 'resumed', sessionId });
-
-      return sessionId;
-    } catch (err) {
-      if (onMessage) {
-        const envelope = createEnvelope(MSG_CHAT_STATUS, { status: 'error', message: err.message }, 'bridge');
-        onMessage(envelope);
-      }
-      throw err;
-    }
-  }
-
-  /**
-   * Send a user message and stream the response for a specific session.
-   * Emits protocol envelopes via the session's onMessage callback.
-   * @param {string} sessionId
-   * @param {string} text - User message text
-   */
-  async sendMessage(sessionId, text) {
-    const entry = this._sessions.get(sessionId);
-    if (!entry) {
-      throw new Error(`No active session with ID "${sessionId}". Call createSession() or resumeSession() first.`);
-    }
-
-    if (entry.streaming) {
-      throw new Error('Already streaming a response. Wait for completion or call stop().');
-    }
-
-    entry.streaming = true;
-    this._emit(sessionId, MSG_CHAT_STATUS, { status: 'thinking' });
-
-    try {
-      await entry.session.send(text);
-
-      let currentText = '';
-
-      for await (const msg of entry.session.stream()) {
-        if (msg.type === 'assistant') {
-          const textBlocks = (msg.message?.content || []).filter(b => b.type === 'text');
-          for (const block of textBlocks) {
-            if (block.text && block.text !== currentText) {
-              const delta = block.text.slice(currentText.length);
-              if (delta) {
-                this._emit(sessionId, MSG_CHAT_STREAM, { delta, fullText: block.text });
-              }
-              currentText = block.text;
-            }
-          }
-        }
-
-        if (msg.type === 'tool_use') {
-          this._emit(sessionId, MSG_CHAT_TOOL_USE, {
-            toolName: msg.tool_name || msg.name,
-            toolId: msg.id,
-            input: msg.input,
-          });
-        }
-
-        if (msg.type === 'tool_result') {
-          this._emit(sessionId, MSG_CHAT_TOOL_RESULT, {
-            toolId: msg.tool_use_id,
-            output: msg.content,
-          });
-        }
-
-        if (msg.type === 'result') {
-          if (currentText) {
-            this._emit(sessionId, MSG_CHAT_ASSISTANT, { text: currentText, sessionId });
-          }
-          break;
-        }
-      }
-    } catch (err) {
-      this._emit(sessionId, MSG_CHAT_STATUS, { status: 'error', message: err.message });
-    } finally {
-      entry.streaming = false;
-      this._emit(sessionId, MSG_CHAT_STATUS, { status: 'idle' });
-    }
-  }
-
-  /**
-   * Stop the current generation for a specific session.
-   * @param {string} sessionId
-   */
-  async stop(sessionId) {
-    const entry = this._sessions.get(sessionId);
-    if (entry && entry.streaming) {
-      try {
-        entry.session.close();
-      } catch { /* best effort */ }
-      this._sessions.delete(sessionId);
-      this._emit(sessionId, MSG_CHAT_STATUS, { status: 'stopped' });
-    }
-  }
-
-  /**
-   * List available sessions for the current project.
-   * @param {string} [dir] - Project directory to filter by
-   * @returns {Promise<Array>}
-   */
-  async listSessions(dir) {
-    try {
-      const sdk = await getSDK();
-      const sessions = await sdk.listSessions({ dir, limit: 20 });
-      return sessions.map(s => ({
-        sessionId: s.sessionId,
-        summary: s.summary,
-        lastModified: s.lastModified,
-      }));
-    } catch {
-      return [];
-    }
-  }
-
-  /**
-   * Close a specific session.
-   * @param {string} sessionId
-   */
-  async closeSession(sessionId) {
-    const entry = this._sessions.get(sessionId);
-    if (entry) {
-      try {
-        entry.session.close();
-      } catch { /* already closed */ }
-      this._sessions.delete(sessionId);
-    }
-  }
-
-  /**
-   * Close all sessions and clean up resources.
-   */
-  async closeAll() {
-    for (const [id, entry] of this._sessions) {
-      try {
-        entry.session.close();
-      } catch { /* already closed */ }
-    }
-    this._sessions.clear();
-  }
-
-  /**
-   * Emit a protocol envelope via the session's onMessage callback.
-   * @param {string} sessionId
-   * @param {string} type
-   * @param {object} payload
-   */
-  _emit(sessionId, type, payload) {
-    const entry = this._sessions.get(sessionId);
-    if (entry?.onMessage) {
-      const envelope = createEnvelope(type, payload, 'bridge');
-      entry.onMessage(envelope);
-    }
-  }
-}

package/src/claude-session.test.js

@@ -1,312 +0,0 @@
-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);
-  };
-
-  function makeMockSession(id) {
-    return {
-      sessionId: id,
-      send: vi.fn(),
-      stream: vi.fn(),
-      close: vi.fn(),
-    };
-  }
-
-  describe('createSession', () => {
-    it('creates a session and emits started status', async () => {
-      const mockSession = makeMockSession('test-session-123');
-      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);
-      expect(emittedMessages).toHaveLength(1);
-      expect(emittedMessages[0].type).toBe('chat:status');
-      expect(emittedMessages[0].payload.status).toBe('started');
-    });
-
-    it('passes cwd and pluginDir to the SDK', async () => {
-      const mockSession = makeMockSession('s1');
-      unstable_v2_createSession.mockReturnValue(mockSession);
-
-      await manager.createSession({
-        cwd: '/test/dir',
-        pluginDir: '/test/plugin',
-        onMessage: mockOnMessage,
-      });
-
-      const opts = unstable_v2_createSession.mock.calls[0][0];
-      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(() => {
-        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');
-      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(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());
-      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('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());
-      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('session-1');
-      const session2 = makeMockSession('session-2');
-      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).toBe('session-1');
-      expect(id2).toBe('session-2');
-      expect(manager.isActive('session-1')).toBe(true);
-      expect(manager.isActive('session-2')).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');
-    });
-
-    it('closing one session does not affect others', async () => {
-      const session1 = makeMockSession('session-1');
-      const session2 = makeMockSession('session-2');
-      unstable_v2_createSession
-        .mockReturnValueOnce(session1)
-        .mockReturnValueOnce(session2);
-
-      await manager.createSession({ onMessage: mockOnMessage });
-      await manager.createSession({ onMessage: mockOnMessage });
-
-      await manager.closeSession('session-1');
-
-      expect(manager.isActive('session-1')).toBe(false);
-      expect(manager.isActive('session-2')).toBe(true);
-    });
-
-    it('closeAll closes all sessions', async () => {
-      const session1 = makeMockSession('session-1');
-      const session2 = makeMockSession('session-2');
-      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');
-      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 () => {
-      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 () => {
-      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');
-      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 loadable', 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());
-      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());
-      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();
-    });
-  });
-});