agentgui 1.0.991 → 1.0.993

package/lib/acp-sdk-manager.js

@@ -179,12 +179,6 @@ export function getPort(agentId) {
   return acpMachine.isHealthy(agentId) ? (ACP_TOOLS.find(t => t.id === agentId)?.port || null) : null;
 }
 
-export function getRunningPorts() {
-  const ports = {};
-  for (const tool of ACP_TOOLS) { if (acpMachine.isHealthy(tool.id)) ports[tool.id] = tool.port; }
-  return ports;
-}
-
 export async function restart(agentId) {
   const tool = ACP_TOOLS.find(t => t.id === agentId);
   if (!tool) return false;

package/lib/acp-server-machine.js

@@ -160,10 +160,6 @@ export function getBackoffDelay(toolId) {
   return calcBackoff(purgeOldRestarts(s.context.restarts));
 }
 
-export function getMachineActors() {
-  return actors;
-}
-
 export function stopAll() {
   for (const [, actor] of actors) actor.stop();
   actors.clear();

package/lib/agent-descriptors.js

@@ -43,6 +43,3 @@ export function getAgentDescriptor(agentId) {
   return agentDescriptorCache.get(agentId) || null;
 }
 
-export function getAllDescriptors() {
-  return Object.fromEntries(agentDescriptorCache);
-}

package/lib/asset-server.js

@@ -124,40 +124,3 @@ export function serveFile(filePath, res, req, { compressAndSend, acceptsEncoding
     });
   });
 }
-
-export function createChunkBatcher(queries, debugLog) {
-  const pending = [];
-  let timer = null;
-  const BATCH_SIZE = 10;
-  const BATCH_INTERVAL = 50;
-
-  function flush() {
-    if (pending.length === 0) return;
-    const batch = pending.splice(0);
-    try {
-      const tx = queries._db ? queries._db.transaction(() => {
-        for (const c of batch) queries.createChunk(c.sessionId, c.conversationId, c.sequence, c.type, c.data);
-      }) : null;
-      if (tx) { tx(); } else {
-        for (const c of batch) {
-          try { queries.createChunk(c.sessionId, c.conversationId, c.sequence, c.type, c.data); } catch (e) { debugLog(`[chunk] ${e.message}`); }
-        }
-      }
-    } catch (err) {
-      debugLog(`[chunk-batch] Batch write failed: ${err.message}`);
-      for (const c of batch) {
-        try { queries.createChunk(c.sessionId, c.conversationId, c.sequence, c.type, c.data); } catch (_) {}
-      }
-    }
-  }
-
-  function add(sessionId, conversationId, sequence, blockType, blockData) {
-    pending.push({ sessionId, conversationId, sequence, type: blockType, data: blockData });
-    if (pending.length >= BATCH_SIZE) { if (timer) { clearTimeout(timer); timer = null; } flush(); }
-    else if (!timer) { timer = setTimeout(() => { timer = null; flush(); }, BATCH_INTERVAL); }
-  }
-
-  function drain() { if (timer) { clearTimeout(timer); timer = null; } flush(); }
-
-  return { add, drain };
-}

package/lib/claude-runner-run.js

@@ -43,6 +43,4 @@ export async function runClaudeWithStreaming(prompt, cwd, agentId = 'claude-code
   return agent.run(prompt, cwd, enhancedConfig);
 }
 
-export function getRegisteredAgents() { return registry.list(); }
-export function isAgentRegistered(agentId) { return registry.has(agentId); }
 export default runClaudeWithStreaming;

package/lib/execution-machine.js

@@ -140,17 +140,6 @@ export function snapshot(convId) {
   return actor ? actor.getSnapshot() : null;
 }
 
-export function isStreaming(convId) {
-  const s = snapshot(convId);
-  return s ? s.value === 'streaming' || s.value === 'rate_limited' : false;
-}
-
-export function isActive(convId) {
-  const s = snapshot(convId);
-  if (!s) return false;
-  return s.value === 'streaming' || s.value === 'rate_limited' || s.value === 'draining';
-}
-
 export function getContext(convId) {
   const s = snapshot(convId);
   return s ? s.context : null;

package/lib/gm-agent-configs.js

@@ -64,14 +64,3 @@ export async function installGMAgentConfigs() {
   });
   log('results: ' + summary.join(', '));
 }
-
-export async function forceReinstallGMAgentConfigs() {
-  log('force reinstalling all agent configs');
-  const results = await Promise.allSettled(GM_PACKAGES.map(p => runInstaller(p.pkg)));
-  const summary = GM_PACKAGES.map((p, i) => {
-    const r = results[i];
-    const ok = r.status === 'fulfilled' && r.value;
-    return p.pkg + ': ' + (ok ? 'ok' : 'failed');
-  });
-  log('results: ' + summary.join(', '));
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.991",
+  "version": "1.0.993",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",

package/lib/plugins/files-plugin.js

@@ -1,114 +0,0 @@
-// Files plugin - file browser, upload handler, drag-drop support
-
-import path from 'path';
-import fs from 'fs';
-import { confineToRoots, fsAllowRoots } from '../http-handler.js';
-
-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) => {
-      const conf = confineToRoots(dir, fsAllowRoots());
-      if (!conf.ok) return [];
-      try {
-        const entries = fs.readdirSync(conf.realPath);
-        return entries.map(entry => {
-          const fullPath = path.join(conf.realPath, entry);
-          try {
-            const stat = fs.statSync(fullPath);
-            return {
-              name: entry,
-              path: fullPath,
-              isDirectory: stat.isDirectory(),
-              size: stat.size,
-            };
-          } catch (_) {
-            return null;
-          }
-        }).filter(Boolean);
-      } catch (e) {
-        return [];
-      }
-    };
-
-    return {
-      routes: [
-        {
-          method: 'GET',
-          path: '/files/:conversationId',
-          handler: (req, res) => {
-            const { conversationId } = req.params;
-            const { dir } = req.query;
-            const requestedDir = dir || process.cwd();
-            const conf = confineToRoots(requestedDir, fsAllowRoots());
-            if (!conf.ok) {
-              return res.status(403).json({ error: 'Path not allowed' });
-            }
-            const entries = browseDirectory(conf.realPath);
-            res.json({ entries, currentDir: conf.realPath });
-          },
-        },
-        {
-          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;
-            if (!folderPath || typeof folderPath !== 'string') {
-              return res.status(400).json({ error: 'path is required' });
-            }
-            // Sanitize each path component - reject traversal attempts
-            const parts = folderPath.split(/[/\\]/);
-            for (const part of parts) {
-              if (part === '..' || part === '.' || /[<>:"|?*\x00-\x1f]/.test(part)) {
-                return res.status(400).json({ error: 'Invalid path component' });
-              }
-            }
-            const conf = confineToRoots(folderPath, fsAllowRoots());
-            if (!conf.ok && conf.reason !== 'not found') {
-              return res.status(403).json({ error: 'Path not allowed' });
-            }
-            // For mkdir, path may not exist yet; re-check parent is confined
-            const parentConf = confineToRoots(path.dirname(folderPath), fsAllowRoots());
-            if (!parentConf.ok) {
-              return res.status(403).json({ error: 'Path not allowed' });
-            }
-            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() {},
-};