groove-dev 0.20.0 → 0.21.0

package/node_modules/@groove-dev/daemon/package.json

@@ -15,5 +15,9 @@
     "express": "^4.21.0",
     "minimatch": "^10.0.0"
   },
+  "optionalDependencies": {
+    "discord.js": "^14.0.0",
+    "@slack/bolt": "^4.0.0"
+  },
   "private": true
 }

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

@@ -838,6 +838,92 @@ Keep responses concise. Help them think, don't lecture them about the system the
     res.json({ id: agent.id, integrations });
   });
 
+  // --- Gateways (Telegram, Discord, Slack) ---
+
+  app.get('/api/gateways', (req, res) => {
+    res.json(daemon.gateways.list());
+  });
+
+  app.post('/api/gateways', async (req, res) => {
+    try {
+      const result = await daemon.gateways.create(req.body || {});
+      res.json(result);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/gateways/:id', (req, res) => {
+    const gw = daemon.gateways.get(req.params.id);
+    if (!gw) return res.status(404).json({ error: 'Gateway not found' });
+    res.json(gw);
+  });
+
+  app.patch('/api/gateways/:id', async (req, res) => {
+    try {
+      const result = await daemon.gateways.update(req.params.id, req.body || {});
+      res.json(result);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/gateways/:id', async (req, res) => {
+    try {
+      await daemon.gateways.delete(req.params.id);
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/gateways/:id/test', async (req, res) => {
+    try {
+      const result = await daemon.gateways.test(req.params.id);
+      res.json(result);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/gateways/:id/connect', async (req, res) => {
+    try {
+      const result = await daemon.gateways.connect(req.params.id);
+      res.json(result);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/gateways/:id/disconnect', async (req, res) => {
+    try {
+      const result = await daemon.gateways.disconnect(req.params.id);
+      res.json(result);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/gateways/:id/credentials', (req, res) => {
+    try {
+      const { key, value } = req.body || {};
+      if (!key || !value) return res.status(400).json({ error: 'key and value are required' });
+      daemon.gateways.setCredential(req.params.id, key, value);
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/gateways/:id/credentials/:key', (req, res) => {
+    try {
+      daemon.gateways.deleteCredential(req.params.id, req.params.key);
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
   // --- Schedules ---
 
   app.get('/api/schedules', (req, res) => {

package/node_modules/@groove-dev/daemon/src/gateways/base.js

@@ -0,0 +1,87 @@
+// GROOVE — Base Gateway Interface
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+export class BaseGateway {
+  static type = 'base';
+  static displayName = 'Base Gateway';
+  static description = '';
+  static credentialKeys = []; // [{ key, label, required, help }]
+
+  constructor(daemon, config) {
+    this.daemon = daemon;
+    this.config = config; // { id, type, enabled, chatId, allowedUsers, notifications }
+    this.connected = false;
+  }
+
+  /**
+   * Connect to the messaging platform. Called by GatewayManager.start().
+   */
+  async connect() {
+    throw new Error('Gateway must implement connect()');
+  }
+
+  /**
+   * Gracefully disconnect. Called by GatewayManager.stop().
+   */
+  async disconnect() {
+    throw new Error('Gateway must implement disconnect()');
+  }
+
+  /**
+   * Send a message to the configured chat/channel.
+   * @param {string} text — formatted message text
+   * @param {object} [options] — platform-specific options (replyMarkup, embeds, blocks, etc.)
+   */
+  async send(text, options) {
+    throw new Error('Gateway must implement send()');
+  }
+
+  /**
+   * Process an inbound command from chat. Checks authorization, then delegates
+   * to GatewayManager.routeCommand() for actual execution.
+   * @param {string} command — command name (without leading /)
+   * @param {string[]} args — command arguments
+   * @param {string} userId — platform-specific user ID
+   * @returns {{ text: string, options?: object } | null}
+   */
+  async handleCommand(command, args, userId) {
+    if (!this._isAuthorized(userId)) {
+      return { text: 'Unauthorized. Your user ID is not in the gateway allowlist.' };
+    }
+    return this.daemon.gateways.routeCommand(this, command, args, userId);
+  }
+
+  /**
+   * Check if a user is authorized to send commands.
+   * Empty allowlist = open access (for personal bots).
+   */
+  _isAuthorized(userId) {
+    const allow = this.config.allowedUsers || [];
+    if (allow.length === 0) return true;
+    return allow.includes(String(userId));
+  }
+
+  /**
+   * Get the credential value for this gateway from CredentialStore.
+   */
+  _getCredential(key) {
+    return this.daemon.credentials.getKey(`gateway:${this.config.id}:${key}`);
+  }
+
+  /**
+   * Return current gateway status for API responses.
+   */
+  getStatus() {
+    return {
+      id: this.config.id,
+      type: this.constructor.type,
+      displayName: this.constructor.displayName,
+      connected: this.connected,
+      enabled: this.config.enabled,
+      chatId: this.config.chatId || null,
+      notifications: this.config.notifications || { preset: 'critical' },
+      commandPermission: this.config.commandPermission || 'full',
+      allowedUsers: (this.config.allowedUsers || []).length,
+    };
+  }
+}

package/node_modules/@groove-dev/daemon/src/gateways/discord.js

@@ -0,0 +1,220 @@
+// GROOVE — Discord Gateway (discord.js)
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { BaseGateway } from './base.js';
+import { truncate, statusEmoji, formatTokens, formatDuration } from './formatter.js';
+
+// Embed colors (decimal)
+const COLORS = {
+  success: 0x2ecc71,
+  danger: 0xe74c3c,
+  warning: 0xf39c12,
+  info: 0x3498db,
+  accent: 0x5865f2, // Discord blurple
+};
+
+export class DiscordGateway extends BaseGateway {
+  static type = 'discord';
+  static displayName = 'Discord';
+  static description = 'Discord bot for notifications and agent commands';
+  static credentialKeys = [
+    { key: 'bot_token', label: 'Bot Token', required: true, help: 'Discord Developer Portal \u2192 Bot \u2192 Token' },
+  ];
+
+  constructor(daemon, config) {
+    super(daemon, config);
+    this.client = null;
+    this.channel = null;
+    this._djs = null; // cached discord.js module
+  }
+
+  async connect() {
+    const token = this._getCredential('bot_token');
+    if (!token) throw new Error('Discord bot token not configured');
+
+    try {
+      this._djs = await import('discord.js');
+    } catch {
+      throw new Error('Discord gateway requires discord.js. Install with: npm i discord.js');
+    }
+
+    const { Client, GatewayIntentBits } = this._djs;
+
+    this.client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+      ],
+    });
+
+    // Handle incoming messages (commands)
+    this.client.on('messageCreate', async (msg) => {
+      if (msg.author.bot) return;
+      if (!msg.content.startsWith('/')) return;
+
+      const userId = msg.author.id;
+      const [command, ...args] = msg.content.slice(1).split(/\s+/);
+
+      // Auto-capture channelId
+      if (!this.config.chatId) {
+        this.config.chatId = msg.channel.id;
+        this.daemon.gateways._save(this.config.id);
+      }
+
+      const response = await this.handleCommand(command, args, userId);
+      if (response) {
+        await msg.channel.send(this._buildReply(response));
+      }
+    });
+
+    // Handle button interactions (approve/reject)
+    this.client.on('interactionCreate', async (interaction) => {
+      if (!interaction.isButton()) return;
+
+      const userId = interaction.user.id;
+      if (!this._isAuthorized(userId)) {
+        await interaction.reply({ content: 'Unauthorized.', ephemeral: true });
+        return;
+      }
+
+      const [action, ...rest] = interaction.customId.split(':');
+      const approvalId = rest.join(':');
+      if (!approvalId) {
+        await interaction.reply({ content: 'Invalid action.', ephemeral: true });
+        return;
+      }
+
+      try {
+        let responseText;
+        if (action === 'approve') {
+          this.daemon.supervisor.approve(approvalId);
+          responseText = `\u2705 Approved: ${approvalId}`;
+        } else if (action === 'reject') {
+          this.daemon.supervisor.reject(approvalId);
+          responseText = `\u274c Rejected: ${approvalId}`;
+        } else {
+          await interaction.reply({ content: 'Unknown action.', ephemeral: true });
+          return;
+        }
+
+        // Update the original message — remove buttons, add resolution
+        await interaction.update({
+          components: [],
+          embeds: [
+            ...(interaction.message.embeds || []),
+            this._embed({ description: responseText, color: action === 'approve' ? COLORS.success : COLORS.danger }),
+          ],
+        });
+      } catch (err) {
+        await interaction.reply({ content: `Error: ${err.message}`, ephemeral: true }).catch(() => {});
+      }
+    });
+
+    await this.client.login(token);
+
+    // Resolve target channel
+    if (this.config.chatId) {
+      try {
+        this.channel = await this.client.channels.fetch(this.config.chatId);
+      } catch { /* channel will be set on first message */ }
+    }
+
+    this.connected = true;
+    console.log(`[Groove:Discord] Connected as ${this.client.user.tag}`);
+  }
+
+  async disconnect() {
+    if (this.client) {
+      this.client.destroy();
+      this.client = null;
+    }
+    this.channel = null;
+    this.connected = false;
+    this._djs = null;
+    console.log('[Groove:Discord] Disconnected');
+  }
+
+  async send(text, options = {}) {
+    const ch = await this._resolveChannel();
+    if (!ch) return;
+
+    const payload = {};
+
+    // Build embed for rich notifications
+    if (options.approvalId) {
+      // Approval request — embed with action buttons
+      payload.embeds = [this._embed({
+        title: '\ud83d\udea8 Approval Required',
+        description: text,
+        color: COLORS.warning,
+      })];
+      payload.components = [this._approvalButtons(options.approvalId)];
+    } else if (options.embed) {
+      payload.embeds = [options.embed];
+    } else {
+      // Plain text — truncate to Discord's 2000 char limit
+      payload.content = truncate(text, 2000);
+    }
+
+    await ch.send(payload);
+  }
+
+  getStatus() {
+    return {
+      ...super.getStatus(),
+      botTag: this.client?.user?.tag || null,
+    };
+  }
+
+  // -------------------------------------------------------------------
+  // Discord-Specific Helpers
+  // -------------------------------------------------------------------
+
+  async _resolveChannel() {
+    if (!this.channel && this.config.chatId && this.client) {
+      try {
+        this.channel = await this.client.channels.fetch(this.config.chatId);
+      } catch { return null; }
+    }
+    return this.channel;
+  }
+
+  /**
+   * Build a discord.js EmbedBuilder-compatible plain object.
+   */
+  _embed({ title, description, color, fields, footer }) {
+    const embed = { color: color || COLORS.accent };
+    if (title) embed.title = title;
+    if (description) embed.description = truncate(description, 4096);
+    if (fields) embed.fields = fields;
+    if (footer) embed.footer = { text: footer };
+    embed.timestamp = new Date().toISOString();
+    return embed;
+  }
+
+  /**
+   * Build an ActionRow with Approve/Reject buttons.
+   */
+  _approvalButtons(approvalId) {
+    if (!this._djs) return {};
+    const { ActionRowBuilder, ButtonBuilder, ButtonStyle } = this._djs;
+    return new ActionRowBuilder().addComponents(
+      new ButtonBuilder().setCustomId(`approve:${approvalId}`).setLabel('Approve').setStyle(ButtonStyle.Success).setEmoji('\u2705'),
+      new ButtonBuilder().setCustomId(`reject:${approvalId}`).setLabel('Reject').setStyle(ButtonStyle.Danger).setEmoji('\u274c'),
+    );
+  }
+
+  /**
+   * Build a reply payload from a command response.
+   */
+  _buildReply(response) {
+    if (!response) return {};
+    // Wrap command responses in a code block for readability
+    const text = response.text || '';
+    if (text.length > 1900) {
+      return { content: '```\n' + truncate(text, 1900) + '\n```' };
+    }
+    return { content: '```\n' + text + '\n```' };
+  }
+}

package/node_modules/@groove-dev/daemon/src/gateways/formatter.js

@@ -0,0 +1,201 @@
+// GROOVE — Gateway Message Formatter
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+/**
+ * Truncate text to a maximum length, adding ellipsis if needed.
+ */
+export function truncate(text, max = 2000) {
+  if (!text || text.length <= max) return text || '';
+  return text.slice(0, max - 3) + '...';
+}
+
+/**
+ * Format a duration in ms to human-readable string.
+ */
+export function formatDuration(ms) {
+  if (!ms || ms < 0) return '0s';
+  if (ms < 60_000) return `${Math.round(ms / 1000)}s`;
+  if (ms < 3_600_000) return `${Math.round(ms / 60_000)}m`;
+  const h = Math.floor(ms / 3_600_000);
+  const m = Math.round((ms % 3_600_000) / 60_000);
+  return m > 0 ? `${h}h ${m}m` : `${h}h`;
+}
+
+/**
+ * Format token count with K/M suffix.
+ */
+export function formatTokens(n) {
+  if (!n || n < 0) return '0';
+  if (n < 1000) return String(n);
+  if (n < 1_000_000) return `${(n / 1000).toFixed(1)}K`;
+  return `${(n / 1_000_000).toFixed(2)}M`;
+}
+
+/**
+ * Format USD cost.
+ */
+export function formatCost(usd) {
+  if (!usd || usd < 0) return '$0.00';
+  if (usd < 0.01) return `$${usd.toFixed(4)}`;
+  return `$${usd.toFixed(2)}`;
+}
+
+const STATUS_EMOJI = {
+  running: '\u{1f7e2}',    // green circle
+  completed: '\u2705',      // check mark
+  crashed: '\u{1f534}',     // red circle
+  killed: '\u26d4',          // no entry
+  starting: '\u{1f7e1}',    // yellow circle
+  stopped: '\u26ab',         // black circle
+};
+
+/**
+ * Get emoji for agent status.
+ */
+export function statusEmoji(status) {
+  return STATUS_EMOJI[status] || '\u2753'; // question mark fallback
+}
+
+/**
+ * Convert a daemon broadcast event into a human-readable one-liner summary.
+ * Returns null if the event shouldn't generate a notification.
+ */
+export function eventToSummary(event) {
+  switch (event.type) {
+    case 'agent:exit': {
+      const status = event.status || 'unknown';
+      const emoji = statusEmoji(status);
+      const id = event.agentId ? ` (${event.agentId})` : '';
+      return `${emoji} Agent${id} ${status}`;
+    }
+
+    case 'approval:request': {
+      const d = event.data || {};
+      const name = d.agentName || d.agentId || 'unknown';
+      const desc = d.action?.description || 'action pending';
+      return `\u{1f6a8} Approval needed — ${name}: ${truncate(desc, 200)}`;
+    }
+
+    case 'approval:resolved': {
+      const d = event.data || {};
+      const status = d.status || 'resolved';
+      const name = d.agentName || d.agentId || 'unknown';
+      return `${status === 'approved' ? '\u2705' : '\u274c'} Approval ${status} — ${name}`;
+    }
+
+    case 'conflict:detected': {
+      const d = event.data || event;
+      return `\u26a0\ufe0f Scope conflict: ${d.agentName || 'agent'} tried to modify ${d.filePath || 'file'} (owned by ${d.ownerName || 'another agent'})`;
+    }
+
+    case 'rotation:start':
+      return `\u{1f504} Rotating ${event.agentName || 'agent'}...`;
+
+    case 'rotation:complete': {
+      const saved = event.tokensSaved ? ` (saved ${formatTokens(event.tokensSaved)} tokens)` : '';
+      return `\u{1f504} Rotated ${event.agentName || 'agent'}${saved}`;
+    }
+
+    case 'rotation:failed':
+      return `\u274c Rotation failed: ${truncate(event.error, 200)}`;
+
+    case 'phase2:spawned':
+      return `\u{1f195} QC agent spawned: ${event.name || 'qc'}`;
+
+    case 'schedule:execute':
+      return `\u23f0 Scheduled agent spawned (schedule: ${event.scheduleId || 'unknown'})`;
+
+    case 'qc:activated':
+      return `\u{1f6e1}\ufe0f QC activated — ${event.agentCount || '4+'} agents running`;
+
+    case 'journalist:cycle': {
+      const d = event.data || {};
+      const summary = d.lastSynthesis || d.summary;
+      if (summary) return `\u{1f4f0} Journalist: ${truncate(summary, 500)}`;
+      return `\u{1f4f0} Journalist cycle #${d.cycleCount || d.cycle || '?'}`;
+    }
+
+    case 'team:created':
+      return `\u{1f4c1} Team created: ${event.team?.name || 'unnamed'}`;
+
+    case 'team:deleted':
+      return `\u{1f5d1}\ufe0f Team deleted (agents moved to default)`;
+
+    default:
+      return null;
+  }
+}
+
+/**
+ * Format an agent list for display in chat.
+ * Returns a multi-line string.
+ */
+export function agentListText(agents) {
+  if (!agents || agents.length === 0) return 'No agents running.';
+
+  const lines = agents.map((a) => {
+    const emoji = statusEmoji(a.status);
+    const tokens = a.tokensUsed ? ` | ${formatTokens(a.tokensUsed)} tokens` : '';
+    const ctx = a.contextUsage ? ` | ctx ${Math.round(a.contextUsage * 100)}%` : '';
+    return `${emoji} ${a.name || a.id} (${a.role})${tokens}${ctx}`;
+  });
+
+  return lines.join('\n');
+}
+
+/**
+ * Format a daemon status summary for chat.
+ */
+export function statusText(agents, uptime) {
+  const running = agents.filter((a) => a.status === 'running' || a.status === 'starting');
+  const completed = agents.filter((a) => a.status === 'completed');
+  const crashed = agents.filter((a) => a.status === 'crashed');
+
+  const lines = [
+    `Groove Daemon — ${formatDuration(uptime)} uptime`,
+    `Agents: ${running.length} running, ${completed.length} completed, ${crashed.length} crashed`,
+  ];
+
+  if (running.length > 0) {
+    lines.push('');
+    lines.push('Active:');
+    for (const a of running) {
+      const tokens = a.tokensUsed ? ` | ${formatTokens(a.tokensUsed)}` : '';
+      lines.push(`  ${statusEmoji(a.status)} ${a.name || a.id} (${a.role})${tokens}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Format a list of approvals for chat.
+ */
+export function approvalsText(approvals) {
+  if (!approvals || approvals.length === 0) return 'No pending approvals.';
+
+  return approvals.map((a) => {
+    const desc = a.action?.description || 'action pending';
+    return `\u{1f6a8} [${a.id}] ${a.agentName || a.agentId}: ${truncate(desc, 150)}`;
+  }).join('\n');
+}
+
+/**
+ * Format a list of teams for chat.
+ */
+export function teamsText(teams) {
+  if (!teams || teams.length === 0) return 'No teams.';
+  return teams.map((t) => `\u{1f4c1} ${t.name}${t.isDefault ? ' (default)' : ''} — ${t.agentCount || 0} agents`).join('\n');
+}
+
+/**
+ * Format a list of schedules for chat.
+ */
+export function schedulesText(schedules) {
+  if (!schedules || schedules.length === 0) return 'No schedules.';
+  return schedules.map((s) => {
+    const status = s.enabled ? '\u2705' : '\u26ab';
+    const running = s.isRunning ? ' (running)' : '';
+    return `${status} ${s.name} — ${s.cronDescription || s.cron}${running}`;
+  }).join('\n');
+}