groove-dev 0.27.8 → 0.27.12

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

@@ -36,8 +36,10 @@ import { MemoryStore } from './memory.js';
 import { TerminalManager } from './terminal-pty.js';
 import { GatewayManager } from './gateways/manager.js';
 import { McpManager } from './mcp-manager.js';
+import { TunnelManager } from './tunnel-manager.js';
 import { ModelManager } from './model-manager.js';
 import { LlamaServerManager } from './llama-server.js';
+import { RepoImporter } from './repo-import.js';
 import { isFirstRun, runFirstTimeSetup, loadConfig, saveConfig, printWelcome } from './firstrun.js';
 
 const DEFAULT_PORT = 31415;
@@ -137,6 +139,8 @@ export class Daemon {
     this.modelManager = new ModelManager(this);
     this.llamaServer = new LlamaServerManager(this);
     this.mcpManager = new McpManager(this);
+    this.tunnelManager = new TunnelManager(this);
+    this.repoImporter = new RepoImporter(this);
 
     // HTTP + WebSocket server
     this.app = express();
@@ -450,6 +454,9 @@ export class Daemon {
     this.fileWatcher.unwatchAll();
     this.terminalManager.killAll();
 
+    // Disconnect all SSH tunnels
+    this.tunnelManager.shutdown();
+
     // Kill all agent processes, stop MCP servers, and stop inference servers
     await this.processes.killAll();
     this.mcpManager.stopAll();

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

@@ -37,6 +37,17 @@ export class Introducer {
       lines.push(`You have no file scope restrictions.`);
     }
 
+    // Sandbox boundary for imported repos
+    if (newAgent.workingDir) {
+      const sandboxPath = resolve(newAgent.workingDir, '.groove', 'sandbox.json');
+      if (existsSync(sandboxPath)) {
+        lines.push('');
+        lines.push(`## HARD BOUNDARY`);
+        lines.push('');
+        lines.push(`You MUST NOT read, write, or modify ANY file outside \`${newAgent.workingDir}/\`. This is a sandboxed imported repo. If setup instructions require changes outside this directory, ask the user first.`);
+      }
+    }
+
     lines.push('');
 
     if (others.length === 0) {
@@ -249,7 +260,13 @@ export class Introducer {
         lines.push('');
         lines.push(`## Integrations (${integrationSections.length} connected)`);
         lines.push('');
-        lines.push('You have integrations connected via GROOVE. To use them, make HTTP POST requests:');
+        lines.push('These integrations are ALREADY INSTALLED, AUTHENTICATED, AND READY TO USE. You do NOT need to:');
+        lines.push('- Ask the user for any API keys, OAuth tokens, or credentials for these services');
+        lines.push('- Set up authentication or run any auth flows');
+        lines.push('- Direct the user to any external auth pages');
+        lines.push('The user has already configured everything. Just use the tools.');
+        lines.push('');
+        lines.push('To use them, make HTTP POST requests:');
         lines.push('```');
         lines.push('POST http://localhost:31415/api/integrations/{id}/exec');
         lines.push('Body: {"tool": "tool_name", "params": {...}}');
@@ -257,14 +274,65 @@ export class Introducer {
         lines.push('To discover available tools: `GET http://localhost:31415/api/integrations/{id}/tools`');
         lines.push('');
         lines.push('**Approval gates:** Some tools require human approval (e.g., sending emails, creating charges).');
-        lines.push('If you get a `requiresApproval: true` response with an `approvalId`, tell the user the action');
-        lines.push('needs approval in the GROOVE GUI. Do NOT retry until the user confirms it has been approved.');
-        lines.push('To retry: include `"approvalId": "<id>"` in your next exec request body.');
+        lines.push('If you get a `requiresApproval: true` response, the action has been queued for user approval.');
+        lines.push('GROOVE will show the user an approval modal and auto-execute the action once approved.');
+        lines.push('Do NOT tell the user to approve anything. Do NOT retry the request yourself. Just wait — you will receive a message confirming the result once the action is approved and executed.');
         lines.push('');
         lines.push(integrationSections.join('\n\n'));
       }
     }
 
+    // GitHub repo import — teach agents to use the tracked import API
+    // Attached repos — only inject repos explicitly attached to this agent
+    if (newAgent.repos && newAgent.repos.length > 0 && this.daemon.repoImporter) {
+      const repoSections = [];
+      for (const importId of newAgent.repos) {
+        const manifest = this.daemon.repoImporter.getImport(importId);
+        if (manifest && manifest.status === 'active') {
+          const stack = manifest.stackInfo ? ` (${manifest.stackInfo.runtime || 'unknown'})` : '';
+          repoSections.push(`- **${manifest.name || manifest.repo}**${stack}: \`${manifest.clonedTo}\` — import ID: ${manifest.id}`);
+        }
+      }
+      if (repoSections.length > 0) {
+        lines.push('');
+        lines.push(`## Attached Repositories (${repoSections.length})`);
+        lines.push('');
+        lines.push('These repos are cloned and attached to you. Use the paths below — do NOT re-clone them:');
+        lines.push(...repoSections);
+        lines.push('');
+        lines.push('If you spawn processes or modify config files for these repos, register them:');
+        lines.push('- `POST http://localhost:31415/api/repos/{importId}/process` with `{ "pid": <number>, "command": "description" }`');
+      }
+    }
+
+    // Lightweight import API reference for cloning new repos
+    lines.push('');
+    lines.push('## GitHub Repo Import');
+    lines.push('');
+    lines.push('To clone a NEW GitHub repo, use: `POST http://localhost:31415/api/repos/import` with `{ "repoUrl": "...", "targetPath": "~/Projects/name", "createTeam": true }`. Do NOT run `git clone` directly.');
+
+    // Surface stored API keys so agents know what's available in their environment
+    const KEY_MAP = { codex: 'OPENAI_API_KEY', gemini: 'GEMINI_API_KEY', ollama: 'OLLAMA_API_KEY' };
+    try {
+      const credProviders = this.daemon.credentials?.listProviders() || [];
+      if (credProviders.length > 0) {
+        lines.push('');
+        lines.push('## Available API Keys');
+        lines.push('');
+        lines.push('GROOVE has API keys stored and injected into your environment. Do NOT ask the user for these:');
+        for (const cp of credProviders) {
+          const envVar = KEY_MAP[cp.provider];
+          if (envVar) {
+            lines.push(`- **${cp.provider}**: available as \`${envVar}\` in your environment`);
+          } else {
+            lines.push(`- **${cp.provider}**: stored in GROOVE credentials`);
+          }
+        }
+        lines.push('');
+        lines.push('If a third-party tool needs one of these keys, it is already in your environment — do not ask the user to provide it.');
+      }
+    } catch { /* credentials not available */ }
+
     return lines.join('\n');
   }
 

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

@@ -138,7 +138,7 @@ export class Journalist {
     for (const agent of agents) {
       const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.name}.log`);
       if (!existsSync(logPath)) {
-        result[agent.id] = { agent, entries: [] };
+        result[agent.id] = { agent, entries: [], explorationEntries: [] };
         continue;
       }
 
@@ -147,10 +147,10 @@ export class Journalist {
         const size = Buffer.byteLength(content);
         this.lastLogSizes[agent.id] = size;
 
-        const entries = this.filterLog(content, agent);
-        result[agent.id] = { agent, entries };
+        const { entries, explorationEntries } = this.filterLog(content, agent);
+        result[agent.id] = { agent, entries, explorationEntries };
       } catch {
-        result[agent.id] = { agent, entries: [] };
+        result[agent.id] = { agent, entries: [], explorationEntries: [] };
       }
     }
 
@@ -160,7 +160,9 @@ export class Journalist {
   filterLog(rawLog, agent) {
     // Parse stream-json lines and extract meaningful events.
     // Focus on PROGRESS (writes, edits, commands with results) not EXPLORATION (reads, greps).
+    // Exploration tools are tracked separately so handoff briefs can include what was examined.
     const entries = [];
+    const explorationEntries = [];
     const lines = rawLog.split('\n');
     const toolResults = new Map(); // tool_use_id -> result text
 
@@ -198,8 +200,17 @@ export class Journalist {
               if (block.type === 'tool_use') {
                 const tool = block.name;
 
-                // Skip exploration tools — reads/searches are noise for synthesis
-                if (tool === 'Read' || tool === 'Glob' || tool === 'Grep') continue;
+                // Track exploration tools separately — they're noise for synthesis
+                // but valuable for handoff briefs (what files/patterns were examined)
+                if (tool === 'Read' || tool === 'Glob' || tool === 'Grep') {
+                  explorationEntries.push({
+                    type: 'exploration',
+                    tool,
+                    input: this.summarizeToolInput(tool, block.input),
+                    timestamp: data.timestamp,
+                  });
+                  continue;
+                }
 
                 const entry = {
                   type: 'tool',
@@ -223,10 +234,11 @@ export class Journalist {
 
                 entries.push(entry);
               } else if (block.type === 'text' && block.text) {
-                // Only keep substantial reasoning (decisions, conclusions)
-                // Short fragments like "Let me check..." are noise
+                // Keep reasoning that contains decisions or conclusions.
+                // Under 50 chars is noise ("Let me check...", "OK"), but 50-200
+                // often contains key decisions like "Using X instead of Y".
                 const text = block.text.trim();
-                if (text.length > 200) {
+                if (text.length > 50) {
                   entries.push({ type: 'thinking', text: text.slice(0, 2000), timestamp: data.timestamp });
                 }
               }
@@ -250,7 +262,7 @@ export class Journalist {
       }
     }
 
-    return entries;
+    return { entries, explorationEntries };
   }
 
   summarizeToolInput(toolName, input) {
@@ -260,6 +272,12 @@ export class Journalist {
         return input.file_path || input.path || '';
       case 'Edit':
         return input.file_path || input.path || '';
+      case 'Read':
+        return input.file_path || input.path || '';
+      case 'Grep':
+        return `${input.pattern || ''}${input.path ? ' in ' + input.path : ''}`;
+      case 'Glob':
+        return input.pattern || '';
       case 'Bash':
         return (input.command || '').slice(0, 150);
       default:
@@ -653,10 +671,11 @@ export class Journalist {
 
   // --- Handoff Brief for Context Rotation ---
 
-  async generateHandoffBrief(agent) {
+  async generateHandoffBrief(agent, options = {}) {
     const filteredLogs = this.collectFilteredLogs([agent]);
     const agentLog = filteredLogs[agent.id];
     const entries = agentLog?.entries || [];
+    const explorationEntries = agentLog?.explorationEntries || [];
 
     // Get current project map — scoped to agent's workspace if applicable
     const mapPath = resolve(this.daemon.projectDir, 'GROOVE_PROJECT_MAP.md');
@@ -684,6 +703,33 @@ export class Journalist {
       .slice(-3)
       .join('\n');
 
+    // Build exploration summary — what files/patterns were examined
+    const explorationSummary = explorationEntries
+      .map((e) => `- ${e.tool}: ${e.input}`)
+      .slice(-20)
+      .join('\n');
+
+    // Build file changes section — group Edit/Write operations by file path
+    const fileChanges = {};
+    for (const e of entries.filter((e) => e.type === 'tool' && (e.tool === 'Edit' || e.tool === 'Write'))) {
+      const file = e.input || 'unknown';
+      if (!fileChanges[file]) fileChanges[file] = [];
+      if (e.diff) fileChanges[file].push(e.diff);
+      else fileChanges[file].push(e.tool === 'Write' ? 'created' : 'modified');
+    }
+    const fileChangesSummary = Object.entries(fileChanges)
+      .map(([file, changes]) => `- **${file}**: ${changes.slice(0, 3).join('; ')}`)
+      .slice(0, 20)
+      .join('\n');
+
+    // Layer 7 memory: discoveries, constraints, specializations
+    const discoveries = this.daemon.memory?.getDiscoveriesMarkdown(agent.role, 10, 2000) || '';
+    const constraints = this.daemon.memory?.getConstraintsMarkdown(2000) || '';
+    const specialization = this.daemon.memory?.getSpecialization(agent.id);
+    const specLine = specialization?.avgQualityScore != null
+      ? `- Quality profile: ${specialization.avgQualityScore}/100 across ${specialization.sessionCount} sessions`
+      : '';
+
     // Pull recent rotation history from persistent memory (Layer 7).
     // Gives the new agent causal continuity: what the last 3 agents struggled
     // with, decided, and solved — not just what the current session did.
@@ -700,11 +746,15 @@ export class Journalist {
       ? agentFeedback.map((fb) => `- "${fb.message}"`).join('\n')
       : '';
 
+    // Rotation reason for the new agent
+    const rotationTrigger = `- Rotation trigger: ${options.reason || 'manual'}${options.qualityScore ? ` (quality: ${options.qualityScore}/100)` : ''}`;
+
     return [
       `# Session Continuation`,
       ``,
       `You are **${agent.name}** (role: ${agent.role}). This is an internal context refresh — `,
       `the conversation with the user is ongoing and must feel seamless to them. They cannot see this brief.`,
+      rotationTrigger,
       ``,
       `## CRITICAL: Finish What You Were Doing`,
       ``,
@@ -729,6 +779,7 @@ export class Journalist {
       `- Scope: ${agent.scope?.join(', ') || 'unrestricted'}`,
       `- Provider: ${agent.provider}`,
       agent.workingDir ? `- Working directory: ${agent.workingDir}` : '',
+      specLine,
       ``,
       `## Session State`,
       `- Tokens used before refresh: ${agent.tokensUsed}`,
@@ -737,6 +788,10 @@ export class Journalist {
       toolSummary ? `### Recent tool calls (what you were doing)\n${toolSummary}\n` : '',
       resultSummary ? `### Last results\n${resultSummary}\n` : '',
       errorSummary ? `### Unresolved errors\n${errorSummary}\n` : '',
+      fileChangesSummary ? `## Files Modified\n\n${fileChangesSummary}\n` : '',
+      explorationSummary ? `## Exploration Context\n\n${explorationSummary}\n` : '',
+      discoveries ? `## Known Issues & Fixes\n\n${discoveries}\n` : '',
+      constraints ? `## Project Constraints\n\n${constraints}\n` : '',
       `## Current Project State`,
       ``,
       projectMap ? projectMap.slice(0, 10000) : 'No project map available yet.',

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

@@ -2,7 +2,7 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
 import { spawn as cpSpawn } from 'child_process';
-import { createWriteStream, mkdirSync, chmodSync, existsSync, readFileSync, unlinkSync, readdirSync, copyFileSync } from 'fs';
+import { createWriteStream, mkdirSync, chmodSync, existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, copyFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { getProvider, getInstalledProviders } from './providers/index.js';
@@ -66,6 +66,19 @@ Do NOT write code unless explicitly asked. Use your MCP tools (database queries,
 - Researching topics to produce accurate, substantive writing
 You CAN use code tools to create and edit text files, markdown documents, and structured content. For best results, apply a writing skill from the Marketplace that matches your task.
 
+`,
+  chat: `You are a Chat agent — a conversational companion, friend, and assistant. You are warm, curious, and genuinely engaged. You can discuss anything: ideas, philosophy, science, culture, coding, life.
+
+Your primary mode is conversation, but you can still perform ANY task the user asks — code, research, analysis, writing. When no task is given, lean into being a great conversational partner.
+
+Key behaviors:
+- Be genuinely interested in the user's thoughts
+- Ask thoughtful follow-up questions
+- Share perspectives and explore ideas together
+- Match the user's energy — playful, serious, philosophical, technical
+- Remember context within the conversation
+- Be honest and direct, not sycophantic
+
 `,
   frontend: `You are a Frontend agent. You build and modify UI components, views, and state management. Focus on:
 - Writing clean React/JSX with Tailwind CSS classes — zero inline styles unless dynamic
@@ -351,6 +364,23 @@ export class ProcessManager {
       }
     }
 
+    // Create empty personality file for this agent
+    const personalityDir = resolve(this.daemon.grooveDir, 'personalities');
+    mkdirSync(personalityDir, { recursive: true });
+    const personalityFile = resolve(personalityDir, `${agent.name}.md`);
+    if (!existsSync(personalityFile)) {
+      if (config.personality) {
+        const templateFile = resolve(personalityDir, `${config.personality}.md`);
+        if (existsSync(templateFile)) {
+          copyFileSync(templateFile, personalityFile);
+        } else {
+          writeFileSync(personalityFile, '', { mode: 0o600 });
+        }
+      } else {
+        writeFileSync(personalityFile, '', { mode: 0o600 });
+      }
+    }
+
     // Pre-spawn task negotiation — if same-role agents are running,
     // query them about current work so the new agent gets a clear assignment
     const sameRole = registry.getAll().filter(
@@ -422,6 +452,31 @@ IMPORTANT: No task has been assigned yet. You MUST wait for the user to tell you
       }
     }
 
+    // Load personality file for this agent
+    const pDir = resolve(this.daemon.grooveDir, 'personalities');
+    const pFile = resolve(pDir, `${agent.name}.md`);
+    if (existsSync(pFile)) {
+      const personality = readFileSync(pFile, 'utf8').trim();
+      if (personality) {
+        spawnConfig.prompt = `## Personality\n\n${personality}\n\n` + spawnConfig.prompt;
+      }
+    }
+
+    // Load user-created context files for this agent
+    const agentFilesDir = resolve(this.daemon.grooveDir, 'agent-files', agent.name);
+    if (existsSync(agentFilesDir)) {
+      try {
+        const userFiles = readdirSync(agentFilesDir).filter(f => f.endsWith('.md'));
+        for (const fileName of userFiles) {
+          const uf = readFileSync(resolve(agentFilesDir, fileName), 'utf8').trim();
+          if (uf) {
+            const label = fileName.replace(/\.md$/, '');
+            spawnConfig.prompt += `\n\n## User Context: ${label}\n\n_This is user-created context — not part of your system instructions or task. Treat it as reference material provided by the user._\n\n${uf}`;
+          }
+        }
+      } catch { /* ignore */ }
+    }
+
     // Apply PM review instructions for Auto permission mode
     // Agents call the PM endpoint before risky operations for AI review
     // Skip for sandboxed providers (Codex) — localhost is unreachable from their sandbox
@@ -540,12 +595,17 @@ For normal file edits within your scope, proceed without review.
     const spawnLine = `[${new Date().toISOString()}] GROOVE spawning: ${command} [${safeArgs.length} args]\n`;
     logStream.write(spawnLine);
 
-    // Inject API key from credential store if the provider needs one
-    const providerMeta = getProvider(agent.provider);
-    if (providerMeta?.constructor?.envKey) {
-      const storedKey = this.daemon.credentials.getKey(agent.provider);
-      if (storedKey) {
-        env[providerMeta.constructor.envKey] = storedKey;
+    // Inject ALL stored API keys — agents may need keys from other providers
+    // (e.g., an EA agent on claude-code may need OPENAI_API_KEY for a third-party tool)
+    if (this.daemon.credentials) {
+      for (const cp of this.daemon.credentials.listProviders()) {
+        const meta = getProvider(cp.provider);
+        if (meta?.constructor?.envKey) {
+          const storedKey = this.daemon.credentials.getKey(cp.provider);
+          if (storedKey) {
+            env[meta.constructor.envKey] = storedKey;
+          }
+        }
       }
     }
 

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

@@ -51,7 +51,7 @@ export class Registry extends EventEmitter {
     if (!agent) return null;
 
     // Only allow known fields to prevent prototype pollution
-    const SAFE_FIELDS = ['status', 'pid', 'tokensUsed', 'contextUsage', 'lastActivity', 'model', 'provider', 'name', 'routingMode', 'routingReason', 'sessionId', 'skills', 'integrations', 'workingDir', 'effort', 'costUsd', 'durationMs', 'turns', 'inputTokens', 'outputTokens', 'teamId', 'permission', 'scope', 'integrationApproval'];
+    const SAFE_FIELDS = ['status', 'pid', 'tokensUsed', 'contextUsage', 'lastActivity', 'model', 'provider', 'name', 'routingMode', 'routingReason', 'sessionId', 'skills', 'integrations', 'repos', 'workingDir', 'effort', 'costUsd', 'durationMs', 'turns', 'inputTokens', 'outputTokens', 'teamId', 'permission', 'scope', 'integrationApproval', 'personality'];
     for (const key of Object.keys(updates)) {
       if (SAFE_FIELDS.includes(key)) {
         agent[key] = updates[key];