groove-dev 0.27.113 → 0.27.116

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

@@ -1,8 +1,8 @@
 // GROOVE — Teams (Live Agent Groups)
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync, rmSync } from 'fs';
-import { resolve } from 'path';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync, rmSync, readdirSync, cpSync } from 'fs';
+import { resolve, basename } from 'path';
 import { randomUUID } from 'crypto';
 import { validateTeamName } from './validate.js';
 
@@ -141,29 +141,67 @@ export class Teams {
   }
 
   /**
-   * Delete a team — kills its agents, removes its directory, drops it from the
-   * registry. Deleting the default team regenerates a fresh empty one so users
-   * can wipe accumulated state and keep working without restarting the daemon.
+   * Archive a team — kills its agents, moves its directory to archived-teams/,
+   * stores metadata.json for later restore.
    */
-  delete(id) {
+  archive(id) {
     const team = this.teams.get(id);
     if (!team) throw new Error('Team not found');
 
-    // Kill any running agents in this team
-    const agents = this.daemon.registry.getAll().filter((a) => a.teamId === id);
-    for (const agent of agents) {
-      if (agent.status === 'running' || agent.status === 'starting') {
-        try { this.daemon.processes.kill(agent.id); } catch { /* ignore */ }
+    const agents = this._killAndRemoveAgents(id);
+
+    if (
+      team.workingDir &&
+      team.workingDir !== this.daemon.projectDir &&
+      existsSync(team.workingDir)
+    ) {
+      try {
+        const archiveDir = resolve(this.daemon.grooveDir, 'archived-teams');
+        mkdirSync(archiveDir, { recursive: true });
+        const slug = basename(team.workingDir);
+        const archiveName = `${slug}-${Date.now()}`;
+        const archivePath = resolve(archiveDir, archiveName);
+
+        try {
+          renameSync(team.workingDir, archivePath);
+        } catch (err) {
+          if (err.code === 'EXDEV') {
+            cpSync(team.workingDir, archivePath, { recursive: true });
+            rmSync(team.workingDir, { recursive: true, force: true });
+          } else {
+            throw err;
+          }
+        }
+
+        const metadata = {
+          originalName: team.name,
+          originalId: team.id,
+          deletedAt: new Date().toISOString(),
+          agentCount: agents.length,
+          originalWorkingDir: team.workingDir,
+        };
+        writeFileSync(resolve(archivePath, 'metadata.json'), JSON.stringify(metadata, null, 2));
+      } catch (err) {
+        console.log(`[Groove:Teams] Failed to archive directory: ${err.message}`);
       }
     }
 
-    // Remove agents from registry
-    for (const agent of agents) {
-      this.daemon.registry.remove(agent.id);
-    }
+    this._removeTeamAndCleanup(team, id);
+    return true;
+  }
+
+  /**
+   * Delete a team — kills its agents, removes its directory permanently.
+   * If permanent is false (default), delegates to archive() instead.
+   */
+  delete(id, { permanent = false } = {}) {
+    if (!permanent) return this.archive(id);
+
+    const team = this.teams.get(id);
+    if (!team) throw new Error('Team not found');
+
+    this._killAndRemoveAgents(id);
 
-    // Remove the team's working directory — refuse to nuke the project root
-    // (legacy default teams that were never migrated point there).
     if (
       team.workingDir &&
       team.workingDir !== this.daemon.projectDir &&
@@ -172,24 +210,109 @@ export class Teams {
       try {
         rmSync(team.workingDir, { recursive: true, force: true });
       } catch (err) {
-        console.log(`[Groove:Teams] Failed to remove directory: ${err.message}`);
+        console.log(`[Groove:Teams] Failed to delete directory: ${err.message}`);
+      }
+    }
+
+    this._removeTeamAndCleanup(team, id);
+    return true;
+  }
+
+  _killAndRemoveAgents(teamId) {
+    const agents = this.daemon.registry.getAll().filter((a) => a.teamId === teamId);
+    for (const agent of agents) {
+      if (agent.status === 'running' || agent.status === 'starting') {
+        try { this.daemon.processes.kill(agent.id); } catch { /* ignore */ }
       }
     }
+    for (const agent of agents) {
+      this.daemon.registry.remove(agent.id);
+    }
+    return agents;
+  }
 
+  _removeTeamAndCleanup(team, id) {
     this.teams.delete(id);
     this._save();
     this.daemon.broadcast({ type: 'team:deleted', teamId: id });
 
-    // Always keep a default team available — regenerate one with a clean folder
     if (team.isDefault) {
       this._ensureDefault();
       const fresh = this.getDefault();
       if (fresh) this.daemon.broadcast({ type: 'team:created', team: fresh });
     }
 
-    // Clean up orphaned logs immediately — don't wait for the 24h GC cycle
     try { this.daemon._gc(); } catch { /* gc should never block deletion */ }
+  }
+
+  listArchived() {
+    const archiveDir = resolve(this.daemon.grooveDir, 'archived-teams');
+    if (!existsSync(archiveDir)) return [];
+    const entries = readdirSync(archiveDir, { withFileTypes: true });
+    const result = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const metaPath = resolve(archiveDir, entry.name, 'metadata.json');
+      try {
+        const meta = JSON.parse(readFileSync(metaPath, 'utf8'));
+        result.push({ id: entry.name, ...meta });
+      } catch {
+        result.push({ id: entry.name, originalName: entry.name, deletedAt: null, agentCount: 0 });
+      }
+    }
+    return result;
+  }
+
+  restore(archivedId) {
+    const archiveDir = resolve(this.daemon.grooveDir, 'archived-teams');
+    const archivePath = resolve(archiveDir, archivedId);
+    if (!existsSync(archivePath)) throw new Error('Archived team not found');
+
+    let meta = {};
+    const metaPath = resolve(archivePath, 'metadata.json');
+    try { meta = JSON.parse(readFileSync(metaPath, 'utf8')); } catch { /* use defaults */ }
+
+    const name = meta.originalName || archivedId;
+    let workingDir = meta.originalWorkingDir || resolve(this.daemon.projectDir, slugify(name));
+
+    if (existsSync(workingDir)) {
+      workingDir = resolve(this.daemon.projectDir, `${slugify(name)}-${Date.now()}`);
+    }
+
+    try {
+      renameSync(archivePath, workingDir);
+    } catch (err) {
+      if (err.code === 'EXDEV') {
+        cpSync(archivePath, workingDir, { recursive: true });
+        rmSync(archivePath, { recursive: true, force: true });
+      } else {
+        throw err;
+      }
+    }
+
+    // Remove the metadata file from the restored directory
+    const restoredMetaPath = resolve(workingDir, 'metadata.json');
+    try { rmSync(restoredMetaPath); } catch { /* may not exist */ }
+
+    const id = randomUUID().slice(0, 8);
+    const team = {
+      id,
+      name,
+      isDefault: false,
+      workingDir,
+      createdAt: new Date().toISOString(),
+    };
+    this.teams.set(id, team);
+    this._save();
+    this.daemon.broadcast({ type: 'team:created', team });
+    return team;
+  }
 
+  purge(archivedId) {
+    const archiveDir = resolve(this.daemon.grooveDir, 'archived-teams');
+    const archivePath = resolve(archiveDir, archivedId);
+    if (!existsSync(archivePath)) throw new Error('Archived team not found');
+    rmSync(archivePath, { recursive: true, force: true });
     return true;
   }
 

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

@@ -3,15 +3,13 @@
 
 import { execFileSync, spawn } from 'child_process';
 import { existsSync, writeFileSync, readFileSync, statSync } from 'fs';
-import { resolve, dirname, join } from 'path';
-import { fileURLToPath } from 'url';
+import { resolve } from 'path';
 import { createConnection } from 'net';
 import crypto from 'crypto';
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
 function getLocalVersion() {
   try {
-    const pkg = JSON.parse(readFileSync(join(__dirname, '..', '..', '..', 'package.json'), 'utf8'));
+    const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
     return pkg.version || '0.0.0';
   } catch { return '0.0.0'; }
 }
@@ -34,6 +32,11 @@ function validateField(value, name) {
   }
 }
 
+function sshCmd(cmd) {
+  const nvmProbe = 'export NVM_DIR="${NVM_DIR:-$HOME/.nvm}"; [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"; ';
+  return `bash -lc '${nvmProbe}${cmd}'`;
+}
+
 export class TunnelManager {
   constructor(daemon) {
     this.daemon = daemon;
@@ -217,7 +220,7 @@ export class TunnelManager {
         '-o', 'StrictHostKeyChecking=accept-new',
         '-o', 'BatchMode=yes',
         target,
-        `bash -lc '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(`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`),
       ], {
         encoding: 'utf8',
         timeout: 20000,
@@ -412,7 +415,7 @@ export class TunnelManager {
       const installCmd = config.user === 'root' ? `npm i -g --prefer-online ${pinnedPkg}` : `sudo npm i -g --prefer-online ${pinnedPkg}`;
 
       try {
-        execFileSync('ssh', [...sshBase, `bash -lc '${installCmd}'`], {
+        execFileSync('ssh', [...sshBase, sshCmd(installCmd)], {
           encoding: 'utf8',
           timeout: 120000,
           stdio: ['pipe', 'pipe', 'pipe'],
@@ -420,14 +423,14 @@ export class TunnelManager {
       } catch {
         const fallbackPkg = 'groove-dev';
         const fallbackCmd = config.user === 'root' ? `npm i -g --prefer-online ${fallbackPkg}` : `sudo npm i -g --prefer-online ${fallbackPkg}`;
-        execFileSync('ssh', [...sshBase, `bash -lc '${fallbackCmd}'`], {
+        execFileSync('ssh', [...sshBase, sshCmd(fallbackCmd)], {
           encoding: 'utf8',
           timeout: 120000,
           stdio: ['pipe', 'pipe', 'pipe'],
         });
       }
 
-      const verOutput = execFileSync('ssh', [...sshBase, `bash -lc 'groove --version'`], {
+      const verOutput = execFileSync('ssh', [...sshBase, sshCmd('groove --version')], {
         encoding: 'utf8',
         timeout: 10000,
         stdio: ['pipe', 'pipe', 'pipe'],
@@ -438,8 +441,8 @@ export class TunnelManager {
         this.daemon.broadcast({ type: 'tunnel.version-mismatch', data: { id, localVersion: localVer, remoteVersion: installedVer, message: 'Pinned version not available on npm, installed latest' } });
       }
 
-      const restartCmd = `kill $(lsof -t -i:${REMOTE_PORT}) 2>/dev/null || true; sleep 2; nohup groove start > /tmp/groove-daemon.log 2>&1 < /dev/null & disown; sleep 4; curl -sf http://localhost:${REMOTE_PORT}/api/status`;
-      const restartResult = execFileSync('ssh', [...sshBase, `bash -lc '${restartCmd}'`], {
+      const restartCmd = `kill $(lsof -t -i:${REMOTE_PORT}) 2>/dev/null || true; sleep 2; 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`;
+      const restartResult = execFileSync('ssh', [...sshBase, sshCmd(restartCmd)], {
         encoding: 'utf8',
         timeout: 60000,
         stdio: ['pipe', 'pipe', 'pipe'],
@@ -484,30 +487,40 @@ export class TunnelManager {
 
     let usedFallback = false;
     try {
-      execFileSync('ssh', [...sshBase, `bash -lc '${installCmd}'`], {
+      execFileSync('ssh', [...sshBase, sshCmd(installCmd)], {
         encoding: 'utf8',
         timeout: 120000,
         stdio: ['pipe', 'pipe', 'pipe'],
       });
     } catch (err) {
-      if (localVer !== '0.0.0' && pkg.includes('@')) {
-        const fallbackCmd = config.user === 'root' ? 'npm i -g --prefer-online groove-dev' : 'sudo npm i -g --prefer-online groove-dev';
+      const errOutput = err.stdout?.toString() || err.stderr?.toString() || err.message;
+      if (errOutput.includes('ENOTEMPTY')) {
         try {
-          execFileSync('ssh', [...sshBase, `bash -lc '${fallbackCmd}'`], {
-            encoding: 'utf8',
-            timeout: 120000,
-            stdio: ['pipe', 'pipe', 'pipe'],
-          });
-          usedFallback = true;
-        } catch { /* fall through to original error */ }
-      }
-      if (!usedFallback) {
-        const output = err.stdout?.toString() || err.stderr?.toString() || err.message;
-        throw new Error(`Remote upgrade failed: ${output.slice(-400)}`);
+          execFileSync('ssh', [...sshBase, sshCmd('rm -rf $(npm root -g)/.groove-dev-* $(npm root -g)/groove-dev 2>/dev/null || true')], { encoding: 'utf8', timeout: 15000, stdio: ['pipe', 'pipe', 'pipe'] });
+          execFileSync('ssh', [...sshBase, sshCmd(installCmd)], { encoding: 'utf8', timeout: 120000, stdio: ['pipe', 'pipe', 'pipe'] });
+        } catch (retryErr) {
+          const retryOutput = retryErr.stdout?.toString() || retryErr.stderr?.toString() || retryErr.message;
+          throw new Error(`Remote upgrade failed after cleanup: ${retryOutput.slice(-400)}`);
+        }
+      } else {
+        if (localVer !== '0.0.0' && pkg.includes('@')) {
+          const fallbackCmd = config.user === 'root' ? 'npm i -g --prefer-online groove-dev' : 'sudo npm i -g --prefer-online groove-dev';
+          try {
+            execFileSync('ssh', [...sshBase, sshCmd(fallbackCmd)], {
+              encoding: 'utf8',
+              timeout: 120000,
+              stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            usedFallback = true;
+          } catch { /* fall through to original error */ }
+        }
+        if (!usedFallback) {
+          throw new Error(`Remote upgrade failed: ${errOutput.slice(-400)}`);
+        }
       }
     }
 
-    const verOutput = execFileSync('ssh', [...sshBase, `bash -lc 'groove --version'`], {
+    const verOutput = execFileSync('ssh', [...sshBase, sshCmd('groove --version')], {
       encoding: 'utf8',
       timeout: 10000,
       stdio: ['pipe', 'pipe', 'pipe'],
@@ -537,7 +550,7 @@ export class TunnelManager {
       ? `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; ` +
+      `${cdPrefix}GROOVE_BIN=$(which groove) && nohup "$GROOVE_BIN" 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__) ` +
@@ -550,7 +563,7 @@ export class TunnelManager {
         '-o', 'ConnectTimeout=10',
         '-o', 'BatchMode=yes',
         target,
-        `bash -lc '${remoteCmd}'`,
+        sshCmd(remoteCmd),
       ], {
         encoding: 'utf8',
         timeout: 45000,
@@ -564,8 +577,9 @@ export class TunnelManager {
       }
     } catch (err) {
       if (err.message.includes('Remote daemon failed')) throw err;
-      const output = err.stdout?.toString() || err.stderr?.toString() || err.message;
-      throw new Error(`Failed to start remote daemon: ${output.slice(-300)}`);
+      const output = err.stdout?.toString() || err.stderr?.toString() || '';
+      if (output.includes('__DAEMON_OK__')) return;
+      throw new Error(`Failed to start remote daemon: ${(output || err.message).slice(-300)}`);
     }
   }
 
@@ -585,7 +599,7 @@ export class TunnelManager {
 
     // Non-interactive SSH doesn't source shell profiles, so npm/node may not be on PATH.
     // Use a login shell (-l) to get the user's full environment.
-    const remoteCmd = (cmd) => `bash -lc '${cmd}'`;
+    const remoteCmd = (cmd) => sshCmd(cmd);
 
     // Step 1: Check if node/npm are available
     try {
@@ -623,7 +637,16 @@ export class TunnelManager {
         stdio: ['pipe', 'pipe', 'pipe'],
       });
     } catch (err) {
-      if (localVer !== '0.0.0' && pkg.includes('@')) {
+      const errOutput = err.stdout?.toString() || err.stderr?.toString() || err.message;
+      if (errOutput.includes('ENOTEMPTY')) {
+        try {
+          execFileSync('ssh', [...sshBase, remoteCmd('rm -rf $(npm root -g)/.groove-dev-* $(npm root -g)/groove-dev 2>/dev/null || true')], { encoding: 'utf8', timeout: 15000, stdio: ['pipe', 'pipe', 'pipe'] });
+          execFileSync('ssh', [...sshBase, remoteCmd(installCmd)], { encoding: 'utf8', timeout: 120000, stdio: ['pipe', 'pipe', 'pipe'] });
+        } catch (retryErr) {
+          const retryOutput = retryErr.stdout?.toString() || retryErr.stderr?.toString() || retryErr.message;
+          throw new Error(`npm install failed after cleanup: ${retryOutput.slice(-400)}`);
+        }
+      } else if (localVer !== '0.0.0' && pkg.includes('@')) {
         const fallbackCmd = config.user === 'root' ? 'npm i -g --prefer-online groove-dev' : 'sudo npm i -g --prefer-online groove-dev';
         try {
           execFileSync('ssh', [...sshBase, remoteCmd(fallbackCmd)], {
@@ -636,8 +659,7 @@ export class TunnelManager {
           throw new Error(`npm install failed: ${output.slice(-400)}`);
         }
       } else {
-        const output = err.stdout?.toString() || err.stderr?.toString() || err.message;
-        throw new Error(`npm install failed: ${output.slice(-400)}`);
+        throw new Error(`npm install failed: ${errOutput.slice(-400)}`);
       }
     }
 
@@ -645,7 +667,7 @@ export class TunnelManager {
     try {
       const result = execFileSync('ssh', [
         ...sshBase,
-        remoteCmd(`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)`),
+        remoteCmd(`GROOVE_BIN=$(which groove) && nohup "$GROOVE_BIN" 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)`),
       ], {
         encoding: 'utf8',
         timeout: 45000,
@@ -683,29 +705,40 @@ export class TunnelManager {
     const installCmd = config.user === 'root' ? `npm i -g --prefer-online ${pinnedPkg}` : `sudo npm i -g --prefer-online ${pinnedPkg}`;
 
     try {
-      execFileSync('ssh', [...sshBase, `bash -lc '${installCmd}'`], {
-        encoding: 'utf8',
-        timeout: 120000,
-        stdio: ['pipe', 'pipe', 'pipe'],
-      });
-    } catch {
-      const fallbackCmd = config.user === 'root' ? 'npm i -g --prefer-online groove-dev' : 'sudo npm i -g --prefer-online groove-dev';
-      execFileSync('ssh', [...sshBase, `bash -lc '${fallbackCmd}'`], {
+      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')) {
+        try {
+          execFileSync('ssh', [...sshBase, sshCmd('rm -rf $(npm root -g)/.groove-dev-* $(npm root -g)/groove-dev 2>/dev/null || true')], { encoding: 'utf8', timeout: 15000, stdio: ['pipe', 'pipe', 'pipe'] });
+          execFileSync('ssh', [...sshBase, sshCmd(installCmd)], { encoding: 'utf8', timeout: 120000, stdio: ['pipe', 'pipe', 'pipe'] });
+        } catch (retryErr) {
+          const retryOutput = retryErr.stdout?.toString() || retryErr.stderr?.toString() || retryErr.message;
+          throw new Error(`npm install failed after cleanup: ${retryOutput.slice(-400)}`);
+        }
+      } else {
+        const fallbackCmd = config.user === 'root' ? 'npm i -g --prefer-online groove-dev' : 'sudo npm i -g --prefer-online groove-dev';
+        execFileSync('ssh', [...sshBase, sshCmd(fallbackCmd)], {
+          encoding: 'utf8',
+          timeout: 120000,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+      }
     }
 
-    const verOutput = execFileSync('ssh', [...sshBase, `bash -lc 'groove --version'`], {
+    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();
 
-    const restartCmd = `kill $(lsof -t -i:${REMOTE_PORT}) 2>/dev/null || true; sleep 2; nohup groove start > /tmp/groove-daemon.log 2>&1 < /dev/null & disown; sleep 4; curl -sf http://localhost:${REMOTE_PORT}/api/status`;
-    const restartResult = execFileSync('ssh', [...sshBase, `bash -lc '${restartCmd}'`], {
+    const restartCmd = `kill $(lsof -t -i:${REMOTE_PORT}) 2>/dev/null || true; sleep 2; 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`;
+    const restartResult = execFileSync('ssh', [...sshBase, sshCmd(restartCmd)], {
       encoding: 'utf8',
       timeout: 60000,
       stdio: ['pipe', 'pipe', 'pipe'],