agentgui 1.0.639 → 1.0.641

package/lib/claude-runner.js

@@ -10,8 +10,8 @@ function getSpawnOptions(cwd, additionalOptions = {}) {
   if (!options.env) {
     options.env = { ...process.env };
   }
-  // Allow spawning claude inside another claude session
-  delete options.env.CLAUDECODE;
+  // Keep CLAUDECODE for plugin support (gm plugin requires this)
+  // Don't delete it as it prevents plugins from loading
   return options;
 }
 
@@ -613,7 +613,7 @@ registry.register({
   closeStdin: true, // must close stdin or claude 2.1.72 hangs waiting for input in --print mode
   useJsonRpcStdin: false,
   supportedFeatures: ['streaming', 'resume', 'system-prompt', 'permissions-skip'],
-  spawnEnv: { MAX_THINKING_TOKENS: '0', AGENTGUI_SUBPROCESS: '1' },
+  spawnEnv: { MAX_THINKING_TOKENS: '0' },
 
   buildArgs(prompt, config) {
     const {

package/lib/ws-handlers-conv.js

@@ -5,7 +5,7 @@ function notFound(msg = 'Not found') { fail(404, msg); }
 
 export function register(router, deps) {
   const { queries, activeExecutions, messageQueues, rateLimitState,
-    broadcastSync, processMessageWithStreaming, activeProcessesByConvId } = deps;
+    broadcastSync, processMessageWithStreaming, activeProcessesByConvId, steeringTimeouts } = deps;
 
   router.handle('conv.ls', () => {
     const conversations = queries.getConversationsList();
@@ -118,7 +118,11 @@ export function register(router, deps) {
     if (!conv) notFound('Conversation not found');
     if (!p.content) fail(400, 'Missing content');
     const entry = activeExecutions.get(p.id);
-    if (!entry) fail(409, 'No active execution to steer');
+    if (!entry) {
+      // Allow steering if we still have a process, even if execution entry is gone
+      const proc = activeProcessesByConvId.get(p.id);
+      if (!proc || !proc.stdin) fail(409, 'No active execution to steer');
+    }
     const proc = activeProcessesByConvId.get(p.id);
     if (!proc || !proc.stdin) fail(409, 'Process not available for steering');
 
@@ -129,7 +133,7 @@ export function register(router, deps) {
     try {
       // Send steering prompt using JSON-RPC format so agent processes it immediately
       // Get the active session ID from the entry
-      const sessionId = entry.sessionId;
+      const sessionId = entry?.sessionId || queries.getConversation(p.id)?.sessionId;
 
       // Send JSON-RPC prompt request with requestId for tracking
       const promptRequest = {
@@ -143,6 +147,19 @@ export function register(router, deps) {
       };
 
       proc.stdin.write(JSON.stringify(promptRequest) + '\n');
+
+      // Clear the steering cleanup timeout so process stays alive longer
+      const timeout = steeringTimeouts.get(p.id);
+      if (timeout) {
+        clearTimeout(timeout);
+        // Set a new timeout (another 30 seconds for follow-up steers)
+        const newTimeout = setTimeout(() => {
+          activeProcessesByConvId.delete(p.id);
+          steeringTimeouts.delete(p.id);
+        }, 30000);
+        steeringTimeouts.set(p.id, newTimeout);
+      }
+
       return { ok: true, steered: true, conversationId: p.id, messageId: message.id };
     } catch (err) {
       fail(500, `Failed to steer: ${err.message}`);

package/lib/ws-handlers-session.js

@@ -74,6 +74,7 @@ export function register(router, deps) {
   const { db, discoveredAgents, modelCache,
     getAgentDescriptor, activeScripts, broadcastSync, startGeminiOAuth,
     geminiOAuthState } = deps;
+  console.log('[ws-handlers-session] register() called with discoveredAgents.length:', discoveredAgents.length);
 
   router.handle('sess.get', (p) => {
     const sess = db.getSession(p.id);
@@ -101,12 +102,16 @@ export function register(router, deps) {
     return { sessionId: p.id, events: [], total: 0, limit, offset, hasMore: false, metadata: { status: 'pending', startTime: Date.now(), duration: 0, eventCount: 0 } };
   });
 
-  router.handle('agent.ls', () => ({
-    agents: discoveredAgents.map(a => ({
-      id: a.id, name: a.name, icon: a.icon, path: a.path,
-      protocol: a.protocol || 'unknown', description: a.description || '', status: 'available'
-    }))
-  }));
+  router.handle('agent.ls', () => {
+    console.log('[agent.ls] discoveredAgents.length:', discoveredAgents.length);
+    console.log('[agent.ls] agent IDs:', discoveredAgents.map(a => a.id).join(', '));
+    return {
+      agents: discoveredAgents.map(a => ({
+        id: a.id, name: a.name, icon: a.icon, path: a.path,
+        protocol: a.protocol || 'unknown', description: a.description || '', status: 'available'
+      }))
+    };
+  });
   // Note: agent.subagents is handled by ws-handlers-util.js which is registered after this file
   // Keeping this note to avoid duplicate handler registration
 

package/lib/ws-handlers-util.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-import { execSync, spawn } from 'child_process';
+import { execSync, spawn, spawnSync } from 'child_process';
 
 function err(code, message) { const e = new Error(message); e.code = code; throw e; }
 
@@ -13,10 +13,8 @@ export function register(router, deps) {
 
   router.handle('home', () => ({ home: os.homedir(), cwd: STARTUP_CWD }));
 
-  router.handle('agent.ls', () => {
-    const agents = discoveredAgents || [];
-    return { agents };
-  });
+  // NOTE: agent.ls is handled by ws-handlers-session.js to ensure proper agent mapping
+  // Do not re-register here as it will override the session handler
 
   router.handle('folders', (p) => {
     const folderPath = p.path || STARTUP_CWD;
@@ -270,65 +268,48 @@ export function register(router, deps) {
     }
   });
 
-  router.handle('agent.subagents', async (p) => {
-    const { id } = p;
-    if (!id) err(400, 'Missing agent id');
-
-    // For Claude Code, read skills from ~/.claude/skills directory
-    if (id === 'cli-claude') {
-      const skillsDir = path.join(os.homedir(), '.claude', 'skills');
-      try {
-        const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
-        const skills = entries
-          .filter(e => e.isDirectory() || e.isSymbolicLink())
-          .map(e => {
-            // Try to read SKILL.md to get the actual name
-            const md = path.join(skillsDir, e.name, 'SKILL.md');
-            let name = e.name;
-            try {
-              const content = fs.readFileSync(md, 'utf-8');
-              const m = content.match(/^name:\s*(.+)$/m);
-              if (m) name = m[1].trim();
-            } catch (_) {
-              // Fallback: format the directory name as the skill name
-              name = e.name
-                .split(/[\-_]/)
-                .map(w => w.charAt(0).toUpperCase() + w.slice(1))
-                .join(' ');
-            }
-            return { id: e.name, name };
-          })
-          .sort((a, b) => a.name.localeCompare(b.name));
-
-        if (skills.length > 0) {
-          console.log(`[agent.subagents] Found ${skills.length} Claude Code skills:`, skills.map(s => s.name).join(', '));
-          return { subAgents: skills };
-        }
-        return { subAgents: [] };
-      } catch (err) {
-        console.error(`[agent.subagents] Error reading skills directory:`, err.message);
-        return { subAgents: [] };
-      }
-    }
-
-    // Map CLI agent IDs to their corresponding plugin sub-agents
-    const subAgentMap = {
-      'cli-opencode': [{ id: 'gm-oc', name: 'GM OpenCode' }],
-      'cli-gemini': [{ id: 'gm-gc', name: 'GM Gemini' }],
-      'cli-kilo': [{ id: 'gm-kilo', name: 'GM Kilo' }],
-      'cli-codex': []
-    };
-
-    const subAgents = subAgentMap[id] || [];
-
-    // Filter to only installed sub-agents
-    try {
-      const tools = await toolManager.getAllToolsAsync();
-      const installedPlugins = new Set(tools.filter(t => t.category === 'plugin' && t.installed).map(t => t.id));
-      const availableSubAgents = subAgents.filter(sa => installedPlugins.has(sa.id));
-      return { subAgents: availableSubAgents };
-    } catch (e) {
-      return { subAgents };
-    }
+  router.handle('agent.subagents', async (p) => {
+    const { id } = p;
+    if (!id) err(400, 'Missing agent id');
+
+    // Claude Code: run 'claude agents list' and parse output
+    if (id === 'claude-code' || id === 'cli-claude') {
+      const spawnEnv = { ...process.env };
+      delete spawnEnv.CLAUDECODE;
+      const result = spawnSync('claude', ['agents', 'list'], {
+        encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'],
+        env: spawnEnv
+      });
+      if (result.status !== 0 || !result.stdout) return { subAgents: [] };
+      const output = result.stdout.trim();
+      // Output format: '  agentId · model' lines under section headers
+      const agents = [];
+      for (const line of output.split('
+')) {
+        const match = line.match(/^s{2}(S+)s+·/);
+        if (match) {
+          const id = match[1];
+          agents.push({ id, name: id });
+        }
+      }
+      console.log('[agent.subagents] claude agents list found:', agents.map(a => a.id).join(', '));
+      return { subAgents: agents };
+    }
+
+    // ACP agents: hardcoded map filtered by installed tools
+    const subAgentMap = {
+      'opencode':     [{ id: 'gm-oc',   name: 'GM OpenCode' }],
+      'cli-opencode': [{ id: 'gm-oc',   name: 'GM OpenCode' }],
+      'gemini':       [{ id: 'gm-gc',   name: 'GM Gemini'   }],
+      'cli-gemini':   [{ id: 'gm-gc',   name: 'GM Gemini'   }],
+      'kilo':         [{ id: 'gm-kilo', name: 'GM Kilo'     }],
+      'cli-kilo':     [{ id: 'gm-kilo', name: 'GM Kilo'     }],
+      'codex':        [],
+      'cli-codex':    []
+    };
+    const subAgents = subAgentMap[id] || [];
+    const tools = await toolManager.getAllToolsAsync();
+    const installed = new Set(tools.filter(t => t.category === 'plugin' && t.installed).map(t => t.id));
+    return { subAgents: subAgents.filter(sa => installed.has(sa.id)) };
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.639",
+  "version": "1.0.641",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -300,6 +300,7 @@ const messageQueues = new Map();
 const rateLimitState = new Map();
 const activeProcessesByRunId = new Map();
 const activeProcessesByConvId = new Map(); // Store process handles by conversationId for steering
+const steeringTimeouts = new Map(); // Track timeout handles for process cleanup
 const acpQueries = queries;
 const checkpointManager = new CheckpointManager(queries);
 const STUCK_AGENT_THRESHOLD_MS = 600000;
@@ -512,6 +513,29 @@ function discoverAgents() {
       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)`);
+    }
+  }
+  console.log('[discoverAgents] Final agent count:', agents.length, 'Agent IDs:', agents.map(a => a.id).join(', '));
+
   return agents;
 }
 
@@ -533,16 +557,23 @@ initializeDescriptors(discoveredAgents);
 // Agent discovery happens asynchronously in background to not block startup
 async function initializeAgentDiscovery() {
   try {
-    discoveredAgents = discoverAgents();
+    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 })));
+    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);
   }
 }
 
 // Start immediately but don't wait for it
-initializeAgentDiscovery().catch(() => {});
+const startTime = Date.now();
+initializeAgentDiscovery().then(() => {
+  console.log('[INIT] initializeAgentDiscovery completed in', Date.now() - startTime, 'ms');
+}).catch(() => {});
 
 const modelCache = new Map();
 
@@ -1878,6 +1909,7 @@ const server = http.createServer(async (req, res) => {
     }
 
     if (pathOnly === '/api/agents' && req.method === 'GET') {
+      console.log(`[API /api/agents] Returning ${discoveredAgents.length} agents:`, discoveredAgents.map(a => a.id).join(', '));
             sendJSON(req, res, 200, { agents: discoveredAgents });
       return;
     }
@@ -3936,7 +3968,12 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
     }
 
     activeExecutions.delete(conversationId);
-    activeProcessesByConvId.delete(conversationId);
+    // Keep process alive for steering for up to 30 seconds after execution completes
+    const steeringTimeout = setTimeout(() => {
+      activeProcessesByConvId.delete(conversationId);
+      steeringTimeouts.delete(conversationId);
+    }, 30000);
+    steeringTimeouts.set(conversationId, steeringTimeout);
     batcher.drain();
     debugLog(`[stream] Claude returned ${outputs.length} outputs, sessionId=${claudeSessionId}`);
 
@@ -4281,14 +4318,16 @@ const wsRouter = new WsRouter();
 
 registerConvHandlers(wsRouter, {
   queries, activeExecutions, messageQueues, rateLimitState,
-  broadcastSync, processMessageWithStreaming, activeProcessesByConvId
+  broadcastSync, processMessageWithStreaming, activeProcessesByConvId, steeringTimeouts
 });
 
+console.log('[INIT] About to call registerSessionHandlers, discoveredAgents.length:', discoveredAgents.length);
 registerSessionHandlers(wsRouter, {
   db: queries, discoveredAgents, modelCache,
   getAgentDescriptor, activeScripts, broadcastSync,
   startGeminiOAuth, geminiOAuthState: () => geminiOAuthState
 });
+console.log('[INIT] registerSessionHandlers completed');
 
 registerRunHandlers(wsRouter, {
   queries, discoveredAgents, activeExecutions, activeProcessesByRunId,

package/static/index.html

@@ -1120,9 +1120,6 @@
       .message { max-width: 95%; }
       .messages-wrapper { padding: 0.375rem 0.5rem; }
       .input-section { padding: 0.5rem; padding-bottom: calc(0.5rem + env(safe-area-inset-bottom)); }
-      .cli-selector { display: none !important; }
-      .sub-agent-selector { display: none !important; }
-      .model-selector { display: none !important; }
     }
 
     /* ===== SCROLLBAR STYLING ===== */

package/static/js/client.js

@@ -442,6 +442,11 @@ class AgentGUIClient {
 
     if (this.ui.agentSelector) {
       this.ui.agentSelector.addEventListener('change', () => {
+        // Load models for the selected sub-agent
+        const selectedSubAgentId = this.ui.agentSelector.value;
+        if (selectedSubAgentId) {
+          this.loadModelsForAgent(selectedSubAgentId);
+        }
         if (!this._agentLocked) {
           this.saveAgentAndModelToConversation();
         }
@@ -2068,13 +2073,34 @@ class AgentGUIClient {
           .join('');
         this.ui.agentSelector.style.display = 'inline-block';
         console.log(`[Agent Selector] Loaded ${subAgents.length} sub-agents for ${cliAgentId}`);
-        this.loadModelsForAgent(cliAgentId);
+        // Auto-select first sub-agent and load its models
+        const firstSubAgentId = subAgents[0].id;
+        this.ui.agentSelector.value = firstSubAgentId;
+        this.loadModelsForAgent(firstSubAgentId);
       } else {
         console.log(`[Agent Selector] No sub-agents found for ${cliAgentId}`);
+        // Load models for the CLI agent itself (fallback for agents without sub-agents)
+        const cliToAcpMap = {
+          'cli-opencode': 'opencode',
+          'cli-gemini': 'gemini',
+          'cli-kilo': 'kilo',
+          'cli-codex': 'codex'
+        };
+        const acpAgentId = cliToAcpMap[cliAgentId] || cliAgentId;
+        this.loadModelsForAgent(acpAgentId);
       }
     } catch (err) {
       // No sub-agents available for this CLI tool — keep hidden
       console.warn(`[Agent Selector] Failed to load sub-agents for ${cliAgentId}:`, err.message);
+      // Fallback: load models for the corresponding ACP agent
+      const cliToAcpMap = {
+        'cli-opencode': 'opencode',
+        'cli-gemini': 'gemini',
+        'cli-kilo': 'kilo',
+        'cli-codex': 'codex'
+      };
+      const acpAgentId = cliToAcpMap[cliAgentId] || cliAgentId;
+      this.loadModelsForAgent(acpAgentId);
     }
   }