groove-dev 0.27.157 → 0.27.159

package/packages/daemon/src/process.js

@@ -507,6 +507,7 @@ export class ProcessManager {
 
     if (finalStatus === 'completed' && agent.role === 'planner') {
       this._extractRecommendedTeam(agent, logPath);
+      this._consumeRecommendedTeamAutonomous(agent);
       this._handleReviewComplete(agent);
     }
 
@@ -534,7 +535,7 @@ export class ProcessManager {
 
     this._checkPhase2(agent.id);
 
-    if (finalStatus === 'completed' && agent.role === 'fullstack' && agent.teamId) {
+    if (finalStatus === 'completed' && agent.role === 'fullstack' && agent.teamId && agent.metadata?.isQcPhase2) {
       this._triggerReview(agent);
     }
 
@@ -1755,6 +1756,114 @@ For normal file edits within your scope, proceed without review.
     } catch { /* best effort */ }
   }
 
+  /**
+   * Daemon-autonomous consumption of recommended-team.json.
+   * If the file exists and the GUI hasn't already consumed it (no _pendingPhase2
+   * for this team), broadcast a notification so the GUI picks it up on next tick.
+   * This closes the race where GUI polling stops before the file is written.
+   */
+  _consumeRecommendedTeamAutonomous(agent) {
+    try {
+      const workDir = agent.workingDir || this.daemon.projectDir;
+      const targetPath = resolve(workDir, '.groove', 'recommended-team.json');
+      if (!existsSync(targetPath)) return;
+
+      const teamId = agent.teamId || null;
+
+      // If phase 2 is already pending for this team, GUI already consumed it
+      const pending = this.daemon._pendingPhase2 || [];
+      if (teamId && pending.some(g => g.agents.some(a => a.teamId === teamId))) return;
+
+      // Broadcast so the GUI knows to fetch — even if its polling interval was cleared
+      this.daemon.broadcast({
+        type: 'recommended-team:ready',
+        teamId,
+        agentId: agent.id,
+        agentName: agent.name,
+      });
+
+      // Delayed self-consumption: if the GUI doesn't consume within 5s, daemon does it directly
+      setTimeout(() => {
+        if (!existsSync(targetPath)) return; // GUI consumed it
+        try {
+          const raw = JSON.parse(readFileSync(targetPath, 'utf8'));
+          delete raw._meta;
+          const agentConfigs = Array.isArray(raw) ? raw : (raw.agents || []);
+          if (agentConfigs.length === 0) return;
+
+          const phase1 = agentConfigs.filter(a => !a.phase || a.phase === 1);
+          const phase2 = agentConfigs.filter(a => a.phase === 2);
+          if (phase1.length === 0) return;
+
+          // Check again — GUI may have consumed during the timeout
+          const currentPending = this.daemon._pendingPhase2 || [];
+          if (teamId && currentPending.some(g => g.agents.some(a => a.teamId === teamId))) return;
+
+          const baseDir = agent.workingDir || this.daemon.projectDir;
+          const projectDir = raw.projectDir || null;
+          let projectWorkingDir = baseDir;
+          if (projectDir) {
+            const safeName = String(projectDir).replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 64);
+            projectWorkingDir = resolve(baseDir, safeName);
+            mkdirSync(projectWorkingDir, { recursive: true });
+          }
+
+          const defaultTeamId = teamId || this.daemon.teams.getDefault()?.id || null;
+          const phase1Ids = [];
+
+          // Spawn phase 1 agents
+          const spawnPromises = phase1.map(async (config) => {
+            try {
+              const validated = validateAgentConfig({
+                role: config.role,
+                scope: config.scope || [],
+                prompt: config.prompt || '',
+                provider: config.provider || agent.provider || this.daemon.config?.defaultProvider,
+                model: config.model || agent.model || this.daemon.config?.defaultModel || 'auto',
+                permission: config.permission || 'auto',
+                workingDir: config.workingDir || projectWorkingDir,
+                name: config.name || undefined,
+              });
+              validated.teamId = defaultTeamId;
+              const spawned = await this.spawn(validated);
+              phase1Ids.push(spawned.id);
+              return spawned;
+            } catch (err) {
+              console.error(`[Groove] Autonomous team launch: failed to spawn ${config.role}: ${err.message}`);
+              return null;
+            }
+          });
+
+          Promise.all(spawnPromises).then(() => {
+            // Set up phase 2 pending
+            if (phase2.length > 0 && phase1Ids.length > 0) {
+              this.daemon._pendingPhase2 = this.daemon._pendingPhase2 || [];
+              this.daemon._pendingPhase2.push({
+                waitFor: phase1Ids,
+                agents: phase2.map(c => ({
+                  role: c.role, scope: c.scope || [], prompt: c.prompt || '',
+                  provider: c.provider || agent.provider || this.daemon.config?.defaultProvider,
+                  model: c.model || agent.model || this.daemon.config?.defaultModel || 'auto',
+                  permission: c.permission || 'auto',
+                  workingDir: c.workingDir || projectWorkingDir,
+                  name: c.name || undefined,
+                  teamId: defaultTeamId,
+                })),
+              });
+            }
+
+            // Clean up the file
+            try { unlinkSync(targetPath); } catch { /* */ }
+            this.daemon.audit?.log('team.autonomousLaunch', { teamId: defaultTeamId, phase1: phase1Ids.length, phase2: phase2.length });
+            console.log(`[Groove] Autonomous team launch: ${phase1Ids.length} phase 1 agents spawned for team ${defaultTeamId}`);
+          });
+        } catch (err) {
+          console.error(`[Groove] Autonomous team consumption failed: ${err.message}`);
+        }
+      }, 5000);
+    } catch { /* best effort */ }
+  }
+
   /**
    * Check if a completed/crashed agent was the last phase 1 agent in a team.
    * If so, auto-spawn the phase 2 (QC/finisher) agents.
@@ -1834,13 +1943,26 @@ For normal file edits within your scope, proceed without review.
           try {
             const validated = validateAgentConfig(config);
             if (!validated.teamId) validated.teamId = this.daemon.teams.getDefault()?.id || null;
+            validated.metadata = { ...(validated.metadata || {}), isQcPhase2: true };
+            const existingId = existing?.id || null;
             const p = this.spawn(validated).then((agent) => {
+              registry.update(agent.id, { metadata: { ...(agent.metadata || {}), isQcPhase2: true } });
               this.daemon.broadcast({
                 type: 'phase2:spawned',
                 agentId: agent.id,
+                oldAgentId: existingId,
                 name: agent.name,
                 role: agent.role,
               });
+              if (existingId) {
+                this.daemon.broadcast({
+                  type: 'rotation:complete',
+                  agentId: agent.id,
+                  oldAgentId: existingId,
+                  agentName: agent.name,
+                  reason: 'phase2_respawn',
+                });
+              }
               this.daemon.audit.log('phase2.autoSpawn', { id: agent.id, name: agent.name, role: agent.role });
             }).catch((err) => {
               console.error(`[Groove] Phase 2 spawn failed for ${config.role}: ${err.message}`);
@@ -1884,6 +2006,7 @@ For normal file edits within your scope, proceed without review.
     const teamId = agent.teamId;
     if (!teamId) return;
     if (this._reviewTriggered.has(teamId)) return;
+    this._reviewTriggered.add(teamId);
 
     const registry = this.daemon.registry;
     const teamAgents = registry.getAll().filter(a => a.teamId === teamId);
@@ -1898,7 +2021,6 @@ For normal file edits within your scope, proceed without review.
       a.role !== 'planner' && (a.status === 'running' || a.status === 'starting'));
     if (hasRunning) return;
 
-    this._reviewTriggered.add(teamId);
     this._reviewPending.add(teamId);
 
     const journalist = this.daemon.journalist;
@@ -1912,6 +2034,12 @@ For normal file edits within your scope, proceed without review.
       for (const f of (journalist?.getAgentFiles(a) || [])) allFiles.add(f);
     }
 
+    if (!originalSpec.trim() && !plannerResult.trim() && allFiles.size === 0) {
+      console.log(`[Groove] Review skipped for team ${teamId}: no spec, plan, or files to review`);
+      this._reviewPending.delete(teamId);
+      return;
+    }
+
     const reviewPrompt = `You are reviewing a completed team build against the original specification.
 
 ## Original Task

package/packages/daemon/src/tunnel-manager.js

@@ -225,6 +225,14 @@ export class TunnelManager {
     const keyArgs = config.sshKeyPath ? ['-i', config.sshKeyPath] : [];
 
     try {
+      const probeCmd = [
+        `NV=$(node --version 2>/dev/null || echo "");`,
+        `echo "__NODE__${`$\{NV\}`}__NODE_END__";`,
+        `S=$(curl -sf http://localhost:${REMOTE_PORT}/api/status 2>/dev/null);`,
+        `if [ -n "$S" ]; then echo "__GROOVE_RUNNING__$S__GROOVE_END__";`,
+        `else which groove >/dev/null 2>&1 && echo __GROOVE_VER__$(groove --version 2>/dev/null || echo unknown)__GROOVE_STOPPED__ || echo __GROOVE_NOT_INSTALLED__; fi`,
+      ].join(' ');
+
       const result = execFileSync('ssh', [
         ...keyArgs,
         '-p', String(config.port || 22),
@@ -232,27 +240,32 @@ export class TunnelManager {
         '-o', 'StrictHostKeyChecking=accept-new',
         '-o', 'BatchMode=yes',
         target,
-        sshCmd(`S=$(curl -sf http://localhost:${REMOTE_PORT}/api/status 2>/dev/null); if [ -n "$S" ]; then echo "__GROOVE_RUNNING__$S__GROOVE_END__"; else which groove >/dev/null 2>&1 && echo __GROOVE_VER__$(groove --version 2>/dev/null || echo unknown)__GROOVE_STOPPED__ || echo __GROOVE_NOT_INSTALLED__; fi`),
+        sshCmd(probeCmd),
       ], {
         encoding: 'utf8',
         timeout: 15000,
         stdio: ['pipe', 'pipe', 'pipe'],
       });
 
+      const nodeMatch = result.match(/__NODE__(.+?)__NODE_END__/);
+      const nodeVersionRaw = nodeMatch ? nodeMatch[1].trim() : '';
+      const nodeInstalled = nodeVersionRaw.startsWith('v');
+      const nodeVersion = nodeInstalled ? nodeVersionRaw : null;
+
       if (result.includes('__GROOVE_NOT_INSTALLED__')) {
-        return { reachable: true, daemonRunning: false, grooveInstalled: false };
+        return { reachable: true, daemonRunning: false, grooveInstalled: false, nodeInstalled, nodeVersion };
       }
       if (result.includes('__GROOVE_STOPPED__')) {
         const verMatch = result.match(/__GROOVE_VER__(.+?)__GROOVE_STOPPED__/);
         const remoteVersion = verMatch ? verMatch[1].trim() : null;
-        return { reachable: true, daemonRunning: false, grooveInstalled: true, remoteVersion };
+        return { reachable: true, daemonRunning: false, grooveInstalled: true, remoteVersion, nodeInstalled, nodeVersion };
       }
       const runMatch = result.match(/__GROOVE_RUNNING__(.+?)__GROOVE_END__/);
       let remoteVersion = null;
       if (runMatch) {
         try { remoteVersion = JSON.parse(runMatch[1]).version || null; } catch { /* ignore */ }
       }
