groove-dev 0.27.68 → 0.27.70

package/CLAUDE.md

@@ -263,3 +263,10 @@ Audit-driven release. Multi-agent orchestration system with 7 coordination layer
 - Dashboard: routing donut, cache panel, context health gauges
 - Monitor/QC agent mode (stay active, loop)
 - Distribution: demo video, HN launch, Twitter content
+
+<!-- GROOVE:START -->
+## GROOVE Orchestration (auto-injected)
+Active agents: 0
+See AGENTS_REGISTRY.md for full agent state.
+**Memory policy:** GROOVE manages project memory automatically. Do not read or write MEMORY.md or .groove/memory/ files directly.
+<!-- GROOVE:END -->

package/node_modules/@groove-dev/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.68",
+  "version": "0.27.70",
   "description": "GROOVE CLI — manage AI coding agents from your terminal",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/node_modules/@groove-dev/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/daemon",
-  "version": "0.27.68",
+  "version": "0.27.70",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/node_modules/@groove-dev/daemon/src/api.js

@@ -8,6 +8,7 @@ import { existsSync, readFileSync, readdirSync, statSync, writeFileSync, mkdirSy
 import { spawn, execFile, execFileSync } from 'child_process';
 import { createHash, randomUUID } from 'crypto';
 import { hostname, networkInterfaces, homedir } from 'os';
+import { StringDecoder } from 'string_decoder';
 import { lookup as mimeLookup } from './mimetypes.js';
 import { listProviders, getProvider } from './providers/index.js';
 import { OllamaProvider } from './providers/ollama.js';
@@ -4299,14 +4300,17 @@ Keep responses concise. Help them think, don't lecture them about the system the
       hardware: getLocalHardware(),
       startedAt: Date.now(),
       events: [],
+      lastTokenTiming: null,
     };
+    if (!daemon.networkBenchmarks) daemon.networkBenchmarks = [];
 
     pushNodeEvent('starting', { pid: proc.pid, signal, device });
     broadcastNodeStatus();
 
     let stderrBuf = '';
+    const stderrDecoder = new StringDecoder('utf8');
     proc.stderr.on('data', (chunk) => {
-      stderrBuf += chunk.toString();
+      stderrBuf += stderrDecoder.write(chunk);
       let idx;
       while ((idx = stderrBuf.indexOf('\n')) !== -1) {
         const line = stderrBuf.slice(0, idx).trim();
@@ -4367,14 +4371,49 @@ Keep responses concise. Help them think, don't lecture them about the system the
         if (entry.capabilities || entry.hardware) {
           daemon.networkNode.hardware = normalizeHardware(entry.capabilities || entry.hardware); changed = true;
         }
+        if (entry.type === 'token') {
+          const timing = {
+            token_ms: entry.token_ms, pipeline_ms: entry.pipeline_ms,
+            prefill_ms: entry.prefill_ms, logits_deser_ms: entry.logits_deser_ms,
+            sample_ms: entry.sample_ms, decode_ms: entry.decode_ms,
+            tps: entry.tps, ttft_ms: entry.ttft_ms, is_prefill: entry.is_prefill,
+            tokens_generated: entry.tokens_generated,
+            stages: Array.isArray(entry.stages) ? entry.stages : [],
+          };
+          daemon.networkNode.lastTokenTiming = timing;
+          daemon.broadcast({ type: 'network:token:timing', data: timing });
+        }
+        if (entry.type === 'timing') {
+          const summary = {
+            ttft_ms: entry.ttft_ms, tps: entry.tps,
+            tokens_generated: entry.tokens_generated,
+            total_network_ms: entry.total_network_ms,
+            total_compute_ms: entry.total_compute_ms,
+            p2p_sends: entry.p2p_sends, relay_sends: entry.relay_sends,
+            stage_0_avg_ms: entry.stage_0_avg_ms, stage_0_count: entry.stage_0_count,
+            stage_1_avg_ms: entry.stage_1_avg_ms, stage_1_count: entry.stage_1_count,
+            t: Date.now(),
+          };
+          if (!daemon.networkBenchmarks) daemon.networkBenchmarks = [];
+          daemon.networkBenchmarks.push(summary);
+          if (daemon.networkBenchmarks.length > 100) daemon.networkBenchmarks.shift();
+          daemon.broadcast({ type: 'network:timing:summary', data: summary });
+        }
         pushNodeEvent(msg || 'log', entry);
         if (changed) broadcastNodeStatus();
       }
     });
 
