agentgui 1.0.397 → 1.0.399

package/lib/ws-handlers-util.js

@@ -0,0 +1,186 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execSync } from 'child_process';
+
+function err(code, message) { const e = new Error(message); e.code = code; throw e; }
+
+export function register(router, deps) {
+  const { queries, wsOptimizer, modelDownloadState, ensureModelsDownloaded,
+    broadcastSync, getSpeech, getProviderConfigs, saveProviderConfig,
+    startGeminiOAuth, exchangeGeminiOAuthCode, geminiOAuthState,
+    STARTUP_CWD } = deps;
+
+  router.handle('home', () => ({ home: os.homedir(), cwd: STARTUP_CWD }));
+
+  router.handle('folders', (p) => {
+    const folderPath = p.path || STARTUP_CWD;
+    try {
+      const expanded = folderPath.startsWith('~') ? folderPath.replace('~', os.homedir()) : folderPath;
+      const entries = fs.readdirSync(expanded, { withFileTypes: true });
+      const folders = entries
+        .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+        .map(e => ({ name: e.name }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+      return { folders };
+    } catch (e) { err(400, e.message); }
+  });
+
+  router.handle('clone', (p) => {
+    const repo = (p.repo || '').trim();
+    if (!repo || !/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(repo)) {
+      err(400, 'Invalid repo format. Use org/repo or user/repo');
+    }
+    const cloneDir = STARTUP_CWD || os.homedir();
+    const repoName = repo.split('/')[1];
+    const targetPath = path.join(cloneDir, repoName);
+    if (fs.existsSync(targetPath)) err(409, `Directory already exists: ${repoName}`);
+    try {
+      const isWindows = os.platform() === 'win32';
+      execSync('git clone https://github.com/' + repo + '.git', {
+        cwd: cloneDir, encoding: 'utf-8', timeout: 120000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+        shell: isWindows
+      });
+      return { ok: true, repo, path: targetPath, name: repoName };
+    } catch (e) { err(500, (e.stderr || e.message || 'Clone failed').trim()); }
+  });
+
+  router.handle('git.check', () => {
+    try {
+      const isWindows = os.platform() === 'win32';
+      const devnull = isWindows ? '' : ' 2>/dev/null';
+      const remoteUrl = execSync('git remote get-url origin' + devnull, { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows }).trim();
+      const statusResult = execSync('git status --porcelain' + devnull, { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
+      const hasChanges = statusResult.trim().length > 0;
+      const unpushedResult = execSync('git rev-list --count --not --remotes' + devnull, { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
+      const hasUnpushed = parseInt(unpushedResult.trim() || '0', 10) > 0;
+      const ownsRemote = !remoteUrl.includes('github.com/') || remoteUrl.includes(process.env.GITHUB_USER || '');
+      return { ownsRemote, hasChanges, hasUnpushed, remoteUrl };
+    } catch {
+      return { ownsRemote: false, hasChanges: false, hasUnpushed: false, remoteUrl: '' };
+    }
+  });
+
+  router.handle('git.push', () => {
+    try {
+      const isWindows = os.platform() === 'win32';
+      const cmd = isWindows
+        ? 'git add -A & git commit -m "Auto-commit" & git push'
+        : 'git add -A && git commit -m "Auto-commit" && git push';
+      execSync(cmd, { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
+      return { success: true };
+    } catch (e) { err(500, e.message); }
+  });
+
+  router.handle('speech.status', async () => {
+    try {
+      const { getStatus } = await getSpeech();
+      const base = getStatus();
+      let pythonDetected = false, pythonVersion = null;
+      try {
+        const { createRequire } = await import('module');
+        const r = createRequire(import.meta.url);
+        const serverTTS = r('webtalk/server-tts');
+        if (typeof serverTTS.detectPython === 'function') {
+          const py = serverTTS.detectPython();
+          pythonDetected = py.found;
+          pythonVersion = py.version || null;
+        }
+      } catch {}
+      return {
+        ...base, pythonDetected, pythonVersion,
+        setupMessage: base.ttsReady ? 'pocket-tts ready' : 'Will setup on first TTS request',
+        modelsDownloading: modelDownloadState.downloading,
+        modelsComplete: modelDownloadState.complete,
+        modelsError: modelDownloadState.error,
+        modelsProgress: modelDownloadState.progress,
+      };
+    } catch {
+      return {
+        sttReady: false, ttsReady: false, sttLoading: false, ttsLoading: false,
+        setupMessage: 'Will setup on first TTS request',
+        modelsDownloading: modelDownloadState.downloading,
+        modelsComplete: modelDownloadState.complete,
+        modelsError: modelDownloadState.error,
+      };
+    }
+  });
+
+  router.handle('speech.download', () => {
+    if (modelDownloadState.complete) return { ok: true, modelsComplete: true, message: 'Models already ready' };
+    if (!modelDownloadState.downloading) {
+      modelDownloadState.error = null;
+      ensureModelsDownloaded().then(ok => {
+        broadcastSync({ type: 'model_download_progress', progress: { done: true, complete: ok, error: ok ? null : 'Download failed' } });
+      }).catch(e => {
+        broadcastSync({ type: 'model_download_progress', progress: { done: true, error: e.message } });
+      });
+    }
+    return { ok: true, message: 'Starting model download' };
+  });
+
+  router.handle('voices', async () => {
+    try {
+      const { getVoices } = await getSpeech();
+      return { ok: true, voices: getVoices() };
+    } catch { return { ok: true, voices: [] }; }
+  });
+
+  router.handle('auth.configs', () => getProviderConfigs());
+
+  router.handle('auth.save', (p) => {
+    const { providerId, apiKey, defaultModel } = p;
+    if (typeof providerId !== 'string' || !providerId.length || providerId.length > 100) err(400, 'Invalid providerId');
+    if (typeof apiKey !== 'string' || !apiKey.length || apiKey.length > 10000) err(400, 'Invalid apiKey');
+    if (defaultModel !== undefined && (typeof defaultModel !== 'string' || defaultModel.length > 200)) err(400, 'Invalid defaultModel');
+    const configPath = saveProviderConfig(providerId, apiKey, defaultModel || '');
+    return { success: true, path: configPath };
+  });
+
+  router.handle('import.claude', () => ({ imported: queries.importClaudeCodeConversations() }));
+
+  router.handle('discover.claude', () => ({ discovered: queries.discoverClaudeCodeConversations() }));
+
+  router.handle('gemini.start', async () => {
+    try {
+      const result = await startGeminiOAuth();
+      return { authUrl: result.authUrl, mode: result.mode };
+    } catch (e) { err(500, e.message); }
+  });
+
+  router.handle('gemini.status', () => {
+    const st = typeof geminiOAuthState === 'function' ? geminiOAuthState() : geminiOAuthState;
+    return st;
+  });
+
+  router.handle('gemini.relay', async (p) => {
+    const { code, state } = p;
+    if (!code || !state) err(400, 'Missing code or state');
+    try {
+      const email = await exchangeGeminiOAuthCode(code, state);
+      return { success: true, email };
+    } catch (e) { err(400, e.message); }
+  });
+
+  router.handle('gemini.complete', async (p) => {
+    const pastedUrl = (p.url || '').trim();
+    if (!pastedUrl) err(400, 'No URL provided');
+    let parsed;
+    try { parsed = new URL(pastedUrl); } catch { err(400, 'Invalid URL. Paste the full URL from the browser address bar.'); }
+    const urlError = parsed.searchParams.get('error');
+    if (urlError) {
+      const desc = parsed.searchParams.get('error_description') || urlError;
+      return { error: desc };
+    }
+    const code = parsed.searchParams.get('code');
+    const state = parsed.searchParams.get('state');
+    try {
+      const email = await exchangeGeminiOAuthCode(code, state);
+      return { success: true, email };
+    } catch (e) { err(400, e.message); }
+  });
+
+  router.handle('ws.stats', () => wsOptimizer.getStats());
+}

package/lib/ws-optimizer.js

@@ -116,7 +116,7 @@ class WSOptimizer {
     this.clientQueues = new Map();
   }
 
-  sendToClient(ws, event) {
+  sendToClient(ws, event, originalType) {
     if (ws.readyState !== 1) return;
     let queue = this.clientQueues.get(ws);
     if (!queue) {
@@ -124,7 +124,7 @@ class WSOptimizer {
       this.clientQueues.set(ws, queue);
     }
     const data = typeof event === 'string' ? event : JSON.stringify(event);
-    const priority = typeof event === 'object' ? getPriority(event.type) : 2;
+    const priority = typeof event === 'object' ? getPriority(originalType || event.type) : 2;
     queue.add(data, priority);
   }
 

package/lib/ws-protocol.js

@@ -0,0 +1,81 @@
+class WsRouter {
+  constructor() {
+    this.handlers = new Map();
+    this.legacyHandler = null;
+  }
+
+  handle(method, fn) {
+    this.handlers.set(method, fn);
+    return this;
+  }
+
+  onLegacy(fn) {
+    this.legacyHandler = fn;
+    return this;
+  }
+
+  reply(ws, requestId, data) {
+    if (ws.readyState === 1) {
+      ws.send(JSON.stringify({ r: requestId, d: data || {} }));
+    }
+  }
+
+  replyError(ws, requestId, code, message) {
+    if (ws.readyState === 1) {
+      ws.send(JSON.stringify({ r: requestId, e: { c: code, m: message } }));
+    }
+  }
+
+  send(ws, type, data) {
+    if (ws.readyState === 1) {
+      ws.send(JSON.stringify({ t: type, d: data || {} }));
+    }
+  }
+
+  broadcast(clients, type, data) {
+    const msg = JSON.stringify({ t: type, d: data || {} });
+    for (const ws of clients) {
+      if (ws.readyState === 1) ws.send(msg);
+    }
+  }
+
+  async onMessage(ws, rawData) {
+    let parsed;
+    try {
+      parsed = JSON.parse(rawData);
+    } catch {
+      if (ws.readyState === 1) {
+        ws.send(JSON.stringify({ r: null, e: { c: 400, m: 'Invalid JSON' } }));
+      }
+      return;
+    }
+
+    if (parsed.m && parsed.r !== undefined) {
+      const handler = this.handlers.get(parsed.m);
+      if (!handler) {
+        this.replyError(ws, parsed.r, 404, `Unknown method: ${parsed.m}`);
+        return;
+      }
+      try {
+        const result = await handler(parsed.p || {}, ws);
+        this.reply(ws, parsed.r, result);
+      } catch (err) {
+        const code = err.code || 500;
+        const message = err.message || 'Internal error';
+        this.replyError(ws, parsed.r, code, message);
+      }
+      return;
+    }
+
+    if (this.legacyHandler) {
+      this.legacyHandler(parsed, ws);
+      return;
+    }
+
+    if (parsed.r !== undefined) {
+      this.replyError(ws, parsed.r, 400, 'Missing method');
+    }
+  }
+}
+
+export { WsRouter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.397",
+  "version": "1.0.399",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",
@@ -17,7 +17,8 @@
   "homepage": "https://github.com/AnEntrypoint/agentgui#readme",
   "scripts": {
     "start": "node server.js",
-    "dev": "node server.js --watch"
+    "dev": "node server.js --watch",
+    "postinstall": "node scripts/patch-fsbrowse.js"
   },
   "dependencies": {
     "@anthropic-ai/claude-code": "^2.1.37",

package/scripts/patch-fsbrowse.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+/**
+ * Patch script to fix Windows path duplication issue in fsbrowse
+ * Fixes: Error ENOENT: no such file or directory, scandir 'C:\C:\dev'
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const fsbrowsePath = path.join(__dirname, '..', 'node_modules', 'fsbrowse', 'index.js');
+
+if (!fs.existsSync(fsbrowsePath)) {
+  console.warn('[PATCH] fsbrowse not found, skipping patch');
+  process.exit(0);
+}
+
+try {
+  let content = fs.readFileSync(fsbrowsePath, 'utf8');
+
+  // Check if patch is already applied
+  if (content.includes('sanitizedIsAbsoluteOnDrive')) {
+    console.log('[PATCH] fsbrowse Windows path fix already applied');
+    process.exit(0);
+  }
+
+  // Replace the makeResolver function with the fixed version
+  const oldMakeResolver = `function makeResolver(baseDir) {
+  return function resolveWithBaseDir(relPath) {
+    const sanitized = sanitizePath(relPath);
+    const fullPath = path.resolve(baseDir, sanitized);
+    if (!fullPath.startsWith(baseDir)) {
+      return { ok: false, error: 'EPATHINJECTION' };
+    }
+    return { ok: true, path: fullPath };
+  };
+}`;
+
+  const newMakeResolver = `function makeResolver(baseDir) {
+  const normalizedBase = path.normalize(baseDir);
+  const baseDriveLetter = normalizedBase.match(/^[A-Z]:/i)?.[0];
+
+  return function resolveWithBaseDir(relPath) {
+    const sanitized = sanitizePath(relPath);
+    let fullPath;
+
+    // Extract drive letter from both paths to check for same-drive duplication on Windows
+    const sanitizedDriveLetter = sanitized.match(/^[A-Z]:/i)?.[0];
+    const sanitizedIsAbsoluteOnDrive = /^[A-Z]:/i.test(sanitized);
+
+    // If both paths are on the same Windows drive, strip the drive letter from relPath
+    // to avoid duplication like C:\\C:\\dev
+    if (baseDriveLetter && sanitizedIsAbsoluteOnDrive && sanitizedDriveLetter === baseDriveLetter) {
+      // Remove drive letter and leading slashes to make it relative
+      const relativePath = sanitized.replace(/^[A-Z]:[\/\\]?/i, '');
+      fullPath = path.resolve(normalizedBase, relativePath);
+    } else {
+      fullPath = path.resolve(normalizedBase, sanitized);
+    }
+
+    // Normalize for consistent comparison
+    const normalizedFullPath = path.normalize(fullPath);
+    const normalizedComparisonBase = path.normalize(normalizedBase);
+
+    // Check path injection - convert backslashes to forward slashes for comparison
+    const normalizedCheck = normalizedFullPath.replace(/\\\\/g, '/');
+    const normalizedBaseCheck = normalizedComparisonBase.replace(/\\\\/g, '/');
+
+    if (!normalizedCheck.startsWith(normalizedBaseCheck)) {
+      return { ok: false, error: 'EPATHINJECTION' };
+    }
+    return { ok: true, path: normalizedFullPath };
+  };
+}`;
+
+  if (content.includes(oldMakeResolver)) {
+    content = content.replace(oldMakeResolver, newMakeResolver);
+    fs.writeFileSync(fsbrowsePath, content, 'utf8');
+    console.log('[PATCH] fsbrowse Windows path fix applied successfully');
+  } else {
+    console.warn('[PATCH] Could not find makeResolver function to patch');
+  }
+} catch (err) {
+  console.error('[PATCH] Error applying fsbrowse patch:', err.message);
+  process.exit(1);
+}