agentgui 1.0.589 → 1.0.591

package/database.js

@@ -199,6 +199,37 @@ function initSchema() {
     CREATE INDEX IF NOT EXISTS idx_tool_install_history_tool ON tool_install_history(tool_id);
     CREATE INDEX IF NOT EXISTS idx_tool_install_history_completed ON tool_install_history(completed_at);
 
+    CREATE TABLE IF NOT EXISTS workflow_runs (
+      id TEXT PRIMARY KEY,
+      workflowName TEXT NOT NULL,
+      workflowId TEXT,
+      runId TEXT,
+      sha TEXT,
+      branch TEXT,
+      status TEXT,
+      conclusion TEXT,
+      htmlUrl TEXT,
+      triggeredAt INTEGER NOT NULL,
+      completedAt INTEGER,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_workflow_runs_name ON workflow_runs(workflowName);
+    CREATE INDEX IF NOT EXISTS idx_workflow_runs_sha ON workflow_runs(sha);
+    CREATE INDEX IF NOT EXISTS idx_workflow_runs_completed ON workflow_runs(completedAt);
+
+    CREATE TABLE IF NOT EXISTS oauth_tokens (
+      id TEXT PRIMARY KEY,
+      provider TEXT NOT NULL,
+      token TEXT NOT NULL,
+      email TEXT,
+      expires_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_oauth_tokens_provider ON oauth_tokens(provider);
+
   `);
 }
 

package/lib/plugin-interface.js

@@ -0,0 +1,36 @@
+// Plugin interface contract - every plugin must implement this
+
+export default {
+  // Plugin metadata
+  name: 'plugin-name', // unique identifier
+  version: '1.0.0',
+  dependencies: [], // list of other plugin names this depends on
+
+  // Lifecycle methods (all required)
+  async init(config, plugins) {
+    // config = { router, wsManager, db, logger, env }
+    // plugins = Map<name, plugin> of all loaded plugins
+    // MUST return: { routes[], wsHandlers{}, api{}, stop() }
+    return {
+      routes: [], // [ { method, path, handler } ]
+      wsHandlers: {}, // { eventType: handler(data, clients) }
+      api: {}, // exported functions for other plugins
+    };
+  },
+
+  async reload(state) {
+    // Called on hot reload. Preserve state from previous instance.
+    // Return new state (or updated state from previous)
+    return state;
+  },
+
+  async stop() {
+    // Graceful shutdown. Clean up resources.
+    // No need to return anything.
+  },
+
+  // Optional: Called when another plugin throws error
+  async handleError(error, context) {
+    // context = { pluginName, phase, ... }
+  },
+};

package/lib/plugin-loader.js

@@ -0,0 +1,200 @@
+// 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();
+    const result = [];
+
+    const visit = (name) => {
+      if (visited.has(name)) return;
+      visited.add(name);
+
+      const plugin = this.registry.get(name);
+      for (const dep of (plugin?.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/acp-plugin.js

@@ -0,0 +1,90 @@
+// ACP plugin - OpenCode, Gemini, Kilo, Codex startup and health checks
+
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+
+export default {
+  name: 'acp',
+  version: '1.0.0',
+  dependencies: ['tools'],
+
+  async init(config, plugins) {
+    const tools = plugins.get('tools');
+    const toolProcesses = new Map();
+    const healthCheckIntervals = new Map();
+    const restartCounts = new Map();
+    const acpPorts = new Map();
+
+    const toolSpecs = [
+      { name: 'opencode', port: 18100, cmd: 'opencode acp --port 18100' },
+      { name: 'gemini', port: 18101, cmd: 'gemini acp --port 18101' },
+      { name: 'kilo', port: 18102, cmd: 'kilo acp --port 18102' },
+      { name: 'codex', port: 18103, cmd: 'codex acp --port 18103' },
+    ];
+
+    const startTool = async (spec) => {
+      try {
+        const proc = spawn('bash', ['-c', spec.cmd]);
+        toolProcesses.set(spec.name, proc);
+        acpPorts.set(spec.name, spec.port);
+        restartCounts.set(spec.name, 0);
+
+        // Health check every 30s
+        const interval = setInterval(() => {
+          if (proc.killed) {
+            clearInterval(interval);
+            healthCheckIntervals.delete(spec.name);
+          }
+        }, 30000);
+        healthCheckIntervals.set(spec.name, interval);
+      } catch (e) {
+        console.error(`[ACP] Failed to start ${spec.name}:`, e.message);
+      }
+    };
+
+    // Start all ACP tools
+    for (const spec of toolSpecs) {
+      await startTool(spec);
+    }
+
+    return {
+      routes: [
+        {
+          method: 'GET',
+          path: '/api/acp/status',
+          handler: (req, res) => {
+            const status = {};
+            for (const [name, proc] of toolProcesses) {
+              status[name] = {
+                running: !proc.killed,
+                port: acpPorts.get(name),
+                pid: proc.pid,
+                restarts: restartCounts.get(name) || 0,
+              };
+            }
+            res.json({ tools: status });
+          },
+        },
+      ],
+      wsHandlers: {},
+      api: {
+        getStatus: () => Object.fromEntries(acpPorts),
+      },
+      stop: async () => {
+        for (const [name, interval] of healthCheckIntervals) {
+          clearInterval(interval);
+        }
+        for (const [name, proc] of toolProcesses) {
+          if (proc && !proc.killed) proc.kill();
+        }
+      },
+    };
+  },
+
+  async reload(state) {
+    return state;
+  },
+
+  async stop() {},
+};

package/lib/plugins/agents-plugin.js

@@ -0,0 +1,80 @@
+// Agents plugin - agent discovery, runner spawning, process management
+
+import path from 'path';
+import { runClaudeWithStreaming } from '../claude-runner.js';
+
+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);
+              // Use runClaudeWithStreaming instead
+              activeExecutions.set(id, { sessionId: session.id });
+
+              res.json({ sessionId: session.id, pid: proc.pid });
+            } 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/auth-plugin.js

@@ -0,0 +1,132 @@
+// Auth plugin - OAuth2, provider config, agentauth integration
+
+import http from 'http';
+
+export default {
+  name: 'auth',
+  version: '1.0.0',
+  dependencies: ['database'],
+
+  async init(config, plugins) {
+    const db = plugins.get('database');
+    const providerConfigs = new Map();
+    const oauthClients = new Map();
+    const sessions = new Map();
+
+    // Detect provider configs on startup
+    const detectProviders = () => {
+      const providers = [
+        { id: 'anthropic', name: 'Anthropic', configured: false },
+        { id: 'google', name: 'Google', configured: false },
+        { id: 'github', name: 'GitHub', configured: false },
+      ];
+      providers.forEach(p => providerConfigs.set(p.id, p));
+      return providers;
+    };
+
+    detectProviders();
+
+    // Agentauth integration
+    const agentauthStart = async (provider, scopes) => {
+      return new Promise((resolve, reject) => {
+        const options = {
+          hostname: 'localhost',
+          port: 8765,
+          path: '/auth/start',
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+        };
+
+        const req = http.request(options, (res) => {
+          let data = '';
+          res.on('data', chunk => data += chunk);
+          res.on('end', () => {
+            try {
+              resolve(JSON.parse(data));
+            } catch (e) {
+              reject(new Error('Agentauth unavailable'));
+            }
+          });
+        });
+
+        req.on('error', () => reject(new Error('Agentauth service not running')));
+        req.write(JSON.stringify({ provider, scopes }));
+        req.end();
+      });
+    };
+
+    return {
+      routes: [
+        {
+          method: 'GET',
+          path: '/api/auth/status',
+          handler: (req, res) => {
+            res.json({ authenticated: sessions.size > 0, sessions: Array.from(sessions.keys()) });
+          },
+        },
+        {
+          method: 'GET',
+          path: '/api/auth/configs',
+          handler: (req, res) => {
+            const masked = Array.from(providerConfigs.values()).map(p => ({
+              id: p.id,
+              name: p.name,
+              configured: p.configured,
+            }));
+            res.json({ providers: masked });
+          },
+        },
+        {
+          method: 'POST',
+          path: '/api/auth/callback',
+          handler: (req, res) => {
+            const { code } = req.body;
+            res.json({ success: true, code });
+          },
+        },
+        {
+          method: 'POST',
+          path: '/api/auth/logout',
+          handler: (req, res) => {
+            sessions.clear();
+            res.json({ success: true });
+          },
+        },
+        {
+          method: 'POST',
+          path: '/api/auth/agentauth-start',
+          handler: async (req, res) => {
+            const { provider, scopes } = req.body;
+            try {
+              const result = await agentauthStart(provider, scopes);
+              res.json(result);
+            } catch (e) {
+              res.status(503).json({ error: e.message });
+            }
+          },
+        },
+        {
+          method: 'GET',
+          path: '/api/auth/agentauth-status',
+          handler: async (req, res) => {
+            const { code } = req.query;
+            res.json({ status: 'polling-not-implemented' });
+          },
+        },
+      ],
+      wsHandlers: {},
+      api: {
+        getProviders: () => Array.from(providerConfigs.values()),
+      },
+      stop: async () => {
+        sessions.clear();
+      },
+    };
+  },
+
+  async reload(state) {
+    return state;
+  },
+
+  async stop() {},
+};

package/lib/plugins/database-plugin.js

@@ -0,0 +1,43 @@
+// Database plugin - SQLite init, schema, checkpoint recovery
+
+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/files-plugin.js

@@ -0,0 +1,83 @@
+// Files plugin - file browser, upload handler, drag-drop support
+
+import path from 'path';
+import fs from 'fs';
+
+export default {
+  name: 'files',
+  version: '1.0.0',
+  dependencies: ['database'],
+
+  async init(config, plugins) {
+    const db = plugins.get('database');
+    const uploadedFiles = new Map();
+
+    const browseDirectory = (dir) => {
+      try {
+        const entries = fs.readdirSync(dir);
+        return entries.map(entry => {
+          const fullPath = path.join(dir, entry);
+          const stat = fs.statSync(fullPath);
+          return {
+            name: entry,
+            path: fullPath,
+            isDirectory: stat.isDirectory(),
+            size: stat.size,
+          };
+        });
+      } catch (e) {
+        return [];
+      }
+    };
+
+    return {
+      routes: [
+        {
+          method: 'GET',
+          path: '/files/:conversationId',
+          handler: (req, res) => {
+            const { conversationId } = req.params;
+            const { dir } = req.query;
+            const entries = browseDirectory(dir || process.cwd());
+            res.json({ entries, currentDir: dir || process.cwd() });
+          },
+        },
+        {
+          method: 'POST',
+          path: '/api/upload/:conversationId',
+          handler: async (req, res) => {
+            const { conversationId } = req.params;
+            uploadedFiles.set(conversationId, Date.now());
+            res.json({ success: true, conversationId });
+          },
+        },
+        {
+          method: 'POST',
+          path: '/api/folders',
+          handler: async (req, res) => {
+            const { path: folderPath } = req.body;
+            try {
+              fs.mkdirSync(folderPath, { recursive: true });
+              res.json({ success: true, path: folderPath });
+            } catch (e) {
+              res.status(400).json({ error: e.message });
+            }
+          },
+        },
+      ],
+      wsHandlers: {},
+      api: {
+        browseDirectory,
+      },
+      stop: async () => {
+        uploadedFiles.clear();
+      },
+    };
+  },
+
+  async reload(state) {
+    return state;
+  },
+
+  async stop() {},
+};