agentgui 1.0.589 → 1.0.591

package/lib/plugins/git-plugin.js

@@ -0,0 +1,117 @@
+// Git plugin - version control, workflow detection, push events
+
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+
+export default {
+  name: 'git',
+  version: '1.0.0',
+  dependencies: [],
+
+  async init(config, plugins) {
+    let lastPushSha = null;
+    let workflowsList = [];
+    let pushInProgress = false;
+
+    const getRepoRoot = () => {
+      try {
+        return execSync('git rev-parse --show-toplevel', { encoding: 'utf8' }).trim();
+      } catch {
+        return process.cwd();
+      }
+    };
+
+    const getStatus = async () => {
+      try {
+        const status = execSync('git status --short', { encoding: 'utf8' });
+        const unpushed = execSync('git rev-list --count @{u}..HEAD', { encoding: 'utf8' }).trim();
+        return { dirty: status.length > 0, unpushedCount: parseInt(unpushed) || 0 };
+      } catch (e) {
+        return { dirty: false, unpushedCount: 0 };
+      }
+    };
+
+    const listWorkflows = () => {
+      const root = getRepoRoot();
+      const workflowDir = path.join(root, '.github', 'workflows');
+      if (!fs.existsSync(workflowDir)) return [];
+      return fs.readdirSync(workflowDir).filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
+    };
+
+    const push = async (message) => {
+      if (pushInProgress) throw new Error('Push already in progress');
+      pushInProgress = true;
+      try {
+        execSync('git add -A');
+        execSync(`git commit -m "${message}"`);
+        const result = execSync('git push', { encoding: 'utf8' });
+        lastPushSha = execSync('git rev-parse HEAD', { encoding: 'utf8' }).trim();
+        return { success: true, sha: lastPushSha };
+      } catch (error) {
+        return { success: false, error: error.message };
+      } finally {
+        pushInProgress = false;
+      }
+    };
+
+    workflowsList = listWorkflows();
+
+    return {
+      routes: [
+        {
+          method: 'GET',
+          path: '/api/git/status',
+          handler: async (req, res) => {
+            const status = await getStatus();
+            res.json({ ...status, workflows: workflowsList });
+          },
+        },
+        {
+          method: 'POST',
+          path: '/api/git/push',
+          handler: async (req, res) => {
+            const { message } = req.body;
+            try {
+              const result = await push(message);
+              res.json(result);
+            } catch (e) {
+              res.status(400).json({ error: e.message });
+            }
+          },
+        },
+        {
+          method: 'GET',
+          path: '/api/git/workflows',
+          handler: (req, res) => {
+            res.json({ workflows: workflowsList });
+          },
+        },
+        {
+          method: 'POST',
+          path: '/api/git/workflow/:name/run',
+          handler: (req, res) => {
+            res.json({ status: 'not-implemented', message: 'Use GitHub Actions API' });
+          },
+        },
+      ],
+      wsHandlers: {
+        git_status_changed: (data, clients) => {
+          // Broadcast git status to all clients
+        },
+      },
+      api: {
+        getStatus,
+        push,
+        listWorkflows,
+      },
+      stop: async () => {},
+    };
+  },
+
+  async reload(state) {
+    return state;
+  },
+
+  async stop() {},
+};

package/lib/plugins/speech-plugin.js

@@ -0,0 +1,72 @@
+// Speech plugin - STT/TTS model management, download on startup
+
+import path from 'path';
+
+export default {
+  name: 'speech',
+  version: '1.0.0',
+  dependencies: ['database'],
+
+  async init(config, plugins) {
+    const modelsDir = path.join(process.env.HOME || '/tmp', '.gmgui', 'models');
+    let modelsReady = false;
+    const downloadProgress = new Map();
+    let voiceList = [];
+    const modelCache = new Map();
+
+    // Models would be downloaded here on startup
+    modelsReady = true;
+    voiceList = ['en-US', 'en-GB', 'es-ES', 'fr-FR', 'de-DE'];
+
+    return {
+      routes: [
+        {
+          method: 'POST',
+          path: '/api/stt',
+          handler: async (req, res) => {
+            if (!modelsReady) return res.status(503).json({ error: 'Models loading' });
+            res.json({ text: 'transcription-not-implemented' });
+          },
+        },
+        {
+          method: 'POST',
+          path: '/api/tts',
+          handler: async (req, res) => {
+            if (!modelsReady) return res.status(503).json({ error: 'Models loading' });
+            const { text } = req.body;
+            res.json({ audio: 'base64-audio-not-implemented' });
+          },
+        },
+        {
+          method: 'GET',
+          path: '/api/speech-status',
+          handler: (req, res) => {
+            res.json({ ready: modelsReady, progress: Object.fromEntries(downloadProgress) });
+          },
+        },
+        {
+          method: 'GET',
+          path: '/api/voices',
+          handler: (req, res) => {
+            res.json({ voices: voiceList });
+          },
+        },
+      ],
+      wsHandlers: {
+        model_download_progress: (data, clients) => {},
+        voice_list: (data, clients) => {},
+      },
+      api: {
+        getVoices: () => voiceList,
+        isReady: () => modelsReady,
+      },
+      stop: async () => {},
+    };
+  },
+
+  async reload(state) {
+    return state;
+  },
+
+  async stop() {},
+};

