groove-dev 0.27.68 → 0.27.70

package/node_modules/@groove-dev/gui/src/components/network/token-waterfall.jsx

@@ -0,0 +1,111 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+import { useMemo, memo } from 'react';
+import { useGrooveStore } from '../../stores/groove';
+import { HEX } from '../../lib/theme-hex';
+import { cn } from '../../lib/cn';
+import { Badge } from '../ui/badge';
+
+const PHASE_COLORS = {
+  serialize_ms: HEX.info,
+  send_ms: HEX.accent,
+  wait_ms: HEX.text3,
+  forward_ms: HEX.success,
+  queue_ms: HEX.warning,
+};
+
+const PHASE_LABELS = {
+  serialize_ms: 'Serialize',
+  send_ms: 'Send',
+  wait_ms: 'Wait',
+  forward_ms: 'Forward',
+  queue_ms: 'Queue',
+};
+
+function shortAddr(addr) {
+  if (!addr || typeof addr !== 'string') return '\u2014';
+  if (addr.length < 14) return addr;
+  return `${addr.slice(0, 6)}\u2026${addr.slice(-4)}`;
+}
+
+export const TokenWaterfall = memo(function TokenWaterfall() {
+  const timing = useGrooveStore((s) => s.networkTokenTiming);
+
+  const stages = useMemo(() => {
+    if (!timing?.stages || !Array.isArray(timing.stages)) return [];
+    return timing.stages;
+  }, [timing]);
+
+  if (!stages.length) {
+    return (
+      <div className="flex items-center justify-center py-6">
+        <span className="text-xs font-mono text-text-3">Waiting for token timing data\u2026</span>
+      </div>
+    );
+  }
+
+  const maxRtt = Math.max(...stages.map((s) => s.rtt_ms || 1), 1);
+  const phases = Object.keys(PHASE_COLORS);
+
+  return (
+    <div className="flex flex-col gap-0.5">
+      <div className="flex items-center gap-3 px-3 py-1.5 flex-wrap">
+        {phases.map((p) => (
+          <div key={p} className="flex items-center gap-1">
+            <span className="w-2 h-2 rounded-sm flex-shrink-0" style={{ background: PHASE_COLORS[p] }} />
+            <span className="text-2xs font-mono text-text-3">{PHASE_LABELS[p]}</span>
+          </div>
+        ))}
+      </div>
+
+      {stages.map((stage, i) => {
+        const rtt = stage.rtt_ms || 1;
+        const tel = stage.node_telemetry;
+        const gpuModel = tel?.gpu_model;
+        const device = tel?.device;
+
+        return (
+          <div key={i} className="flex items-center gap-2 px-3 py-1">
+            <div className="w-[110px] flex-shrink-0 flex flex-col gap-0.5">
+              <div className="flex items-center gap-1.5">
+                <span className="text-2xs font-mono text-text-2 truncate">{shortAddr(stage.node)}</span>
+                <Badge variant={stage.via === 'p2p' ? 'success' : 'warning'} className="text-2xs px-1 py-0 leading-tight">
+                  {stage.via || '?'}
+                </Badge>
+              </div>
+              {gpuModel && (
+                <div className="flex items-center gap-1">
+                  {device && (
+                    <span className={cn(
+                      'text-2xs font-mono px-1 py-0 rounded leading-tight',
+                      device === 'cuda' ? 'bg-info/20 text-info' : 'bg-purple/20 text-purple',
+                    )}>
+                      {device}
+                    </span>
+                  )}
+                  <span className="text-2xs font-mono text-text-4 truncate">{gpuModel}</span>
+                </div>
+              )}
+            </div>
+            <div className="flex-1 min-w-0 h-4 bg-surface-2 rounded-sm overflow-hidden relative flex">
+              {phases.map((p) => {
+                const ms = stage[p] || 0;
+                const pct = (ms / maxRtt) * 100;
+                return (
+                  <div
+                    key={p}
+                    className="h-full flex-shrink-0 transition-all"
+                    style={{ width: `${pct}%`, background: PHASE_COLORS[p] }}
+                    title={`${PHASE_LABELS[p]}: ${ms.toFixed(1)}ms`}
+                  />
+                );
+              })}
+            </div>
+            <span className="text-2xs font-mono text-text-3 tabular-nums w-[52px] text-right flex-shrink-0">
+              {rtt.toFixed(1)}ms
+            </span>
+          </div>
+        );
+      })}
+    </div>
+  );
+});

package/node_modules/@groove-dev/gui/src/stores/groove.js

