agentgui 1.0.751 → 1.0.752

package/lib/agent-discovery.js

@@ -0,0 +1,161 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+
+const BINARIES = [
+  { cmd: 'claude', id: 'claude-code', name: 'Claude Code', icon: 'C', protocol: 'cli' },
+  { cmd: 'opencode', id: 'opencode', name: 'OpenCode', icon: 'O', protocol: 'acp', npxPackage: 'opencode-ai' },
+  { cmd: 'gemini', id: 'gemini', name: 'Gemini CLI', icon: 'G', protocol: 'acp', npxPackage: '@google/gemini-cli' },
+  { cmd: 'kilo', id: 'kilo', name: 'Kilo Code', icon: 'K', protocol: 'acp', npxPackage: '@kilocode/cli' },
+  { cmd: 'goose', id: 'goose', name: 'Goose', icon: 'g', protocol: 'acp' },
+  { cmd: 'openhands', id: 'openhands', name: 'OpenHands', icon: 'H', protocol: 'acp' },
+  { cmd: 'augment', id: 'augment', name: 'Augment Code', icon: 'A', protocol: 'acp' },
+  { cmd: 'cline', id: 'cline', name: 'Cline', icon: 'c', protocol: 'acp' },
+  { cmd: 'kimi', id: 'kimi', name: 'Kimi CLI', icon: 'K', protocol: 'acp' },
+  { cmd: 'qwen-code', id: 'qwen', name: 'Qwen Code', icon: 'Q', protocol: 'acp' },
+  { cmd: 'codex', id: 'codex', name: 'Codex CLI', icon: 'X', protocol: 'acp', npxPackage: '@openai/codex' },
+  { cmd: 'mistral-vibe', id: 'mistral', name: 'Mistral Vibe', icon: 'M', protocol: 'acp' },
+  { cmd: 'kiro', id: 'kiro', name: 'Kiro CLI', icon: 'k', protocol: 'acp' },
+  { cmd: 'fast-agent', id: 'fast-agent', name: 'fast-agent', icon: 'F', protocol: 'acp' },
+];
+
+const CLI_WRAPPERS = [
+  { id: 'cli-opencode', name: 'OpenCode', icon: 'O', protocol: 'cli-wrapper', acpId: 'opencode' },
+  { id: 'cli-gemini', name: 'Gemini', icon: 'G', protocol: 'cli-wrapper', acpId: 'gemini' },
+  { id: 'cli-kilo', name: 'Kilo', icon: 'K', protocol: 'cli-wrapper', acpId: 'kilo' },
+  { id: 'cli-codex', name: 'Codex', icon: 'X', protocol: 'cli-wrapper', acpId: 'codex' },
+];
+
+export function findCommand(cmd, rootDir) {
+  const isWindows = os.platform() === 'win32';
+  const localBin = path.join(rootDir, 'node_modules', '.bin', isWindows ? cmd + '.cmd' : cmd);
+  if (fs.existsSync(localBin)) {
+    console.log(`[agent-discovery] Found ${cmd} in local node_modules`);
+    return localBin;
+  }
+  try {
+    const timeoutMs = 10000;
+    if (isWindows) {
+      const result = execSync(`where ${cmd}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'], timeout: timeoutMs }).trim();
+      if (result) {
+        console.log(`[agent-discovery] Found ${cmd} in PATH`);
+        return result.split('\n')[0].trim();
+      }
+    } else {
+      const result = execSync(`which ${cmd}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'], timeout: timeoutMs }).trim();
+      if (result) {
+        console.log(`[agent-discovery] Found ${cmd} in PATH`);
+        return result;
+      }
+    }
+  } catch (err) {
+    console.log(`[agent-discovery] ${cmd} not found or timed out`);
+    return null;
+  }
+  return null;
+}
+
+export async function queryACPServerAgents(baseUrl) {
+  const endpoint = baseUrl.endsWith('/') ? baseUrl + 'agents/search' : baseUrl + '/agents/search';
+  try {
+    const response = await fetch(endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
+      body: JSON.stringify({}),
+      signal: AbortSignal.timeout(5000)
+    });
+    if (!response.ok) {
+      console.error(`Failed to query ACP agents from ${baseUrl}: ${response.status}`);
+      return [];
+    }
+    const data = await response.json();
+    if (!data?.agents || !Array.isArray(data.agents)) {
+      console.error(`Invalid agents response from ${baseUrl}`);
+      return [];
+    }
+    return data.agents.map(agent => ({
+      id: agent.agent_id || agent.id,
+      name: agent.metadata?.ref?.name || agent.name || 'Unknown Agent',
+      metadata: {
+        ref: {
+          name: agent.metadata?.ref?.name,
+          version: agent.metadata?.ref?.version,
+          url: agent.metadata?.ref?.url,
+          tags: agent.metadata?.ref?.tags
+        },
+        description: agent.metadata?.description,
+        author: agent.metadata?.author,
+        license: agent.metadata?.license
+      },
+      specs: agent.specs ? {
+        capabilities: agent.specs.capabilities,
+        input_schema: agent.specs.input_schema || agent.specs.input,
+        output_schema: agent.specs.output_schema || agent.specs.output,
+        thread_state_schema: agent.specs.thread_state_schema || agent.specs.thread_state,
+        config_schema: agent.specs.config_schema || agent.specs.config,
+        custom_streaming_update_schema: agent.specs.custom_streaming_update_schema || agent.specs.custom_streaming_update
+      } : null,
+      custom_data: agent.custom_data,
+      icon: agent.metadata?.ref?.name?.charAt(0) || 'A',
+      protocol: 'acp',
+      path: baseUrl
+    }));
+  } catch (error) {
+    console.error(`ACP agents query failed for ${baseUrl}: ${error.message}`);
+    return [];
+  }
+}
+
+export function discoverAgents(rootDir) {
+  const agents = [];
+  for (const bin of BINARIES) {
+    const result = findCommand(bin.cmd, rootDir);
+    if (result) {
+      agents.push({ id: bin.id, name: bin.name, icon: bin.icon, path: result, protocol: bin.protocol });
+    } else if (bin.npxPackage) {
+      agents.push({ id: bin.id, name: bin.name, icon: bin.icon, path: null, protocol: bin.protocol, npxPackage: bin.npxPackage, npxLaunchable: true });
+    } else if (bin.id === 'claude-code') {
+      agents.push({ id: bin.id, name: bin.name, icon: bin.icon, path: null, protocol: bin.protocol, npxPackage: '@anthropic-ai/claude-code', npxLaunchable: true });
+    }
+  }
+
+  console.log('[discoverAgents] Found agents:', agents.map(a => a.id).join(', '));
+  for (const wrapper of CLI_WRAPPERS) {
+    if (agents.some(a => a.id === wrapper.acpId)) {
+      console.log(`[discoverAgents] Adding CLI wrapper for ${wrapper.id}`);
+      agents.push(wrapper);
+    } else {
+      console.log(`[discoverAgents] Skipping CLI wrapper ${wrapper.id} (ACP agent ${wrapper.acpId} not found)`);
+    }
+  }
+  const wrappedAcpIds = new Set(CLI_WRAPPERS.filter(w => agents.some(a => a.id === w.acpId)).map(w => w.acpId));
+  const filtered = agents.filter(a => !wrappedAcpIds.has(a.id));
+  console.log('[discoverAgents] Final agent count:', filtered.length, 'Agent IDs:', filtered.map(a => a.id).join(', '));
+  return filtered;
+}
+
+export async function discoverExternalACPServers(discoveredAgents) {
+  const externalAgents = [];
+  for (const agent of discoveredAgents.filter(a => a.protocol === 'acp' && a.acpPort)) {
+    try {
+      const agents = await queryACPServerAgents(`http://localhost:${agent.acpPort}`);
+      externalAgents.push(...agents);
+    } catch (_) {}
+  }
+  return externalAgents;
+}
+
+export async function initializeAgentDiscovery(discoveredAgents, rootDir, logError) {
+  try {
+    const agents = discoverAgents(rootDir);
+    discoveredAgents.length = 0;
+    discoveredAgents.push(...agents);
+    console.log('[AGENTS] Discovered:', discoveredAgents.map(a => ({ id: a.id, found: !!a.path, protocol: a.protocol })));
+    console.log('[AGENTS] Total count:', discoveredAgents.length);
+  } catch (err) {
+    console.error('[AGENTS] Discovery error:', err.message);
+    if (logError) logError('initializeAgentDiscovery', err);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.751",
+  "version": "1.0.752",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",

package/server.js

@@ -17,6 +17,7 @@ import fsbrowse from 'fsbrowse';
 import { queries } from './database.js';
 import { runClaudeWithStreaming } from './lib/claude-runner.js';
 import { initializeDescriptors, getAgentDescriptor } from './lib/agent-descriptors.js';
+import { findCommand, queryACPServerAgents, discoverAgents, discoverExternalACPServers, initializeAgentDiscovery } from './lib/agent-discovery.js';
 import { WSOptimizer } from './lib/ws-optimizer.js';
 import { WsRouter } from './lib/ws-protocol.js';
 import { encode as wsEncode } from './lib/codec.js';
@@ -49,14 +50,20 @@ process.on('unhandledRejection', (reason, promise) => {
   if (reason instanceof Error) console.error(reason.stack);
 });
 
-process.on('SIGINT', () => {
-  console.log('[SIGNAL] SIGINT received - graceful shutdown');
+function gracefulShutdown(signal) {
+  console.log(`[SIGNAL] ${signal} received - graceful shutdown`);
   try { pm2Manager.disconnect(); } catch (_) {}
   if (jsonlWatcher) try { jsonlWatcher.stop(); } catch (_) {}
+  for (const [convId, entry] of activeExecutions) {
+    try { if (entry.pid) process.kill(entry.pid, 'SIGTERM'); } catch (_) {}
+  }
   stopACPTools().catch(() => {}).finally(() => {
     try { wss.close(() => server.close(() => process.exit(0))); } catch (_) { process.exit(0); }
+    setTimeout(() => process.exit(1), 5000);
   });
-});
+}
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
 process.on('SIGHUP', () => { console.log('[SIGNAL] SIGHUP received (ignored - uncrashable)'); });
 process.on('beforeExit', (code) => { console.log('[PROCESS] beforeExit with code:', code); });
 process.on('exit', (code) => { console.log('[PROCESS] exit with code:', code); });
@@ -444,180 +451,12 @@ expressApp.use(BASE_URL + '/files/:conversationId', (req, res, next) => {
   router(req, res, next);
 });
 
-function findCommand(cmd) {
-  const isWindows = os.platform() === 'win32';
-  const localBin = path.join(path.dirname(fileURLToPath(import.meta.url)), 'node_modules', '.bin', isWindows ? cmd + '.cmd' : cmd);
-  if (fs.existsSync(localBin)) {
-    console.log(`[agent-discovery] Found ${cmd} in local node_modules`);
-    return localBin;
-  }
-  try {
-    // Increase timeout to 10 seconds to handle slower systems and running agents
-    const timeoutMs = 10000;
-    if (isWindows) {
-      const result = execSync(`where ${cmd}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'], timeout: timeoutMs }).trim();
-      if (result) {
-        console.log(`[agent-discovery] Found ${cmd} in PATH`);
-        return result.split('\n')[0].trim();
-      }
-    } else {
-      const result = execSync(`which ${cmd}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'], timeout: timeoutMs }).trim();
-      if (result) {
-        console.log(`[agent-discovery] Found ${cmd} in PATH`);
-        return result;
-      }
-    }
-  } catch (err) {
-    console.log(`[agent-discovery] ${cmd} not found or timed out`);
-    return null;
-  }
-  return null;
-}
-
-async function queryACPServerAgents(baseUrl) {
-  const endpoint = baseUrl.endsWith('/') ? baseUrl + 'agents/search' : baseUrl + '/agents/search';
-  try {
-    const response = await fetch(endpoint, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
-      body: JSON.stringify({}),
-      signal: AbortSignal.timeout(5000)
-    });
-    if (!response.ok) {
-      console.error(`Failed to query ACP agents from ${baseUrl}: ${response.status}`);
-      return [];
-    }
-    const data = await response.json();
-    if (!data?.agents || !Array.isArray(data.agents)) {
-      console.error(`Invalid agents response from ${baseUrl}`);
-      return [];
-    }
-    return data.agents.map(agent => ({
-      id: agent.agent_id || agent.id,
-      name: agent.metadata?.ref?.name || agent.name || 'Unknown Agent',
-      metadata: {
-        ref: {
-          name: agent.metadata?.ref?.name,
-          version: agent.metadata?.ref?.version,
-          url: agent.metadata?.ref?.url,
-          tags: agent.metadata?.ref?.tags
-        },
-        description: agent.metadata?.description,
-        author: agent.metadata?.author,
-        license: agent.metadata?.license
-      },
-      specs: agent.specs ? {
-        capabilities: agent.specs.capabilities,
-        input_schema: agent.specs.input_schema || agent.specs.input,
-        output_schema: agent.specs.output_schema || agent.specs.output,
-        thread_state_schema: agent.specs.thread_state_schema || agent.specs.thread_state,
-        config_schema: agent.specs.config_schema || agent.specs.config,
-        custom_streaming_update_schema: agent.specs.custom_streaming_update_schema || agent.specs.custom_streaming_update
-      } : null,
-      custom_data: agent.custom_data,
-      icon: agent.metadata?.ref?.name?.charAt(0) || 'A',
-      protocol: 'acp',
-      path: baseUrl
-    }));
-  } catch (error) {
-    console.error(`ACP agents query failed for ${baseUrl}: ${error.message}`);
-    return [];
-  }
-}
-
-function discoverAgents() {
-  const agents = [];
-  const binaries = [
-    { cmd: 'claude', id: 'claude-code', name: 'Claude Code', icon: 'C', protocol: 'cli' },
-    { cmd: 'opencode', id: 'opencode', name: 'OpenCode', icon: 'O', protocol: 'acp', npxPackage: 'opencode-ai' },
-    { cmd: 'gemini', id: 'gemini', name: 'Gemini CLI', icon: 'G', protocol: 'acp', npxPackage: '@google/gemini-cli' },
-    { cmd: 'kilo', id: 'kilo', name: 'Kilo Code', icon: 'K', protocol: 'acp', npxPackage: '@kilocode/cli' },
-    { cmd: 'goose', id: 'goose', name: 'Goose', icon: 'g', protocol: 'acp' },
-    { cmd: 'openhands', id: 'openhands', name: 'OpenHands', icon: 'H', protocol: 'acp' },
-    { cmd: 'augment', id: 'augment', name: 'Augment Code', icon: 'A', protocol: 'acp' },
-    { cmd: 'cline', id: 'cline', name: 'Cline', icon: 'c', protocol: 'acp' },
-    { cmd: 'kimi', id: 'kimi', name: 'Kimi CLI', icon: 'K', protocol: 'acp' },
-    { cmd: 'qwen-code', id: 'qwen', name: 'Qwen Code', icon: 'Q', protocol: 'acp' },
-    { cmd: 'codex', id: 'codex', name: 'Codex CLI', icon: 'X', protocol: 'acp', npxPackage: '@openai/codex' },
-    { cmd: 'mistral-vibe', id: 'mistral', name: 'Mistral Vibe', icon: 'M', protocol: 'acp' },
-    { cmd: 'kiro', id: 'kiro', name: 'Kiro CLI', icon: 'k', protocol: 'acp' },
-    { cmd: 'fast-agent', id: 'fast-agent', name: 'fast-agent', icon: 'F', protocol: 'acp' },
-  ];
-  for (const bin of binaries) {
-    const result = findCommand(bin.cmd);
-    if (result) {
-      agents.push({ id: bin.id, name: bin.name, icon: bin.icon, path: result, protocol: bin.protocol });
-    } else if (bin.npxPackage) {
-      // For npx-launchable packages (including claude-code as fallback)
-      agents.push({ id: bin.id, name: bin.name, icon: bin.icon, path: null, protocol: bin.protocol, npxPackage: bin.npxPackage, npxLaunchable: true });
-    } else if (bin.id === 'claude-code') {
-      // Ensure Claude Code is always available as an npx-launchable agent
-      agents.push({ id: bin.id, name: bin.name, icon: bin.icon, path: null, protocol: bin.protocol, npxPackage: '@anthropic-ai/claude-code', npxLaunchable: true });
-    }
-  }
-
-  // Add CLI tool wrappers for ACP agents (these map CLI commands to plugin sub-agents)
-  // These allow users to select "OpenCode", "Gemini", etc. and then pick a model/variant
-  const cliWrappers = [
-    { id: 'cli-opencode', name: 'OpenCode', icon: 'O', protocol: 'cli-wrapper', acpId: 'opencode' },
-    { id: 'cli-gemini', name: 'Gemini', icon: 'G', protocol: 'cli-wrapper', acpId: 'gemini' },
-    { id: 'cli-kilo', name: 'Kilo', icon: 'K', protocol: 'cli-wrapper', acpId: 'kilo' },
-    { id: 'cli-codex', name: 'Codex', icon: 'X', protocol: 'cli-wrapper', acpId: 'codex' },
-  ];
-
-  // Only add CLI wrappers for agents that are already discovered
-  console.log('[discoverAgents] Found agents:', agents.map(a => a.id).join(', '));
-  for (const wrapper of cliWrappers) {
-    if (agents.some(a => a.id === wrapper.acpId)) {
-      console.log(`[discoverAgents] Adding CLI wrapper for ${wrapper.id}`);
-      agents.push(wrapper);
-      console.log(`[discoverAgents] After push, agents.length = ${agents.length}, includes ${wrapper.id}? ${agents.some(a => a.id === wrapper.id)}`);
-    } else {
-      console.log(`[discoverAgents] Skipping CLI wrapper ${wrapper.id} (ACP agent ${wrapper.acpId} not found)`);
-    }
-  }
-  // Remove raw ACP agents that have a cli-wrapper (avoid duplicates in UI)
-  const wrappedAcpIds = new Set(cliWrappers.filter(w => agents.some(a => a.id === w.acpId)).map(w => w.acpId));
-  const filtered = agents.filter(a => !wrappedAcpIds.has(a.id));
-  console.log('[discoverAgents] Final agent count:', filtered.length, 'Agent IDs:', filtered.map(a => a.id).join(', '));
-
-  return filtered;
-}
-
-// Function to discover agents from external ACP servers
-async function discoverExternalACPServers() {
-  const externalAgents = [];
-  for (const agent of discoveredAgents.filter(a => a.protocol === 'acp' && a.acpPort)) {
-    try {
-      const agents = await queryACPServerAgents(`http://localhost:${agent.acpPort}`);
-      externalAgents.push(...agents);
-    } catch (_) {}
-  }
-  return externalAgents;
-}
-
 let discoveredAgents = [];
 initializeDescriptors(discoveredAgents);
 
-// Agent discovery happens asynchronously in background to not block startup
-async function initializeAgentDiscovery() {
-  try {
-    const agents = discoverAgents();
-    // Mutate the existing array instead of reassigning to preserve closure references in handlers
-    discoveredAgents.length = 0;
-    discoveredAgents.push(...agents);
-    initializeDescriptors(discoveredAgents);
-    console.log('[AGENTS] Discovered:', discoveredAgents.map(a => ({ id: a.id, found: !!a.path, protocol: a.protocol })));
-    console.log('[AGENTS] Total count:', discoveredAgents.length);
-  } catch (err) {
-    console.error('[AGENTS] Discovery error:', err.message);
-    logError('initializeAgentDiscovery', err);
-  }
-}
-
-// Start immediately but don't wait for it
 const startTime = Date.now();
-initializeAgentDiscovery().then(() => {
+initializeAgentDiscovery(discoveredAgents, rootDir, logError).then(() => {
+  initializeDescriptors(discoveredAgents);
   console.log('[INIT] initializeAgentDiscovery completed in', Date.now() - startTime, 'ms');
 }).catch(() => {});
 
@@ -666,7 +505,7 @@ function getGeminiOAuthCreds() {
   }
   const oauthRelPath = path.join('node_modules', '@google', 'gemini-cli-core', 'dist', 'src', 'code_assist', 'oauth2.js');
   try {
-    const geminiPath = findCommand('gemini');
+    const geminiPath = findCommand('gemini', rootDir);
     if (geminiPath) {
       const realPath = fs.realpathSync(geminiPath);
       const pkgRoot = path.resolve(path.dirname(realPath), '..');
@@ -1364,6 +1203,9 @@ function sendJSON(req, res, statusCode, data) {
   compressAndSend(req, res, statusCode, 'application/json', JSON.stringify(data));
 }
 
+const _rateLimitMap = new LRUCache({ max: 1000, ttl: 60000 });
+const RATE_LIMIT_MAX = parseInt(process.env.RATE_LIMIT_MAX || '300', 10);
+
 const server = http.createServer(async (req, res) => {
   res.setHeader('Access-Control-Allow-Origin', '*');
   res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
@@ -1371,6 +1213,17 @@ const server = http.createServer(async (req, res) => {
   if (req.method === 'OPTIONS') { res.writeHead(200); res.end(); return; }
   if (req.headers.upgrade && req.headers.upgrade.toLowerCase() === 'websocket') return;
 
+  const clientIp = req.headers['x-forwarded-for']?.split(',')[0]?.trim() || req.socket.remoteAddress;
+  const hits = (_rateLimitMap.get(clientIp) || 0) + 1;
+  _rateLimitMap.set(clientIp, hits);
+  res.setHeader('X-RateLimit-Limit', RATE_LIMIT_MAX);
+  res.setHeader('X-RateLimit-Remaining', Math.max(0, RATE_LIMIT_MAX - hits));
+  if (hits > RATE_LIMIT_MAX) {
+    res.writeHead(429, { 'Retry-After': '60' });
+    res.end('Too Many Requests');
+    return;
+  }
+
   const _pwd = process.env.PASSWORD;
   if (_pwd) {
     const _auth = req.headers['authorization'] || '';
@@ -1437,6 +1290,20 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    if (pathOnly === '/api/health' && req.method === 'GET') {
+      sendJSON(req, res, 200, {
+        status: 'ok',
+        version: PKG_VERSION,
+        uptime: process.uptime(),
+        agents: discoveredAgents.length,
+        activeExecutions: activeExecutions.size,
+        wsClients: wss.clients.size,
+        memory: process.memoryUsage(),
+        acp: getACPStatus()
+      });
+      return;
+    }
+
     if (pathOnly === '/api/conversations' && req.method === 'GET') {
       const conversations = queries.getConversationsList();
       // Filter out stale streaming state using a single bulk query instead of N+1 per-conversation queries
@@ -2426,7 +2293,7 @@ const server = http.createServer(async (req, res) => {
         const localResult = queries.searchAgents(discoveredAgents, body);
         
         // Get external agents from ACP servers
-        const externalAgents = await discoverExternalACPServers();
+        const externalAgents = await discoverExternalACPServers(discoveredAgents);
         const externalResult = queries.searchAgents(externalAgents, body);
         
         // Combine results

package/static/app.js

@@ -749,4 +749,82 @@ function downloadScreenshot() {
   console.log('Download screenshot not yet implemented');
 }
 
+function showShortcutsOverlay() {
+  if (document.querySelector('.shortcuts-overlay')) return;
+  const overlay = document.createElement('div');
+  overlay.className = 'shortcuts-overlay';
+  overlay.innerHTML = `<div class="shortcuts-panel">
+    <h3>Keyboard Shortcuts</h3>
+    <table>
+      <tr><td><kbd>Ctrl</kbd>+<kbd>N</kbd></td><td>New conversation</td></tr>
+      <tr><td><kbd>Ctrl</kbd>+<kbd>B</kbd></td><td>Toggle sidebar</td></tr>
+      <tr><td><kbd>Ctrl</kbd>+<kbd>Enter</kbd></td><td>Send message</td></tr>
+      <tr><td><kbd>Escape</kbd></td><td>Cancel stream / blur input</td></tr>
+      <tr><td><kbd>?</kbd></td><td>Show this help</td></tr>
+    </table>
+    <p style="margin:1rem 0 0;font-size:0.75rem;color:#9ca3af;">Press Escape to close</p>
+  </div>`;
+  overlay.addEventListener('click', (e) => { if (e.target === overlay) overlay.remove(); });
+  document.body.appendChild(overlay);
+}
+
+document.addEventListener('keydown', (e) => {
+  if (e.key === '?' && !e.ctrlKey && !e.metaKey) {
+    const tag = document.activeElement?.tagName;
+    if (tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT') return;
+    e.preventDefault();
+    showShortcutsOverlay();
+  }
+  if (e.key === 'Escape' && document.querySelector('.shortcuts-overlay')) {
+    document.querySelector('.shortcuts-overlay').remove();
+  }
+});
+
+(function initSidebarSearch() {
+  const input = document.getElementById('sidebarSearchInput');
+  if (!input) return;
+  let debounceTimer;
+  input.addEventListener('input', () => {
+    clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      const query = input.value.trim();
+      const list = document.querySelector('[data-conversation-list]');
+      if (!list) return;
+      const items = list.querySelectorAll('li[data-conv-id]');
+      if (!query) {
+        items.forEach(li => li.style.display = '');
+        return;
+      }
+      const lower = query.toLowerCase();
+      items.forEach(li => {
+        const text = li.textContent.toLowerCase();
+        li.style.display = text.includes(lower) ? '' : 'none';
+      });
+    }, 150);
+  });
+})();
+
+(function initErrorBoundary() {
+  let toastEl = null;
+  let hideTimer = null;
+  function showErrorToast(title, detail) {
+    if (toastEl) toastEl.remove();
+    toastEl = document.createElement('div');
+    toastEl.className = 'error-toast';
+    toastEl.innerHTML = `<div class="error-toast-title">${title}</div><div class="error-toast-detail">${detail}</div>`;
+    toastEl.addEventListener('click', () => { toastEl.remove(); toastEl = null; });
+    document.body.appendChild(toastEl);
+    clearTimeout(hideTimer);
+    hideTimer = setTimeout(() => { if (toastEl) { toastEl.remove(); toastEl = null; } }, 8000);
+  }
+  window.addEventListener('error', (e) => {
+    if (e.filename) showErrorToast('JavaScript Error', `${e.message} at ${e.filename.split('/').pop()}:${e.lineno}`);
+  });
+  window.addEventListener('unhandledrejection', (e) => {
+    const msg = e.reason?.message || String(e.reason || 'Unknown');
+    showErrorToast('Unhandled Promise Rejection', msg);
+  });
+  window.showErrorToast = showErrorToast;
+})();
+
 window.addEventListener('load', initializeApp);

package/static/css/main.css

@@ -3054,4 +3054,108 @@
     html.dark .html-rendered-container {
       border-color: #262626;
     }
+
+    .sidebar-search-bar {
+      padding: 0.25rem 0.75rem 0.5rem;
+    }
+    .sidebar-search-input {
+      width: 100%;
+      padding: 0.375rem 0.5rem;
+      border: 1px solid #d1d5db;
+      border-radius: 0.375rem;
+      background: #f9fafb;
+      color: #111827;
+      font-size: 0.8125rem;
+      outline: none;
+      box-sizing: border-box;
+    }
+    .sidebar-search-input:focus {
+      border-color: #3b82f6;
+      box-shadow: 0 0 0 2px rgba(59,130,246,0.15);
+    }
+    html.dark .sidebar-search-input {
+      background: #1f2937;
+      border-color: #374151;
+      color: #e5e7eb;
+    }
+
+    .shortcuts-overlay {
+      position: fixed;
+      inset: 0;
+      background: rgba(0,0,0,0.5);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      z-index: 9999;
+    }
+    .shortcuts-panel {
+      background: white;
+      border-radius: 0.75rem;
+      padding: 1.5rem;
+      max-width: 400px;
+      width: 90%;
+      box-shadow: 0 25px 50px rgba(0,0,0,0.25);
+    }
+    html.dark .shortcuts-panel {
+      background: #1f2937;
+      color: #e5e7eb;
+    }
+    .shortcuts-panel h3 {
+      margin: 0 0 1rem;
+      font-size: 1.125rem;
+    }
+    .shortcuts-panel table {
+      width: 100%;
+      border-collapse: collapse;
+    }
+    .shortcuts-panel td {
+      padding: 0.375rem 0;
+      font-size: 0.875rem;
+    }
+    .shortcuts-panel td:first-child {
+      font-weight: 600;
+      white-space: nowrap;
+      padding-right: 1rem;
+    }
+    .shortcuts-panel kbd {
+      background: #f3f4f6;
+      border: 1px solid #d1d5db;
+      border-radius: 0.25rem;
+      padding: 0.125rem 0.375rem;
+      font-size: 0.75rem;
+      font-family: inherit;
+    }
+    html.dark .shortcuts-panel kbd {
+      background: #374151;
+      border-color: #4b5563;
+    }
+
+    .error-toast {
+      position: fixed;
+      bottom: 1rem;
+      right: 1rem;
+      background: #dc2626;
+      color: white;
+      padding: 0.75rem 1rem;
+      border-radius: 0.5rem;
+      font-size: 0.875rem;
+      max-width: 400px;
+      z-index: 9998;
+      box-shadow: 0 10px 25px rgba(0,0,0,0.2);
+      cursor: pointer;
+      animation: slideInRight 0.2s ease-out;
+    }
+    .error-toast-title {
+      font-weight: 600;
+      margin-bottom: 0.25rem;
+    }
+    .error-toast-detail {
+      opacity: 0.85;
+      font-size: 0.8125rem;
+      word-break: break-word;
+    }
+    @keyframes slideInRight {
+      from { transform: translateX(100%); opacity: 0; }
+      to { transform: translateX(0); opacity: 1; }
+    }
 

package/static/index.html

@@ -21,7 +21,7 @@
     })();
   </script>
 
-    <link rel="stylesheet" href="/gm/css/main.css">
+    <link rel="stylesheet" href="/gm/css/main.css">
   <link rel="stylesheet" href="/gm/css/tools-popup.css">
 </head>
 <body>
@@ -39,6 +39,9 @@
           <button id="newConversationBtn" class="sidebar-new-btn" data-new-conversation title="Start new conversation">+ New</button>
         </div>
       </div>
+      <div class="sidebar-search-bar" id="sidebarSearchBar">
+        <input type="text" class="sidebar-search-input" id="sidebarSearchInput" placeholder="Search conversations..." autocomplete="off" spellcheck="false">
+      </div>
       <div class="clone-input-bar" id="cloneInputBar" style="display:none;">
         <input type="text" class="clone-input" id="cloneRepoInput" placeholder="org/repo" autocomplete="off" spellcheck="false">
         <button class="clone-go-btn" id="cloneGoBtn" title="Clone">Go</button>