agentgui 1.0.994 → 1.0.996

package/AGENTS.md

@@ -116,8 +116,7 @@ When `PASSWORD` env var is set, every HTTP route is gated by `lib/http-handler.j
 - `site/app/js/app.js` — webjsx view + state; renders the `AgentChat` kit (from `anentrypoint-design`) for the chat surface and wires agentgui's WS/ccsniff state as kit callbacks; history/settings remain agentgui-local. Exposes `window.__agentgui`
 
 The chat GUI lives in the design kit, not in agentgui. The reusable multi-agent chat surface is the `AgentChat` component in `anentrypoint-design` (`src/components/agent-chat.js`); agentgui keeps only the transport glue (WS `backend.js`, ccsniff history wiring, agent orchestration) and passes state + callbacks into the kit. To change chat UI, edit the kit and push it (CI publishes to npm -> unpkg `@latest`), not agentgui.
-- `server.js` — boots ACP/agents/websocket plugins, mounts `createHistoryRouter()` from `ccsniff` at `/`, serves `site/app/` as static root
-- Plugins kept (lib/plugins/): acp, agents, database, files, stream, websocket, workflow
+- `server.js` — initializes the ACP-SDK manager + agent registry, registers WS handlers (`ws-handlers-util.js`), mounts `createHistoryRouter()` from `ccsniff` at `/`, serves `site/app/` as static root. The `lib/plugins/` system was removed (2026-06-20, 20th run) — it was dead scaffolding (routes 404, wsHandlers never wired, api unconsumed); all server logic lives directly in `server.js` + `lib/ws-handlers-util.js` + `lib/http-handler.js` + `lib/routes-upload.js` + `database.js`.
 
 Dependencies:
 - `ccsniff` (>=1.1.0) — exports `createHistoryRouter({projectsDir})` mountable on Express; serves `/v1/history/{sessions,sessions/:sid/events,search,snapshot,reindex,stream}`. Reads `~/.claude/projects` (override via `CLAUDE_PROJECTS_DIR`).
@@ -157,15 +156,9 @@ Why it works: `process.execPath` becomes bun, so the spawned child server also r
 
 Rule: any CI step that spawns the agentgui server (directly or via a script that inherits `process.execPath`) must invoke it with `bun`.
 
-## Plugin Dependencies
+## Plugin system removed (2026-06-20 — 20th run)
 
-**`lib/plugins/stream-plugin.js` must not import packages missing from package.json.**
-
-The plugin loader runs at startup and logs failures silently if a plugin import fails. If stream plugin fails to load due to missing dependency (e.g., `uuid`), the error cascades: `agents` and `websocket` plugins both declare `stream` as a dependency and fail with "Plugin stream not found in registry", cascading to boot failure.
-
-Fix for uuid: replaced `import { v4 as uuidv4 } from 'uuid'` with `import { randomUUID as uuidv4 } from 'crypto'` (Node.js built-in, zero deps).
-
-Pattern: all imports in lib/plugins/* must be either built-in (crypto, fs, path, etc.) or already in package.json. No new npm packages should be added to plugins without adding them to dependencies.
+The entire `lib/plugins/` system + `plugin-loader.js` was deleted as dead scaffolding (commits up to e73ed0e): plugin routes were unreachable (http-handler forwarded only a few prefixes -> 404), plugin `wsHandlers` were never wired (the real WS handlers come from `registerWsHandlers` in `ws-handlers-util.js`), plugin `api` objects were never consumed, and the inits were no-ops or managed local Maps nobody read. Removed across 7 commits (acp, files, agents, then database/stream/workflow/websocket + loader). The general lesson survives: any import under `lib/` must be a built-in (crypto, fs, path) or already in package.json — a missing dep crashes boot.
 
 ## Plugin Tool Provisioning on Windows
 

package/README.md

@@ -133,14 +133,12 @@ lib/ws-optimizer.js    Per-client priority queue for WS event batching
 lib/ws-handlers-*.js   WebSocket RPC handlers (conv, msg, queue, session, run, util, oauth, scripts)
 lib/speech.js          Speech-to-text and text-to-speech via @huggingface/transformers
 lib/tool-manager.js    Tool detection, install, update facade
-lib/plugins/           Server plugins (acp, agents, auth, database, files, git, speech, stream, tools, websocket, workflow)
-static/index.html      Main HTML shell
-static/app.js          App initialization
-static/js/client.js    Main client logic
-static/js/conversations.js       Conversation management
-static/js/streaming-renderer.js  Renders agent streaming events as HTML
-static/js/websocket-manager.js   WebSocket connection handling
-static/js/*.machine.js           XState v5 state machines (ws, conv, tool-install, voice, conv-list, prompt)
+lib/ws-handlers-util.js WS RPC handler registration (agents.list, chat.sendMessage, ...)
+lib/http-handler.js    Static serving + /api/* routes + auth gate + path confinement
+lib/routes-upload.js   Express app for multipart upload + fsbrowse file serving
+site/app/index.html    SPA shell; imports the anentrypoint-design kit
+site/app/js/app.js     webjsx view + state; renders the AgentChat kit, wires WS callbacks
+site/app/js/backend.js Same-origin WS/HTTP client (transport glue)
 ```
 
 ### Key Details
