@shaykec/bridge 0.4.19 → 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,414 +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 { randomUUID } from 'crypto';
-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 {
-  /**
-   * @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();
-  }
-
-  /**
-   * Check if the Agent SDK is available.
-   * @returns {Promise<boolean>}
-   */
-  async isAvailable() {
-    try {
-      await this._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.
-   *
-   * 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 (our UUID handle)
-   */
-  async createSession(options = {}) {
-    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',
-    };
-
-    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);
-      // 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 });
-
-      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 this._getSDK();
-
-    // Close existing entry for this ID if present
-    await this.closeSession(sessionId);
-
-    const onMessage = options.onMessage;
-
-    const sessionOpts = {
-      model: options.model || 'claude-sonnet-4-6',
-      allowedTools: [
-        'Bash(*)', 'Read', 'Write', 'Edit', 'Glob', 'Grep',
-      ],
-      permissionMode: 'bypassPermissions',
-    };
-
-    if (options.cwd) sessionOpts.cwd = options.cwd;
-
-    if (options.pluginDir) {
-      sessionOpts.plugins = [{ type: 'local', path: options.pluginDir }];
-    }
-
-    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 });
-
-      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()) {
-        // 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) {
-            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' });
-    }
-  }
-
-  /**
-   * 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
-   */
-  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 this._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);
-    }
-  }
-}