agentgui 1.0.816 → 1.0.818

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2026-04-11
+- refactor: split jsonl-watcher.js parse/event logic into jsonl-parser.js; watcher retains file watching/polling only
+- refactor: split tool-version.js into tool-version-check.js (sync) and tool-version-fetch.js (async/network)
+
 ## [Unreleased]
 ### Refactor
 - Strip all standalone comment lines (// and /* */ block lines) from 14 static JS files: event-filter.js, image-loader.js, syntax-highlighter.js, client.js, streaming-renderer.js, ui-components.js, conversations.js, websocket-manager.js, conv-machine.js, ws-machine.js, ws-client.js, state-barrier.js, script-runner.js, theme.js. Total 781 comment lines removed. All files syntax-verified.

package/lib/jsonl-parser.js

@@ -0,0 +1,179 @@
+import path from 'path';
+
+export class JsonlParser {
+  constructor({ broadcastSync, queries, ownedSessionIds }) {
+    this._bc = broadcastSync;
+    this._q = queries;
+    this._owned = ownedSessionIds;
+    this._convMap = new Map();
+    this._emitted = new Map();
+    this._seqs = new Map();
+    this._streaming = new Set();
+    this._sessions = new Map();
+  }
+
+  clear() {
+    this._convMap.clear();
+    this._emitted.clear();
+    this._seqs.clear();
+    this._streaming.clear();
+    this._sessions.clear();
+  }
+
+  removeSid(sid) {
+    this._convMap.delete(sid);
+    this._seqs.delete(sid);
+    this._streaming.delete(sid);
+    this._sessions.delete(sid);
+    for (const key of [...this._emitted.keys()]) if (key.startsWith(`${sid}:`)) this._emitted.delete(key);
+  }
+
+  endAllStreaming() {
+    for (const sid of [...this._streaming]) this._endStreaming(this._convMap.get(sid), sid);
+  }
+
+  _line(fp, line) {
+    line = line.trim(); if (!line) return;
+    let e; try { e = JSON.parse(line); } catch (_) { return; }
+    if (!e || !e.sessionId) return;
+    if (this._owned?.has(e.sessionId)) return;
+    const cid = this._conv(e.sessionId, e, fp);
+    if (cid) this._route(cid, e.sessionId, e);
+  }
+
+  _conv(sid, e) {
+    if (this._convMap.has(sid)) return this._convMap.get(sid);
+    const found = this._q.getConversations().find(c => c.claudeSessionId === sid);
+    if (found) { this._convMap.set(sid, found.id); return found.id; }
+    if (e.type === 'queue-operation' || e.type === 'last-prompt') return null;
+    if (e.type === 'user' && e.isMeta) return null;
+    const cwd = e.cwd || process.cwd();
+    const branch = e.gitBranch || '';
+    const base = path.basename(cwd);
+    const title = branch ? `${branch} @ ${base}` : base;
+    const conv = this._q.createConversation('claude-code', title, cwd);
+    this._q.setClaudeSessionId(conv.id, sid);
+    this._convMap.set(sid, conv.id);
+    this._bc({ type: 'conversation_created', conversation: conv, timestamp: Date.now() });
+    return conv.id;
+  }
+
+  _seq(sid) { const n = (this._seqs.get(sid) || 0) + 1; this._seqs.set(sid, n); return n; }
+
+  _dbSession(cid, sid) {
+    if (this._sessions.has(sid)) return this._sessions.get(sid);
+    const sess = this._q.createSession(cid);
+    this._q.updateSession(sess.id, { status: 'active' });
+    this._sessions.set(sid, sess.id);
+    return sess.id;
+  }
+
+  _emit(cid, sid, block, role, extra) {
+    const dbSid = this._dbSession(cid, sid);
+    const seq = this._seq(sid);
+    try { this._q.createChunk(dbSid, cid, seq, block.type || 'unknown', block); } catch (_) {}
+    this._bc({ type: 'streaming_progress', sessionId: dbSid, conversationId: cid, block, blockRole: role, seq, timestamp: Date.now(), ...extra });
+  }
+
+  _emitBlocks(cid, sid, blocks, role) {
+    for (const b of blocks) {
+      if (!b || !b.type) continue;
+      this._emit(cid, sid, b, role);
+    }
+  }
+
+  _startStreaming(cid, sid) {
+    if (this._streaming.has(sid)) return;
+    this._streaming.add(sid);
+    const dbSid = this._dbSession(cid, sid);
+    this._q.setIsStreaming(cid, true);
+    this._bc({ type: 'streaming_start', sessionId: dbSid, conversationId: cid, agentId: 'cli-claude', timestamp: Date.now() });
+  }
+
+  _endStreaming(cid, sid) {
+    if (!this._streaming.has(sid)) return;
+    this._streaming.delete(sid);
+    const dbSid = this._sessions.get(sid);
+    if (dbSid) {
+      try { this._q.updateSession(dbSid, { status: 'completed', completed_at: Date.now() }); } catch (_) {}
+    }
+    this._q.setIsStreaming(cid, false);
+    this._bc({ type: 'streaming_complete', sessionId: dbSid || sid, conversationId: cid, agentId: 'cli-claude', eventCount: 0, seq: this._seq(sid), timestamp: Date.now() });
+    this._sessions.delete(sid);
+  }
+
+  _route(cid, sid, e) {
+    if (e.type === 'queue-operation' || e.type === 'last-prompt' || (e.type === 'user' && e.isMeta)) return;
+
+    if (e.isApiErrorMessage && e.error === 'rate_limit') {
+      this._bc({ type: 'streaming_error', sessionId: this._sessions.get(sid) || sid, conversationId: cid, error: 'Rate limit hit', recoverable: true, timestamp: Date.now() });
+      return;
+    }
+
+    if (e.type === 'system') {
+      if (e.subtype === 'init') { this._startStreaming(cid, sid); return; }
+      if (e.subtype === 'turn_duration' || e.subtype === 'stop_hook_summary') { this._endStreaming(cid, sid); return; }
+      this._startStreaming(cid, sid);
+      this._emit(cid, sid, { type: 'system', subtype: e.subtype, model: e.model, cwd: e.cwd, tools: e.tools, preTokens: e.compactMetadata?.preTokens }, 'system');
+      return;
+    }
+
+    if (e.type === 'assistant' && e.message?.content) {
+      this._startStreaming(cid, sid);
+      const key = `${sid}:${e.message.id}`;
+      const prev = this._emitted.get(key) || 0;
+      const content = e.message.content;
+      const newBlocks = content.slice(prev);
+      if (newBlocks.length > 0) {
+        this._emitted.set(key, content.length);
+        this._emitBlocks(cid, sid, newBlocks, 'assistant');
+      }
+      if (e.message.stop_reason) this._emitted.delete(key);
+      return;
+    }
+
+    if (e.type === 'user' && e.message?.content) {
+      if (e.isCompactSummary) { this._emit(cid, sid, { type: 'compact_summary', content: e.message.content }, 'system'); return; }
+      this._startStreaming(cid, sid);
+      const content = e.message.content;
+      const textParts = Array.isArray(content)
+        ? content.filter(b => b.type === 'text' && b.text && !b.text.startsWith('<task-notification>')).map(b => b.text).join('\n')
+        : (typeof content === 'string' && !content.startsWith('<task-notification>') ? content : '');
+      if (textParts) {
+        try { this._q.createMessage(cid, 'user', textParts); } catch (_) {}
+      }
+      const blocks = Array.isArray(content) ? content : [];
+      for (const b of blocks) if (b.type === 'tool_result') this._emit(cid, sid, b, 'tool_result');
+      return;
+    }
+
+    if (e.type === 'progress') {
+      this._startStreaming(cid, sid);
+      const d = e.data || {};
+      if (d.type === 'agent_progress') {
+        const inner = d.message?.message || d.message;
+        const content = inner?.content;
+        if (Array.isArray(content)) {
+          const role = inner.role === 'user' ? 'tool_result' : 'assistant';
+          this._emitBlocks(cid, sid, content, role);
+        }
+        return;
+      }
+      if (d.type === 'hook_progress') {
+        this._emit(cid, sid, { type: 'hook_progress', hookEvent: d.hookEvent, hookName: d.hookName }, 'system');
+        return;
+      }
+      if (d.type === 'mcp_progress') {
+        this._emit(cid, sid, { type: 'mcp_progress', status: d.status, serverName: d.serverName, toolName: d.toolName }, 'system');
+        return;
+      }
+      this._emit(cid, sid, { type: d.type || e.subtype || 'progress', content: e.content || d }, 'progress');
+      return;
+    }
+
+    if (e.type === 'result') {
+      this._emit(cid, sid, { type: 'result', result: e.result, subtype: e.subtype, duration_ms: e.duration_ms, total_cost_usd: e.total_cost_usd, is_error: e.is_error || false }, 'result', { isResult: true });
+      this._endStreaming(cid, sid);
+    }
+  }
+}

package/lib/jsonl-watcher.js

@@ -1,22 +1,16 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { JsonlParser } from './jsonl-parser.js';
 
 const PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
 const DEBOUNCE_MS = 16;
 
 export class JsonlWatcher {
   constructor({ broadcastSync, queries, ownedSessionIds }) {
-    this._bc = broadcastSync;
-    this._q = queries;
-    this._owned = ownedSessionIds;
+    this._parser = new JsonlParser({ broadcastSync, queries, ownedSessionIds });
     this._tails = new Map();
-    this._convMap = new Map();
-    this._emitted = new Map();
     this._timers = new Map();
-    this._seqs = new Map();
-    this._streaming = new Set();
-    this._sessions = new Map();
     this._watcher = null;
   }
 
@@ -24,7 +18,7 @@ export class JsonlWatcher {
     if (!fs.existsSync(PROJECTS_DIR)) return;
     this._scanDir(PROJECTS_DIR, 0);
     for (const [fp, t] of this._timers.entries()) { clearTimeout(t); this._timers.delete(fp); this._read(fp); }
-    for (const sid of [...this._streaming]) this._endStreaming(this._convMap.get(sid), sid);
+    this._parser.endAllStreaming();
     try {
       this._watcher = fs.watch(PROJECTS_DIR, { recursive: true }, (_, f) => {
         if (f && f.endsWith('.jsonl')) this._debounce(path.join(PROJECTS_DIR, f));
@@ -40,13 +34,9 @@ export class JsonlWatcher {
   }
 
   removeConversation(conversationId) {
-    const sids = [...this._convMap.entries()].filter(([, cid]) => cid === conversationId).map(([sid]) => sid);
+    const sids = [...this._parser._convMap.entries()].filter(([, cid]) => cid === conversationId).map(([sid]) => sid);
     for (const sid of sids) {
-      this._convMap.delete(sid);
-      this._seqs.delete(sid);
-      this._streaming.delete(sid);
-      this._sessions.delete(sid);
-      for (const key of [...this._emitted.keys()]) if (key.startsWith(`${sid}:`)) this._emitted.delete(key);
+      this._parser.removeSid(sid);
       for (const [fp, s] of this._tails.entries()) {
         if (!fp.includes(sid)) continue;
         if (s.fd !== null) try { fs.closeSync(s.fd); } catch (_) {}
@@ -60,9 +50,9 @@ export class JsonlWatcher {
   removeAllConversations() {
     for (const s of this._tails.values()) if (s.fd !== null) try { fs.closeSync(s.fd); } catch (_) {}
     for (const t of this._timers.values()) clearTimeout(t);
-    this._tails.clear(); this._convMap.clear(); this._emitted.clear();
-    this._timers.clear(); this._seqs.clear(); this._streaming.clear();
-    this._sessions.clear();
+    this._tails.clear();
+    this._timers.clear();
+    this._parser.clear();
   }
 
   _scanDir(dir, depth) {
@@ -99,155 +89,10 @@ export class JsonlWatcher {
       s.partial = text.slice(start);
       const ms = Number(process.hrtime.bigint() - t0) / 1e6;
       if (ms > 5) console.warn(`[JsonlWatcher] hot path ${ms.toFixed(1)}ms (${lines.length} lines)`);
-      for (const l of lines) this._line(fp, l);
+      for (const l of lines) this._parser._line(fp, l);
     } catch (e) {
       if (e.code !== 'ENOENT') console.error('[JsonlWatcher] read error:', e.message);
       if (s.fd !== null) { try { fs.closeSync(s.fd); } catch (_) {} s.fd = null; }
     }
   }
-
-  _line(fp, line) {
-    line = line.trim(); if (!line) return;
-    let e; try { e = JSON.parse(line); } catch (_) { return; }
-    if (!e || !e.sessionId) return;
-    if (this._owned?.has(e.sessionId)) return;
-    const cid = this._conv(e.sessionId, e, fp);
-    if (cid) this._route(cid, e.sessionId, e);
-  }
-
-  _conv(sid, e) {
-    if (this._convMap.has(sid)) return this._convMap.get(sid);
-    const found = this._q.getConversations().find(c => c.claudeSessionId === sid);
-    if (found) { this._convMap.set(sid, found.id); return found.id; }
-    if (e.type === 'queue-operation' || e.type === 'last-prompt') return null;
-    if (e.type === 'user' && e.isMeta) return null;
-    const cwd = e.cwd || process.cwd();
-    const branch = e.gitBranch || '';
-    const base = path.basename(cwd);
-    const title = branch ? `${branch} @ ${base}` : base;
-    const conv = this._q.createConversation('claude-code', title, cwd);
-    this._q.setClaudeSessionId(conv.id, sid);
-    this._convMap.set(sid, conv.id);
-    this._bc({ type: 'conversation_created', conversation: conv, timestamp: Date.now() });
-    return conv.id;
-  }
-
-  _seq(sid) { const n = (this._seqs.get(sid) || 0) + 1; this._seqs.set(sid, n); return n; }
-
-  _dbSession(cid, sid) {
-    if (this._sessions.has(sid)) return this._sessions.get(sid);
-    const sess = this._q.createSession(cid);
-    this._q.updateSession(sess.id, { status: 'active' });
-    this._sessions.set(sid, sess.id);
-    return sess.id;
-  }
-
-  _emit(cid, sid, block, role, extra) {
-    const dbSid = this._dbSession(cid, sid);
-    const seq = this._seq(sid);
-    try { this._q.createChunk(dbSid, cid, seq, block.type || 'unknown', block); } catch (_) {}
-    this._bc({ type: 'streaming_progress', sessionId: dbSid, conversationId: cid, block, blockRole: role, seq, timestamp: Date.now(), ...extra });
-  }
-
-  _emitBlocks(cid, sid, blocks, role) {
-    for (const b of blocks) {
-      if (!b || !b.type) continue;
-      this._emit(cid, sid, b, role);
-    }
-  }
-
-  _startStreaming(cid, sid) {
-    if (this._streaming.has(sid)) return;
-    this._streaming.add(sid);
-    const dbSid = this._dbSession(cid, sid);
-    this._q.setIsStreaming(cid, true);
-    this._bc({ type: 'streaming_start', sessionId: dbSid, conversationId: cid, agentId: 'cli-claude', timestamp: Date.now() });
-  }
-
-  _endStreaming(cid, sid) {
-    if (!this._streaming.has(sid)) return;
-    this._streaming.delete(sid);
-    const dbSid = this._sessions.get(sid);
-    if (dbSid) {
-      try { this._q.updateSession(dbSid, { status: 'completed', completed_at: Date.now() }); } catch (_) {}
-    }
-    this._q.setIsStreaming(cid, false);
-    this._bc({ type: 'streaming_complete', sessionId: dbSid || sid, conversationId: cid, agentId: 'cli-claude', eventCount: 0, seq: this._seq(sid), timestamp: Date.now() });
-    this._sessions.delete(sid);
-  }
-
-  _route(cid, sid, e) {
-    if (e.type === 'queue-operation' || e.type === 'last-prompt' || (e.type === 'user' && e.isMeta)) return;
-
-    if (e.isApiErrorMessage && e.error === 'rate_limit') {
-      this._bc({ type: 'streaming_error', sessionId: this._sessions.get(sid) || sid, conversationId: cid, error: 'Rate limit hit', recoverable: true, timestamp: Date.now() });
-      return;
-    }
-
-    if (e.type === 'system') {
-      if (e.subtype === 'init') { this._startStreaming(cid, sid); return; }
-      if (e.subtype === 'turn_duration' || e.subtype === 'stop_hook_summary') { this._endStreaming(cid, sid); return; }
-      this._startStreaming(cid, sid);
-      this._emit(cid, sid, { type: 'system', subtype: e.subtype, model: e.model, cwd: e.cwd, tools: e.tools, preTokens: e.compactMetadata?.preTokens }, 'system');
-      return;
-    }
-
-    if (e.type === 'assistant' && e.message?.content) {
-      this._startStreaming(cid, sid);
-      const key = `${sid}:${e.message.id}`;
-      const prev = this._emitted.get(key) || 0;
-      const content = e.message.content;
-      const newBlocks = content.slice(prev);
-      if (newBlocks.length > 0) {
-        this._emitted.set(key, content.length);
-        this._emitBlocks(cid, sid, newBlocks, 'assistant');
-      }
-      if (e.message.stop_reason) this._emitted.delete(key);
-      return;
-    }
-
-    if (e.type === 'user' && e.message?.content) {
-      if (e.isCompactSummary) { this._emit(cid, sid, { type: 'compact_summary', content: e.message.content }, 'system'); return; }
-      this._startStreaming(cid, sid);
-      const content = e.message.content;
-      const textParts = Array.isArray(content)
-        ? content.filter(b => b.type === 'text' && b.text && !b.text.startsWith('<task-notification>')).map(b => b.text).join('\n')
-        : (typeof content === 'string' && !content.startsWith('<task-notification>') ? content : '');
-      if (textParts) {
-        try { this._q.createMessage(cid, 'user', textParts); } catch (_) {}
-      }
-      const blocks = Array.isArray(content) ? content : [];
-      for (const b of blocks) if (b.type === 'tool_result') this._emit(cid, sid, b, 'tool_result');
-      return;
-    }
-
-    if (e.type === 'progress') {
-      this._startStreaming(cid, sid);
-      const d = e.data || {};
-      if (d.type === 'agent_progress') {
-        const inner = d.message?.message || d.message;
-        const content = inner?.content;
-        if (Array.isArray(content)) {
-          const role = inner.role === 'user' ? 'tool_result' : 'assistant';
-          this._emitBlocks(cid, sid, content, role);
-        }
-        return;
-      }
-      if (d.type === 'hook_progress') {
-        this._emit(cid, sid, { type: 'hook_progress', hookEvent: d.hookEvent, hookName: d.hookName }, 'system');
-        return;
-      }
-      if (d.type === 'mcp_progress') {
-        this._emit(cid, sid, { type: 'mcp_progress', status: d.status, serverName: d.serverName, toolName: d.toolName }, 'system');
-        return;
-      }
-      this._emit(cid, sid, { type: d.type || e.subtype || 'progress', content: e.content || d }, 'progress');
-      return;
-    }
-
-    if (e.type === 'result') {
-      this._emit(cid, sid, { type: 'result', result: e.result, subtype: e.subtype, duration_ms: e.duration_ms, total_cost_usd: e.total_cost_usd, is_error: e.is_error || false }, 'result', { isResult: true });
-      this._endStreaming(cid, sid);
-    }
-  }
 }

package/lib/tool-manager.js

@@ -1,4 +1,4 @@
-import { checkToolViaBunx, clearVersionCache } from './tool-version.js';
+import { checkToolViaBunx, clearVersionCache } from './tool-version-fetch.js';
 import { createInstaller } from './tool-spawner.js';
 import { autoProvision as _autoProvision, startPeriodicUpdateCheck as _startPeriodicUpdateCheck, stopPeriodicUpdateCheck } from './tool-provisioner.js';
 

package/lib/tool-provisioner.js

@@ -1,4 +1,4 @@
-import { checkToolViaBunx } from './tool-version.js';
+import { checkToolViaBunx } from './tool-version-fetch.js';
 import * as toolInstallMachine from './tool-install-machine.js';
 
 let updateCheckInterval = null;

package/lib/tool-spawner.js

@@ -1,6 +1,7 @@
 import { spawn } from 'child_process';
 import os from 'os';
-import { getCliVersion, getInstalledVersion, clearVersionCache, checkToolViaBunx } from './tool-version.js';
+import { getCliVersion, getInstalledVersion } from './tool-version-check.js';
+import { clearVersionCache, checkToolViaBunx } from './tool-version-fetch.js';
 import * as toolInstallMachine from './tool-install-machine.js';
 
 const isWindows = os.platform() === 'win32';

package/lib/{tool-version.js → tool-version-check.js}

@@ -1,13 +1,12 @@
 import os from 'os';
 import fs from 'fs';
 import path from 'path';
-import https from 'https';
 import { execSync } from 'child_process';
 
 const isWindows = os.platform() === 'win32';
 const homeDir = os.homedir();
 
-const BIN_MAP = {
+export const BIN_MAP = {
   '@anthropic-ai/claude-code': 'claude',
   'opencode-ai': 'opencode',
   '@google/gemini-cli': 'gemini',
@@ -31,7 +30,7 @@ function getClaudeInstalledPluginPath(pluginId) {
   return null;
 }
 
-const FRAMEWORK_PATHS = {
+export const FRAMEWORK_PATHS = {
   claude: {
     pluginDir: (pluginId) => getClaudeInstalledPluginPath(pluginId) || path.join(homeDir, '.claude', 'plugins', pluginId),
     versionFile: (pluginId) => {
@@ -96,15 +95,12 @@ export function getInstalledVersion(pkg, pluginId = null, frameWork = null, tool
     const tool = tools.find(t => t.pkg === pkg);
     const actualPluginId = pluginId || tool?.pluginId || pkg;
     const actualFrameWork = frameWork || tool?.frameWork;
-
     const frameworks = actualFrameWork ? [actualFrameWork] : Object.keys(FRAMEWORK_PATHS);
     for (const fw of frameworks) {
       const fwConfig = FRAMEWORK_PATHS[fw];
       if (!fwConfig) continue;
-
       const version = tryReadVersion(fwConfig, actualPluginId);
       if (version) return version;
-
       if (fwConfig.fallbackInstalled) {
         const hasMarker = fwConfig.markerFile && fs.existsSync(fwConfig.markerFile(actualPluginId));
         const hasDir = fs.existsSync(fwConfig.pluginDir(actualPluginId));
@@ -177,62 +173,3 @@ export function compareVersions(v1, v2) {
   }
   return false;
 }
-
-const versionCache = new Map();
-
-export function getPublishedVersion(pkg) {
-  const cacheKey = `published-${pkg}`;
-  const cached = versionCache.get(cacheKey);
-  if (cached && Date.now() - cached.timestamp < 3600000) {
-    return cached.version;
-  }
-  return null;
-}
-
-export async function fetchPublishedVersion(pkg) {
-  const cacheKey = `published-${pkg}`;
-  const cached = versionCache.get(cacheKey);
-  if (cached && Date.now() - cached.timestamp < 3600000) {
-    return cached.version;
-  }
-  try {
-    const version = await new Promise((resolve, reject) => {
-      const url = `https://registry.npmjs.org/${pkg}/latest`;
-      https.get(url, { headers: { 'User-Agent': 'agentgui-version-check/1.0' } }, (res) => {
-        let data = '';
-        res.on('data', chunk => { data += chunk; });
-        res.on('end', () => {
-          try { resolve(JSON.parse(data).version || null); } catch (e) { reject(e); }
-        });
-      }).on('error', reject);
-    });
-    if (version) versionCache.set(cacheKey, { version, timestamp: Date.now() });
-    return version;
-  } catch (_) {}
-  return null;
-}
-
-export function clearVersionCache() {
-  versionCache.clear();
-}
-
-export async function checkToolViaBunx(pkg, pluginId = null, category = 'plugin', frameWork = null, skipPublishedVersion = false, tools = []) {
-  try {
-    const isCli = category === 'cli';
-    const installed = isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg, frameWork);
-    const installedVersion = isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId, frameWork, tools);
-    let publishedVersion = null;
-    if (!skipPublishedVersion) {
-      publishedVersion = await fetchPublishedVersion(pkg);
-    }
-    const needsUpdate = installed && publishedVersion && compareVersions(installedVersion, publishedVersion);
-    const isUpToDate = installed && !needsUpdate;
-    return { installed, isUpToDate, upgradeNeeded: needsUpdate, output: 'version-check', installedVersion, publishedVersion };
-  } catch (err) {
-    console.log(`[tool-manager] Error checking ${pkg}:`, err.message);
-    const isCli = category === 'cli';
-    const installed = isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg, frameWork);
-    const installedVersion = isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId, frameWork, tools);
-    return { installed, isUpToDate: false, upgradeNeeded: false, output: '', installedVersion, publishedVersion: null };
-  }
-}

package/lib/tool-version-fetch.js

@@ -0,0 +1,61 @@
+import https from 'https';
+import { checkCliInstalled, getCliVersion, checkToolInstalled, compareVersions, getInstalledVersion } from './tool-version-check.js';
+
+const versionCache = new Map();
+
+export function getPublishedVersion(pkg) {
+  const cacheKey = `published-${pkg}`;
+  const cached = versionCache.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < 3600000) {
+    return cached.version;
+  }
+  return null;
+}
+
+export async function fetchPublishedVersion(pkg) {
+  const cacheKey = `published-${pkg}`;
+  const cached = versionCache.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < 3600000) {
+    return cached.version;
+  }
+  try {
+    const version = await new Promise((resolve, reject) => {
+      const url = `https://registry.npmjs.org/${pkg}/latest`;
+      https.get(url, { headers: { 'User-Agent': 'agentgui-version-check/1.0' } }, (res) => {
+        let data = '';
+        res.on('data', chunk => { data += chunk; });
+        res.on('end', () => {
+          try { resolve(JSON.parse(data).version || null); } catch (e) { reject(e); }
+        });
+      }).on('error', reject);
+    });
+    if (version) versionCache.set(cacheKey, { version, timestamp: Date.now() });
+    return version;
+  } catch (_) {}
+  return null;
+}
+
+export function clearVersionCache() {
+  versionCache.clear();
+}
+
+export async function checkToolViaBunx(pkg, pluginId = null, category = 'plugin', frameWork = null, skipPublishedVersion = false, tools = []) {
+  try {
+    const isCli = category === 'cli';
+    const installed = isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg, frameWork);
+    const installedVersion = isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId, frameWork, tools);
+    let publishedVersion = null;
+    if (!skipPublishedVersion) {
+      publishedVersion = await fetchPublishedVersion(pkg);
+    }
+    const needsUpdate = installed && publishedVersion && compareVersions(installedVersion, publishedVersion);
+    const isUpToDate = installed && !needsUpdate;
+    return { installed, isUpToDate, upgradeNeeded: needsUpdate, output: 'version-check', installedVersion, publishedVersion };
+  } catch (err) {
+    console.log(`[tool-manager] Error checking ${pkg}:`, err.message);
+    const isCli = category === 'cli';
+    const installed = isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg, frameWork);
+    const installedVersion = isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId, frameWork, tools);
+    return { installed, isUpToDate: false, upgradeNeeded: false, output: '', installedVersion, publishedVersion: null };
+  }
+}

package/package.json

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