agentgui 1.0.721 → 1.0.723

package/lib/jsonl-watcher.js

@@ -12,10 +12,11 @@ export class JsonlWatcher {
     this._owned = ownedSessionIds;
     this._tails = new Map();
     this._convMap = new Map();
-    this._frags = new Map();
+    this._emitted = new Map();
     this._timers = new Map();
     this._seqs = new Map();
     this._streaming = new Set();
+    this._sessions = new Map();
     this._watcher = null;
   }
 
@@ -42,7 +43,8 @@ export class JsonlWatcher {
       this._convMap.delete(sid);
       this._seqs.delete(sid);
       this._streaming.delete(sid);
-      for (const key of [...this._frags.keys()]) if (key.startsWith(`${sid}:`)) this._frags.delete(key);
+      this._sessions.delete(sid);
+      for (const key of [...this._emitted.keys()]) if (key.startsWith(`${sid}:`)) this._emitted.delete(key);
       for (const [fp, s] of this._tails.entries()) {
         if (!fp.includes(sid)) continue;
         if (s.fd !== null) try { fs.closeSync(s.fd); } catch (_) {}
@@ -56,8 +58,9 @@ export class JsonlWatcher {
   removeAllConversations() {
     for (const s of this._tails.values()) if (s.fd !== null) try { fs.closeSync(s.fd); } catch (_) {}
     for (const t of this._timers.values()) clearTimeout(t);
-    this._tails.clear(); this._convMap.clear(); this._frags.clear();
+    this._tails.clear(); this._convMap.clear(); this._emitted.clear();
     this._timers.clear(); this._seqs.clear(); this._streaming.clear();
+    this._sessions.clear();
   }
 
   _scanDir(dir, depth) {
@@ -114,7 +117,8 @@ export class JsonlWatcher {
     if (this._convMap.has(sid)) return this._convMap.get(sid);
     const found = this._q.getConversations().find(c => c.claudeSessionId === sid);
     if (found) { this._convMap.set(sid, found.id); return found.id; }
-    if (e.type !== 'user' || e.isMeta) return null;
+    if (e.type === 'queue-operation' || e.type === 'last-prompt') return null;
+    if (e.type === 'user' && e.isMeta) return null;
     const cwd = e.cwd || process.cwd();
     const branch = e.gitBranch || '';
     const base = path.basename(cwd);
@@ -128,28 +132,60 @@ export class JsonlWatcher {
 
   _seq(sid) { const n = (this._seqs.get(sid) || 0) + 1; this._seqs.set(sid, n); return n; }
 
+  _dbSession(cid, sid) {
+    if (this._sessions.has(sid)) return this._sessions.get(sid);
+    const sess = this._q.createSession(cid);
+    this._q.updateSession(sess.id, { status: 'active' });
+    this._sessions.set(sid, sess.id);
+    return sess.id;
+  }
+
   _emit(cid, sid, block, role, extra) {
-    this._bc({ type: 'streaming_progress', sessionId: sid, conversationId: cid, block, blockRole: role, seq: this._seq(sid), timestamp: Date.now(), ...extra });
+    const dbSid = this._dbSession(cid, sid);
+    const seq = this._seq(sid);
+    try { this._q.createChunk(dbSid, cid, seq, block.type || 'unknown', block); } catch (_) {}
+    this._bc({ type: 'streaming_progress', sessionId: dbSid, conversationId: cid, block, blockRole: role, seq, timestamp: Date.now(), ...extra });
+  }
+
+  _emitBlocks(cid, sid, blocks, role) {
+    for (const b of blocks) {
+      if (!b || !b.type) continue;
+      this._emit(cid, sid, b, role);
+    }
   }
 
   _startStreaming(cid, sid) {
     if (this._streaming.has(sid)) return;
     this._streaming.add(sid);
-    this._bc({ type: 'streaming_start', sessionId: sid, conversationId: cid, agentId: 'cli-claude', timestamp: Date.now() });
+    const dbSid = this._dbSession(cid, sid);
+    this._q.setIsStreaming(cid, true);
+    this._bc({ type: 'streaming_start', sessionId: dbSid, conversationId: cid, agentId: 'cli-claude', timestamp: Date.now() });
   }
 
   _endStreaming(cid, sid) {
     if (!this._streaming.has(sid)) return;
     this._streaming.delete(sid);
-    this._bc({ type: 'streaming_complete', sessionId: sid, conversationId: cid, agentId: 'cli-claude', eventCount: 0, seq: this._seq(sid), timestamp: Date.now() });
+    const dbSid = this._sessions.get(sid);
+    if (dbSid) {
+      try { this._q.updateSession(dbSid, { status: 'completed', completed_at: Date.now() }); } catch (_) {}
+    }
+    this._q.setIsStreaming(cid, false);
+    this._bc({ type: 'streaming_complete', sessionId: dbSid || sid, conversationId: cid, agentId: 'cli-claude', eventCount: 0, seq: this._seq(sid), timestamp: Date.now() });
+    this._sessions.delete(sid);
   }
 
   _route(cid, sid, e) {
-    if (e.type === 'queue-operation' || (e.type === 'user' && e.isMeta)) return;
+    if (e.type === 'queue-operation' || e.type === 'last-prompt' || (e.type === 'user' && e.isMeta)) return;
+
+    if (e.isApiErrorMessage && e.error === 'rate_limit') {
+      this._bc({ type: 'streaming_error', sessionId: this._sessions.get(sid) || sid, conversationId: cid, error: 'Rate limit hit', recoverable: true, timestamp: Date.now() });
+      return;
+    }
 
     if (e.type === 'system') {
       if (e.subtype === 'init') { this._startStreaming(cid, sid); return; }
       if (e.subtype === 'turn_duration' || e.subtype === 'stop_hook_summary') { this._endStreaming(cid, sid); return; }
+      this._startStreaming(cid, sid);
       this._emit(cid, sid, { type: 'system', subtype: e.subtype, model: e.model, cwd: e.cwd, tools: e.tools, preTokens: e.compactMetadata?.preTokens }, 'system');
       return;
     }
@@ -157,32 +193,53 @@ export class JsonlWatcher {
     if (e.type === 'assistant' && e.message?.content) {
       this._startStreaming(cid, sid);
       const key = `${sid}:${e.message.id}`;
-      const prevCount = this._frags.get(key)?.message?.content?.length || 0;
-      const newBlocks = e.message.content.slice(prevCount);
-      if (e.message.stop_reason === null || e.message.stop_reason === undefined) this._frags.set(key, e);
-      else this._frags.delete(key);
-      for (const b of newBlocks) this._emit(cid, sid, b, 'assistant');
+      const prev = this._emitted.get(key) || 0;
+      const content = e.message.content;
+      const newBlocks = content.slice(prev);
+      if (newBlocks.length > 0) {
+        this._emitted.set(key, content.length);
+        this._emitBlocks(cid, sid, newBlocks, 'assistant');
+      }
+      if (e.message.stop_reason) this._emitted.delete(key);
       return;
     }
 
     if (e.type === 'user' && e.message?.content) {
       if (e.isCompactSummary) { this._emit(cid, sid, { type: 'compact_summary', content: e.message.content }, 'system'); return; }
       this._startStreaming(cid, sid);
-      const blocks = Array.isArray(e.message.content) ? e.message.content : [];
+      const content = e.message.content;
+      const textParts = Array.isArray(content)
+        ? content.filter(b => b.type === 'text' && b.text && !b.text.startsWith('<task-notification>')).map(b => b.text).join('\n')
+        : (typeof content === 'string' && !content.startsWith('<task-notification>') ? content : '');
+      if (textParts) {
+        try { this._q.createMessage(cid, 'user', textParts); } catch (_) {}
+      }
+      const blocks = Array.isArray(content) ? content : [];
       for (const b of blocks) if (b.type === 'tool_result') this._emit(cid, sid, b, 'tool_result');
       return;
     }
 
     if (e.type === 'progress') {
       this._startStreaming(cid, sid);
-      const dataType = e.data?.type || e.subtype || 'progress';
-      const content = dataType === 'agent_progress' ? e.data?.message : (e.data || e.content);
-      this._emit(cid, sid, { type: dataType, agentId: e.agentId, content }, 'progress');
-      return;
-    }
-
-    if (e.isApiErrorMessage && e.error === 'rate_limit') {
-      this._bc({ type: 'streaming_error', sessionId: sid, conversationId: cid, error: 'Rate limit hit', recoverable: true, timestamp: Date.now() });
+      const d = e.data || {};
+      if (d.type === 'agent_progress') {
+        const inner = d.message?.message || d.message;
+        const content = inner?.content;
+        if (Array.isArray(content)) {
+          const role = inner.role === 'user' ? 'tool_result' : 'assistant';
+          this._emitBlocks(cid, sid, content, role);
+        }
+        return;
+      }
+      if (d.type === 'hook_progress') {
+        this._emit(cid, sid, { type: 'hook_progress', hookEvent: d.hookEvent, hookName: d.hookName }, 'system');
+        return;
+      }
+      if (d.type === 'mcp_progress') {
+        this._emit(cid, sid, { type: 'mcp_progress', status: d.status, serverName: d.serverName, toolName: d.toolName }, 'system');
+        return;
+      }
+      this._emit(cid, sid, { type: d.type || e.subtype || 'progress', content: e.content || d }, 'progress');
       return;
     }
 

package/lib/plugin-loader.js

@@ -1,162 +1,188 @@
-import fs from 'fs';
-import path from 'path';
-import { EventEmitter } from 'events';
-
-class PluginLoader extends EventEmitter {
-  constructor(pluginDir) {
-    super();
-    this.pluginDir = pluginDir;
-    this.registry = new Map();
-    this.instances = new Map();
-    this.states = new Map();
-    this.watchers = new Map();
-    this.errorCounts = new Map();
-    this.fileMap = new Map();
-  }
-
-  async loadPlugin(fileName) {
-    const filePath = path.join(this.pluginDir, `${fileName}.js`);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`Plugin file not found: ${filePath}`);
-    }
-    const fileUrl = `file://${filePath}?v=${Date.now()}`;
-    try {
-      const plugin = await import(fileUrl);
-      const mod = plugin.default || plugin;
-      const regName = mod.name || fileName;
-      this.registry.set(regName, mod);
-      this.fileMap.set(regName, fileName);
-      return mod;
-    } catch (error) {
-      console.error(`Failed to load plugin ${fileName}:`, error.message);
-      throw error;
-    }
-  }
-
-  async initializePlugin(name, config) {
-    const plugin = this.registry.get(name);
-    if (!plugin) {
-      throw new Error(`Plugin ${name} not found in registry`);
-    }
-    if (this.instances.has(name)) {
-      return this.instances.get(name);
-    }
-    for (const depName of (plugin.dependencies || [])) {
-      if (!this.instances.has(depName)) {
-        await this.initializePlugin(depName, config);
-      }
-    }
-    try {
-      const result = await plugin.init(config, this.instances);
-      this.instances.set(name, result);
-      return result;
-    } catch (error) {
-      console.error(`[PluginLoader] Error initializing ${name}:`, error.message);
-      throw error;
-    }
-  }
-
-  get(name) {
-    return this.instances.get(name);
-  }
-
-  async reloadPlugin(name) {
-    const plugin = this.registry.get(name);
-    if (!plugin) {
-      console.warn(`[PluginLoader] Cannot reload ${name}: not found`);
-      return;
-    }
-    const state = this.instances.get(name);
-    if (!state) {
-      console.warn(`[PluginLoader] Cannot reload ${name}: not initialized`);
-      return;
-    }
-    try {
-      if (state.stop) await state.stop();
-      const fileName = this.fileMap.get(name) || name;
-      await this.loadPlugin(fileName);
-      const reloadedPlugin = this.registry.get(name);
-      const newState = await reloadedPlugin.reload(state);
-      this.instances.set(name, newState);
-      this.emit('reload', { name, success: true });
-      console.log(`[PluginLoader] Reloaded plugin: ${name}`);
-    } catch (error) {
-      console.error(`[PluginLoader] Error reloading ${name}:`, error.message);
-      this.emit('reload', { name, success: false, error: error.message });
-    }
-  }
-
-  watchPlugin(name, callback) {
-    const fileName = this.fileMap.get(name) || name;
-    const filePath = path.join(this.pluginDir, `${fileName}.js`);
-    if (this.watchers.has(name)) return;
-    const watcher = fs.watch(filePath, async (eventType) => {
-      if (eventType === 'change') {
-        setTimeout(() => callback(name), 100);
-      }
-    });
-    this.watchers.set(name, watcher);
-  }
-
-  unwatchPlugin(name) {
-    const watcher = this.watchers.get(name);
-    if (watcher) {
-      watcher.close();
-      this.watchers.delete(name);
-    }
-  }
-
-  async loadAllPlugins(config) {
-    if (!fs.existsSync(this.pluginDir)) {
-      fs.mkdirSync(this.pluginDir, { recursive: true });
-      return;
-    }
-    const files = fs.readdirSync(this.pluginDir).filter(f => f.endsWith('.js'));
-    for (const file of files) {
-      const fileName = file.replace('.js', '');
-      try {
-        await this.loadPlugin(fileName);
-      } catch (error) {
-        console.error(`[PluginLoader] Failed to load ${fileName}:`, error.message);
-      }
-    }
-    const sorted = this.topologicalSort();
-    for (const name of sorted) {
-      try {
-        await this.initializePlugin(name, config);
-      } catch (error) {
-        console.error(`[PluginLoader] Failed to initialize ${name}:`, error.message);
-      }
-    }
-  }
-
-  topologicalSort() {
-    const visited = new Set(), result = [];
-    const visit = (name) => {
-      if (visited.has(name)) return;
-      visited.add(name);
-      for (const dep of (this.registry.get(name)?.dependencies || [])) { if (this.registry.has(dep)) visit(dep); }
-      result.push(name);
-    };
-    for (const name of this.registry.keys()) visit(name);
-    return result;
-  }
-
-  async shutdown() {
-    const sorted = this.topologicalSort().reverse();
-    for (const name of sorted) {
-      const state = this.instances.get(name);
-      if (state && state.stop) {
-        try {
-          await state.stop();
-        } catch (error) {
-          console.error(`[PluginLoader] Error stopping ${name}:`, error.message);
-        }
-      }
-      this.unwatchPlugin(name);
-    }
-    this.instances.clear();
-    this.registry.clear();
-  }
-}
-export default PluginLoader;
+// Plugin loader - manages registry, dependencies, hot reload, error isolation
+
+import fs from 'fs';
+import path from 'path';
+import { EventEmitter } from 'events';
+
+class PluginLoader extends EventEmitter {
+  constructor(pluginDir) {
+    super();
+    this.pluginDir = pluginDir;
+    this.registry = new Map(); // name => plugin module
+    this.instances = new Map(); // name => initialized plugin state
+    this.states = new Map(); // name => { routes, wsHandlers, api, ... }
+    this.watchers = new Map(); // name => file watcher
+    this.errorCounts = new Map(); // name => { count, firstTime }
+  }
+
+  // Load plugin module from disk
+  async loadPlugin(name) {
+    const filePath = path.join(this.pluginDir, `${name}.js`);
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`Plugin file not found: ${filePath}`);
+    }
+    // Clear module cache for hot reload (ES modules use import cache differently)
+    const fileUrl = `file://${filePath}?v=${Date.now()}`;
+    try {
+      const plugin = await import(fileUrl);
+      this.registry.set(name, plugin.default || plugin);
+      return plugin.default || plugin;
+    } catch (error) {
+      console.error(`Failed to load plugin ${name}:`, error.message);
+      throw error;
+    }
+  }
+
+  // Initialize plugin and all dependencies
+  async initializePlugin(name, config) {
+    const plugin = this.registry.get(name);
+    if (!plugin) {
+      throw new Error(`Plugin ${name} not found in registry`);
+    }
+
+    // Check if already initialized
+    if (this.instances.has(name)) {
+      return this.instances.get(name);
+    }
+
+    // Initialize dependencies first
+    for (const depName of (plugin.dependencies || [])) {
+      if (!this.instances.has(depName)) {
+        await this.initializePlugin(depName, config);
+      }
+    }
+
+    // Initialize this plugin
+    try {
+      const result = await plugin.init(config, this.instances);
+      this.instances.set(name, result);
+      return result;
+    } catch (error) {
+      console.error(`[PluginLoader] Error initializing ${name}:`, error.message);
+      throw error;
+    }
+  }
+
+  // Get initialized plugin result
+  get(name) {
+    return this.instances.get(name);
+  }
+
+  // Hot reload a plugin
+  async reloadPlugin(name) {
+    const plugin = this.registry.get(name);
+    if (!plugin) {
+      console.warn(`[PluginLoader] Cannot reload ${name}: not found`);
+      return;
+    }
+
+    const state = this.instances.get(name);
+    if (!state) {
+      console.warn(`[PluginLoader] Cannot reload ${name}: not initialized`);
+      return;
+    }
+
+    try {
+      // Stop old instance
+      if (state.stop) await state.stop();
+
+      // Reload plugin module
+      this.loadPlugin(name);
+      const reloadedPlugin = this.registry.get(name);
+
+      // Reinitialize with preserved state
+      const newState = await reloadedPlugin.reload(state);
+      this.instances.set(name, newState);
+      this.emit('reload', { name, success: true });
+      console.log(`[PluginLoader] Reloaded plugin: ${name}`);
+    } catch (error) {
+      console.error(`[PluginLoader] Error reloading ${name}:`, error.message);
+      this.emit('reload', { name, success: false, error: error.message });
+    }
+  }
+
+  // Watch a plugin file for changes
+  watchPlugin(name, callback) {
+    const filePath = path.join(this.pluginDir, `${name}.js`);
+    if (this.watchers.has(name)) {
+      return; // Already watching
+    }
+
+    const watcher = fs.watch(filePath, async (eventType) => {
+      if (eventType === 'change') {
+        setTimeout(() => callback(name), 100); // Debounce
+      }
+    });
+
+    this.watchers.set(name, watcher);
+  }
+
+  // Stop watching a plugin
+  unwatchPlugin(name) {
+    const watcher = this.watchers.get(name);
+    if (watcher) {
+      watcher.close();
+      this.watchers.delete(name);
+    }
+  }
+
+  // Load all plugins from directory
+  async loadAllPlugins(config) {
+    if (!fs.existsSync(this.pluginDir)) {
+      fs.mkdirSync(this.pluginDir, { recursive: true });
+      return;
+    }
+
+    const files = fs.readdirSync(this.pluginDir).filter(f => f.endsWith('.js'));
+    for (const file of files) {
+      const name = file.replace('.js', '');
+      try {
+        await this.loadPlugin(name);
+      } catch (error) {
+        console.error(`[PluginLoader] Failed to load ${name}:`, error.message);
+      }
+    }
+
+    // Initialize in dependency order
+    const sorted = this.topologicalSort();
+    for (const name of sorted) {
+      try {
+        await this.initializePlugin(name, config);
+      } catch (error) {
+        console.error(`[PluginLoader] Failed to initialize ${name}:`, error.message);
+      }
+    }
+  }
+
+  // Topological sort by dependencies
+  topologicalSort() {
+    const visited = new Set(), result = [];
+    const visit = (name) => {
+      if (visited.has(name)) return;
+      visited.add(name);
+      for (const dep of (this.registry.get(name)?.dependencies || [])) { if (this.registry.has(dep)) visit(dep); }
+      result.push(name);
+    };
+    for (const name of this.registry.keys()) visit(name);
+    return result;
+  }
+
+  // Graceful shutdown
+  async shutdown() {
+    const sorted = this.topologicalSort().reverse();
+    for (const name of sorted) {
+      const state = this.instances.get(name);
+      if (state && state.stop) {
+        try {
+          await state.stop();
+        } catch (error) {
+          console.error(`[PluginLoader] Error stopping ${name}:`, error.message);
+        }
+      }
+      this.unwatchPlugin(name);
+    }
+    this.instances.clear();
+    this.registry.clear();
+  }
+}
+export default PluginLoader;

package/lib/plugins/agents-plugin.js

@@ -49,9 +49,10 @@ export default {
               if (!agent) return res.status(404).json({ error: 'Agent not found' });
 
               const session = stream.api.createSession(id);
+              // Use runClaudeWithStreaming instead
               activeExecutions.set(id, { sessionId: session.id });
 
-              res.json({ sessionId: session.id });
+              res.json({ sessionId: session.id, pid: proc.pid });
             } catch (e) {
               res.status(500).json({ error: e.message });
             }

package/lib/plugins/database-plugin.js

@@ -1,6 +1,6 @@
 // Database plugin - SQLite init, schema, checkpoint recovery
 
-import * as dbModule from '../../database.js';
+import * as dbModule from '../database.js';
 
 export default {
   name: 'database',

package/lib/plugins/stream-plugin.js

@@ -8,8 +8,7 @@ export default {
   dependencies: ['database'],
 
   async init(config, plugins) {
-    const dbPlugin = plugins.get('database');
-    const db = dbPlugin?.api || {};
+    const db = plugins.get('database');
     const activeSessions = new Map();
     const pendingMessages = new Map();
     const rateLimitState = new Map();

package/lib/tool-provisioner.js

@@ -38,7 +38,7 @@ export async function autoProvision(TOOLS, statusCache, install, broadcast) {
           broadcast({ type: 'tool_update_failed', toolId: tool.id, data: result });
         }
       } else {
-        log(`${tool.id} v${status.installedVersion || 'unknown'} up-to-date`);
+        log(`${tool.id} v${status.installedVersion} up-to-date`);
         broadcast({ type: 'tool_status_update', toolId: tool.id, data: { installed: true, isUpToDate: true, installedVersion: status.installedVersion, status: 'installed' } });
       }
     } catch (err) {

package/package.json

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

package/server.js

@@ -4479,7 +4479,7 @@ const BROADCAST_TYPES = new Set([
   'streaming_start', 'streaming_progress', 'streaming_complete', 'streaming_error',
   'tool_install_started', 'tool_install_progress', 'tool_install_complete', 'tool_install_failed',
   'tool_update_progress', 'tool_update_complete', 'tool_update_failed',
-  'tool_status_update', 'tool_update_available',
+  'tool_status_update',
   'tools_update_started', 'tools_update_complete', 'tools_refresh_complete',
   'pm2_monit_update', 'pm2_monitoring_started', 'pm2_monitoring_stopped',
   'pm2_list_response', 'pm2_start_response', 'pm2_stop_response',
@@ -5257,7 +5257,7 @@ import PluginLoader from './lib/plugin-loader.js';
 const pluginLoader = new PluginLoader(path.join(__dirname, 'lib', 'plugins'));
 async function loadPluginExtensions() {
   try {
-    await pluginLoader.loadAllPlugins({ router: expressApp, baseUrl: BASE_URL, logger: console, env: process.env });
+    await pluginLoader.loadAllPlugins({ router: app, baseUrl: BASE_URL, logger: console, env: process.env });
     const names = Array.from(pluginLoader.registry.keys());
     if (names.length > 0) {
       for (const name of names) {
@@ -5266,7 +5266,7 @@ async function loadPluginExtensions() {
         for (const route of state.routes) {
           const fullPath = BASE_URL + route.path;
           const method = (route.method || 'GET').toLowerCase();
-          if (expressApp[method]) expressApp[method](fullPath, route.handler);
+          if (app[method]) app[method](fullPath, route.handler);
         }
       }
       console.log(`[PLUGINS] Loaded extensions: ${names.join(', ')}`);