-      return { reachable: true, daemonRunning: true, grooveInstalled: true, remoteVersion };
+      return { reachable: true, daemonRunning: true, grooveInstalled: true, remoteVersion, nodeInstalled, nodeVersion };
     } catch (err) {
       const stderr = err.stderr?.toString() || '';
       if (stderr.includes('Permission denied')) {
@@ -271,14 +284,17 @@ export class TunnelManager {
 
     if (this.active.has(id)) {
       const existing = this.active.get(id);
-      return { localPort: existing.localPort, pid: existing.pid };
+      return { localPort: existing.localPort, pid: existing.pid, name: config.name };
     }
 
     this.daemon.broadcast({ type: 'tunnel.status', data: { id, step: 'testing' } });
 
+    // For known servers, skip the full test — tunnel first, check version after
     let testResult;
     if (opts.skipTest && opts.testResult) {
       testResult = opts.testResult;
+    } else if (config.lastConnected && opts.skipTest !== false) {
+      testResult = { reachable: true, daemonRunning: true, grooveInstalled: true, remoteVersion: null };
     } else {
       testResult = await this.test(id);
     }
@@ -286,22 +302,19 @@ export class TunnelManager {
       throw new Error(testResult.error || 'Host unreachable');
     }
 
+    // First-time only: install groove if missing, start daemon if not running
     let preConnectHandled = false;
     if (!testResult.daemonRunning && !testResult.grooveInstalled) {
       this.daemon.broadcast({ type: 'tunnel.status', data: { id, step: 'installing' } });
       await this.remoteInstall(id);
       preConnectHandled = true;
     } else if (!testResult.daemonRunning && testResult.grooveInstalled) {
-      const localVer = getLocalVersion();
-      if (testResult.remoteVersion && testResult.remoteVersion !== localVer) {
-        this.daemon.broadcast({ type: 'tunnel.status', data: { id, step: 'upgrading', from: testResult.remoteVersion, to: localVer } });
-        await this._remoteUpgrade(id, config);
-      }
       this.daemon.broadcast({ type: 'tunnel.status', data: { id, step: 'starting' } });
       await this.autoStart(id);
       preConnectHandled = true;
     }
 
+    // Establish SSH tunnel
     this.daemon.broadcast({ type: 'tunnel.status', data: { id, step: 'connecting' } });
 
     const localPort = await this._findAvailablePort();
@@ -357,9 +370,7 @@ export class TunnelManager {
       failCount: 0,
     });
 
-    // Verify the remote daemon is actually reachable through the tunnel.
-    // The cached test result (line 270) assumes daemonRunning=true based on
-    // lastConnected, but the daemon may have stopped since then.
+    // Verify daemon is reachable through tunnel, start if needed
     let remoteAlive = false;
     try {
       const probe = await fetch(`http://localhost:${localPort}/api/health`, {
@@ -371,7 +382,6 @@ export class TunnelManager {
     if (!remoteAlive && config.autoStart) {
       this.daemon.broadcast({ type: 'tunnel.status', data: { id, step: 'starting' } });
       await this.autoStart(id);
-      // Give the daemon a moment to accept connections through the tunnel
       for (let i = 0; i < 5; i++) {
         await new Promise(r => setTimeout(r, 1000));
         try {
@@ -385,9 +395,9 @@ export class TunnelManager {
       this.daemon.broadcast({ type: 'tunnel.status', data: { id, step: 'waiting', message: 'Remote daemon not running. Start it manually or enable auto-start.' } });
     }
 
-    const skipUpgrade = remoteAlive && testResult.remoteVersion && testResult.remoteVersion === getLocalVersion();
-    if (remoteAlive && !preConnectHandled && !skipUpgrade) {
-      await this._checkAndUpgradeRunning(id, config, localPort);
+    // Auto-upgrade: check version through tunnel, upgrade if behind (non-blocking)
+    if (remoteAlive && !preConnectHandled) {
+      this._checkAndUpgradeRunning(id, config, localPort).catch(() => {});
     }
 
     const remoteVer = testResult?.remoteVersion || null;
@@ -440,97 +450,93 @@ export class TunnelManager {
   }
 
   async _checkAndUpgradeRunning(id, config, localPort) {
-    const localVer = getLocalVersion();
-    if (localVer === '0.0.0') return;
-
     try {
+      // Get remote daemon version
       const resp = await fetch(`http://localhost:${localPort}/api/status`, {
         signal: AbortSignal.timeout(5000),
       });
       if (!resp.ok) return;
       const status = await resp.json();
-      const oldVersion = status.version;
-      if (!oldVersion || oldVersion === localVer) return;
-
-      this.daemon.broadcast({ type: 'tunnel.status', data: { id, step: 'upgrading', from: oldVersion, to: localVer } });
+      const remoteVer = status.version;
+      if (!remoteVer) return;
 
+      // Check latest version on npm (from the remote server)
       const target = `${config.user}@${config.host}`;
       const keyArgs = config.sshKeyPath ? ['-i', config.sshKeyPath] : [];
       const sshBase = [...keyArgs, '-p', String(config.port || 22), '-o', 'ConnectTimeout=10', '-o', 'BatchMode=yes', target];
-      const pinnedPkg = `groove-dev@${localVer}`;
-      const installCmd = npmGlobalInstall(pinnedPkg, config.user);
 
+      let npmVer;
       try {
-        execFileSync('ssh', [...sshBase, sshCmd(installCmd)], {
-          encoding: 'utf8',
-          timeout: 120000,
-          stdio: ['pipe', 'pipe', 'pipe'],
-        });
-      } catch {
-        const fallbackCmd = npmGlobalInstall('groove-dev', config.user);
-        execFileSync('ssh', [...sshBase, sshCmd(fallbackCmd)], {
-          encoding: 'utf8',
-          timeout: 120000,
-          stdio: ['pipe', 'pipe', 'pipe'],
-        });
+        npmVer = execFileSync('ssh', [...sshBase, sshCmd('npm view groove-dev version 2>/dev/null')], {
+          encoding: 'utf8', timeout: 15000, stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+      } catch { return; }
+
+      if (!npmVer || npmVer === remoteVer) {
+        const localVer = getLocalVersion();
+        this.daemon.broadcast({ type: 'tunnel.version-info', data: { id, localVersion: localVer, remoteVersion: remoteVer, match: remoteVer === localVer } });
+        return;
       }
 
-      const verOutput = execFileSync('ssh', [...sshBase, sshCmd('groove --version')], {
-        encoding: 'utf8',
-        timeout: 10000,
-        stdio: ['pipe', 'pipe', 'pipe'],
-      }).trim();
-      const installedVer = verOutput.replace(/[^0-9.]/g, '') || verOutput.trim();
+      // Remote is behind npm — upgrade
+      this.daemon.broadcast({ type: 'tunnel.status', data: { id, step: 'upgrading', from: remoteVer, to: npmVer } });
 
-      if (installedVer !== localVer) {
-        this.daemon.broadcast({ type: 'tunnel.version-mismatch', data: { id, localVersion: localVer, remoteVersion: installedVer, message: 'Pinned version not available on npm, installed latest' } });
+      const installCmd = npmGlobalInstall(`groove-dev@${npmVer}`, config.user);
+      const cleanupCmd = 'rm -rf $(npm root -g)/.groove-dev-* $(npm root -g)/groove-dev 2>/dev/null || true';
+
+      try {
+        execFileSync('ssh', [...sshBase, sshCmd(installCmd)], {
+          encoding: 'utf8', timeout: 120000, stdio: ['pipe', 'pipe', 'pipe'],
+        });
+      } catch (err) {
+        const errOutput = err.stdout?.toString() || err.stderr?.toString() || err.message;
+        if (errOutput.includes('ENOTEMPTY')) {
+          execFileSync('ssh', [...sshBase, sshCmd(cleanupCmd)], { encoding: 'utf8', timeout: 15000, stdio: ['pipe', 'pipe', 'pipe'] });
+          execFileSync('ssh', [...sshBase, sshCmd(installCmd)], { encoding: 'utf8', timeout: 120000, stdio: ['pipe', 'pipe', 'pipe'] });
+        } else {
+          throw err;
+        }
       }
 
+      // Restart remote daemon
       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 restartCmd = `kill $(lsof -t -i:${REMOTE_PORT}) 2>/dev/null || true; sleep 2; ${cdPrefix}GROOVE_BIN=$(which groove) && nohup "$GROOVE_BIN" start > /tmp/groove-daemon.log 2>&1 < /dev/null & disown; sleep 4; curl -sf http://localhost:${REMOTE_PORT}/api/status && (${setProjectDir}true) || true`;
-      const restartResult = execFileSync('ssh', [...sshBase, sshCmd(restartCmd)], {
-        encoding: 'utf8',
-        timeout: 60000,
-        stdio: ['pipe', 'pipe', 'pipe'],
+      execFileSync('ssh', [...sshBase, sshCmd(restartCmd)], {
+        encoding: 'utf8', timeout: 60000, stdio: ['pipe', 'pipe', 'pipe'],
       });
 
+      // Verify through tunnel
       let daemonVer = null;
-      try { daemonVer = JSON.parse(restartResult.trim()).version || null; } catch { /* parse failed */ }
-
       for (let i = 0; i < 3; i++) {
         try {
           const check = await fetch(`http://localhost:${localPort}/api/status`, {
             signal: AbortSignal.timeout(3000),
           });
           if (check.ok) {
-            const checkData = await check.json();
-            daemonVer = checkData.version || daemonVer;
+            daemonVer = (await check.json()).version || null;
             break;
           }
         } catch { /* retry */ }
         await new Promise(r => setTimeout(r, 2000));
       }
 
+      const localVer = getLocalVersion();
       if (daemonVer) {
         this.daemon.broadcast({ type: 'tunnel.version-info', data: { id, localVersion: localVer, remoteVersion: daemonVer, match: daemonVer === localVer } });
       } else {
-        this.daemon.broadcast({ type: 'tunnel.upgrade-failed', data: { id, error: 'Daemon did not respond after restart', from: oldVersion, attempted: localVer } });
+        this.daemon.broadcast({ type: 'tunnel.upgrade-failed', data: { id, error: 'Daemon did not respond after restart', from: remoteVer, attempted: npmVer } });
       }
 
-      this.daemon.audit.log('tunnel.upgrade', { id, from: oldVersion, to: daemonVer || installedVer });
+      this.daemon.audit.log('tunnel.upgrade', { id, from: remoteVer, to: daemonVer || npmVer });
     } catch (err) {
       try {
         const verify = await fetch(`http://localhost:${localPort}/api/status`, { signal: AbortSignal.timeout(5000) });
         if (verify.ok) {
           const verifyData = await verify.json();
-          if (verifyData.version === localVer) {
-            this.daemon.broadcast({ type: 'tunnel.version-info', data: { id, localVersion: localVer, remoteVersion: verifyData.version, match: true } });
-            return;
-          }
-          this.daemon.broadcast({ type: 'tunnel.version-mismatch', data: { id, localVersion: localVer, remoteVersion: verifyData.version, message: 'Upgrade timed out but remote is reachable' } });
+          this.daemon.broadcast({ type: 'tunnel.version-info', data: { id, localVersion: getLocalVersion(), remoteVersion: verifyData.version, match: false } });
           return;
         }
       } catch { /* tunnel verification failed */ }