agentgui 1.0.917 → 1.0.918

package/lib/ws-handlers-util.js

@@ -1,175 +1,106 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { execSync, spawnSync } from 'child_process';
-import * as toolInstallMachine from './tool-install-machine.js';
-
-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,
-    STARTUP_CWD, voiceCacheManager, toolManager, discoveredAgents } = deps;
-
-  router.handle('home', () => ({ home: os.homedir(), cwd: STARTUP_CWD }));
-
-  router.handle('folders', (p) => {
-    const folderPath = p.path || STARTUP_CWD;
-    try {
-      const raw = folderPath.startsWith('~') ? folderPath.replace('~', os.homedir()) : folderPath;
-      const entries = fs.readdirSync(path.resolve(raw), { withFileTypes: true });
-      return { folders: entries.filter(e => e.isDirectory() && !e.name.startsWith('.')).map(e => ({ name: e.name })).sort((a, b) => a.name.localeCompare(b.name)) };
-    } 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 githubUser = process.env.GITHUB_USER;
-      const ownsRemote = !remoteUrl.includes('github.com/') || (!!githubUser && remoteUrl.includes(githubUser));
-      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 () => {
-    const modelState = { modelsDownloading: modelDownloadState.downloading, modelsComplete: modelDownloadState.complete, modelsError: modelDownloadState.error };
-    try {
-      const { getStatus } = await getSpeech();
-      const base = getStatus();
-      return { ...base, setupMessage: base.ttsReady ? 'pocket-tts ready' : 'Will setup on first TTS request', ...modelState, modelsProgress: modelDownloadState.progress };
-    } catch {
-      return { sttReady: false, ttsReady: false, sttLoading: false, ttsLoading: false, setupMessage: 'Will setup on first TTS request', ...modelState };
-    }
-  });
-
-  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('ws.stats', () => wsOptimizer.getStats());
-
-  router.handle('voice.cache', async (p) => {
-    const { conversationId, text } = p;
-    if (!conversationId || !text) err(400, 'Missing conversationId or text');
-    try {
-      const cached = queries.getVoiceCache(conversationId, text);
-      if (cached && cached.audioBlob) {
-        return { ok: true, cached: true, byteSize: cached.byteSize };
-      }
-      return { ok: true, cached: false };
-    } catch (e) { err(500, e.message); }
-  });
-
-  router.handle('voice.generate', async (p) => {
-    const { conversationId, text } = p;
-    if (!conversationId || !text) err(400, 'Missing conversationId or text');
-    try {
-      const result = await voiceCacheManager.getOrGenerateCache(conversationId, text);
-      return { ok: true, byteSize: result.byteSize, cached: true };
-    } catch (e) { err(500, e.message); }
-  });
-
-  router.handle('tools.list', async () => {
-    try {
-      const tools = await toolManager.getAllToolsAsync();
-      return { tools: tools.map((t) => {
-        const machineState = toolInstallMachine.getState(t.id);
-        return { id: t.id, name: t.name, pkg: t.pkg, category: t.category || 'plugin', installed: t.installed, status: t.installed ? (t.isUpToDate ? 'installed' : 'needs_update') : 'not_installed', isUpToDate: t.isUpToDate, upgradeNeeded: t.upgradeNeeded, hasUpdate: t.upgradeNeeded && t.installed, installedVersion: t.installedVersion, publishedVersion: t.publishedVersion, machineState };
-      }) };
-    } catch (e) { err(500, e.message); }
-  });
-
-  const SUB_AGENT_MAP = {
-    'opencode': [{ id: 'gm-oc', name: 'GM OpenCode' }], 'cli-opencode': [{ id: 'gm-oc', name: 'GM OpenCode' }],
-    'gemini': [{ id: 'gm-gc', name: 'GM Gemini' }], 'cli-gemini': [{ id: 'gm-gc', name: 'GM Gemini' }],
-    'kilo': [{ id: 'gm-kilo', name: 'GM Kilo' }], 'cli-kilo': [{ id: 'gm-kilo', name: 'GM Kilo' }],
-    'codex': [], 'cli-codex': []
-  };
-
-  router.handle('agent.subagents', async (p) => {
-    if (!p.id) err(400, 'Missing agent id');
-    if (p.id === 'claude-code' || p.id === 'cli-claude') {
-      const spawnEnv = { ...process.env }; delete spawnEnv.CLAUDECODE;
-      const result = spawnSync('claude', ['agents', 'list'], { encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'], env: spawnEnv });
-      if (result.status !== 0 || !result.stdout) return { subAgents: [] };
-      const agents = result.stdout.trim().split('\n').filter(l => l.trim()).map(l => l.match(/^  (\S+)\s+·/)).filter(Boolean).map(m => ({ id: m[1], name: m[1] }));
-      console.log('[agent.subagents] claude agents list found:', agents.map(a => a.id).join(', '));
-      return { subAgents: agents };
-    }
-    const subAgents = SUB_AGENT_MAP[p.id] || [];
-    const tools = await toolManager.getAllToolsAsync();
-    const installed = new Set(tools.filter(t => t.category === 'plugin' && t.installed).map(t => t.id));
-    return { subAgents: subAgents.filter(sa => installed.has(sa.id)) };
-  });
-}
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execSync, spawnSync } from 'child_process';
+
+function err(code, message) { const e = new Error(message); e.code = code; throw e; }
+
+const SUB_AGENT_MAP = {
+  'opencode': [{ id: 'gm-oc', name: 'GM OpenCode' }], 'cli-opencode': [{ id: 'gm-oc', name: 'GM OpenCode' }],
+  'gemini': [{ id: 'gm-gc', name: 'GM Gemini' }], 'cli-gemini': [{ id: 'gm-gc', name: 'GM Gemini' }],
+  'kilo': [{ id: 'gm-kilo', name: 'GM Kilo' }], 'cli-kilo': [{ id: 'gm-kilo', name: 'GM Kilo' }],
+  'codex': [], 'cli-codex': []
+};
+
+export function register(router, deps) {
+  const { queries, wsOptimizer, broadcastSync, getProviderConfigs, saveProviderConfig, STARTUP_CWD, discoveredAgents } = deps;
+
+  router.handle('home', () => ({ home: os.homedir(), cwd: STARTUP_CWD }));
+
+  router.handle('folders', (p) => {
+    const folderPath = p.path || STARTUP_CWD;
+    try {
+      const raw = folderPath.startsWith('~') ? folderPath.replace('~', os.homedir()) : folderPath;
+      const entries = fs.readdirSync(path.resolve(raw), { withFileTypes: true });
+      return { folders: entries.filter(e => e.isDirectory() && !e.name.startsWith('.')).map(e => ({ name: e.name })).sort((a, b) => a.name.localeCompare(b.name)) };
+    } 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 githubUser = process.env.GITHUB_USER;
+      const ownsRemote = !remoteUrl.includes('github.com/') || (!!githubUser && remoteUrl.includes(githubUser));
+      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('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('ws.stats', () => wsOptimizer.getStats());
+
+  router.handle('agent.subagents', async (p) => {
+    if (!p.id) err(400, 'Missing agent id');
+    if (p.id === 'claude-code' || p.id === 'cli-claude') {
+      const spawnEnv = { ...process.env }; delete spawnEnv.CLAUDECODE;
+      const result = spawnSync('claude', ['agents', 'list'], { encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'], env: spawnEnv });
+      if (result.status !== 0 || !result.stdout) return { subAgents: [] };
+      const agents = result.stdout.trim().split('\n').filter(l => l.trim()).map(l => l.match(/^  (\S+)\s+·/)).filter(Boolean).map(m => ({ id: m[1], name: m[1] }));
+      return { subAgents: agents };
+    }
+    return { subAgents: SUB_AGENT_MAP[p.id] || [] };
+  });
+}

package/lib/ws-legacy-handlers.js

@@ -1,9 +1,4 @@
-import { spawn } from 'child_process';
-import { createRequire } from 'module';
-
-const _req = createRequire(import.meta.url);
-
-export function registerLegacyHandler(wsRouter, { subscriptionIndex, execMachine, activeExecutions, messageQueues, checkpointManager, queries, pm2Manager, pm2Subscribers, getSeq, sendWs, debugLog }) {
+export function registerLegacyHandler(wsRouter, { subscriptionIndex, execMachine, activeExecutions, messageQueues, queries, getSeq, sendWs, debugLog }) {
   wsRouter.onLegacy((data, ws) => {
     try {
       if (data.type === 'subscribe') {
@@ -29,19 +24,6 @@ export function registerLegacyHandler(wsRouter, { subscriptionIndex, execMachine
           const queueLength = execMachine.getQueue(data.conversationId).length || messageQueues.get(data.conversationId)?.length || 0;
           sendWs(ws, { type: 'streaming_start', sessionId, conversationId: data.conversationId, agentId: conv?.agentType || conv?.agentId || 'claude-code', queueLength, resumed: true, seq: getSeq(), timestamp: Date.now() });
         }
-        if (data.conversationId && checkpointManager.hasPendingCheckpoint(data.conversationId)) {
-          const checkpoint = checkpointManager.getPendingCheckpoint(data.conversationId);
-          if (checkpoint) {
-            debugLog(`[checkpoint] Injecting ${checkpoint.events.length} events to client for ${data.conversationId}`);
-            const latestSession = queries.getLatestSession(data.conversationId);
-            if (latestSession) {
-              sendWs(ws, { type: 'streaming_resumed', sessionId: latestSession.id, conversationId: data.conversationId, resumeFrom: checkpoint.sessionId, eventCount: checkpoint.events.length, chunkCount: checkpoint.chunks.length, timestamp: Date.now() });
-              checkpointManager.injectCheckpointEvents(latestSession.id, checkpoint, (evt) => {
-                sendWs(ws, { ...evt, sessionId: latestSession.id, conversationId: data.conversationId });
-              });
-            }
-          }
-        }
       } else if (data.type === 'unsubscribe') {
         if (data.sessionId) {
           ws.subscriptions.delete(data.sessionId);
@@ -57,97 +39,12 @@ export function registerLegacyHandler(wsRouter, { subscriptionIndex, execMachine
         debugLog(`[WebSocket] Client ${ws.clientId} unsubscribed from ${data.sessionId || data.conversationId}`);
       } else if (data.type === 'get_subscriptions') {
         sendWs(ws, { type: 'subscriptions', subscriptions: Array.from(ws.subscriptions), timestamp: Date.now() });
-      } else if (data.type === 'set_voice') {
-        ws.ttsVoiceId = data.voiceId || 'default';
       } else if (data.type === 'latency_report') {
         ws.latencyTier = data.quality || 'good';
         ws.latencyAvg = data.avg || 0;
         ws.latencyTrend = data.trend || 'stable';
       } else if (data.type === 'ping') {
         sendWs(ws, { type: 'pong', requestId: data.requestId, timestamp: Date.now() });
-      } else if (data.type === 'terminal_start') {
-        if (ws.terminalProc) { try { ws.terminalProc.kill(); } catch (_) {} }
-        try {
-          const pty = _req('node-pty');
-          const shell = process.env.SHELL || '/bin/bash';
-          const cwd = data.cwd || process.env.STARTUP_CWD || process.env.HOME || '/';
-          const proc = pty.spawn(shell, [], { name: 'xterm-256color', cols: data.cols || 80, rows: data.rows || 24, cwd, env: { ...process.env, TERM: 'xterm-256color', COLORTERM: 'truecolor' } });
-          ws.terminalProc = proc;
-          ws.terminalPty = true;
-          proc.on('data', (chunk) => { if (ws.readyState === 1) sendWs(ws, { type: 'terminal_output', data: Buffer.from(chunk).toString('base64'), encoding: 'base64' }); });
-          proc.on('exit', (code) => { if (ws.readyState === 1) sendWs(ws, { type: 'terminal_exit', code }); ws.terminalProc = null; });
-          proc.on('error', (err) => { console.error('[TERMINAL] PTY error (contained):', err.message); if (ws.readyState === 1) sendWs(ws, { type: 'terminal_exit', code: 1, error: err.message }); ws.terminalProc = null; });
-          sendWs(ws, { type: 'terminal_started', timestamp: Date.now() });
-        } catch (_e) {
-          console.error('[TERMINAL] Failed to spawn PTY, falling back to pipes:', _e.message);
-          const shell = process.env.SHELL || '/bin/bash';
-          const cwd = data.cwd || process.env.STARTUP_CWD || process.env.HOME || '/';
-          const proc = spawn(shell, ['-i'], { cwd, env: { ...process.env, TERM: 'xterm-256color', COLORTERM: 'truecolor' }, stdio: ['pipe', 'pipe', 'pipe'] });
-          ws.terminalProc = proc;
-          ws.terminalPty = false;
-          proc.stdout.on('data', (chunk) => { if (ws.readyState === 1) sendWs(ws, { type: 'terminal_output', data: chunk.toString('base64'), encoding: 'base64' }); });
-          proc.stderr.on('data', (chunk) => { if (ws.readyState === 1) sendWs(ws, { type: 'terminal_output', data: chunk.toString('base64'), encoding: 'base64' }); });
-          proc.on('exit', (code) => { if (ws.readyState === 1) sendWs(ws, { type: 'terminal_exit', code }); ws.terminalProc = null; });
-          proc.on('error', (err) => { console.error('[TERMINAL] Spawn error (contained):', err.message); if (ws.readyState === 1) sendWs(ws, { type: 'terminal_exit', code: 1, error: err.message }); ws.terminalProc = null; });
-          proc.stdin.on('error', () => {});
-          proc.stdout.on('error', () => {});
-          proc.stderr.on('error', () => {});
-          sendWs(ws, { type: 'terminal_started', timestamp: Date.now() });
-        }
-      } else if (data.type === 'terminal_input') {
-        if (ws.terminalProc) {
-          try {
-            const input = Buffer.from(data.data, 'base64');
-            if (ws.terminalPty) { ws.terminalProc.write(input); }
-            else if (ws.terminalProc.stdin && ws.terminalProc.stdin.writable) { ws.terminalProc.stdin.write(input); }
-          } catch (_) {}
-        }
-      } else if (data.type === 'terminal_resize') {
-        if (ws.terminalProc && ws.terminalPty) {
-          try {
-            const { cols, rows } = data;
-            if (cols && rows && typeof ws.terminalProc.resize === 'function') { ws.terminalProc.resize(cols, rows); }
-          } catch (_) {}
-        }
-      } else if (data.type === 'terminal_stop') {
-        if (ws.terminalProc) { try { ws.terminalProc.kill(); } catch (_) {} ws.terminalProc = null; }
-      } else if (data.type === 'pm2_list') {
-        if (!pm2Manager.connected) {
-          if (ws.readyState === 1) sendWs(ws, { type: 'pm2_unavailable', reason: 'PM2 not connected', timestamp: Date.now() });
-        } else {
-          pm2Manager.listProcesses().then(processes => {
-            if (ws.readyState === 1) {
-              const hasActive = processes.some(p => ['online', 'launching', 'stopping', 'waiting restart'].includes(p.status));
-              sendWs(ws, { type: 'pm2_list_response', processes, hasActive });
-            }
-          }).catch(() => { if (ws.readyState === 1) sendWs(ws, { type: 'pm2_unavailable', reason: 'list failed', timestamp: Date.now() }); });
-        }
-      } else if (data.type === 'pm2_start_monitoring') {
-        pm2Subscribers.add(ws);
-        ws.pm2Subscribed = true;
-        if (!pm2Manager.connected) {
-          if (ws.readyState === 1) sendWs(ws, { type: 'pm2_unavailable', reason: 'PM2 not connected', timestamp: Date.now() });
-        } else {
-          sendWs(ws, { type: 'pm2_monitoring_started' });
-        }
-      } else if (data.type === 'pm2_stop_monitoring') {
-        pm2Subscribers.delete(ws);
-        ws.pm2Subscribed = false;
-        sendWs(ws, { type: 'pm2_monitoring_stopped' });
-      } else if (data.type === 'pm2_start') {
-        pm2Manager.startProcess(data.name).then(result => { sendWs(ws, { type: 'pm2_start_response', name: data.name, ...result }); });
-      } else if (data.type === 'pm2_stop') {
-        pm2Manager.stopProcess(data.name).then(result => { sendWs(ws, { type: 'pm2_stop_response', name: data.name, ...result }); });
-      } else if (data.type === 'pm2_restart') {
-        pm2Manager.restartProcess(data.name).then(result => { sendWs(ws, { type: 'pm2_restart_response', name: data.name, ...result }); });
-      } else if (data.type === 'pm2_delete') {
-        pm2Manager.deleteProcess(data.name).then(result => { sendWs(ws, { type: 'pm2_delete_response', name: data.name, ...result }); });
-      } else if (data.type === 'pm2_logs') {
-        pm2Manager.getLogs(data.name, { lines: data.lines || 100 }).then(result => { sendWs(ws, { type: 'pm2_logs_response', name: data.name, ...result }); });
-      } else if (data.type === 'pm2_flush_logs') {
-        pm2Manager.flushLogs(data.name).then(result => { sendWs(ws, { type: 'pm2_flush_logs_response', name: data.name, ...result }); });
-      } else if (data.type === 'pm2_ping') {
-        pm2Manager.ping().then(result => { sendWs(ws, { type: 'pm2_ping_response', ...result }); });
       }
     } catch (err) { console.error('[WS-LEGACY] Handler error (contained):', err.message); }
   });

package/lib/ws-setup.js

@@ -3,7 +3,7 @@ import path from 'path';
 import { WebSocketServer } from 'ws';
 import { registerLegacyHandler } from './ws-legacy-handlers.js';
 
-export function createWsSetup(server, { BASE_URL, watch, staticDir, _assetCache, htmlState, sendWs, wsRouter, debugLog, subscriptionIndex, syncClients, pm2Subscribers, wsOptimizer, legacyDeps }) {
+export function createWsSetup(server, { BASE_URL, watch, staticDir, _assetCache, htmlState, sendWs, wsRouter, debugLog, subscriptionIndex, syncClients, wsOptimizer, legacyDeps }) {
   const hotReloadClients = [];
 
   const wss = new WebSocketServer({ server, perMessageDeflate: false });
@@ -31,14 +31,12 @@ export function createWsSetup(server, { BASE_URL, watch, staticDir, _assetCache,
       ws.on('message', (msg) => { try { wsRouter.onMessage(ws, msg); } catch (e) { console.error('[WS] Message handler error (contained):', e.message); } });
       ws.on('pong', () => { ws.isAlive = true; });
       ws.on('close', () => {
-        if (ws.terminalProc) { try { ws.terminalProc.kill(); } catch (_) {} ws.terminalProc = null; }
         syncClients.delete(ws);
         wsOptimizer.removeClient(ws);
         for (const sub of ws.subscriptions) {
           const idx = subscriptionIndex.get(sub);
           if (idx) { idx.delete(ws); if (idx.size === 0) subscriptionIndex.delete(sub); }
         }
-        if (ws.pm2Subscribed) pm2Subscribers.delete(ws);
         debugLog(`[WebSocket] Client ${ws.clientId} disconnected`);
       });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.917",
+  "version": "1.0.918",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",
@@ -26,10 +26,8 @@
     "@agentclientprotocol/sdk": "^0.4.1",
     "@anthropic-ai/claude-code": "^2.1.37",
     "@google/gemini-cli": "latest",
-    "@huggingface/transformers": "^3.8.1",
     "@kilocode/cli": "latest",
     "@lanmower/ccf": "^1.0.4",
-    "audio-decode": "^2.2.3",
     "better-sqlite3": "^12.6.2",
     "busboy": "^1.6.0",
     "ccfollow": "^1.0.7",
@@ -37,13 +35,10 @@
     "express": "^5.2.1",
     "form-data": "^4.0.5",
     "fsbrowse": "latest",
-    "google-auth-library": "^10.5.0",
     "lru-cache": "^11.2.7",
     "msgpackr": "^1.11.8",
-    "onnxruntime-node": "1.21.0",
     "opencode-ai": "^1.2.15",
     "p-retry": "^7.1.1",
-    "pm2": "^5.4.3",
     "puppeteer-core": "^24.37.5",
     "webjsx": "^0.0.73",
     "webtalk": "^1.0.31",
@@ -51,15 +46,6 @@
     "xstate": "^5.28.0",
     "zod": "^4.3.6"
   },
-  "optionalDependencies": {
-    "node-pty": "^1.0.0"
-  },
-  "overrides": {
-    "onnxruntime-web": "npm:empty-npm-package@1.0.0",
-    "sharp": "npm:empty-npm-package@1.0.0",
-    "onnxruntime-common": "1.21.0",
-    "onnxruntime-node": "1.21.0"
-  },
   "devDependencies": {
     "electron": "^35.0.0",
     "playwright": "^1.59.1",

package/server.js

@@ -9,11 +9,8 @@ import { queries } from './database.js';
 import { runClaudeWithStreaming } from './lib/claude-runner-run.js';
 import { initializeDescriptors, getAgentDescriptor } from './lib/agent-descriptors.js';
 import { discoverExternalACPServers, initializeAgentDiscovery } from './lib/agent-discovery.js';
-import { startGeminiOAuth, exchangeGeminiOAuthCode, handleGeminiOAuthCallback, getGeminiOAuthStatus, getGeminiOAuthState } from './lib/oauth-gemini.js';
-import { initSpeechManager, getSpeech, voiceCacheManager, modelDownloadState, ensureModelsDownloaded, eagerTTS } from './lib/speech-manager.js';
 import { createRegistry } from './lib/routes-registry.js';
 import { BROADCAST_TYPES } from './lib/broadcast.js';
-import { startCodexOAuth, exchangeCodexOAuthCode, handleCodexOAuthCallback, getCodexOAuthStatus, getCodexOAuthState, CODEX_HOME, CODEX_AUTH_FILE } from './lib/oauth-codex.js';
 import { WSOptimizer } from './lib/ws-optimizer.js';
 import { WsRouter } from './lib/ws-protocol.js';
 import { encode as wsEncode } from './lib/codec.js';
@@ -25,12 +22,8 @@ import { createAutoImport, createDbRecovery, createPluginLoader } from './lib/se
 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';
-import * as toolInstallMachine from './lib/tool-install-machine.js';
 import { _assetCache, htmlState, generateETag, warmAssetCache, serveFile as _serveFile } from './lib/asset-server.js';
 import { installGMAgentConfigs } from './lib/gm-agent-configs.js';
-import * as toolManager from './lib/tool-manager.js';
-import { pm2Manager } from './lib/pm2-manager.js';
-import CheckpointManager from './lib/checkpoint-manager.js';
 import { createBroadcast } from './lib/broadcast.js';
 import { createRecovery } from './lib/recovery.js';
 import { parseRateLimitResetTime } from './lib/process-message-rate-limit.js';
@@ -42,9 +35,7 @@ import { logError, errLogPath, makeCleanupExecution, makeGetModelsForAgent } fro
 
 
 process.on('uncaughtException', (err, origin) => { console.error('[FATAL] Uncaught exception:', err.message, '| origin:', origin); console.error(err.stack); });
-
 process.on('unhandledRejection', (reason) => { console.error('[FATAL] Unhandled rejection:', reason instanceof Error ? reason.message : reason); if (reason instanceof Error) console.error(reason.stack); });
-
 process.on('SIGHUP', () => { console.log('[SIGNAL] SIGHUP received (ignored - uncrashable)'); });
 process.on('beforeExit', (code) => { console.log('[PROCESS] beforeExit with code:', code); });
 process.on('exit', (code) => { console.log('[PROCESS] exit with code:', code); });
@@ -55,7 +46,6 @@ const messageQueues = new Map();
 const rateLimitState = new Map();
 let _jsonlWatcher = null;
 const activeProcessesByRunId = new Map();
-const checkpointManager = new CheckpointManager(queries);
 const STUCK_AGENT_THRESHOLD_MS = 1800000;
 const NO_PID_GRACE_PERIOD_MS = 60000;
 
@@ -98,12 +88,11 @@ const _assetDeps = { compressAndSend, acceptsEncoding, watch, BASE_URL, PKG_VERS
 function serveFile(filePath, res, req) { return _serveFile(filePath, res, req, _assetDeps); }
 
 const _routes = {};
-const server = http.createServer(createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, serveFile, staticDir, messageQueues, getWss: () => wss, activeExecutions, getACPStatus, discoveredAgents, PKG_VERSION, RATE_LIMIT_MAX, rateLimitMap: _rateLimitMap, routes: _routes, handleGeminiOAuthCallback, handleCodexOAuthCallback, PORT }));
+const server = http.createServer(createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, serveFile, staticDir, messageQueues, getWss: () => wss, activeExecutions, getACPStatus, discoveredAgents, PKG_VERSION, RATE_LIMIT_MAX, rateLimitMap: _rateLimitMap, routes: _routes, PORT }));
 
 let broadcastSeq = 0;
 const syncClients = new Set();
 const subscriptionIndex = new Map();
-const pm2Subscribers = new Set();
 
 const wsOptimizer = new WSOptimizer();
 
@@ -120,24 +109,23 @@ const { scheduleRetry, drainMessageQueue } = createMessageQueue({ queries, messa
 
 const { processMessageWithStreaming } = createProcessMessage({
   queries, activeExecutions, rateLimitState, execMachine,
-  broadcastSync, runClaudeWithStreaming, cleanupExecution, checkpointManager,
+  broadcastSync, runClaudeWithStreaming, cleanupExecution,
   discoveredAgents, STARTUP_CWD, buildSystemPrompt,
-  parseRateLimitResetTime, eagerTTS, touchACP,
+  parseRateLimitResetTime, touchACP,
   getJsonlWatcher: () => _jsonlWatcher,
   debugLog, logError,
   scheduleRetry, drainMessageQueue, createEventHandler
 });
 
 const wsRouter = new WsRouter();
-createRegistry(wsRouter, { queries, sendJSON, parseBody, broadcastSync, debugLog, PORT, BASE_URL, rootDir, STARTUP_CWD, PKG_VERSION, processMessageWithStreaming, activeExecutions, activeProcessesByRunId, activeScripts, messageQueues, rateLimitState, cleanupExecution, discoveredAgents, getACPStatus, modelCache, getModelsForAgent, logError, toolManager, syncClients, wsOptimizer, errLogPath, getJsonlWatcher: () => getJsonlWatcher(), routes: _routes });
+createRegistry(wsRouter, { queries, sendJSON, parseBody, broadcastSync, debugLog, PORT, BASE_URL, rootDir, STARTUP_CWD, PKG_VERSION, processMessageWithStreaming, activeExecutions, activeProcessesByRunId, activeScripts, messageQueues, rateLimitState, cleanupExecution, discoveredAgents, getACPStatus, modelCache, getModelsForAgent, logError, syncClients, wsOptimizer, errLogPath, getJsonlWatcher: () => getJsonlWatcher(), routes: _routes });
 
 
 const { wss, hotReloadClients } = createWsSetup(server, {
   BASE_URL, watch, staticDir, _assetCache, htmlState, sendWs, wsRouter, debugLog,
-  subscriptionIndex, syncClients, pm2Subscribers, wsOptimizer,
+  subscriptionIndex, syncClients, wsOptimizer,
   legacyDeps: {
-    subscriptionIndex, execMachine, activeExecutions, messageQueues,
-    checkpointManager, queries, pm2Manager, pm2Subscribers,
+    subscriptionIndex, execMachine, activeExecutions, messageQueues, queries,
     getSeq: () => ++broadcastSeq, sendWs, debugLog
   }
 });
@@ -147,7 +135,6 @@ const { killActiveExecutions, recoverStaleSessions, resumeInterruptedStreams, is
   processMessageWithStreaming,
   queries,
   broadcastSync,
-  checkpointManager,
   drainMessageQueue,
   stuckThresholdMs: STUCK_AGENT_THRESHOLD_MS,
   noPidGracePeriodMs: NO_PID_GRACE_PERIOD_MS
@@ -157,7 +144,6 @@ process.on('SIGTERM', () => {
   console.log('[SIGNAL] SIGTERM received - graceful shutdown');
   killActiveExecutions();
   const _jw = getJsonlWatcher(); if (_jw) try { _jw.stop(); } catch (_) {}
-  try { pm2Manager.disconnect(); } catch (_) {}
   stopACPTools().catch(() => {}).finally(() => {
     try { wss.close(() => server.close(() => process.exit(0))); } catch (_) { process.exit(0); }
     setTimeout(() => process.exit(1), 5000);
@@ -180,9 +166,7 @@ const onServerListenStart = () => {
 server.on('error', (err) => {
   if (err.code === 'EADDRINUSE') {
     console.error(`Port ${PORT} already in use. Waiting 3 seconds before retry...`);
-    setTimeout(() => {
-      server.listen(PORT, onServerListenStart);
-    }, 3000);
+    setTimeout(() => { server.listen(PORT, onServerListenStart); }, 3000);
   } else {
     console.error('[SERVER] Error (contained):', err.message);
   }
@@ -195,11 +179,10 @@ const { loadPluginExtensions } = createPluginLoader({ pluginsDir: path.join(__di
 setInterval(performDbRecovery, 300000);
 
 const { onServerReady, getJsonlWatcher } = createOnServerReady({
-  queries, broadcastSync, warmAssetCache, staticDir, toolManager, discoveredAgents,
+  queries, broadcastSync, warmAssetCache, staticDir, discoveredAgents,
   PORT, BASE_URL, watch, setWatcher: (w) => { _jsonlWatcher = w; }, resumeInterruptedStreams, activeExecutions,
   debugLog, installGMAgentConfigs, startACPTools, getACPStatus, execMachine,
-  toolInstallMachine, getSpeech, ensureModelsDownloaded, performAutoImport,
-  performAgentHealthCheck, pm2Manager, pm2Subscribers, recoverStaleSessions
+  performAutoImport, performAgentHealthCheck, recoverStaleSessions
 });
 
 server.listen(PORT, onServerListenStart);