groove-dev 0.27.67 → 0.27.69

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.67",
+  "version": "0.27.69",
   "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.67",
+  "version": "0.27.69",
   "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');

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

@@ -3,7 +3,7 @@
 
 import { spawn as cpSpawn } from 'child_process';
 import { createWriteStream, mkdirSync, chmodSync, existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, copyFileSync } from 'fs';
-import { resolve, dirname } from 'path';
+import { resolve, dirname, isAbsolute } from 'path';
 import { fileURLToPath } from 'url';
 import { getProvider, getInstalledProviders } from './providers/index.js';
 import { AgentLoop } from './agent-loop.js';
@@ -366,13 +366,19 @@ export class ProcessManager {
   async spawn(config) {
     const { registry, locks, introducer } = this.daemon;
 
-    // Validate workingDir is within the project directory
+    // Validate workingDir. Must be an absolute path to an existing directory.
+    // We intentionally do NOT require it to live under daemon.projectDir — remote
+    // SSH users legitimately run projects anywhere on the server (e.g. /var/www,
+    // /opt/myapp) while daemon.projectDir defaults to their homedir.
     if (config.workingDir) {
+      if (typeof config.workingDir !== 'string' || config.workingDir.includes('\0') || !isAbsolute(config.workingDir)) {
+        throw new Error('workingDir must be an absolute path');
+      }
       const resolved = resolve(config.workingDir);
-      const projResolved = resolve(this.daemon?.projectDir || process.cwd());
-      if (!resolved.startsWith(projResolved)) {
-        throw new Error('workingDir must be within project directory');
+      if (!existsSync(resolved)) {
+        throw new Error(`workingDir does not exist: ${resolved}`);
       }
+      config.workingDir = resolved;
     }
 
     // Ambassador spawn guard: one ambassador per federation peer

package/node_modules/@groove-dev/daemon/src/tunnel-manager.js

@@ -396,6 +396,24 @@ export class TunnelManager {
     const target = `${config.user}@${config.host}`;
     const keyArgs = config.sshKeyPath ? ['-i', config.sshKeyPath] : [];
 
+    // Build the remote bash command:
+    //   1. cd into the saved projectDir (if set) so the daemon inherits that cwd
+    //   2. launch `groove start` detached via nohup
+    //   3. poll /api/health until it responds
+    //   4. explicitly POST /api/project-dir so the daemon's projectDir matches
+    //      config.projectDir even if the backgrounded cwd didn't stick (this
+    //      also updates the editor root used for /api/browse, /api/files/*)
+    const cdPrefix = config.projectDir ? `cd "${config.projectDir}" && ` : '';
+    const setProjectDir = config.projectDir
+      ? `curl -sf -X POST -H 'Content-Type: application/json' --data '{"path":"${config.projectDir}"}' http://localhost:${REMOTE_PORT}/api/project-dir > /dev/null 2>&1 || true; `
+      : '';
+    const remoteCmd =
+      `${cdPrefix}nohup groove start > /tmp/groove-daemon.log 2>&1 < /dev/null & disown; ` +
+      `sleep 5; ` +
+      `curl -sf http://localhost:${REMOTE_PORT}/api/health > /dev/null ` +
+      `&& (${setProjectDir}echo __DAEMON_OK__) ` +
+      `|| (echo __DAEMON_FAIL__; tail -20 /tmp/groove-daemon.log 2>/dev/null)`;
+
     try {
       const result = execFileSync('ssh', [
         ...keyArgs,
@@ -403,7 +421,7 @@ export class TunnelManager {
         '-o', 'ConnectTimeout=10',
         '-o', 'BatchMode=yes',
         target,
-        `bash -lc '${config.projectDir ? `cd "${config.projectDir}" && ` : ''}nohup groove start > /tmp/groove-daemon.log 2>&1 < /dev/null & disown; sleep 5; curl -sf http://localhost:${REMOTE_PORT}/api/health > /dev/null && echo __DAEMON_OK__ || (echo __DAEMON_FAIL__; tail -20 /tmp/groove-daemon.log 2>/dev/null)'`,
+        `bash -lc '${remoteCmd}'`,
       ], {
         encoding: 'utf8',
         timeout: 45000,