agentgui 1.0.588 → 1.0.590

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() {},
+};

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() {},
+};