groove-dev 0.16.3 → 0.17.0

package/packages/daemon/src/integrations.js

@@ -0,0 +1,389 @@
+// GROOVE — Integration Store (MCP Server Management)
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { execFileSync } from 'child_process';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const INTEGRATIONS_API = 'https://docs.groovedev.ai/api/v1';
+
+export class IntegrationStore {
+  constructor(daemon) {
+    this.daemon = daemon;
+    this.integrationsDir = resolve(daemon.grooveDir, 'integrations');
+    mkdirSync(this.integrationsDir, { recursive: true });
+
+    // Load bundled registry as fallback
+    this.registry = [];
+    try {
+      const regPath = resolve(__dirname, '../integrations-registry.json');
+      this.registry = JSON.parse(readFileSync(regPath, 'utf8'));
+    } catch { /* no registry file */ }
+
+    // Ensure the integrations directory has a package.json for npm installs
+    this._ensurePackageJson();
+
+    // Fetch live registry in background
+    this._refreshRegistry();
+  }
+
+  _ensurePackageJson() {
+    const pkgPath = resolve(this.integrationsDir, 'package.json');
+    if (!existsSync(pkgPath)) {
+      writeFileSync(pkgPath, JSON.stringify({
+        name: 'groove-integrations',
+        version: '1.0.0',
+        private: true,
+        description: 'MCP server packages managed by Groove',
+      }, null, 2));
+    }
+  }
+
+  async _refreshRegistry() {
+    try {
+      const res = await fetch(`${INTEGRATIONS_API}/integrations?limit=200`, { signal: AbortSignal.timeout(5000) });
+      if (res.ok) {
+        const data = await res.json();
+        this.registry = data.integrations || data;
+      }
+    } catch { /* offline — use bundled */ }
+  }
+
+  /**
+   * Get integrations from the registry with optional search/category filter.
+   */
+  async getRegistry(query) {
+    let items = this.registry.map((s) => ({
+      ...s,
+      installed: this._isInstalled(s.id),
+      configured: this._isConfigured(s),
+    }));
+
+    if (query?.search) {
+      const q = query.search.toLowerCase();
+      items = items.filter((s) =>
+        s.name.toLowerCase().includes(q)
+        || s.description.toLowerCase().includes(q)
+        || (s.tags || []).some((t) => t.includes(q))
+      );
+    }
+
+    if (query?.category && query.category !== 'all') {
+      items = items.filter((s) => s.category === query.category);
+    }
+
+    return items;
+  }
+
+  /**
+   * Get installed integrations only.
+   */
+  getInstalled() {
+    const installed = [];
+    const metaPath = resolve(this.integrationsDir, 'installed.json');
+    let installedMeta = {};
+    if (existsSync(metaPath)) {
+      try { installedMeta = JSON.parse(readFileSync(metaPath, 'utf8')); } catch { /* ignore */ }
+    }
+
+    for (const [id, meta] of Object.entries(installedMeta)) {
+      const regEntry = this.registry.find((r) => r.id === id);
+      if (!regEntry && !meta) continue;
+      installed.push({
+        ...(regEntry || {}),
+        ...meta,
+        id,
+        installed: true,
+        configured: this._isConfigured(regEntry || meta),
+      });
+    }
+
+    return installed;
+  }
+
+  /**
+   * Get available categories from the registry.
+   */
+  getCategories() {
+    const cats = new Map();
+    for (const item of this.registry) {
+      const count = cats.get(item.category) || 0;
+      cats.set(item.category, count + 1);
+    }
+    return Array.from(cats.entries())
+      .map(([id, count]) => ({ id, count }))
+      .sort((a, b) => b.count - a.count);
+  }
+
+  /**
+   * Install an integration (npm install the MCP server package).
+   */
+  async install(integrationId) {
+    const entry = this.registry.find((s) => s.id === integrationId);
+    if (!entry) throw new Error(`Integration not found: ${integrationId}`);
+    if (this._isInstalled(integrationId)) throw new Error(`Integration already installed: ${integrationId}`);
+
+    if (entry.npmPackage) {
+      try {
+        execFileSync('npm', ['install', entry.npmPackage], {
+          cwd: this.integrationsDir,
+          stdio: 'pipe',
+          timeout: 120_000,
+        });
+      } catch (err) {
+        throw new Error(`Failed to install ${entry.npmPackage}: ${err.message}`);
+      }
+    }
+
+    // Record installation metadata
+    const metaPath = resolve(this.integrationsDir, 'installed.json');
+    let installedMeta = {};
+    if (existsSync(metaPath)) {
+      try { installedMeta = JSON.parse(readFileSync(metaPath, 'utf8')); } catch { /* ignore */ }
+    }
+    installedMeta[integrationId] = {
+      name: entry.name,
+      installedAt: new Date().toISOString(),
+      npmPackage: entry.npmPackage,
+    };
+    writeFileSync(metaPath, JSON.stringify(installedMeta, null, 2));
+
+    this.daemon.audit.log('integration.install', { id: integrationId, name: entry.name });
+
+    return { id: integrationId, name: entry.name, installed: true };
+  }
+
+  /**
+   * Uninstall an integration.
+   */
+  async uninstall(integrationId) {
+    if (!this._isInstalled(integrationId)) throw new Error(`Integration not installed: ${integrationId}`);
+
+    const entry = this.registry.find((s) => s.id === integrationId);
+    if (entry?.npmPackage) {
+      try {
+        execFileSync('npm', ['uninstall', entry.npmPackage], {
+          cwd: this.integrationsDir,
+          stdio: 'pipe',
+          timeout: 60_000,
+        });
+      } catch { /* best effort */ }
+    }
+
+    // Remove from installed metadata
+    const metaPath = resolve(this.integrationsDir, 'installed.json');
+    let installedMeta = {};
+    if (existsSync(metaPath)) {
+      try { installedMeta = JSON.parse(readFileSync(metaPath, 'utf8')); } catch { /* ignore */ }
+    }
+    delete installedMeta[integrationId];
+    writeFileSync(metaPath, JSON.stringify(installedMeta, null, 2));
+
+    // Remove credentials for this integration
+    this._removeCredentials(integrationId);
+
+    this.daemon.audit.log('integration.uninstall', { id: integrationId });
+
+    return { id: integrationId, installed: false };
+  }
+
+  /**
+   * Set a credential for an integration.
+   */
+  setCredential(integrationId, key, value) {
+    const credKey = `integration:${integrationId}:${key}`;
+    this.daemon.credentials.setKey(credKey, value);
+    this.daemon.audit.log('integration.credential.set', { id: integrationId, key });
+  }
+
+  /**
+   * Get a credential for an integration.
+   */
+  getCredential(integrationId, key) {
+    const credKey = `integration:${integrationId}:${key}`;
+    return this.daemon.credentials.getKey(credKey);
+  }
+
+  /**
+   * Delete a credential for an integration.
+   */
+  deleteCredential(integrationId, key) {
+    const credKey = `integration:${integrationId}:${key}`;
+    this.daemon.credentials.deleteKey(credKey);
+  }
+
+  /**
+   * Get the status of an integration (installed, configured, credential keys).
+   */
+  getStatus(integrationId) {
+    const entry = this.registry.find((s) => s.id === integrationId);
+    if (!entry) return null;
+
+    const installed = this._isInstalled(integrationId);
+    const envKeys = (entry.envKeys || []).map((ek) => ({
+      ...ek,
+      set: !!this.getCredential(integrationId, ek.key),
+    }));
+    const configured = envKeys.length === 0 || envKeys.every((ek) => !ek.required || ek.set);
+
+    return { id: integrationId, installed, configured, envKeys };
+  }
+
+  /**
+   * Build MCP config object for a set of integration IDs.
+   * Returns the mcpServers object to merge into .mcp.json.
+   */
+  buildMcpConfig(integrationIds) {
+    const mcpServers = {};
+
+    for (const id of integrationIds) {
+      const entry = this.registry.find((s) => s.id === id);
+      if (!entry) continue;
+      if (!this._isInstalled(id)) continue;
+
+      // Build environment with credentials
+      const env = {};
+      for (const ek of (entry.envKeys || [])) {
+        const val = this.getCredential(id, ek.key);
+        if (val) env[ek.key] = val;
+      }
+
+      mcpServers[`groove-${id}`] = {
+        command: entry.command || 'npx',
+        args: entry.args || ['-y', entry.npmPackage],
+        env,
+      };
+    }
+
+    return mcpServers;
+  }
+
+  /**
+   * Write/merge MCP config into the project root .mcp.json.
+   * Only adds/updates groove-* entries, preserves user's own MCP configs.
+   */
+  writeMcpJson(integrationIds) {
+    const mcpJsonPath = resolve(this.daemon.projectDir, '.mcp.json');
+    let existing = {};
+
+    // Read existing .mcp.json if present
+    if (existsSync(mcpJsonPath)) {
+      try {
+        existing = JSON.parse(readFileSync(mcpJsonPath, 'utf8'));
+      } catch { /* start fresh */ }
+    }
+
+    // Build MCP config for requested integrations
+    const grooveServers = this.buildMcpConfig(integrationIds);
+
+    // Remove all existing groove-* entries first
+    if (existing.mcpServers) {
+      for (const key of Object.keys(existing.mcpServers)) {
+        if (key.startsWith('groove-')) {
+          delete existing.mcpServers[key];
+        }
+      }
+    }
+
+    // Merge groove entries
+    existing.mcpServers = { ...(existing.mcpServers || {}), ...grooveServers };
+
+    writeFileSync(mcpJsonPath, JSON.stringify(existing, null, 2));
+  }
+
+  /**
+   * Remove all groove-* entries from .mcp.json.
+   * If only groove entries remain, delete the file.
+   */
+  cleanupMcpJson() {
+    const mcpJsonPath = resolve(this.daemon.projectDir, '.mcp.json');
+    if (!existsSync(mcpJsonPath)) return;
+
+    try {
+      const config = JSON.parse(readFileSync(mcpJsonPath, 'utf8'));
+      if (!config.mcpServers) return;
+
+      // Remove groove-* entries
+      let hasUserEntries = false;
+      for (const key of Object.keys(config.mcpServers)) {
+        if (key.startsWith('groove-')) {
+          delete config.mcpServers[key];
+        } else {
+          hasUserEntries = true;
+        }
+      }
+
+      if (hasUserEntries) {
+        writeFileSync(mcpJsonPath, JSON.stringify(config, null, 2));
+      } else if (Object.keys(config.mcpServers).length === 0) {
+        // If we created this file and it's now empty, remove it
+        // Only if no other top-level keys besides mcpServers
+        const otherKeys = Object.keys(config).filter((k) => k !== 'mcpServers');
+        if (otherKeys.length === 0) {
+          rmSync(mcpJsonPath);
+        } else {
+          writeFileSync(mcpJsonPath, JSON.stringify(config, null, 2));
+        }
+      }
+    } catch { /* ignore cleanup errors */ }
+  }
+
+  /**
+   * Get the combined set of integration IDs from all running agents.
+   */
+  getActiveIntegrations() {
+    const agents = this.daemon.registry.getAll().filter(
+      (a) => a.status === 'running' || a.status === 'starting'
+    );
+    const ids = new Set();
+    for (const agent of agents) {
+      for (const id of (agent.integrations || [])) {
+        ids.add(id);
+      }
+    }
+    return Array.from(ids);
+  }
+
+  /**
+   * Refresh .mcp.json to reflect all currently running agents' integrations.
+   */
+  refreshMcpJson() {
+    const activeIntegrations = this.getActiveIntegrations();
+    if (activeIntegrations.length > 0) {
+      this.writeMcpJson(activeIntegrations);
+    } else {
+      this.cleanupMcpJson();
+    }
+  }
+
+  // --- Internal ---
+
+  _isInstalled(integrationId) {
+    const metaPath = resolve(this.integrationsDir, 'installed.json');
+    if (!existsSync(metaPath)) return false;
+    try {
+      const meta = JSON.parse(readFileSync(metaPath, 'utf8'));
+      return !!meta[integrationId];
+    } catch {
+      return false;
+    }
+  }
+
+  _isConfigured(entry) {
+    if (!entry || !entry.envKeys || entry.envKeys.length === 0) return true;
+    return entry.envKeys
+      .filter((ek) => ek.required)
+      .every((ek) => !!this.getCredential(entry.id, ek.key));
+  }
+
+  _removeCredentials(integrationId) {
+    const entry = this.registry.find((s) => s.id === integrationId);
+    if (!entry?.envKeys) return;
+    for (const ek of entry.envKeys) {
+      try { this.deleteCredential(integrationId, ek.key); } catch { /* ignore */ }
+    }
+  }
+}

