groove-dev 0.19.9 → 0.21.0

package/packages/daemon/src/gateways/slack.js

@@ -0,0 +1,165 @@
+// GROOVE — Slack Gateway (@slack/bolt Socket Mode)
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { BaseGateway } from './base.js';
+import { truncate, statusEmoji, formatTokens } from './formatter.js';
+
+export class SlackGateway extends BaseGateway {
+  static type = 'slack';
+  static displayName = 'Slack';
+  static description = 'Slack bot for notifications and agent commands';
+  static credentialKeys = [
+    { key: 'bot_token', label: 'Bot Token (xoxb-...)', required: true, help: 'Slack App \u2192 OAuth & Permissions' },
+    { key: 'app_token', label: 'App Token (xapp-...)', required: true, help: 'Socket Mode requires an app-level token' },
+  ];
+
+  constructor(daemon, config) {
+    super(daemon, config);
+    this.app = null;
+  }
+
+  async connect() {
+    const botToken = this._getCredential('bot_token');
+    const appToken = this._getCredential('app_token');
+    if (!botToken) throw new Error('Slack bot token not configured');
+    if (!appToken) throw new Error('Slack app token not configured (required for Socket Mode)');
+
+    let App;
+    try {
+      const bolt = await import('@slack/bolt');
+      App = bolt.default?.App || bolt.App;
+    } catch {
+      throw new Error('Slack gateway requires @slack/bolt. Install with: npm i @slack/bolt');
+    }
+
+    this.app = new App({
+      token: botToken,
+      appToken,
+      socketMode: true,
+    });
+
+    // Handle messages starting with /
+    this.app.message(/^\/\w+/, async ({ message, say }) => {
+      const userId = message.user;
+      const [command, ...args] = message.text.slice(1).split(/\s+/);
+
+      // Auto-capture channelId
+      if (!this.config.chatId) {
+        this.config.chatId = message.channel;
+        this.daemon.gateways._save(this.config.id);
+      }
+
+      const response = await this.handleCommand(command, args, userId);
+      if (response) {
+        await say(this._buildReply(response));
+      }
+    });
+
+    // Handle approve button action
+    this.app.action('groove_approve', async ({ action, ack, respond }) => {
+      await ack();
+      const approvalId = action.value;
+      try {
+        this.daemon.supervisor.approve(approvalId);
+        await respond({
+          replace_original: true,
+          text: `\u2705 Approved: ${approvalId}`,
+          blocks: [
+            { type: 'section', text: { type: 'mrkdwn', text: `\u2705 *Approved:* \`${approvalId}\`` } },
+          ],
+        });
+      } catch (err) {
+        await respond({ text: `Error: ${err.message}` });
+      }
+    });
+
+    // Handle reject button action
+    this.app.action('groove_reject', async ({ action, ack, respond }) => {
+      await ack();
+      const approvalId = action.value;
+      try {
+        this.daemon.supervisor.reject(approvalId);
+        await respond({
+          replace_original: true,
+          text: `\u274c Rejected: ${approvalId}`,
+          blocks: [
+            { type: 'section', text: { type: 'mrkdwn', text: `\u274c *Rejected:* \`${approvalId}\`` } },
+          ],
+        });
+      } catch (err) {
+        await respond({ text: `Error: ${err.message}` });
+      }
+    });
+
+    await this.app.start();
+
+    this.connected = true;
+    console.log('[Groove:Slack] Connected via Socket Mode');
+  }
+
+  async disconnect() {
+    if (this.app) {
+      await this.app.stop();
+      this.app = null;
+    }
+    this.connected = false;
+    console.log('[Groove:Slack] Disconnected');
+  }
+
+  async send(text, options = {}) {
+    if (!this.app || !this.config.chatId) return;
+
+    const payload = { channel: this.config.chatId };
+
+    if (options.approvalId) {
+      // Block Kit message with approve/reject buttons
+      payload.text = text; // Fallback for notifications
+      payload.blocks = [
+        { type: 'section', text: { type: 'mrkdwn', text: `\ud83d\udea8 *Approval Required*\n${truncate(text, 2800)}` } },
+        { type: 'divider' },
+        {
+          type: 'actions',
+          elements: [
+            {
+              type: 'button',
+              text: { type: 'plain_text', text: '\u2705 Approve' },
+              style: 'primary',
+              action_id: 'groove_approve',
+              value: options.approvalId,
+            },
+            {
+              type: 'button',
+              text: { type: 'plain_text', text: '\u274c Reject' },
+              style: 'danger',
+              action_id: 'groove_reject',
+              value: options.approvalId,
+            },
+          ],
+        },
+      ];
+    } else {
+      // Standard Block Kit message
+      payload.text = truncate(text, 3000); // Fallback
+      payload.blocks = [
+        { type: 'section', text: { type: 'mrkdwn', text: truncate(text, 3000) } },
+      ];
+    }
+
+    await this.app.client.chat.postMessage(payload);
+  }
+
+  /**
+   * Build a reply payload from a command response.
+   */
+  _buildReply(response) {
+    if (!response) return {};
+    const text = response.text || '';
+    // Wrap in a code block for command output readability
+    return {
+      text,
+      blocks: [
+        { type: 'section', text: { type: 'mrkdwn', text: '```' + truncate(text, 2900) + '```' } },
+      ],
+    };
+  }
+}

