groove-dev 0.27.112 → 0.27.115

package/packages/daemon/src/api.js

@@ -1100,6 +1100,30 @@ export function createApi(app, daemon) {
     }
   });
 
+  app.get('/api/teams/archived', (req, res) => {
+    res.json({ archived: daemon.teams.listArchived() });
+  });
+
+  app.post('/api/teams/archived/:id/restore', (req, res) => {
+    try {
+      const team = daemon.teams.restore(req.params.id);
+      daemon.audit.log('team.restore', { archivedId: req.params.id, newId: team.id, name: team.name });
+      res.json(team);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/teams/archived/:id', (req, res) => {
+    try {
+      daemon.teams.purge(req.params.id);
+      daemon.audit.log('team.purge', { archivedId: req.params.id });
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
   app.patch('/api/teams/:id', (req, res) => {
     try {
       if (req.body.name) daemon.teams.rename(req.params.id, req.body.name);
@@ -3855,6 +3879,48 @@ Keep responses concise. Help them think, don't lecture them about the system the
   // --- Preview Proxy (same-origin iframe support) ---
   // Forwards HTTP requests to the dev server so the GUI can iframe the preview
   // without cross-origin issues. WebSocket upgrade for HMR is handled in index.js.
+
+  function rewriteAbsoluteUrls(body, proxyBase) {
+    let out = body;
+    // HTML attributes: src, href, action, poster
+    out = out.replace(/((?:src|href|action|poster)\s*=\s*(["']))\/(?!\/|api\/preview\/)/g, `$1${proxyBase}/`);
+    // JS imports: from '/' and import('/')
+    out = out.replace(/(from\s+(["']))\/(?!\/|api\/preview\/)/g, `$1${proxyBase}/`);
+    out = out.replace(/(import\s*\(\s*(["']))\/(?!\/|api\/preview\/)/g, `$1${proxyBase}/`);
+    // CSS url()
+    out = out.replace(/(url\s*\(\s*(["']?))\/(?!\/|api\/preview\/)/g, `$1${proxyBase}/`);
+    return out;
+  }
+
+  const REWRITABLE_TYPES = ['text/html', 'application/javascript', 'text/javascript', 'text/css'];
+
+  function handleProxyResponse(proxyRes, res, proxyBase) {
+    const fwdHeaders = { ...proxyRes.headers };
+    delete fwdHeaders['content-security-policy'];
+    delete fwdHeaders['x-frame-options'];
+
+    const ct = (fwdHeaders['content-type'] || '').toLowerCase();
+    const shouldRewrite = REWRITABLE_TYPES.some((t) => ct.includes(t));
+
+    if (!shouldRewrite) {
+      res.writeHead(proxyRes.statusCode, fwdHeaders);
+      proxyRes.pipe(res);
+      return;
+    }
+
+    const chunks = [];
+    proxyRes.on('data', (c) => chunks.push(c));
+    proxyRes.on('end', () => {
+      let body = Buffer.concat(chunks).toString('utf8');
+      body = rewriteAbsoluteUrls(body, proxyBase);
+      const buf = Buffer.from(body, 'utf8');
+      fwdHeaders['content-length'] = buf.length;
+      delete fwdHeaders['transfer-encoding'];
+      res.writeHead(proxyRes.statusCode, fwdHeaders);
+      res.end(buf);
+    });
+  }
+
   app.all('/api/preview/:teamId/proxy/*', (req, res) => {
     const entry = daemon.preview?.get(req.params.teamId);
     if (!entry || !entry.url) return res.status(404).json({ error: 'No active preview for this team' });
@@ -3865,9 +3931,11 @@ Keep responses concise. Help them think, don't lecture them about the system the
     const proxyPath = req.params[0] || '';
     const search = req.url.includes('?') ? '?' + req.url.split('?').slice(1).join('?') : '';
     const fullPath = '/' + proxyPath + search;
+    const proxyBase = `/api/preview/${req.params.teamId}/proxy`;
 
     const headers = { ...req.headers };
     delete headers.host;
+    delete headers['accept-encoding'];
     headers.host = targetUrl.host;
 
     const proxyReq = httpRequest({
@@ -3876,13 +3944,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
       path: fullPath,
       method: req.method,
       headers,
-    }, (proxyRes) => {
-      const fwdHeaders = { ...proxyRes.headers };
-      delete fwdHeaders['content-security-policy'];
-      delete fwdHeaders['x-frame-options'];
-      res.writeHead(proxyRes.statusCode, fwdHeaders);
-      proxyRes.pipe(res);
-    });
+    }, (proxyRes) => handleProxyResponse(proxyRes, res, proxyBase));
 
     proxyReq.on('error', (err) => {
       if (!res.headersSent) res.status(502).json({ error: `Proxy error: ${err.message}` });
@@ -3899,9 +3961,11 @@ Keep responses concise. Help them think, don't lecture them about the system the
     try { targetUrl = new URL(entry.devUrl || entry.url); } catch { return res.status(500).json({ error: 'Invalid preview URL' }); }
 
     const search = req.url.includes('?') ? '?' + req.url.split('?').slice(1).join('?') : '';
+    const proxyBase = `/api/preview/${req.params.teamId}/proxy`;
 
     const headers = { ...req.headers };
     delete headers.host;
+    delete headers['accept-encoding'];
     headers.host = targetUrl.host;
 
     const proxyReq = httpRequest({
@@ -3910,13 +3974,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
       path: '/' + search,
       method: req.method,
       headers,
-    }, (proxyRes) => {
-      const fwdHeaders = { ...proxyRes.headers };
-      delete fwdHeaders['content-security-policy'];
-      delete fwdHeaders['x-frame-options'];
-      res.writeHead(proxyRes.statusCode, fwdHeaders);
-      proxyRes.pipe(res);
-    });
+    }, (proxyRes) => handleProxyResponse(proxyRes, res, proxyBase));
 
     proxyReq.on('error', (err) => {
       if (!res.headersSent) res.status(502).json({ error: `Proxy error: ${err.message}` });
@@ -6183,13 +6241,15 @@ Keep responses concise. Help them think, don't lecture them about the system the
         stdio: ['ignore', 'pipe', 'pipe'],
         env: tagEnv,
       });
+      daemon._networkCheckProc = proc;
       let stdout = '';
       let stderr = '';
       proc.stdout.on('data', (c) => { stdout += c.toString(); });
       proc.stderr.on('data', (c) => { stderr += c.toString(); });
       const timeout = setTimeout(() => { safeKill(proc, 'SIGTERM'); }, 10_000);
-      proc.on('error', () => { clearTimeout(timeout); resolvePromise(null); });
+      proc.on('error', () => { clearTimeout(timeout); daemon._networkCheckProc = null; resolvePromise(null); });
       proc.on('close', (code) => {
+        daemon._networkCheckProc = null;
         clearTimeout(timeout);
         if (code !== 0) return resolvePromise(null);
         const tags = [];

package/packages/daemon/src/filewatcher.js

@@ -8,6 +8,7 @@ export class FileWatcher {
   constructor(daemon) {
     this.daemon = daemon;
     this.watchers = new Map(); // relPath → { watcher, timer }
+    this.dirWatchers = new Map(); // relPath → { watcher, timer }
   }
 
   watch(relPath) {
@@ -51,9 +52,53 @@ export class FileWatcher {
     this.watchers.delete(relPath);
   }
 
+  watchDir(relPath) {
+    if (typeof relPath !== 'string') return;
+    if (relPath && relPath.includes('..')) return;
+    if (this.dirWatchers.has(relPath)) return;
+
+    const fullPath = relPath ? resolve(this.daemon.projectDir, relPath) : this.daemon.projectDir;
+
+    try {
+      const watcher = watch(fullPath, () => {
+        const entry = this.dirWatchers.get(relPath);
+        if (!entry) return;
+
+        if (entry.timer) clearTimeout(entry.timer);
+        entry.timer = setTimeout(() => {
+          this.daemon.broadcast({
+            type: 'file:tree-changed',
+            path: relPath,
+            timestamp: Date.now(),
+          });
+        }, 300);
+      });
+
+      watcher.on('error', () => {
+        this.unwatchDir(relPath);
+      });
+
+      this.dirWatchers.set(relPath, { watcher, timer: null });
+    } catch {
+      // Directory doesn't exist or not watchable — ignore
+    }
+  }
+
+  unwatchDir(relPath) {
+    const entry = this.dirWatchers.get(relPath);
+    if (!entry) return;
+
+    if (entry.timer) clearTimeout(entry.timer);
+    try { entry.watcher.close(); } catch { /* already closed */ }
+    this.dirWatchers.delete(relPath);
+  }
+
   unwatchAll() {
     for (const [relPath] of this.watchers) {
       this.unwatch(relPath);
     }
+    for (const [relPath] of this.dirWatchers) {
+      this.unwatchDir(relPath);
+    }
   }
 }

package/packages/daemon/src/index.js

@@ -290,11 +290,11 @@ export class Daemon {
     });
 
     // Debounced file I/O for registry changes (at most once per 2s)
-    let _registryIoTimer = null;
+    this._registryIoTimer = null;
     const _debouncedRegistryIo = () => {
-      if (_registryIoTimer) return;
-      _registryIoTimer = setTimeout(() => {
-        _registryIoTimer = null;
+      if (this._registryIoTimer) return;
+      this._registryIoTimer = setTimeout(() => {
+        this._registryIoTimer = null;
         this.introducer.writeRegistryFile(this.projectDir);
         this.introducer.injectGrooveSection(this.projectDir);
       }, 2000);
@@ -325,8 +325,9 @@ export class Daemon {
         data: enrichAgents(this.registry.getAll()),
       }));
 
-      // Track which files this client is watching (for cleanup on disconnect)
+      // Track which files/dirs this client is watching (for cleanup on disconnect)
       const watchedFiles = new Set();
+      const watchedDirs = new Set();
 
       ws.on('message', (raw) => {
         try {
@@ -335,7 +336,7 @@ export class Daemon {
           // Validate message type against whitelist
           const VALID_WS_TYPES = new Set([
             'terminal:spawn', 'terminal:resize', 'terminal:input', 'terminal:close', 'terminal:kill', 'terminal:rename',
-            'editor:watch', 'editor:unwatch', 'editor:save',
+            'editor:watch', 'editor:unwatch', 'editor:save', 'editor:watchdir', 'editor:unwatchdir',
             'ping'
           ]);
           if (!msg || typeof msg !== 'object' || !VALID_WS_TYPES.has(msg.type)) return;
@@ -351,6 +352,14 @@ export class Daemon {
             case 'editor:unwatch':
               if (msg.path) { this.fileWatcher.unwatch(msg.path); watchedFiles.delete(msg.path); }
               break;
+            case 'editor:watchdir':
+              if (typeof msg.path === 'string' && !msg.path.includes('..')) {
+                this.fileWatcher.watchDir(msg.path); watchedDirs.add(msg.path);
+              }
+              break;
+            case 'editor:unwatchdir':
+              if (typeof msg.path === 'string') { this.fileWatcher.unwatchDir(msg.path); watchedDirs.delete(msg.path); }
+              break;
             // Terminal
             case 'terminal:spawn': {
               if (msg.cwd !== undefined && (typeof msg.cwd !== 'string' || msg.cwd.includes('..'))) break;
@@ -389,6 +398,9 @@ export class Daemon {
         for (const path of watchedFiles) {
           this.fileWatcher.unwatch(path);
         }
+        for (const path of watchedDirs) {
+          this.fileWatcher.unwatchDir(path);
+        }
         this.terminalManager.cleanupClient(ws);
       });
     });
@@ -779,6 +791,11 @@ export class Daemon {
     if (this._stateSaveInterval) clearInterval(this._stateSaveInterval);
     if (this._classifierInterval) clearInterval(this._classifierInterval);
     if (this._subscriptionPollInterval) clearInterval(this._subscriptionPollInterval);
+    if (this._registryIoTimer) clearTimeout(this._registryIoTimer);
+    if (this._networkCheckProc) {
+      try { this._networkCheckProc.kill(); } catch { /* already exited */ }
+      this._networkCheckProc = null;
+    }
 
     // Clean up file watchers and terminal sessions
     this.fileWatcher.unwatchAll();
@@ -823,10 +840,19 @@ export class Daemon {
 
     // Close server
     return new Promise((resolvePromise) => {
-      this.wss.close(() => {
-        this.server.close(() => {
-          console.log('GROOVE daemon stopped.');
-          resolvePromise();
+      this.federationWss.close(() => {
+        this.wss.close(() => {
+          this.server.close(() => {
+            // Unref lingering handles (idle fetch/undici TLS pool connections,
+            // closed servers) so they don't prevent process exit in tests.
+            for (const h of process._getActiveHandles()) {
+              if (typeof h.unref === 'function' && h !== process.stdout && h !== process.stderr) {
+                h.unref();
+              }
+            }
+            console.log('GROOVE daemon stopped.');
+            resolvePromise();
+          });
         });
       });
     });

package/packages/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';
 
@@ -162,17 +162,39 @@ export class Teams {
       this.daemon.registry.remove(agent.id);
     }
 
-    // Remove the team's working directory — refuse to nuke the project root
-    // (legacy default teams that were never migrated point there).
+    // Archive the team's working directory instead of deleting it
     if (
       team.workingDir &&
       team.workingDir !== this.daemon.projectDir &&
       existsSync(team.workingDir)
     ) {
       try {
-        rmSync(team.workingDir, { recursive: true, force: true });
+        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,
+        };
+        writeFileSync(resolve(archivePath, 'metadata.json'), JSON.stringify(metadata, null, 2));
       } catch (err) {
-        console.log(`[Groove:Teams] Failed to remove directory: ${err.message}`);
+        console.log(`[Groove:Teams] Failed to archive directory: ${err.message}`);
       }
     }
 
@@ -193,6 +215,78 @@ export class Teams {
     return true;
   }
 
+  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;
+    const dirName = slugify(name);
+    let workingDir = resolve(this.daemon.projectDir, dirName);
+
+    if (existsSync(workingDir)) {
+      workingDir = resolve(this.daemon.projectDir, `${dirName}-${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;
+  }
+
   // Migrate old agents (teamName but no teamId) to default team
   migrateAgents() {
     const defaultTeam = this.getDefault();