package/packages/daemon/src/introducer.js

@@ -188,6 +188,29 @@ export class Introducer {
       }
     }
 
+    // Integration context — list MCP tools available to this agent
+    if (newAgent.integrations && newAgent.integrations.length > 0 && this.daemon.integrations) {
+      const integrationSections = [];
+      for (const integrationId of newAgent.integrations) {
+        const entry = this.daemon.integrations.registry.find((s) => s.id === integrationId);
+        if (entry) {
+          const configured = this.daemon.integrations._isConfigured(entry);
+          const status = configured ? 'connected' : 'NOT CONFIGURED — credentials missing';
+          integrationSections.push(`- **${entry.name}** (${status}): ${entry.description}`);
+        }
+      }
+      if (integrationSections.length > 0) {
+        lines.push('');
+        lines.push(`## Integrations (${integrationSections.length} connected)`);
+        lines.push('');
+        lines.push('You have MCP tools available from these integrations. Use them to interact with external services:');
+        lines.push('');
+        lines.push(integrationSections.join('\n'));
+        lines.push('');
+        lines.push('Call these tools directly — they are available in your MCP tool list. Do not attempt to use curl or API calls for services that have an MCP integration attached.');
+      }
+    }
+
     return lines.join('\n');
   }
 

package/packages/daemon/src/process.js