package/packages/daemon/src/gateways/telegram.js

@@ -0,0 +1,265 @@
+// GROOVE — Telegram Gateway (Zero-dependency Bot API)
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { BaseGateway } from './base.js';
+
+const POLL_TIMEOUT = 30; // seconds — Telegram long-poll
+const BACKOFF_BASE = 3000; // ms
+const BACKOFF_MAX = 30000; // ms
+
+export class TelegramGateway extends BaseGateway {
+  static type = 'telegram';
+  static displayName = 'Telegram';
+  static description = 'Telegram bot for notifications and agent commands';
+  static credentialKeys = [
+    { key: 'bot_token', label: 'Bot Token', required: true, help: 'Create a bot via @BotFather on Telegram' },
+  ];
+
+  constructor(daemon, config) {
+    super(daemon, config);
+    this.token = null;
+    this.botInfo = null;
+    this._pollOffset = 0;
+    this._polling = false;
+    this._abort = null;
+    this._backoff = BACKOFF_BASE;
+  }
+
+  async connect() {
+    this.token = this._getCredential('bot_token');
+    if (!this.token) throw new Error('Telegram bot token not configured');
+
+    // Validate token with getMe
+    this.botInfo = await this._api('getMe');
+    this.connected = true;
+    this._backoff = BACKOFF_BASE;
+
+    console.log(`[Groove:Telegram] Connected as @${this.botInfo.username}`);
+
+    // Start polling loop (non-blocking)
+    this._startPolling();
+  }
+
+  async disconnect() {
+    this._polling = false;
+    if (this._abort) {
+      this._abort.abort();
+      this._abort = null;
+    }
+    this.connected = false;
+    console.log('[Groove:Telegram] Disconnected');
+  }
+
+  async send(text, options = {}) {
+    const chatId = this.config.chatId;
+    if (!chatId) return; // No chat configured yet — will auto-capture on first command
+
+    const params = {
+      chat_id: chatId,
+      text,
+      parse_mode: 'HTML',
+      disable_web_page_preview: true,
+    };
+
+    // Add inline keyboard for approval actions
+    if (options.approvalId) {
+      params.reply_markup = {
+        inline_keyboard: [[
+          { text: '\u2705 Approve', callback_data: `approve:${options.approvalId}` },
+          { text: '\u274c Reject', callback_data: `reject:${options.approvalId}` },
+        ]],
+      };
+    }
+
+    await this._api('sendMessage', params);
+  }
+
+  getStatus() {
+    return {
+      ...super.getStatus(),
+      botUsername: this.botInfo?.username || null,
+    };
+  }
+
+  // -------------------------------------------------------------------
+  // Long-Polling Loop
+  // -------------------------------------------------------------------
+
+  async _startPolling() {
+    this._polling = true;
+
+    while (this._polling) {
+      try {
+        this._abort = new AbortController();
+        const updates = await this._api('getUpdates', {
+          offset: this._pollOffset,
+          timeout: POLL_TIMEOUT,
+          allowed_updates: ['message', 'callback_query'],
+        }, this._abort.signal);
+
+        // Reset backoff on success
+        this._backoff = BACKOFF_BASE;
+
+        for (const update of updates) {
+          this._pollOffset = update.update_id + 1;
+          this._handleUpdate(update).catch((err) => {
+            console.log(`[Groove:Telegram] Error handling update: ${err.message}`);
+          });
+        }
+      } catch (err) {
+        if (err.name === 'AbortError') break;
+        console.log(`[Groove:Telegram] Poll error: ${err.message}`);
+        // Exponential backoff
+        await new Promise((r) => setTimeout(r, this._backoff));
+        this._backoff = Math.min(this._backoff * 1.5, BACKOFF_MAX);
+      }
+    }
+  }
+
+  // -------------------------------------------------------------------
+  // Update Handlers
+  // -------------------------------------------------------------------
+
+  async _handleUpdate(update) {
+    if (update.callback_query) {
+      return this._handleCallbackQuery(update.callback_query);
+    }
+
+    const msg = update.message;
+    if (!msg?.text) return;
+
+    // Auto-capture chatId from first message
+    if (!this.config.chatId) {
+      this.config.chatId = String(msg.chat.id);
+      // Persist the captured chatId
+      this.daemon.gateways._save(this.config.id);
+      console.log(`[Groove:Telegram] Auto-captured chatId: ${this.config.chatId}`);
+    }
+
+    // Only process commands (starts with /)
+    if (!msg.text.startsWith('/')) return;
+
+    const userId = String(msg.from.id);
+    const text = msg.text.split('@')[0]; // Remove @botname suffix from group commands
+    const [command, ...args] = text.slice(1).split(/\s+/);
+
+    const response = await this.handleCommand(command, args, userId);
+    if (response) {
+      await this._reply(msg.chat.id, response.text, response.options);
+    }
+  }
+
+  async _handleCallbackQuery(query) {
+    const userId = String(query.from.id);
+
+    // Authorization check
+    if (!this._isAuthorized(userId)) {
+      await this._answerCallback(query.id, 'Unauthorized');
+      return;
+    }
+
+    const data = query.data || '';
+    const [action, ...rest] = data.split(':');
+    const approvalId = rest.join(':');
+
+    if (!approvalId) {
+      await this._answerCallback(query.id, 'Invalid action');
+      return;
+    }
+
+    let responseText;
+    try {
+      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 this._answerCallback(query.id, 'Unknown action');
+        return;
+      }
+    } catch (err) {
+      await this._answerCallback(query.id, `Error: ${err.message}`);
+      return;
+    }
+
+    // Acknowledge the callback
+    await this._answerCallback(query.id, responseText);
+
+    // Update the original message to reflect the action
+    if (query.message) {
+      try {
+        await this._api('editMessageReplyMarkup', {
+          chat_id: query.message.chat.id,
+          message_id: query.message.message_id,
+          reply_markup: { inline_keyboard: [] }, // Remove buttons
+        });
+        await this._api('editMessageText', {
+          chat_id: query.message.chat.id,
+          message_id: query.message.message_id,
+          text: `${query.message.text}\n\n${responseText}`,
+          parse_mode: 'HTML',
+        });
+      } catch { /* best effort — message may be too old to edit */ }
+    }
+  }
+
+  // -------------------------------------------------------------------
+  // Telegram Bot API Helpers
+  // -------------------------------------------------------------------
+
+  async _reply(chatId, text, options = {}) {
+    const params = {
+      chat_id: chatId,
+      text,
+      parse_mode: 'HTML',
+      disable_web_page_preview: true,
+    };
+    if (options.approvalId) {
+      params.reply_markup = {
+        inline_keyboard: [[
+          { text: '\u2705 Approve', callback_data: `approve:${options.approvalId}` },
+          { text: '\u274c Reject', callback_data: `reject:${options.approvalId}` },
+        ]],
+      };
+    }
+    await this._api('sendMessage', params);
+  }
+
+  async _answerCallback(callbackQueryId, text) {
+    await this._api('answerCallbackQuery', {
+      callback_query_id: callbackQueryId,
+      text,
+    });
+  }
+
+  /**
+   * Call the Telegram Bot API.
+   * @param {string} method — API method name
+   * @param {object} [body] — request body (JSON)
+   * @param {AbortSignal} [signal] — abort signal
+   * @returns {any} — result from Telegram API
+   */
+  async _api(method, body, signal) {
+    const url = `https://api.telegram.org/bot${this.token}/${method}`;
+    const options = {
+      method: body ? 'POST' : 'GET',
+      signal,
+    };
+
+    if (body) {
+      options.headers = { 'Content-Type': 'application/json' };
+      options.body = JSON.stringify(body);
+    }
+
+    const res = await fetch(url, options);
+    const data = await res.json();
+
+    if (!data.ok) {
+      throw new Error(data.description || `Telegram API error: ${method}`);
+    }
+
+    return data.result;
+  }
+}