@@ -148,7 +146,7 @@ static/js/*.machine.js           XState v5 state machines (ws, conv, tool-instal
 - Agent discovery scans PATH for known CLI binaries at startup
 - Database lives at `~/.gmgui/data.db` (WAL mode for concurrent access)
 - WebSocket endpoint at `/gm/sync` for real-time updates
-- ACP tools (OpenCode, Kilo) auto-launch as HTTP servers on startup with health checks
+- ACP tools (OpenCode, Kilo, Codex) start on demand as HTTP servers with health checks + restart backoff
 
 ## Use Cases
 

package/lib/server-startup2.js

@@ -1,7 +1,6 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-import PluginLoader from './plugin-loader.js';
 
 export function createAutoImport({ queries, broadcastSync }) {
   const importMtimeCache = new Map();
@@ -57,28 +56,3 @@ export function createDbRecovery({ queries, debugLog }) {
 
   return { performDbRecovery };
 }
-
-export function createPluginLoader({ pluginsDir, expressApp, BASE_URL }) {
-  const pluginLoader = new PluginLoader(pluginsDir);
-
-  async function loadPluginExtensions() {
-    try {
-      await pluginLoader.loadAllPlugins({ router: expressApp, baseUrl: BASE_URL, logger: console, env: process.env });
-      const names = Array.from(pluginLoader.registry.keys());
-      if (names.length > 0) {
-        for (const name of names) {
-          const state = pluginLoader.get(name);
-          if (!state || !state.routes) continue;
-          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);
-          }
-        }
-        console.log(`[PLUGINS] Loaded extensions: ${names.join(', ')}`);
-      }
-    } catch (err) { console.error('[PLUGINS] Extension loading failed (non-fatal):', err.message); }
-  }
-
-  return { loadPluginExtensions };
-}

package/package.json

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

package/server.js

@@ -19,7 +19,7 @@ import { parseBody, acceptsEncoding, compressAndSend, sendJSON } from './lib/htt
 import { createWsSetup } from './lib/ws-setup.js';
 import { createHttpHandler } from './lib/http-handler.js';
 import { createOnServerReady } from './lib/server-startup.js';
-import { createAutoImport, createDbRecovery, createPluginLoader } from './lib/server-startup2.js';
+import { createAutoImport, createDbRecovery } from './lib/server-startup2.js';
 const sendWs = (ws, obj) => { if (ws.readyState === 1) ws.send(wsEncode(obj)); };
 import { startAll as startACPTools, stopAll as stopACPTools, getStatus as getACPStatus, getPort as getACPPort, ensureRunning, queryModels as queryACPModels, touch as touchACP } from './lib/acp-sdk-manager.js';
 import * as execMachine from './lib/execution-machine.js';
@@ -195,7 +195,6 @@ const onServerListenStart = () => {
   if (_serverReadyFired) return;
   _serverReadyFired = true;
   onServerReady();
-  loadPluginExtensions();
 };
 
 let _portRetries = 0;
@@ -218,7 +217,6 @@ server.on('error', (err) => {
 
 const { performAutoImport } = createAutoImport({ queries, broadcastSync });
 const { performDbRecovery } = createDbRecovery({ queries, debugLog });
-const { loadPluginExtensions } = createPluginLoader({ pluginsDir: path.join(__dirname, 'lib', 'plugins'), expressApp, BASE_URL });
 
 setInterval(performDbRecovery, 300000);
 

package/test.js

@@ -76,9 +76,7 @@ await ok('machines: execution + acp-server lifecycle', () => {
   assert.equal(asm.isHealthy('test-tool'), true);
   asm.stopAll();
 });
-await ok('workflow-plugin + agent-registry hermes', async () => {
-  const wp = await import('./lib/plugins/workflow-plugin.js');
-  assert.deepEqual(wp.default.dependencies, ['database']);
+await ok('agent-registry: hermes ACP descriptor', async () => {
   const { registry } = await import('./lib/claude-runner-agents.js');
   const h = registry.get('hermes');
   assert.equal(h.protocol, 'acp'); assert.deepEqual(h.buildArgs(), ['acp']);

package/lib/plugin-loader.js

@@ -1,162 +0,0 @@
-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;

package/lib/plugins/database-plugin.js

@@ -1,43 +0,0 @@
-// Database plugin - SQLite init, schema
-
-import * as dbModule from '../../database.js';
-
-export default {
-  name: 'database',
-  version: '1.0.0',
-  dependencies: [],
-
-  async init(config, plugins) {
-    // Initialize database schema
-    if (dbModule.initializeSchema) dbModule.initializeSchema();
-
-    // Return API for other plugins
-    return {
-      routes: [],
-      wsHandlers: {},
-      api: {
-        // Query functions from database.js
-        queries: dbModule.queries || {},
-
-        // Checkpoint/recovery
-        checkpoint: (label) => {
-          console.log(`[Database] Checkpoint: ${label}`);
-        },
-
-        recover: async (label) => {
-          console.log(`[Database] Recover from: ${label}`);
-        },
-
-        // Direct DB access
-        db: dbModule.dataDir,
-      },
-      stop: async () => {},
-    };
-  },
-
-  async reload(state) {
-    return state;
-  },
-
-  async stop() {},
-};

package/lib/plugins/stream-plugin.js

@@ -1,89 +0,0 @@
-// Stream plugin - session management, streaming execution, rate limiting
-
-import { randomUUID as uuidv4 } from 'crypto';
-
-export default {
-  name: 'stream',
-  version: '1.0.0',
-  dependencies: ['database'],
-
-  async init(config, plugins) {
-    const dbPlugin = plugins.get('database');
-    const db = dbPlugin?.api || {};
-    const activeSessions = new Map();
-    const pendingMessages = new Map();
-    const rateLimitState = new Map();
-    const recoveryCheckpoints = new Map();
-
-    return {
-      routes: [
-        {
-          method: 'GET',
-          path: '/api/sessions/:id',
-          handler: async (req, res) => {
-            const { id } = req.params;
-            const session = activeSessions.get(id);
-            if (!session) return res.status(404).json({ error: 'Session not found' });
-            res.json(session);
-          },
-        },
-        {
-          method: 'GET',
-          path: '/api/sessions/:id/chunks',
-          handler: async (req, res) => {
-            const { id } = req.params;
-            const { since } = req.query;
-            const chunks = db.queries.getStreamChunks(id, since ? parseInt(since) : 0);
-            res.json({ chunks });
-          },
-        },
-        {
-          method: 'GET',
-          path: '/api/sessions/:id/execution',
-          handler: async (req, res) => {
-            const { id } = req.params;
-            const { limit, offset, filterType } = req.query;
-            const events = db.queries.getExecutionEvents(id, parseInt(limit) || 100, parseInt(offset) || 0);
-            res.json({ events });
-          },
-        },
-        {
-          method: 'GET',
-          path: '/api/conversations/:id/sessions/latest',
-          handler: async (req, res) => {
-            const { id } = req.params;
-            const sessions = Array.from(activeSessions.values()).filter(s => s.conversationId === id);
-            const latest = sessions[sessions.length - 1];
-            res.json(latest || { error: 'No sessions' });
-          },
-        },
-      ],
-      wsHandlers: {
-        streaming_start: (data, clients) => {},
-        streaming_progress: (data, clients) => {},
-        streaming_complete: (data, clients) => {},
-        streaming_error: (data, clients) => {},
-        rate_limit_hit: (data, clients) => {},
-      },
-      api: {
-        createSession: (conversationId) => {
-          const session = { id: uuidv4(), conversationId, createdAt: Date.now() };
-          activeSessions.set(session.id, session);
-          return session;
-        },
-        getSession: (id) => activeSessions.get(id),
-        closeSession: (id) => activeSessions.delete(id),
-      },
-      stop: async () => {
-        activeSessions.clear();
-        pendingMessages.clear();
-      },
-    };
-  },
-
-  async reload(state) {
-    return state;
-  },
-
-  async stop() {},
-};

package/lib/plugins/websocket-plugin.js

@@ -1,58 +0,0 @@
-// WebSocket plugin - message routing, optimization, real-time sync
-
-import { WebSocketServer } from 'ws';
-
-export default {
-  name: 'websocket',
-  version: '1.0.0',
-  dependencies: ['database', 'stream'],
-
-  async init(config, plugins) {
-    const subscribers = new Map(); // sessionId/conversationId => Set<client>
-    const routingTable = new Map(); // eventType => handler
-
-    const broadcast = (eventType, data) => {
-      // Broadcast to all subscribed clients
-    };
-
-    const subscribe = (client, id, type) => {
-      if (!subscribers.has(id)) {
-        subscribers.set(id, new Set());
-      }
-      subscribers.get(id).add(client);
-    };
-
-    const unsubscribe = (client, id) => {
-      const set = subscribers.get(id);
-      if (set) set.delete(client);
-    };
-
-    return {
-      routes: [],
-      wsHandlers: {
-        // Routing handlers for all conversation/session events
-        subscribe: (data, clients) => {},
-        unsubscribe: (data, clients) => {},
-        ping: (data, clients) => {},
-      },
-      api: {
-        broadcast,
-        subscribe,
-        unsubscribe,
-        addHandler: (eventType, handler) => {
-          routingTable.set(eventType, handler);
-        },
-      },
-      stop: async () => {
-        subscribers.clear();
-        routingTable.clear();
-      },
-    };
-  },
-
-  async reload(state) {
-    return state;
-  },
-
-  async stop() {},
-};

package/lib/plugins/workflow-plugin.js

@@ -1,104 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-export default {
-  name: 'workflow',
-  version: '1.0.0',
-  dependencies: ['database'],
-
-  async init(config, plugins) {
-    plugins.get('database');
-    const workflowPolls = new Map();
-
-    const getWorkflows = () => {
-      const repoRoot = process.cwd();
-      const workflowDir = path.join(repoRoot, '.github', 'workflows');
-      if (!fs.existsSync(workflowDir)) return [];
-      return fs.readdirSync(workflowDir)
-        .filter(f => f.endsWith('.yml') || f.endsWith('.yaml'))
-        .map(name => ({ name, path: path.join(workflowDir, name) }));
-    };
-
-    const resolvedWorkflowDir = path.resolve(process.cwd(), '.github', 'workflows');
-
-    const isNameSafe = (name) => !/[/\\]/.test(name);
-
-    const parseWorkflow = (filePath) => {
-      try {
-        // Confine to workflowDir: resolve and verify the path stays within the allowed directory
-        const resolved = path.resolve(filePath);
-        if (!resolved.startsWith(resolvedWorkflowDir + path.sep) && resolved !== resolvedWorkflowDir) {
-          return null;
-        }
-        const content = fs.readFileSync(resolved, 'utf8');
-        // Parse YAML manually or return raw content
-        return { name: path.basename(resolved), content };
-      } catch {
-        return null;
-      }
-    };
-
-    return {
-      routes: [
-        {
-          method: 'GET',
-          path: '/api/workflows',
-          handler: (req, res) => {
-            const workflows = getWorkflows();
-            res.json({ workflows });
-          },
-        },
-        {
-          method: 'GET',
-          path: '/api/workflows/:name/history',
-          handler: (req, res) => {
-            if (!isNameSafe(req.params.name)) {
-              return res.status(400).json({ error: 'Invalid workflow name' });
-            }
-            res.json({ history: [] });
-          },
-        },
-        {
-          method: 'POST',
-          path: '/api/workflows/:name/trigger',
-          handler: async (req, res) => {
-            if (!isNameSafe(req.params.name)) {
-              return res.status(400).json({ error: 'Invalid workflow name' });
-            }
-            res.json({ success: true, message: 'Workflow trigger requires GitHub API' });
-          },
-        },
-        {
-          method: 'GET',
-          path: '/api/workflows/:name/status',
-          handler: (req, res) => {
-            if (!isNameSafe(req.params.name)) {
-              return res.status(400).json({ error: 'Invalid workflow name' });
-            }
-            res.json({ status: 'unknown' });
-          },
-        },
-      ],
-      wsHandlers: {
-        workflow_triggered: (data, clients) => {},
-        workflow_progress: (data, clients) => {},
-        workflow_complete: (data, clients) => {},
-      },
-      api: {
-        getWorkflows,
-        parseWorkflow,
-      },
-      stop: async () => {
-        for (const interval of workflowPolls.values()) {
-          clearInterval(interval);
-        }
-      },
-    };
-  },
-
-  async reload(state) {
-    return state;
-  },
-
-  async stop() {},
-};