+    let stdoutBuf = '';
+    const stdoutDecoder = new StringDecoder('utf8');
     proc.stdout.on('data', (chunk) => {
-      const line = chunk.toString().trim();
-      if (line) pushNodeEvent('stdout', { line });
+      stdoutBuf += stdoutDecoder.write(chunk);
+      let idx;
+      while ((idx = stdoutBuf.indexOf('\n')) !== -1) {
+        const line = stdoutBuf.slice(0, idx).trim();
+        stdoutBuf = stdoutBuf.slice(idx + 1);
+        if (line) pushNodeEvent('stdout', { line });
+      }
     });
 
     proc.on('error', (err) => {
@@ -4384,6 +4423,11 @@ Keep responses concise. Help them think, don't lecture them about the system the
     });
 
     proc.on('exit', (code, signal) => {
+      const trailing = stdoutDecoder.end();
+      if (trailing) stdoutBuf += trailing;
+      if (stdoutBuf.trim()) pushNodeEvent('stdout', { line: stdoutBuf.trim() });
+      const trailingErr = stderrDecoder.end();
+      if (trailingErr) stderrBuf += trailingErr;
       daemon.networkNode.active = false;
       daemon.networkNode.status = 'stopped';
       daemon.networkNode.pid = null;
@@ -4409,6 +4453,96 @@ Keep responses concise. Help them think, don't lecture them about the system the
     res.json({ stopping: true });
   });
 
+  app.get('/api/network/benchmarks', networkGate, (req, res) => {
+    res.json(daemon.networkBenchmarks || []);
+  });
+
+  app.get('/api/network/timing', networkGate, (req, res) => {
+    res.json({
+      current: daemon.networkNode?.lastTokenTiming || null,
+      benchmarkCount: (daemon.networkBenchmarks || []).length,
+    });
+  });
+
+  app.get('/api/network/traces', networkGate, (req, res) => {
+    const tracesDir = resolve(homedir(), '.groove', 'traces');
+    if (!existsSync(tracesDir)) return res.json([]);
+    try {
+      const files = readdirSync(tracesDir)
+        .filter((f) => f.endsWith('.jsonl'))
+        .map((f) => {
+          const st = statSync(resolve(tracesDir, f));
+          return { filename: f, size: st.size, mtime: st.mtimeMs };
+        })
+        .sort((a, b) => b.mtime - a.mtime);
+      res.json(files);
+    } catch { res.json([]); }
+  });
+
+  app.get('/api/network/traces/live', networkGate, (req, res) => {
+    const tracesDir = resolve(homedir(), '.groove', 'traces');
+    if (!existsSync(tracesDir)) {
+      return res.json({ lines: [], nextOffset: 0, filename: null, active: false });
+    }
+    try {
+      const files = readdirSync(tracesDir)
+        .filter((f) => f.endsWith('.jsonl'))
+        .map((f) => {
+          const st = statSync(resolve(tracesDir, f));
+          return { filename: f, mtime: st.mtimeMs };
+        })
+        .sort((a, b) => b.mtime - a.mtime);
+      if (files.length === 0) {
+        return res.json({ lines: [], nextOffset: 0, filename: null, active: false });
+      }
+      const newest = files[0];
+      const offset = Math.max(0, parseInt(req.query.offset, 10) || 0);
+      const filePath = resolve(tracesDir, newest.filename);
+      const raw = readFileSync(filePath, 'utf8');
+      const allLines = raw.split('\n').filter(Boolean);
+      const sliced = allLines.slice(offset);
+      const parsed = [];
+      for (const line of sliced) {
+        try { parsed.push(JSON.parse(line)); } catch { /* skip malformed */ }
+      }
+      const active = !!(daemon.networkNode?.active && (daemon.networkNode.sessions || 0) > 0);
+      res.json({
+        lines: parsed,
+        nextOffset: offset + sliced.length,
+        filename: newest.filename,
+        active,
+      });
+    } catch {
+      res.json({ lines: [], nextOffset: 0, filename: null, active: false });
+    }
+  });
+
+  app.get('/api/network/traces/:filename', networkGate, (req, res) => {
+    const { filename } = req.params;
+    if (!filename || /[/\\]/.test(filename) || !filename.endsWith('.jsonl')) {
+      return res.status(400).json({ error: 'Invalid filename' });
+    }
+    const tracesDir = resolve(homedir(), '.groove', 'traces');
+    const filePath = resolve(tracesDir, filename);
+    if (!filePath.startsWith(tracesDir + sep)) {
+      return res.status(400).json({ error: 'Invalid filename' });
+    }
+    if (!existsSync(filePath)) {
+      return res.status(404).json({ error: 'Trace file not found' });
+    }
+    try {
+      const raw = readFileSync(filePath, 'utf8');
+      const lines = raw.split('\n').filter(Boolean).slice(0, 5000);
+      const entries = [];
+      for (const line of lines) {
+        try { entries.push(JSON.parse(line)); } catch { /* skip malformed lines */ }
+      }
+      res.json(entries);
+    } catch (err) {
+      res.status(500).json({ error: `Failed to read trace: ${err.message}` });
+    }
+  });
+
   function isAllowedSignalHost(host) {
     const h = (host || '').replace(/^(wss?|https?):\/\//i, '').replace(/\/.*$/, '').toLowerCase();
     return h === 'signal.groovedev.ai' || h.endsWith('.groovedev.ai');