agentgui 1.0.707 → 1.0.709

package/lib/jsonl-watcher.js

@@ -0,0 +1,168 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
+const DEBOUNCE_MS = 16;
+const genId = (p) => `${p}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+
+export class JsonlWatcher {
+  constructor({ broadcastSync, queries, ownedSessionIds }) {
+    this._bc = broadcastSync;
+    this._q = queries;
+    this._owned = ownedSessionIds;
+    this._tails = new Map();
+    this._convMap = new Map();
+    this._frags = new Map();
+    this._timers = new Map();
+    this._seqs = new Map();
+    this._watcher = null;
+  }
+
+  start() {
+    if (!fs.existsSync(PROJECTS_DIR)) return;
+    this._scan();
+    try {
+      this._watcher = fs.watch(PROJECTS_DIR, { recursive: true }, (_, f) => {
+        if (f && f.endsWith('.jsonl')) this._debounce(path.join(PROJECTS_DIR, f));
+      });
+      this._watcher.on('error', (e) => console.error('[JsonlWatcher]', e.message));
+    } catch (e) { console.error('[JsonlWatcher] start failed:', e.message); }
+  }
+
+  stop() {
+    if (this._watcher) try { this._watcher.close(); } catch (_) {}
+    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);
+  }
+
+  removeConversation(conversationId) {
+    const sids = [...this._convMap.entries()].filter(([, cid]) => cid === conversationId).map(([sid]) => sid);
+    for (const sid of sids) {
+      this._convMap.delete(sid);
+      this._seqs.delete(sid);
+      for (const key of [...this._frags.keys()]) if (key.startsWith(`${sid}:`)) this._frags.delete(key);
+      const fp = path.join(PROJECTS_DIR, sid + '.jsonl');
+      const s = this._tails.get(fp);
+      if (s?.fd !== null) try { fs.closeSync(s.fd); } catch (_) {}
+      this._tails.delete(fp);
+      const t = this._timers.get(fp);
+      if (t) { clearTimeout(t); this._timers.delete(fp); }
+    }
+  }
+
+  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._frags.clear();
+    this._timers.clear();
+    this._seqs.clear();
+  }
+
+  _scan() {
+    try {
+      for (const d of fs.readdirSync(PROJECTS_DIR, { withFileTypes: true })) {
+        if (!d.isDirectory()) continue;
+        try {
+          for (const f of fs.readdirSync(path.join(PROJECTS_DIR, d.name)))
+            if (f.endsWith('.jsonl')) this._debounce(path.join(PROJECTS_DIR, d.name, f));
+        } catch (_) {}
+      }
+    } catch (_) {}
+  }
+
+  _debounce(fp) {
+    const t = this._timers.get(fp);
+    if (t) clearTimeout(t);
+    this._timers.set(fp, setTimeout(() => { this._timers.delete(fp); this._read(fp); }, DEBOUNCE_MS));
+  }
+
+  _read(fp) {
+    let s = this._tails.get(fp);
+    if (!s) { s = { fd: null, offset: 0, partial: '' }; this._tails.set(fp, s); }
+    try {
+      if (s.fd === null) s.fd = fs.openSync(fp, 'r');
+      const stat = fs.fstatSync(s.fd);
+      if (stat.size <= s.offset) return;
+      const buf = Buffer.allocUnsafe(stat.size - s.offset);
+      const n = fs.readSync(s.fd, buf, 0, buf.length, s.offset);
+      s.offset += n;
+      const text = s.partial + buf.toString('utf8', 0, n);
+      const t0 = process.hrtime.bigint();
+      const lines = []; let start = 0, idx;
+      while ((idx = text.indexOf('\n', start)) !== -1) { lines.push(text.slice(start, idx)); start = idx + 1; }
+      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);
+    } 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, fp) {
+    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 !== 'user' || e.isMeta) return null;
+    const cwd = e.cwd || process.cwd();
+    const branch = e.gitBranch || '';
+    const base = path.basename(cwd);
+    const title = branch ? `External: ${branch} @ ${base}` : `External: ${base}`;
+    const conv = this._q.createConversation('cli-claude', 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; }
+
+  _route(cid, sid, e) {
+    if (e.type === 'queue-operation' || (e.type === 'user' && e.isMeta)) return;
+
+    if (e.type === 'system') {
+      if (e.subtype === 'init') { this._bc({ type: 'streaming_start', sessionId: sid, conversationId: cid, agentId: 'cli-claude', timestamp: Date.now() }); return; }
+      if (e.subtype === 'turn_duration') { this._bc({ type: 'streaming_complete', sessionId: sid, conversationId: cid, agentId: 'cli-claude', eventCount: 0, seq: this._seq(sid), timestamp: Date.now() }); return; }
+      const b = { type: 'system', subtype: e.subtype, model: e.model, cwd: e.cwd, tools: e.tools, preTokens: e.compactMetadata?.preTokens };
+      this._bc({ type: 'streaming_progress', sessionId: sid, conversationId: cid, block: b, blockRole: 'system', seq: this._seq(sid), timestamp: Date.now() });
+      return;
+    }
+
+    if (e.type === 'assistant' && e.message?.content) {
+      const key = `${sid}:${e.message.id}`;
+      if (e.message.stop_reason === null || e.message.stop_reason === undefined) { this._frags.set(key, e); return; }
+      this._frags.delete(key);
+      for (const b of e.message.content) this._bc({ type: 'streaming_progress', sessionId: sid, conversationId: cid, block: b, blockRole: 'assistant', seq: this._seq(sid), timestamp: Date.now() });
+      return;
+    }
+
+    if (e.type === 'user' && e.message?.content) {
+      if (e.isCompactSummary) { this._bc({ type: 'streaming_progress', sessionId: sid, conversationId: cid, block: { type: 'compact_summary', content: e.message.content }, seq: this._seq(sid), timestamp: Date.now() }); return; }
+      for (const b of e.message.content) if (b.type === 'tool_result') this._bc({ type: 'streaming_progress', sessionId: sid, conversationId: cid, block: b, blockRole: 'tool_result', seq: this._seq(sid), timestamp: Date.now() });
+      return;
+    }
+
+    if (e.type === 'progress') { this._bc({ type: 'streaming_progress', sessionId: sid, conversationId: cid, block: { type: e.subtype || 'progress', content: e.content }, seq: this._seq(sid), timestamp: Date.now() }); return; }
+
+    if (e.isApiErrorMessage && e.error === 'rate_limit') { this._bc({ type: 'streaming_error', sessionId: sid, conversationId: cid, error: 'Rate limit hit', recoverable: true, timestamp: Date.now() }); return; }
+
+    if (e.type === 'result') {
+      const b = { 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 };
+      this._bc({ type: 'streaming_progress', sessionId: sid, conversationId: cid, block: b, blockRole: 'result', isResult: true, seq: this._seq(sid), timestamp: Date.now() });
+      this._bc({ type: 'streaming_complete', sessionId: sid, conversationId: cid, agentId: 'cli-claude', eventCount: 0, seq: this._seq(sid), timestamp: Date.now() });
+    }
+  }
+}

package/lib/ws-handlers-conv.js

@@ -41,7 +41,8 @@ const ConvSteerSchema = z.object({
 
 export function register(router, deps) {
   const { queries, activeExecutions, messageQueues, rateLimitState,
-    broadcastSync, processMessageWithStreaming, cleanupExecution, logError = () => {} } = deps;
+    broadcastSync, processMessageWithStreaming, cleanupExecution, logError = () => {},
+    getJsonlWatcher = () => null } = deps;
 
   // Per-conversation queue seq counter for event ordering
   const queueSeqByConv = new Map();
@@ -88,12 +89,14 @@ export function register(router, deps) {
 
   router.handle('conv.del', (p) => {
     if (!queries.deleteConversation(p.id)) notFound();
+    getJsonlWatcher()?.removeConversation(p.id);
     broadcastSync({ type: 'conversation_deleted', conversationId: p.id });
     return { deleted: true };
   });
 
   router.handle('conv.del.all', (p) => {
     if (!queries.deleteAllConversations()) fail(500, 'Failed to delete all conversations');
+    getJsonlWatcher()?.removeAllConversations();
     broadcastSync({ type: 'all_conversations_deleted', timestamp: Date.now() });
     return { deleted: true, message: 'All conversations deleted' };
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.707",
+  "version": "1.0.709",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -31,6 +31,7 @@ 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 { JsonlWatcher } from './lib/jsonl-watcher.js';
 
 
 process.on('uncaughtException', (err, origin) => {
@@ -46,6 +47,7 @@ process.on('unhandledRejection', (reason, promise) => {
 process.on('SIGINT', () => {
   console.log('[SIGNAL] SIGINT received - graceful shutdown');
   try { pm2Manager.disconnect(); } catch (_) {}
+  if (jsonlWatcher) try { jsonlWatcher.stop(); } catch (_) {}
   stopACPTools().catch(() => {}).finally(() => {
     try { wss.close(() => server.close(() => process.exit(0))); } catch (_) { process.exit(0); }
   });
@@ -300,6 +302,7 @@ const activeExecutions = new Map();
 const activeScripts = new Map();
 const messageQueues = new Map();
 const rateLimitState = new Map();
+const ownedSessionIds = new Set();
 const activeProcessesByRunId = new Map();
 const checkpointManager = new CheckpointManager(queries);
 const STUCK_AGENT_THRESHOLD_MS = 1800000;
@@ -3820,6 +3823,7 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
       eventCount++;
       const entry = activeExecutions.get(conversationId);
       if (entry) entry.lastActivity = Date.now();
+      if (parsed.session_id) ownedSessionIds.add(parsed.session_id);
       debugLog(`[stream] Event ${eventCount}: type=${parsed.type}`);
 
       if (parsed.type === 'system') {
@@ -4113,6 +4117,7 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
     activeExecutions.delete(conversationId);
     execMachine.send(conversationId, { type: 'COMPLETE' });
     batcher.drain();
+    if (claudeSessionId) ownedSessionIds.delete(claudeSessionId);
     debugLog(`[stream] Claude returned ${outputs.length} outputs, sessionId=${claudeSessionId}`);
 
     // Clear claudeSessionId after successful completion so next message starts fresh
@@ -4141,6 +4146,8 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
   } catch (error) {
     const elapsed = Date.now() - startTime;
     debugLog(`[stream] Error after ${elapsed}ms: ${error.message}`);
+    const conv2 = queries.getConversation(conversationId);
+    if (conv2?.claudeSessionId) ownedSessionIds.delete(conv2.claudeSessionId);
 
     // Check if rate limit was already handled in stream detection
     const existingState = rateLimitState.get(conversationId);
@@ -4511,7 +4518,8 @@ const wsRouter = new WsRouter();
 
 registerConvHandlers(wsRouter, {
   queries, activeExecutions, messageQueues, rateLimitState,
-  broadcastSync, processMessageWithStreaming, cleanupExecution, logError
+  broadcastSync, processMessageWithStreaming, cleanupExecution, logError,
+  getJsonlWatcher: () => jsonlWatcher
 });
 
 console.log('[INIT] About to call registerSessionHandlers, discoveredAgents.length:', discoveredAgents.length);
@@ -5021,6 +5029,8 @@ function performAgentHealthCheck() {
   }
 }
 
+let jsonlWatcher = null;
+
 function onServerReady() {
   // Clear tool status cache on startup to ensure fresh detection
   toolManager.clearStatusCache();
@@ -5036,6 +5046,14 @@ function onServerReady() {
 
   recoverStaleSessions();
 
+  try {
+    jsonlWatcher = new JsonlWatcher({ broadcastSync, queries, ownedSessionIds });
+    jsonlWatcher.start();
+    console.log('[JSONL] Watcher started');
+  } catch (err) {
+    console.error('[JSONL] Watcher failed to start:', err.message);
+  }
+
   resumeInterruptedStreams().catch(err => console.error('[RESUME] Startup error:', err.message));
 
   installGMAgentConfigs().catch(err => console.error('[GM-CONFIG] Startup error:', err.message));