@@ -9,6 +9,55 @@ import { getProvider } from './providers/index.js';
 // Role-specific prompt prefixes — applied during spawn regardless of entry point
 // (SpawnPanel, chat continue, CLI, API) for consistency
 const ROLE_PROMPTS = {
+  // Business roles — use MCP tools, not code
+  cmo: `You are a Chief Marketing Officer agent. You have MCP integrations for communication and research. Focus on:
+- Drafting and reviewing marketing content, social media posts, and campaigns
+- Analyzing market trends and competitive positioning
+- Managing team communications and status updates via Slack
+- Researching topics using web search tools
+Do NOT write code unless explicitly asked. Use your MCP tools to interact with external services.
+
+`,
+  cfo: `You are a Chief Financial Officer agent. You have MCP integrations for financial data and reporting. Focus on:
+- Reviewing revenue, subscriptions, and payment data via Stripe
+- Creating financial summaries and reports
+- Analyzing spending patterns and forecasting
+- Managing financial documents and spreadsheets
+Do NOT write code unless explicitly asked. Use your MCP tools to interact with external services.
+
+`,
+  ea: `You are an Executive Assistant agent. You have MCP integrations for email, calendar, and communication. Focus on:
+- Managing calendar events and scheduling meetings
+- Drafting and sending emails
+- Coordinating team communications via Slack
+- Organizing tasks, reminders, and follow-ups
+Do NOT write code unless explicitly asked. Use your MCP tools to interact with external services.
+
+`,
+  support: `You are a Customer Support agent. You have MCP integrations for communication channels. Focus on:
+- Responding to customer inquiries and tickets
+- Triaging and categorizing support requests
+- Drafting helpful responses and knowledge base articles
+- Escalating critical issues with clear summaries
+Do NOT write code unless explicitly asked. Use your MCP tools to interact with external services.
+
+`,
+  analyst: `You are a Data Analyst agent. You have MCP integrations for databases and data tools. Focus on:
+- Querying databases to extract insights and trends
+- Creating data summaries and reports
+- Identifying patterns, anomalies, and opportunities
+- Presenting findings in clear, actionable format
+Do NOT write code unless explicitly asked. Use your MCP tools (database queries, spreadsheets) to analyze data.
+
+`,
+  home: `You are a Smart Home automation agent. You have MCP integrations for Home Assistant. Focus on:
+- Monitoring and controlling smart home devices
+- Setting up automations and routines
+- Reporting on device status and energy usage
+- Troubleshooting connectivity and configuration issues
+Do NOT write code unless explicitly asked. Use your MCP tools to interact with Home Assistant.
+
+`,
   planner: `You are a planning and architecture agent. Research, analyze, and create plans — do NOT implement code unless explicitly asked. Focus on:
 - Understanding requirements
 - Exploring the codebase
@@ -152,6 +201,11 @@ For normal file edits within your scope, proceed without review.
       }
     }
 
+    // Write MCP config for agent integrations
+    if (config.integrations?.length > 0 && this.daemon.integrations) {
+      this.daemon.integrations.writeMcpJson(config.integrations);
+    }
+
     const { command, args, env } = provider.buildSpawnCommand(spawnConfig);
 
     // Set up log capture
@@ -258,6 +312,11 @@ For normal file edits within your scope, proceed without review.
         status: finalStatus,
       });
 
+      // Refresh MCP config — remove integrations no longer needed by running agents
+      if (this.daemon.integrations) {
+        this.daemon.integrations.refreshMcpJson();
+      }
+
       // Trigger journalist synthesis immediately on completion so the project
       // map is fresh for the next agent that spawns (don't wait for 120s cycle)
       if (finalStatus === 'completed' && this.daemon.journalist) {

package/packages/daemon/src/registry.js

@@ -23,6 +23,7 @@ export class Registry extends EventEmitter {
       permission: config.permission || 'full',
       workingDir: config.workingDir || process.cwd(),
       skills: config.skills || [],
+      integrations: config.integrations || [],
       status: 'starting',
       pid: null,
       spawnedAt: new Date().toISOString(),
@@ -49,7 +50,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', 'name', 'routingMode', 'routingReason', 'sessionId', 'skills'];
+    const SAFE_FIELDS = ['status', 'pid', 'tokensUsed', 'contextUsage', 'lastActivity', 'model', 'name', 'routingMode', 'routingReason', 'sessionId', 'skills', 'integrations'];
     for (const key of Object.keys(updates)) {
       if (SAFE_FIELDS.includes(key)) {
         agent[key] = updates[key];