groove-dev 0.10.10 → 0.12.0

package/packages/daemon/src/firstrun.js

@@ -21,7 +21,7 @@ export function isFirstRun(grooveDir) {
 }
 
 // Show welcome banner on every startup
-export function printWelcome(port) {
+export function printWelcome(port, host = '127.0.0.1') {
   const providers = listProviders();
   const installed = providers.filter((p) => p.installed);
   const notInstalled = providers.filter((p) => !p.installed);
@@ -52,7 +52,32 @@ export function printWelcome(port) {
   }
 
   console.log('');
-  console.log(`  GUI:   http://localhost:${port}`);
+  const isRemote = host !== '127.0.0.1';
+  const isSSH = !!(process.env.SSH_CONNECTION || process.env.SSH_CLIENT);
+
+  if (isRemote) {
+    // Bound to network interface (Tailscale/LAN)
+    console.log(`  GUI:   http://${host}:${port}`);
+    console.log(`  Host:  ${host} (network-accessible)`);
+  } else if (isSSH) {
+    // Running on a VPS via SSH — print remote access instructions
+    const sshUser = process.env.USER || 'user';
+    const sshConn = process.env.SSH_CONNECTION || '';
+    const serverIp = sshConn.split(' ')[2] || '<this-server-ip>';
+
+    console.log(`  GUI:   http://localhost:${port} (this server only)`);
+    console.log('');
+    console.log('  ► Connect from your laptop:');
+    console.log(`    groove connect ${sshUser}@${serverIp}`);
+    console.log('');
+    console.log('  Or manually:');
+    console.log(`    ssh -L ${port + 1}:localhost:${port} ${sshUser}@${serverIp}`);
+    console.log(`    Then open http://localhost:${port + 1}`);
+  } else {
+    // Local machine
+    console.log(`  GUI:   http://localhost:${port}`);
+  }
+
   console.log('  Docs:  https://docs.groovedev.ai');
   console.log('  GitHub: https://github.com/grooveai-dev/groove');
   console.log('');

package/packages/daemon/src/index.js

@@ -3,6 +3,7 @@
 
 import { createServer as createHttpServer } from 'http';
 import { createServer as createNetServer } from 'net';
+import { execFileSync } from 'child_process';
 import { resolve } from 'path';
 import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync } from 'fs';
 import express from 'express';
@@ -23,15 +24,56 @@ import { CredentialStore } from './credentials.js';
 import { TaskClassifier } from './classifier.js';
 import { ModelRouter } from './router.js';
 import { ProjectManager } from './pm.js';
+import { CodebaseIndexer } from './indexer.js';
+import { AuditLogger } from './audit.js';
+import { Federation } from './federation.js';
 import { isFirstRun, runFirstTimeSetup, loadConfig, saveConfig, printWelcome } from './firstrun.js';
 
 const DEFAULT_PORT = 31415;
+const DEFAULT_HOST = '127.0.0.1';
 
 export { loadConfig, saveConfig } from './firstrun.js';
 
+/**
+ * Resolve the --host value to a bind address.
+ * - 'tailscale' → auto-detect via `tailscale ip -4`
+ * - '0.0.0.0' / '::' → rejected (security policy)
+ * - anything else → used as-is
+ */
+function resolveHost(host) {
+  if (!host || host === 'localhost') return DEFAULT_HOST;
+
+  // Block direct internet exposure
+  if (host === '0.0.0.0' || host === '::') {
+    console.error('\n  Direct internet exposure not supported.');
+    console.error('  Use `groove connect` (SSH tunnel) or `--host tailscale` instead.\n');
+    process.exit(1);
+  }
+
+  // Auto-detect Tailscale IP
+  if (host === 'tailscale') {
+    try {
+      const ip = execFileSync('tailscale', ['ip', '-4'], {
+        encoding: 'utf8',
+        timeout: 5000,
+      }).trim().split('\n')[0];
+      if (!ip) throw new Error('empty response');
+      return ip;
+    } catch (err) {
+      console.error('\n  Could not detect Tailscale IP.');
+      console.error('  Make sure Tailscale is installed and running: `tailscale status`');
+      console.error(`  Error: ${err.message}\n`);
+      process.exit(1);
+    }
+  }
+
+  return host;
+}
+
 export class Daemon {
   constructor(options = {}) {
     this.port = options.port !== undefined ? options.port : (parseInt(process.env.GROOVE_PORT, 10) || DEFAULT_PORT);
+    this.host = resolveHost(options.host);
     this.projectDir = options.projectDir || process.cwd();
     this.grooveDir = options.grooveDir || resolve(this.projectDir, '.groove');
     this.pidFile = resolve(this.grooveDir, 'daemon.pid');
@@ -69,6 +111,9 @@ export class Daemon {
     this.classifier = new TaskClassifier();
     this.router = new ModelRouter(this);
     this.pm = new ProjectManager(this);
+    this.indexer = new CodebaseIndexer(this);
+    this.audit = new AuditLogger(this.grooveDir);
+    this.federation = new Federation(this);
 
     // HTTP + WebSocket server
     this.app = express();
@@ -78,13 +123,17 @@ export class Daemon {
       maxPayload: 1024 * 1024, // 1MB max message
       verifyClient: ({ req }) => {
         const origin = req.headers.origin;
-        // Allow: no origin (CLI/native clients), localhost origins
+        // Allow: no origin (CLI/native clients), localhost origins, bound host
         if (!origin) return true;
         const allowed = [
           `http://localhost:${this.port}`,
           `http://127.0.0.1:${this.port}`,
           'http://localhost:3142',
         ];
+        // Allow the bound interface (for Tailscale/LAN access)
+        if (this.host !== DEFAULT_HOST) {
+          allowed.push(`http://${this.host}:${this.port}`);
+        }
         return allowed.includes(origin);
       },
     });
@@ -141,11 +190,12 @@ export class Daemon {
     }
 
     // Auto-find an open port if the default is taken
+    const bindHost = this.host;
     const checkPort = (port) => new Promise((res) => {
       const tester = createNetServer();
       tester.once('error', () => res(false));
       tester.once('listening', () => { tester.close(); res(true); });
-      tester.listen(port, '127.0.0.1');
+      tester.listen(port, bindHost);
     }).catch(() => false);
 
     if (!(await checkPort(this.port))) {
@@ -170,17 +220,21 @@ export class Daemon {
     this.registry.restore(this.state.get('agents') || []);
 
     return new Promise((resolvePromise) => {
-      this.server.listen(this.port, '127.0.0.1', () => {
+      this.server.listen(this.port, this.host, () => {
         writeFileSync(this.pidFile, String(process.pid));
-        // Write actual port so CLI can find us (supports auto-port rotation)
+        // Write actual port and host so CLI can find us
         writeFileSync(resolve(this.grooveDir, 'daemon.port'), String(this.port));
+        writeFileSync(resolve(this.grooveDir, 'daemon.host'), this.host);
 
-        printWelcome(this.port);
+        printWelcome(this.port, this.host);
 
         // Start background services
         this.journalist.start();
         this.rotator.start();
 
+        // Scan codebase for workspace/structure awareness
+        this.indexer.scan();
+
         resolvePromise(this);
       });
     });
@@ -198,10 +252,14 @@ export class Daemon {
     // Kill all agent processes
     await this.processes.killAll();
 
-    // Clean up PID file
+    // Clean up PID and host files
     if (existsSync(this.pidFile)) {
       unlinkSync(this.pidFile);
     }
+    const hostFile = resolve(this.grooveDir, 'daemon.host');
+    if (existsSync(hostFile)) {
+      unlinkSync(hostFile);
+    }
 
     // Clean up generated files
     const registryPath = resolve(this.projectDir, 'AGENTS_REGISTRY.md');

package/packages/daemon/src/indexer.js

@@ -0,0 +1,324 @@
+// GROOVE — Codebase Indexer
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Scans the project structure on daemon start to detect monorepo workspaces,
+// key files, and directory layout. Agents read this instead of spending
+// thousands of tokens exploring the file tree.
+
+import { readdirSync, statSync, readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve, relative, basename, join } from 'path';
+
+const IGNORE_DIRS = new Set([
+  'node_modules', '.git', '.groove', 'dist', 'build', '.next', '.nuxt',
+  '.output', '.cache', '.turbo', '.vercel', '.svelte-kit', 'coverage',
+  '__pycache__', '.venv', 'venv', 'vendor', 'target', '.gradle',
+]);
+
+const KEY_FILES = [
+  'package.json', 'tsconfig.json', 'README.md', 'CLAUDE.md',
+  'ARCHITECTURE.md', 'Cargo.toml', 'go.mod', 'pyproject.toml',
+  'Makefile', 'Dockerfile', 'docker-compose.yml', 'docker-compose.yaml',
+];
+
+const MAX_DEPTH = 4;
+
+export class CodebaseIndexer {
+  constructor(daemon) {
+    this.daemon = daemon;
+    this.index = null;       // { tree, workspaces, keyFiles, stats }
+    this.lastIndexTime = null;
+    this.indexPath = resolve(daemon.grooveDir, 'codebase-index.json');
+  }
+
+  /**
+   * Scan the project directory and build the codebase index.
+   * Called on daemon start. Fast — only reads directory entries, not file contents.
+   */
+  scan() {
+    const rootDir = this.daemon.projectDir;
+    const tree = [];
+    const workspaces = [];
+    const keyFiles = [];
+    let totalFiles = 0;
+    let totalDirs = 0;
+
+    // Recursive directory walker (depth-limited)
+    const walk = (dir, depth, relPath) => {
+      if (depth > MAX_DEPTH) return;
+
+      let entries;
+      try {
+        entries = readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+
+      const dirs = [];
+      const files = [];
+
+      for (const entry of entries) {
+        if (entry.name.startsWith('.') && entry.name !== '.github') continue;
+
+        if (entry.isDirectory()) {
+          if (IGNORE_DIRS.has(entry.name)) continue;
+          dirs.push(entry.name);
+          totalDirs++;
+        } else if (entry.isFile()) {
+          files.push(entry.name);
+          totalFiles++;
+
+          // Track key files
+          if (KEY_FILES.includes(entry.name)) {
+            const filePath = relPath ? `${relPath}/${entry.name}` : entry.name;
+            keyFiles.push(filePath);
+          }
+        }
+      }
+
+      // Add to tree
+      const nodePath = relPath || '.';
+      tree.push({
+        path: nodePath,
+        depth,
+        dirs: dirs.length,
+        files: files.length,
+        children: dirs,
+      });
+
+      // Recurse into subdirectories
+      for (const d of dirs) {
+        walk(resolve(dir, d), depth + 1, relPath ? `${relPath}/${d}` : d);
+      }
+    };
+
+    walk(rootDir, 0, '');
+
+    // Detect workspaces
+    this.detectWorkspaces(rootDir, workspaces, tree);
+
+    this.index = {
+      projectName: basename(rootDir),
+      scannedAt: new Date().toISOString(),
+      stats: { totalFiles, totalDirs, treeDepth: MAX_DEPTH },
+      workspaces,
+      keyFiles,
+      tree,
+    };
+    this.lastIndexTime = Date.now();
+
+    // Persist to .groove/codebase-index.json
+    try {
+      writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
+    } catch {
+      // Non-fatal — index is in memory either way
+    }
+
+    // Broadcast to GUI
+    this.daemon.broadcast({
+      type: 'indexer:complete',
+      data: {
+        workspaceCount: workspaces.length,
+        workspaces,
+        stats: this.index.stats,
+      },
+    });
+
+    return this.index;
+  }
+
+  /**
+   * Detect monorepo workspaces from common patterns.
+   */
+  detectWorkspaces(rootDir, workspaces, tree) {
+    // 1. npm/yarn workspaces (package.json → workspaces field)
+    const rootPkg = this.readJson(resolve(rootDir, 'package.json'));
+    if (rootPkg?.workspaces) {
+      const patterns = Array.isArray(rootPkg.workspaces)
+        ? rootPkg.workspaces
+        : rootPkg.workspaces.packages || [];
+      this.resolveWorkspacePatterns(rootDir, patterns, workspaces, 'npm-workspaces');
+    }
+
+    // 2. pnpm workspaces
+    const pnpmPath = resolve(rootDir, 'pnpm-workspace.yaml');
+    if (existsSync(pnpmPath)) {
+      try {
+        const content = readFileSync(pnpmPath, 'utf8');
+        // Simple YAML parse — extract lines like "  - packages/*"
+        const patterns = [];
+        for (const line of content.split('\n')) {
+          const match = line.match(/^\s*-\s+['"]?([^'"]+)['"]?\s*$/);
+          if (match) patterns.push(match[1]);
+        }
+        if (patterns.length > 0) {
+          this.resolveWorkspacePatterns(rootDir, patterns, workspaces, 'pnpm-workspaces');
+        }
+      } catch { /* ignore */ }
+    }
+
+    // 3. lerna.json
+    const lernaPath = resolve(rootDir, 'lerna.json');
+    if (existsSync(lernaPath)) {
+      const lerna = this.readJson(lernaPath);
+      if (lerna?.packages) {
+        this.resolveWorkspacePatterns(rootDir, lerna.packages, workspaces, 'lerna');
+      }
+    }
+
+    // 4. Fallback: multiple package.json at depth 1-2 (non-declared monorepo)
+    if (workspaces.length === 0) {
+      const subPkgs = tree.filter((node) =>
+        node.depth >= 1 && node.depth <= 2 &&
+        this.hasKeyFile(rootDir, node.path, 'package.json')
+      );
+      if (subPkgs.length >= 2) {
+        for (const node of subPkgs) {
+          const pkgJson = this.readJson(resolve(rootDir, node.path, 'package.json'));
+          workspaces.push({
+            path: node.path,
+            name: pkgJson?.name || basename(node.path),
+            type: 'detected',
+            files: node.files,
+            dirs: node.dirs,
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Resolve workspace glob patterns (e.g. "packages/*") into actual directories.
+   */
+  resolveWorkspacePatterns(rootDir, patterns, workspaces, type) {
+    const seen = new Set(workspaces.map((w) => w.path));
+
+    for (const pattern of patterns) {
+      // Handle simple glob: "packages/*", "apps/*"
+      const clean = pattern.replace(/\/?\*+$/, '');
+      const parentDir = resolve(rootDir, clean);
+
+      if (!existsSync(parentDir)) continue;
+
+      try {
+        const stat = statSync(parentDir);
+
+        if (pattern.includes('*')) {
+          // It's a glob — list children of the parent directory
+          const entries = readdirSync(parentDir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (!entry.isDirectory() || IGNORE_DIRS.has(entry.name)) continue;
+            const wsPath = clean ? `${clean}/${entry.name}` : entry.name;
+            if (seen.has(wsPath)) continue;
+            seen.add(wsPath);
+
+            const fullPath = resolve(rootDir, wsPath);
+            const pkgJson = this.readJson(resolve(fullPath, 'package.json'));
+            const info = this.dirInfo(fullPath);
+            workspaces.push({
+              path: wsPath,
+              name: pkgJson?.name || entry.name,
+              type,
+              files: info.files,
+              dirs: info.dirs,
+            });
+          }
+        } else if (stat.isDirectory()) {
+          // Direct path (e.g. "shared")
+          if (seen.has(clean)) continue;
+          seen.add(clean);
+
+          const pkgJson = this.readJson(resolve(parentDir, 'package.json'));
+          const info = this.dirInfo(parentDir);
+          workspaces.push({
+            path: clean,
+            name: pkgJson?.name || basename(clean),
+            type,
+            files: info.files,
+            dirs: info.dirs,
+          });
+        }
+      } catch { /* skip inaccessible dirs */ }
+    }
+  }
+
+  // ── Helpers ──
+
+  readJson(filePath) {
+    try {
+      return JSON.parse(readFileSync(filePath, 'utf8'));
+    } catch {
+      return null;
+    }
+  }
+
+  hasKeyFile(rootDir, relPath, filename) {
+    return existsSync(resolve(rootDir, relPath, filename));
+  }
+
+  dirInfo(dirPath) {
+    try {
+      const entries = readdirSync(dirPath, { withFileTypes: true });
+      let files = 0, dirs = 0;
+      for (const e of entries) {
+        if (e.name.startsWith('.')) continue;
+        if (e.isFile()) files++;
+        else if (e.isDirectory() && !IGNORE_DIRS.has(e.name)) dirs++;
+      }
+      return { files, dirs };
+    } catch {
+      return { files: 0, dirs: 0 };
+    }
+  }
+
+  // ── Public API ──
+
+  getWorkspaces() {
+    return this.index?.workspaces || [];
+  }
+
+  getIndex() {
+    return this.index;
+  }
+
+  /**
+   * Get a compact structural summary for agent context injection.
+   * Returns a markdown string with workspace layout and key files.
+   */
+  getStructureSummary() {
+    if (!this.index) return null;
+    const { workspaces, keyFiles, stats, projectName } = this.index;
+
+    const lines = [];
+    lines.push(`Project: **${projectName}** (${stats.totalFiles} files, ${stats.totalDirs} directories)`);
+
+    if (workspaces.length > 0) {
+      lines.push('');
+      lines.push(`Workspaces (${workspaces.length}):`);
+      for (const ws of workspaces) {
+        lines.push(`- \`${ws.path}/\` — ${ws.name} (${ws.files} files, ${ws.dirs} subdirs)`);
+      }
+    }
+
+    if (keyFiles.length > 0) {
+      lines.push('');
+      lines.push('Key files:');
+      for (const f of keyFiles.slice(0, 30)) {
+        lines.push(`- ${f}`);
+      }
+      if (keyFiles.length > 30) {
+        lines.push(`- *(+${keyFiles.length - 30} more)*`);
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  getStatus() {
+    return {
+      indexed: !!this.index,
+      lastIndexTime: this.lastIndexTime,
+      workspaceCount: this.index?.workspaces?.length || 0,
+      stats: this.index?.stats || null,
+    };
+  }
+}

package/packages/daemon/src/introducer.js

@@ -26,6 +26,10 @@ export class Introducer {
       `You are **${newAgent.name}** (role: ${newAgent.role}), managed by GROOVE.`,
     ];
 
+    if (newAgent.workingDir) {
+      lines.push(`Your working directory: \`${newAgent.workingDir}\` — you are spawned inside this subdirectory. Stay within it unless coordination requires otherwise.`);
+    }
+
     if (newAgent.scope && newAgent.scope.length > 0) {
       lines.push(`Your file scope: \`${newAgent.scope.join('`, `')}\``);
     } else {
@@ -45,7 +49,8 @@ export class Introducer {
 
       for (const other of others) {
         const scope = other.scope?.length > 0 ? other.scope.join(', ') : 'unrestricted';
-        lines.push(`- **${other.name}** (${other.role}) — scope: ${scope} — ${other.status}`);
+        const dir = other.workingDir ? ` — dir: ${other.workingDir}` : '';
+        lines.push(`- **${other.name}** (${other.role}) — scope: ${scope}${dir} — ${other.status}`);
 
         // Get files this agent created/modified
         const files = this.daemon.journalist?.getAgentFiles(other) || [];
@@ -138,9 +143,54 @@ export class Introducer {
       lines.push(`Read GROOVE_PROJECT_MAP.md for current project context from The Journalist.`);
     }
 
+    // Codebase structure injection — give agents instant orientation
+    const structureSummary = this.daemon.indexer?.getStructureSummary();
+    if (structureSummary) {
+      lines.push('');
+      lines.push(`## Codebase Structure (auto-indexed)`);
+      lines.push('');
+      lines.push(structureSummary);
+    }
+
+    // Architecture injection — auto-detect architecture docs and inject
+    // so every agent understands the big picture without spending tokens exploring
+    const archContent = this.loadArchitectureDoc();
+    if (archContent) {
+      lines.push('');
+      lines.push(`## Architecture (auto-injected)`);
+      lines.push('');
+      lines.push(archContent);
+    }
+
     return lines.join('\n');
   }
 
+  loadArchitectureDoc() {
+    const projectDir = this.daemon.projectDir;
+    const candidates = [
+      'ARCHITECTURE.md',
+      'docs/architecture.md',
+      '.github/ARCHITECTURE.md',
+    ];
+
+    for (const candidate of candidates) {
+      const fullPath = resolve(projectDir, candidate);
+      if (existsSync(fullPath)) {
+        try {
+          let content = readFileSync(fullPath, 'utf8').trim();
+          // Truncate to ~5K chars to keep context budget reasonable
+          if (content.length > 5000) {
+            content = content.slice(0, 5000) + '\n\n*(truncated — read full file for details)*';
+          }
+          return content;
+        } catch {
+          // ignore read errors
+        }
+      }
+    }
+    return null;
+  }
+
   writeRegistryFile(projectDir) {
     const agents = this.daemon.registry.getAll();
 
@@ -158,13 +208,14 @@ export class Introducer {
       ``,
       `*Auto-generated by GROOVE. Do not edit manually.*`,
       ``,
-      `| ID | Name | Role | Provider | Scope | Status |`,
-      `|----|------|------|----------|-------|--------|`,
+      `| ID | Name | Role | Provider | Directory | Scope | Status |`,
+      `|----|------|------|----------|-----------|-------|--------|`,
     ];
 
     for (const a of agents) {
       const scope = a.scope?.length > 0 ? `\`${a.scope.join('`, `')}\`` : '-';
-      lines.push(`| ${escapeMd(a.id)} | ${escapeMd(a.name)} | ${escapeMd(a.role)} | ${escapeMd(a.provider)} | ${scope} | ${escapeMd(a.status)} |`);
+      const dir = a.workingDir ? escapeMd(a.workingDir) : '-';
+      lines.push(`| ${escapeMd(a.id)} | ${escapeMd(a.name)} | ${escapeMd(a.role)} | ${escapeMd(a.provider)} | ${dir} | ${scope} | ${escapeMd(a.status)} |`);
     }
 
     lines.push('');