@@ -106,6 +106,11 @@ export const useGrooveStore = create((set, get) => ({
   networkUpdateProgress: { updating: false, step: null, message: null, percent: 0, error: null },
   networkCompute: { totalRamMb: 0, totalVramMb: 0, totalCpuCores: 0, totalBandwidthMbps: 0, activeNodes: 0, totalNodes: 0, avgLoad: 0 },
   networkSnapshots: [],
+  networkTokenTiming: null,
+  networkBenchmarks: [],
+  networkTraces: [],
+  networkPerfSnapshots: [],
+  networkNodeTelemetry: {},
   networkWallet: { connected: false, address: null, balance: '0.00', token: 'GROOVE', chain: 'base-l2' },
   networkEarnings: { today: 0, thisWeek: 0, allTime: 0, history: [] },
 
@@ -901,6 +906,33 @@ export const useGrooveStore = create((set, get) => ({
           }
           break;
         }
+
+        case 'network:token:timing': {
+          const { __proto__: _a, constructor: _b, prototype: _c, ...td } = msg.data || {};
+          const updates = {
+            networkTokenTiming: td,
+            networkPerfSnapshots: [...get().networkPerfSnapshots, { t: Date.now(), tps: td.tps || 0 }].slice(-100),
+          };
+          if (Array.isArray(td.stages)) {
+            const telMap = { ...get().networkNodeTelemetry };
+            const unsafe = new Set(['__proto__', 'constructor', 'prototype']);
+            for (const stage of td.stages) {
+              const nid = stage.node_telemetry?.node_id;
+              if (nid && typeof nid === 'string' && !unsafe.has(nid)) {
+                telMap[nid] = { ...stage.node_telemetry, forward_ms: stage.forward_ms, updatedAt: Date.now() };
+              }
+            }
+            updates.networkNodeTelemetry = telMap;
+          }
+          set(updates);
+          break;
+        }
+
+        case 'network:timing:summary': {
+          const { __proto__: _a, constructor: _b, prototype: _c, ...sd } = msg.data || {};
+          set((s) => ({ networkBenchmarks: [...s.networkBenchmarks, sd].slice(-100) }));
+          break;
+        }
       }
     };
 
@@ -2279,6 +2311,34 @@ export const useGrooveStore = create((set, get) => ({
     return get().networkEarnings;
   },
 
+  async fetchNetworkBenchmarks() {
+    try {
+      const data = await api.get('/network/benchmarks');
+      if (Array.isArray(data)) set({ networkBenchmarks: data.slice(-100) });
+      return data;
+    } catch { return null; }
+  },
+
+  async fetchNetworkTraces() {
+    try {
+      const data = await api.get('/network/traces');
+      if (Array.isArray(data)) set({ networkTraces: data });
+      return data;
+    } catch { return null; }
+  },
+
+  async fetchNetworkTrace(filename) {
+    try {
+      return await api.get(`/network/traces/${encodeURIComponent(filename)}`);
+    } catch { return null; }
+  },
+
+  async fetchLiveTrace(offset = 0) {
+    try {
+      return await api.get(`/network/traces/live?offset=${offset}`);
+    } catch { return null; }
+  },
+
   async renameFile(oldPath, newPath) {
     try {
       await api.post('/files/rename', { oldPath, newPath });

package/node_modules/@groove-dev/gui/src/views/network.jsx

@@ -17,6 +17,7 @@ import { NodeCard } from '../components/network/node-card';
 import { EarningsCard } from '../components/network/earnings-card';
 import { FleetTable } from '../components/network/fleet-table';
 import { WalletView } from '../components/network/wallet-view';
+import { PerformanceDashboard } from '../components/network/performance-dashboard';
 import { HEX, hexAlpha } from '../lib/theme-hex';
 import { Globe, Download, Check, AlertCircle, Loader2, Trash2, ArrowUpCircle, Zap } from 'lucide-react';
 
@@ -483,6 +484,7 @@ export default function NetworkView() {
         <TabsList className="bg-surface-0 border-b border-border-subtle px-4 flex-shrink-0">
           <TabsTrigger value="overview" className="text-xs">Overview</TabsTrigger>
           <TabsTrigger value="fleet" className="text-xs">Fleet</TabsTrigger>
+          <TabsTrigger value="performance" className="text-xs flex items-center gap-1"><Zap size={10} />Performance</TabsTrigger>
           <TabsTrigger value="wallet" className="text-xs">Wallet</TabsTrigger>
         </TabsList>
 
@@ -494,6 +496,10 @@ export default function NetworkView() {
           <FleetTable />
         </TabsContent>
 
+        <TabsContent value="performance" className="flex-1 min-h-0 overflow-hidden bg-surface-1">
+          <PerformanceDashboard active={activeTab === 'performance'} />
+        </TabsContent>
+
         <TabsContent value="wallet" className="flex-1 min-h-0 overflow-hidden">
           <WalletView />
         </TabsContent>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "groove-dev",
-  "version": "0.27.68",
+  "version": "0.27.70",
   "description": "Open-source agent orchestration layer — the AI company OS. Local model agent engine (GGUF/Ollama/llama-server), HuggingFace model browser, MCP integrations (Slack, Gmail, Stripe, 15+), agent scheduling (cron), business roles (CMO, CFO, EA). GUI dashboard, multi-agent coordination, zero cold-start, infinite sessions. Works with Claude Code, Codex, Gemini CLI, Ollama, any local model.",
   "license": "FSL-1.1-Apache-2.0",
   "author": "Groove Dev <hello@groovedev.ai> (https://groovedev.ai)",

package/packages/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/packages/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/packages/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');