@shaykec/bridge 0.4.19 → 0.4.20

package/src/server.js

@@ -37,13 +37,14 @@ import {
   DEFAULT_PORT,
   INBOX_DIR,
   MAX_LONG_POLL_TIMEOUT_MS,
+  ACHIEVEMENTS,
 } from '@shaykec/shared';
 
 import { TierManager, generateClientId, validateHandshake } from './protocol.js';
 import { EventRouter } from './router.js';
 import { renderTemplate, listTemplates } from './templates.js';
 import { createSession, execCommand, getSession, destroySession, cleanupIdleSessions } from './terminal.js';
-import { ClaudeSessionManager } from './claude-session.js';
+import { createAgentServer } from '@shaykec/agent-web/server';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -84,10 +85,25 @@ export function startServer(options = {}) {
   const port = options.port || DEFAULT_PORT;
   const tierManager = new TierManager();
   const router = new EventRouter(tierManager);
-  const chatSession = new ClaudeSessionManager();
 
-  // Maps sessionId -> clientId for targeted chat message delivery
-  const sessionClientMap = new Map();
+  // Chat is delegated entirely to @shaykec/agent-web
+  const agentConfig = { cwd: process.cwd() };
+  if (options.pluginDir) {
+    agentConfig.plugins = [{ type: 'local', path: options.pluginDir }];
+  }
+  const agentServer = createAgentServer({
+    basePath: '/api',
+    config: agentConfig,
+    hooks: {
+      // Relay chat envelopes to visual WS clients so the canvas receives responses
+      onMessage: (envelope) => {
+        const data = JSON.stringify(envelope);
+        tierManager.broadcastWs(data);
+        tierManager.broadcastSse(data);
+      },
+    },
+  });
+  const chatMiddleware = agentServer.middleware();
 
   if (options.onTierChange) {
     tierManager.onTierChange(options.onTierChange);
@@ -96,47 +112,57 @@ export function startServer(options = {}) {
   // Ensure inbox directory exists
   ensureDir(INBOX_DIR);
 
-  /**
-   * Create an onMessage callback that sends chat envelopes to a specific client.
-   * Falls back to broadcast if the client disconnected.
-   * @param {string} clientId
-   * @returns {function}
-   */
-  function createTargetedSend(clientId) {
-    return (envelope) => {
-      const data = JSON.stringify(envelope);
-      if (!tierManager.sendToClient(clientId, data)) {
-        // Client disconnected — broadcast as fallback
-        tierManager.broadcastWs(data);
-        tierManager.broadcastSse(data);
-      }
-    };
-  }
+  // Create HTTP server
+  const server = createServer((req, res) => {
+    handleRequest(req, res, tierManager, router, options, chatMiddleware);
+  });
+
+  // Both WSSes use noServer to avoid ws library destroying sockets
+  // on path mismatch (ws docs: use noServer for multiple WSSes)
+  const wss = new WebSocketServer({ noServer: true });
+  const chatWss = new WebSocketServer({ noServer: true });
 
-  // Wire up chat messages from browser -> session manager
-  router.onChatMessage = (envelope) => {
-    if (envelope.type === 'chat:send' && envelope.payload?.text) {
-      const sessionId = envelope.payload.sessionId;
-      if (!sessionId || !chatSession.isActive(sessionId)) return;
-      chatSession.sendMessage(sessionId, envelope.payload.text).catch((err) => {
-        console.error('[chat] sendMessage error:', err.message);
+  server.on('upgrade', (req, socket, head) => {
+    const { pathname } = new URL(req.url, `http://${req.headers.host}`);
+    if (pathname === '/ws') {
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        wss.emit('connection', ws, req);
       });
+    } else if (pathname === '/api/ws') {
+      chatWss.handleUpgrade(req, socket, head, (ws) => {
+        chatWss.emit('connection', ws, req);
+      });
+    } else {
+      socket.destroy();
     }
-    if (envelope.type === 'chat:stop') {
-      const sessionId = envelope.payload?.sessionId;
-      if (sessionId) {
-        chatSession.stop(sessionId).catch(() => {});
-      }
-    }
-  };
+  });
 
-  // Create HTTP server
-  const server = createServer((req, res) => {
-    handleRequest(req, res, tierManager, router, options, chatSession, sessionClientMap, createTargetedSend);
+  // Wire agent-web transport to the chat WSS
+  chatWss.on('connection', (ws) => {
+    agentServer.transport.handleWsConnection(
+      ws,
+      () => {},
+      (clientId, envelope) => {
+        if (envelope.type === 'chat:send') {
+          const sessionId = envelope.sessionId || envelope.payload?.sessionId;
+          const text = envelope.payload?.text;
+          if (sessionId && text) {
+            agentServer.sessions.sendMessage(sessionId, text).catch(err => {
+              console.error('[agent-web] sendMessage error:', err.message);
+            });
+          }
+        }
+        if (envelope.type === 'chat:stop') {
+          const sessionId = envelope.sessionId || envelope.payload?.sessionId;
+          if (sessionId) {
+            agentServer.sessions.stopSession(sessionId).catch(() => {});
+          }
+        }
+      }
+    );
   });
 
-  // Create WebSocket server on the same HTTP server
-  const wss = new WebSocketServer({ server, path: '/ws' });
+  agentServer.transport.startHeartbeat();
 
   wss.on('connection', (ws, req) => {
     const clientId = generateClientId();
@@ -185,7 +211,27 @@ export function startServer(options = {}) {
         return;
       }
 
-      // After handshake, route messages through the router
+      // Intercept chat messages and forward to agent-web session manager
+      const { valid: msgValid, envelope: msgEnv } = parseEnvelope(data);
+      if (msgValid && msgEnv.type === 'chat:send') {
+        const sessionId = msgEnv.sessionId || msgEnv.payload?.sessionId;
+        const text = msgEnv.payload?.text;
+        if (sessionId && text) {
+          agentServer.sessions.sendMessage(sessionId, text).catch(err => {
+            console.error('[bridge] chat:send error:', err.message);
+          });
+        }
+        return;
+      }
+      if (msgValid && msgEnv.type === 'chat:stop') {
+        const sessionId = msgEnv.sessionId || msgEnv.payload?.sessionId;
+        if (sessionId) {
+          agentServer.sessions.stopSession(sessionId).catch(() => {});
+        }
+        return;
+      }
+
+      // After handshake, route visual/event messages through the router
       const result = router.handleWsMessage(data, clientId);
       if (!result.handled && result.error) {
         ws.send(JSON.stringify({ error: result.error }));
@@ -226,13 +272,10 @@ export function startServer(options = {}) {
     console.log(`  POST       /api/terminal/exec — execute terminal commands`);
     console.log(`  POST       /api/quiz    — send quiz + wait for answer`);
     console.log(`  POST       /api/game    — send game + wait for result`);
-    console.log(`  POST       /api/terminal/exec — execute terminal commands`);
-    console.log(`  POST       /api/chat/start   — start chat session`);
-    console.log(`  POST       /api/chat/message — send chat message`);
-    console.log(`  POST       /api/chat/stop    — stop generation`);
-    console.log(`  POST       /api/chat/resume  — resume chat session`);
-    console.log(`  GET        /api/chat/sessions — list sessions`);
-    console.log(`  GET        /health      — health check`);
+    console.log(`  REST       /api/chat/*        — chat (via @shaykec/agent-web)`);
+    console.log(`  WebSocket  /api/ws            — chat WebSocket`);
+    console.log(`  SSE        /api/sse           — chat SSE`);
+    console.log(`  GET        /health            — health check`);
     if (existsSync(CANVAS_DIST)) {
       console.log(`  Static     /            — canvas app from ${CANVAS_DIST}`);
     }
@@ -245,21 +288,20 @@ export function startServer(options = {}) {
 
   const close = () => {
     clearInterval(terminalCleanupInterval);
-    chatSession.closeAll().catch(() => {});
-    sessionClientMap.clear();
+    agentServer.close().catch(() => {});
     router.cancelWaiters();
     tierManager.stopHeartbeat();
     wss.close();
     server.close();
   };
 
-  return { server, wss, tierManager, router, chatSession, close };
+  return { server, wss, tierManager, router, agentServer, close };
 }
 
 /**
  * Handle HTTP requests.
  */
-function handleRequest(req, res, tierManager, router, options, chatSession, sessionClientMap, createTargetedSend) {
+function handleRequest(req, res, tierManager, router, options, chatMiddleware) {
   // CORS headers
   res.setHeader('Access-Control-Allow-Origin', '*');
   res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
@@ -274,7 +316,13 @@ function handleRequest(req, res, tierManager, router, options, chatSession, sess
   const url = new URL(req.url, `http://${req.headers.host}`);
   const pathname = url.pathname;
 
-  // --- SSE endpoint ---
+  // --- Chat endpoints delegated to @shaykec/agent-web ---
+  if (pathname.startsWith('/api/chat') || pathname === '/api/sse' || pathname === '/api/health') {
+    chatMiddleware(req, res);
+    return;
+  }
+
+  // --- SSE endpoint (visual/events) ---
   if (req.method === 'GET' && pathname === '/sse') {
     handleSse(req, res, tierManager);
     return;
@@ -336,39 +384,25 @@ function handleRequest(req, res, tierManager, router, options, chatSession, sess
     return;
   }
 
-  if (req.method === 'POST' && pathname === '/api/terminal/exec') {
-    handleApiTerminalExec(req, res, router);
-    return;
-  }
-
   if (req.method === 'POST' && pathname === '/api/open-extension') {
     handleApiOpenExtension(res);
     return;
   }
 
-  // --- Chat API endpoints ---
-  if (req.method === 'POST' && pathname === '/api/chat/start') {
-    handleApiChatStart(req, res, chatSession, sessionClientMap, createTargetedSend, options);
-    return;
-  }
-
-  if (req.method === 'POST' && pathname === '/api/chat/message') {
-    handleApiChatMessage(req, res, chatSession);
-    return;
-  }
-
-  if (req.method === 'POST' && pathname === '/api/chat/stop') {
-    handleApiChatStop(req, res, chatSession);
+  // --- Modules catalog ---
+  if (req.method === 'GET' && pathname === '/api/modules') {
+    handleApiModules(res);
     return;
   }
 
-  if (req.method === 'POST' && pathname === '/api/chat/resume') {
-    handleApiChatResume(req, res, chatSession, sessionClientMap, createTargetedSend, options);
+  // --- Settings ---
+  if (req.method === 'GET' && pathname === '/api/settings') {
+    handleApiSettingsGet(res);
     return;
   }
 
-  if (req.method === 'GET' && pathname === '/api/chat/sessions') {
-    handleApiChatSessions(res, chatSession);
+  if (req.method === 'POST' && pathname === '/api/settings') {
+    handleApiSettingsPost(req, res);
     return;
   }
 
@@ -481,17 +515,196 @@ function handleApiCapture(req, res) {
 }
 
 /**
- * GET /api/progress — return progress data.
+ * GET /api/progress — return progress data with achievements.
  */
 function handleApiProgress(res, options) {
+  let progress;
   if (options.progressProvider && typeof options.progressProvider.getProgress === 'function') {
-    const progress = options.progressProvider.getProgress();
-    sendJson(res, 200, progress);
+    progress = options.progressProvider.getProgress();
   } else {
-    sendJson(res, 200, { user: { xp: 0 }, modules: {} });
+    progress = { user: { xp: 0 }, modules: {} };
+  }
+
+  // Include achievements data from progress file
+  const achievements = progress.achievements || { unlocked: [], progress: {} };
+  const unlocked = (achievements.unlocked || []).map(a => ({
+    id: a.id,
+    date: a.date,
+    trigger: a.trigger,
+    ...a,
+  }));
+
+  // Build near-locked list from progress counters + ACHIEVEMENTS criteria
+  const near = [];
+  const progressCounters = achievements.progress || {};
+  const unlockedIds = new Set(unlocked.map(a => a.id));
+  for (const def of ACHIEVEMENTS) {
+    if (unlockedIds.has(def.id)) continue;
+    const counter = progressCounters[def.id];
+    if (counter && counter.current > 0) {
+      near.push({
+        id: def.id,
+        icon: def.icon,
+        name: def.name,
+        description: def.description,
+        category: def.category,
+        current: counter.current,
+        target: counter.target || def.criteria?.target || 1,
+      });
+    }
+  }
+  near.sort((a, b) => (b.current / b.target) - (a.current / a.target));
+
+  sendJson(res, 200, {
+    ...progress,
+    achievements: { unlocked, near },
+  });
+}
+
+/**
+ * GET /api/modules — return module catalog from built-in + installed modules.
+ */
+function handleApiModules(res) {
+  const modulesDir = resolve(__dirname, '..', '..', 'modules');
+  const modules = [];
+
+  try {
+    if (existsSync(modulesDir)) {
+      const entries = readdirSync(modulesDir);
+      for (const entry of entries) {
+        const yamlPath = join(modulesDir, entry, 'module.yaml');
+        if (!existsSync(yamlPath)) continue;
+        try {
+          const raw = readFileSync(yamlPath, 'utf-8');
+          // Simple YAML parsing for module metadata (no dependency needed)
+          const meta = {};
+          for (const line of raw.split('\n')) {
+            const match = line.match(/^(\w[\w-]*):\s*(.+)$/);
+            if (match) {
+              let val = match[2].trim();
+              if (val.startsWith('"') && val.endsWith('"')) val = val.slice(1, -1);
+              if (val === 'true') val = true;
+              else if (val === 'false') val = false;
+              else if (/^\d+$/.test(val)) val = parseInt(val, 10);
+              meta[match[1]] = val;
+            }
+          }
+          if (meta.slug) {
+            modules.push({
+              slug: meta.slug,
+              title: meta.title || meta.slug,
+              description: meta.description || '',
+              category: meta.category || 'general',
+              difficulty: meta.difficulty || 'beginner',
+              icon: meta.icon || null,
+            });
+          }
+        } catch {
+          // Skip unparseable modules
+        }
+      }
+    }
+  } catch {
+    // Directory read failed
+  }
+
+  sendJson(res, 200, { modules });
+}
+
+/**
+ * Settings file path: ~/.claude-teach/config.yaml
+ */
+const SETTINGS_DIR = join(
+  process.env.HOME || process.env.USERPROFILE || '/tmp',
+  '.claude-teach'
+);
+const SETTINGS_FILE = join(SETTINGS_DIR, 'config.yaml');
+
+const DEFAULT_SETTINGS = {
+  theme: 'dark',
+  accent: 'blue',
+  chatPosition: 'left',
+  fontSize: 14,
+  animations: { confetti: true, transitions: true, diagrams: true },
+};
+
+function readSettings() {
+  try {
+    if (!existsSync(SETTINGS_FILE)) return { ...DEFAULT_SETTINGS };
+    const raw = readFileSync(SETTINGS_FILE, 'utf-8');
+    const settings = { ...DEFAULT_SETTINGS };
+    for (const line of raw.split('\n')) {
+      const match = line.match(/^(\w[\w-]*):\s*(.+)$/);
+      if (match) {
+        let val = match[2].trim();
+        if (val.startsWith('"') && val.endsWith('"')) val = val.slice(1, -1);
+        if (val === 'true') val = true;
+        else if (val === 'false') val = false;
+        else if (/^\d+$/.test(val)) val = parseInt(val, 10);
+        settings[match[1]] = val;
+      }
+    }
+    return settings;
+  } catch {
+    return { ...DEFAULT_SETTINGS };
+  }
+}
+
+function writeSettings(settings) {
+  try {
+    if (!existsSync(SETTINGS_DIR)) mkdirSync(SETTINGS_DIR, { recursive: true });
+    const lines = [];
+    for (const [key, val] of Object.entries(settings)) {
+      if (typeof val === 'object') {
+        // Flatten nested objects (animations)
+        for (const [k, v] of Object.entries(val)) {
+          lines.push(`${key}_${k}: ${v}`);
+        }
+      } else {
+        lines.push(`${key}: ${val}`);
+      }
+    }
+    writeFileSync(SETTINGS_FILE, lines.join('\n') + '\n');
+  } catch {
+    // Ignore write errors
   }
 }
 
+/**
+ * GET /api/settings — return canvas settings.
+ */
+function handleApiSettingsGet(res) {
+  const settings = readSettings();
+  sendJson(res, 200, settings);
+}
+
+/**
+ * POST /api/settings — save canvas settings (partial update).
+ */
+function handleApiSettingsPost(req, res) {
+  let body = '';
+  req.on('data', (chunk) => { body += chunk; });
+  req.on('end', () => {
+    try {
+      const patch = JSON.parse(body);
+      const current = readSettings();
+      // Merge patch into current settings
+      const updated = { ...current };
+      for (const [key, val] of Object.entries(patch)) {
+        if (key === 'animations' && typeof val === 'object') {
+          updated.animations = { ...current.animations, ...val };
+        } else if (DEFAULT_SETTINGS[key] !== undefined) {
+          updated[key] = val;
+        }
+      }
+      writeSettings(updated);
+      sendJson(res, 200, updated);
+    } catch {
+      sendJson(res, 400, { error: 'Invalid JSON' });
+    }
+  });
+}
+
 /**
  * GET /api/events — poll queued user events.
  */
@@ -767,18 +980,7 @@ function handleApiOpenExtension(res) {
     return;
   }
 
-  const platform = process.platform;
-  if (platform === 'darwin') {
-    exec(`open "${extensionDir}"`);
-    exec('open -a "Google Chrome" "chrome://extensions"');
-  } else if (platform === 'linux') {
-    exec(`xdg-open "${extensionDir}"`);
-    exec('google-chrome "chrome://extensions" 2>/dev/null || chromium-browser "chrome://extensions" 2>/dev/null');
-  } else if (platform === 'win32') {
-    exec(`explorer "${extensionDir}"`);
-    exec('start chrome "chrome://extensions"');
-  }
-
+  // Return the path only — no longer auto-opens Finder/Chrome.
   sendJson(res, 200, { ok: true, path: extensionDir });
 }
 
@@ -829,101 +1031,6 @@ function handleApiTerminalExec(req, res, router) {
   });
 }
 
-// --- Chat API handlers ---
-
-function handleApiChatStart(req, res, chatSession, sessionClientMap, createTargetedSend, options) {
-  readBody(req, async (err, body) => {
-    if (err) body = {};
-
-    // clientId is sent by the browser so we can target responses back
-    const clientId = body?.clientId;
-
-    try {
-      const sessionId = await chatSession.createSession({
-        cwd: body?.cwd || process.cwd(),
-        pluginDir: body?.pluginDir || options.pluginDir,
-        onMessage: clientId ? createTargetedSend(clientId) : createTargetedSend('broadcast'),
-      });
-      if (clientId) {
-        sessionClientMap.set(sessionId, clientId);
-      }
-      sendJson(res, 200, { ok: true, sessionId });
-    } catch (startErr) {
-      sendJson(res, 500, { error: startErr.message });
-    }
-  });
-}
-
-function handleApiChatMessage(req, res, chatSession) {
-  readBody(req, (err, body) => {
-    if (err || !body?.text) {
-      sendJson(res, 400, { error: 'Missing "text" in request body' });
-      return;
-    }
-
-    const sessionId = body.sessionId;
-    if (!sessionId || !chatSession.isActive(sessionId)) {
-      sendJson(res, 400, { error: 'No active chat session. Provide a valid "sessionId".' });
-      return;
-    }
-
-    sendJson(res, 200, { ok: true });
-
-    chatSession.sendMessage(sessionId, body.text).catch((sendErr) => {
-      console.error('[chat] sendMessage error:', sendErr.message);
-    });
-  });
-}
-
-function handleApiChatStop(req, res, chatSession) {
-  readBody(req, (err, body) => {
-    const sessionId = body?.sessionId;
-    if (!sessionId) {
-      sendJson(res, 400, { error: 'Missing "sessionId" in request body' });
-      return;
-    }
-    chatSession.stop(sessionId).then(() => {
-      sendJson(res, 200, { ok: true });
-    }).catch((stopErr) => {
-      sendJson(res, 500, { error: stopErr.message });
-    });
-  });
-}
-
-function handleApiChatResume(req, res, chatSession, sessionClientMap, createTargetedSend, options) {
-  readBody(req, async (err, body) => {
-    if (err || !body?.sessionId) {
-      sendJson(res, 400, { error: 'Missing "sessionId" in request body' });
-      return;
-    }
-
-    const clientId = body?.clientId;
-
-    try {
-      await chatSession.resumeSession(body.sessionId, {
-        cwd: body?.cwd || process.cwd(),
-        pluginDir: body?.pluginDir || options.pluginDir,
-        onMessage: clientId ? createTargetedSend(clientId) : createTargetedSend('broadcast'),
-      });
-      if (clientId) {
-        sessionClientMap.set(body.sessionId, clientId);
-      }
-      sendJson(res, 200, { ok: true, sessionId: body.sessionId });
-    } catch (resumeErr) {
-      sendJson(res, 500, { error: resumeErr.message });
-    }
-  });
-}
-
-async function handleApiChatSessions(res, chatSession) {
-  try {
-    const sessions = await chatSession.listSessions(process.cwd());
-    sendJson(res, 200, { sessions });
-  } catch (listErr) {
-    sendJson(res, 500, { error: listErr.message });
-  }
-}
-
 // --- Helpers ---
 
 function readBody(req, callback) {
@@ -958,6 +1065,15 @@ function ensureDir(dirPath) {
 
 // --- Standalone execution ---
 if (process.argv[1] && process.argv[1].includes('bridge/src/server.js')) {
+  // Prevent unhandled errors from crashing the server
+  process.on('uncaughtException', (err) => {
+    console.error('[bridge] Uncaught exception (server kept alive):', err.message);
+  });
+  process.on('unhandledRejection', (err) => {
+    console.error('[bridge] Unhandled rejection (server kept alive):', err?.message || err);
+  });
+
   const port = parseInt(process.env.PORT || process.argv[2] || DEFAULT_PORT, 10);
-  startServer({ port });
+  const pluginDir = resolve(__dirname, '..', '..', 'plugin');
+  startServer({ port, pluginDir });
 }

package/canvas-dist/assets/channel-saCUO1KA.js

@@ -1 +0,0 @@
-import{ap as o,aq as n}from"./index-DYNtb52W.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};

package/canvas-dist/assets/classDiagram-2ON5EDUG-CBLbQwHx.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-B4BG7PRW-Dcov7eRi.js";import{_ as i}from"./index-DYNtb52W.js";import"./chunk-FMBD7UC4-EfGA9ufe.js";import"./chunk-55IACEB6-CTdcUQSV.js";import"./chunk-QN33PNHL-Cu6V1xBU.js";var p={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{p as diagram};

package/canvas-dist/assets/classDiagram-v2-WZHVMYZB-CBLbQwHx.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-B4BG7PRW-Dcov7eRi.js";import{_ as i}from"./index-DYNtb52W.js";import"./chunk-FMBD7UC4-EfGA9ufe.js";import"./chunk-55IACEB6-CTdcUQSV.js";import"./chunk-QN33PNHL-Cu6V1xBU.js";var p={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{p as diagram};

package/canvas-dist/assets/clone-DXnda9BY.js

@@ -1 +0,0 @@
-import{b as r}from"./_baseUniq-EF6Y2_Wm.js";var e=4;function a(o){return r(o,e)}export{a as c};