agentgui 1.0.993 → 1.0.995

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.993",
+  "version": "1.0.995",
   "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/agents-plugin.js

@@ -1,76 +0,0 @@
-import path from 'path';
-
-export default {
-  name: 'agents',
-  version: '1.0.0',
-  dependencies: ['database', 'stream'],
-
-  async init(config, plugins) {
-    const db = plugins.get('database');
-    const stream = plugins.get('stream');
-    const discoveredAgents = new Map();
-    const activeExecutions = new Map();
-
-    // Discover agents on startup
-    const discoverAgents = async () => {
-      const agents = [
-        { id: 'gm-cc', name: 'Claude Code', bin: 'claude', installed: true },
-        { id: 'gm-oc', name: 'OpenCode', bin: 'opencode', installed: false },
-        { id: 'gm-gc', name: 'Gemini CLI', bin: 'gemini', installed: false },
-        { id: 'gm-kilo', name: 'Kilo', bin: 'kilo', installed: false },
-      ];
-      agents.forEach(a => discoveredAgents.set(a.id, a));
-      return agents;
-    };
-
-    await discoverAgents();
-
-    return {
-      routes: [
-        {
-          method: 'GET',
-          path: '/api/agents',
-          handler: (req, res) => {
-            res.json({ agents: Array.from(discoveredAgents.values()) });
-          },
-        },
-        {
-          method: 'POST',
-          path: '/api/conversations/:id/stream',
-          handler: async (req, res) => {
-            const { id } = req.params;
-            const { agentId, message } = req.body;
-
-            try {
-              const agent = discoveredAgents.get(agentId);
-              if (!agent) return res.status(404).json({ error: 'Agent not found' });
-
-              const session = stream.api.createSession(id);
-              activeExecutions.set(id, { sessionId: session.id });
-
-              res.json({ sessionId: session.id });
-            } catch (e) {
-              res.status(500).json({ error: e.message });
-            }
-          },
-        },
-      ],
-      wsHandlers: {},
-      api: {
-        getAgents: () => Array.from(discoveredAgents.values()),
-        discoverAgents,
-      },
-      stop: async () => {
-        for (const proc of activeExecutions.values()) {
-          if (proc && !proc.killed) proc.kill();
-        }
-      },
-    };
-  },
-
-  async reload(state) {
-    return state;
-  },
-
-  async stop() {},
-};

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,62 +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', 'agents'],
-
-  async init(config, plugins) {
-    const db = plugins.get('database');
-    const stream = plugins.get('stream');
-    const agents = plugins.get('agents');
-
-    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() {},
-};