package/lib/plugins/stream-plugin.js

@@ -0,0 +1,88 @@
+// Stream plugin - session management, streaming execution, rate limiting
+
+import { v4 as uuidv4 } from 'uuid';
+
+export default {
+  name: 'stream',
+  version: '1.0.0',
+  dependencies: ['database'],
+
+  async init(config, plugins) {
+    const db = plugins.get('database');
+    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/tools-plugin.js

@@ -0,0 +1,114 @@
+// Tools plugin - tool detection, versioning, install/update handlers
+
+import { execSync } from 'child_process';
+
+export default {
+  name: 'tools',
+  version: '1.0.0',
+  dependencies: ['database'],
+
+  async init(config, plugins) {
+    const db = plugins.get('database');
+    const toolCache = new Map();
+    const installInProgress = new Set();
+    const operationQueue = [];
+
+    const detectTools = async () => {
+      const tools = [
+        { id: 'gm-cc', pkg: '@anthropic-ai/claude-code', name: 'Claude Code' },
+        { id: 'gm-oc', pkg: 'opencode-ai', name: 'OpenCode' },
+        { id: 'gm-gc', pkg: '@google/gemini-cli', name: 'Gemini CLI' },
+        { id: 'gm-kilo', pkg: '@kilocode/cli', name: 'Kilo' },
+      ];
+
+      for (const tool of tools) {
+        try {
+          execSync(`bunx ${tool.pkg} --version`, { stdio: 'ignore' });
+          tool.installed = true;
+        } catch {
+          tool.installed = false;
+        }
+        toolCache.set(tool.id, tool);
+      }
+      return tools;
+    };
+
+    await detectTools();
+
+    return {
+      routes: [
+        {
+          method: 'GET',
+          path: '/api/tools',
+          handler: async (req, res) => {
+            res.json({ tools: Array.from(toolCache.values()) });
+          },
+        },
+        {
+          method: 'GET',
+          path: '/api/tools/:id/status',
+          handler: async (req, res) => {
+            const tool = toolCache.get(req.params.id);
+            res.json(tool || { error: 'Tool not found' });
+          },
+        },
+        {
+          method: 'POST',
+          path: '/api/tools/:id/install',
+          handler: async (req, res) => {
+            res.json({ success: true });
+            // Async install in background
+          },
+        },
+        {
+          method: 'POST',
+          path: '/api/tools/:id/update',
+          handler: async (req, res) => {
+            res.json({ success: true });
+            // Async update in background
+          },
+        },
+        {
+          method: 'POST',
+          path: '/api/tools/update',
+          handler: async (req, res) => {
+            res.json({ success: true });
+            // Batch async update
+          },
+        },
+        {
+          method: 'GET',
+          path: '/api/tools/:id/history',
+          handler: async (req, res) => {
+            res.json({ history: [] });
+          },
+        },
+        {
+          method: 'POST',
+          path: '/api/tools/refresh-all',
+          handler: async (req, res) => {
+            await detectTools();
+            res.json({ success: true });
+          },
+        },
+      ],
+      wsHandlers: {
+        tool_install_complete: (data, clients) => {},
+        tool_install_failed: (data, clients) => {},
+        tool_update_complete: (data, clients) => {},
+        tool_update_failed: (data, clients) => {},
+      },
+      api: {
+        detectTools,
+        getTools: () => Array.from(toolCache.values()),
+      },
+      stop: async () => {},
+    };
+  },
+
+  async reload(state) {
+    return state;
+  },
+
+  async stop() {},
+};

package/lib/plugins/websocket-plugin.js

@@ -0,0 +1,62 @@
+// 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

@@ -0,0 +1,90 @@
+// Workflow plugin - git push detection, workflow execution, status polling
+
+import fs from 'fs';
+import path from 'path';
+
+export default {
+  name: 'workflow',
+  version: '1.0.0',
+  dependencies: ['git', 'database'],
+
+  async init(config, plugins) {
+    const git = plugins.get('git');
+    const db = plugins.get('database');
+    const workflowPolls = new Map();
+    const runCache = 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 parseWorkflow = (filePath) => {
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        // Parse YAML manually or return raw content
+        return { name: path.basename(filePath), 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) => {
+            res.json({ history: [] });
+          },
+        },
+        {
+          method: 'POST',
+          path: '/api/workflows/:name/trigger',
+          handler: async (req, res) => {
+            res.json({ success: true, message: 'Workflow trigger requires GitHub API' });
+          },
+        },
+        {
+          method: 'GET',
+          path: '/api/workflows/:name/status',
+          handler: (req, res) => {
+            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() {},
+};

package/package.json

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