package/packages/daemon/src/index.js

@@ -33,6 +33,7 @@ import { Scheduler } from './scheduler.js';
 import { FileWatcher } from './filewatcher.js';
 import { TimelineTracker } from './timeline.js';
 import { TerminalManager } from './terminal-pty.js';
+import { GatewayManager } from './gateways/manager.js';
 import { isFirstRun, runFirstTimeSetup, loadConfig, saveConfig, printWelcome } from './firstrun.js';
 
 const DEFAULT_PORT = 31415;
@@ -127,6 +128,7 @@ export class Daemon {
     this.scheduler = new Scheduler(this);
     this.fileWatcher = new FileWatcher(this);
     this.terminalManager = new TerminalManager(this);
+    this.gateways = new GatewayManager(this);
 
     // HTTP + WebSocket server
     this.app = express();
@@ -296,6 +298,7 @@ export class Daemon {
         this.rotator.start();
         this.scheduler.start();
         this.timeline.start();
+        this.gateways.start();
         this._startGarbageCollector();
 
         // Scan codebase for workspace/structure awareness
@@ -368,6 +371,7 @@ export class Daemon {
     this.state.save();
 
     // Stop background services
+    await this.gateways.stop();
     this.journalist.stop();
     this.rotator.stop();
     this.scheduler.stop();

package/packages/daemon/src/validate.js

@@ -134,6 +134,61 @@ export function sanitizeForFilename(name) {
   return sanitized;
 }
 
+const VALID_GATEWAY_TYPES = ['telegram', 'discord', 'slack'];
+const VALID_NOTIFICATION_PRESETS = ['critical', 'lifecycle', 'all', 'custom'];
+
+export function validateGatewayConfig(config) {
+  if (!config || typeof config !== 'object') {
+    throw new Error('Invalid gateway config');
+  }
+
+  if (!config.type || !VALID_GATEWAY_TYPES.includes(config.type)) {
+    throw new Error(`Invalid gateway type. Must be one of: ${VALID_GATEWAY_TYPES.join(', ')}`);
+  }
+
+  if (config.chatId !== undefined && config.chatId !== null) {
+    if (typeof config.chatId !== 'string' || config.chatId.length > 100) {
+      throw new Error('Invalid chatId');
+    }
+  }
+
+  if (config.allowedUsers !== undefined && config.allowedUsers !== null) {
+    if (!Array.isArray(config.allowedUsers)) {
+      throw new Error('allowedUsers must be an array');
+    }
+    if (config.allowedUsers.length > 50) {
+      throw new Error('Too many allowed users (max 50)');
+    }
+    for (const u of config.allowedUsers) {
+      if (typeof u !== 'string' || u.length > 100) {
+        throw new Error('Invalid user ID in allowedUsers');
+      }
+    }
+  }
+
+  if (config.notifications !== undefined && config.notifications !== null) {
+    if (typeof config.notifications !== 'object') {
+      throw new Error('notifications must be an object');
+    }
+    if (config.notifications.preset && !VALID_NOTIFICATION_PRESETS.includes(config.notifications.preset)) {
+      throw new Error(`Invalid notification preset. Must be one of: ${VALID_NOTIFICATION_PRESETS.join(', ')}`);
+    }
+  }
+
+  if (config.commandPermission !== undefined && !['full', 'read-only'].includes(config.commandPermission)) {
+    throw new Error('Invalid commandPermission. Must be "full" or "read-only"');
+  }
+
+  return {
+    type: config.type,
+    enabled: config.enabled !== false,
+    chatId: config.chatId || null,
+    allowedUsers: (config.allowedUsers || []).map(String),
+    notifications: config.notifications || { preset: 'critical' },
+    commandPermission: config.commandPermission || 'full',
+  };
+}
+
 export function escapeMd(text) {
   if (!text) return '';
   // Escape markdown special chars that could break table rendering or inject formatting.