onbuzz 3.7.1 → 3.8.0

package/src/services/discordService.js

@@ -0,0 +1,647 @@
+/**
+ * DiscordService — Remote agent interface via Discord Bot
+ *
+ * Purpose:
+ * - Conversational interface with agents from Discord channels
+ * - Many-to-many mapping: each agent can be on 0..N channels, each channel can have 0..N agents
+ * - @agent-name mention routing (single-agent channels route directly)
+ * - Smart response formatting (markdown, code blocks, message splitting)
+ * - Broadcast interception for real-time agent response relay
+ *
+ * Architecture:
+ * - Uses discord.js v14+ (lazy-imported, optional dependency)
+ * - Gateway intents: Guilds, GuildMessages, MessageContent (privileged)
+ * - Intercepts WebSocket broadcasts to capture agent responses
+ * - Routes user messages to agents via orchestrator.processRequest()
+ * - Persists config to {userData}/discord/discord-config.json
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { getUserDataPaths, ensureUserDataDirs } from '../utilities/userDataDir.js';
+import { INTERFACE_TYPES } from '../utilities/constants.js';
+
+const DISCORD_STATUS = {
+  DISCONNECTED: 'disconnected',
+  CONNECTING: 'connecting',
+  CONNECTED: 'connected',
+  FAILED: 'failed'
+};
+
+const MAX_MESSAGE_LENGTH = 1950; // Discord limit is 2000, leave room for formatting
+const INTERACTION_TTL_MS = 30 * 60 * 1000; // 30 minutes — only relay to channels with recent interaction
+
+class DiscordService {
+  constructor(logger = null) {
+    this.logger = logger;
+
+    // Dependencies (set via setters)
+    this.orchestrator = null;
+    this.agentPool = null;
+    this.webSocketManager = null;
+    this.flowExecutor = null;
+
+    // Bot state
+    this.client = null;
+    this.status = DISCORD_STATUS.DISCONNECTED;
+
+    // Channel-agent mappings: channelKey -> [agentId]
+    // channelKey format: "guildId:channelId"
+    this.channelMappings = {};
+
+    // Track recent interactions: agentId -> { channelKey, timestamp }
+    // Used to determine where to relay agent responses
+    this.recentInteractions = new Map();
+
+    // Sticky agent per channel: channelKey -> lastAgentId
+    this.stickyAgent = new Map();
+
+    // Cached Discord metadata for UI display
+    this.knownGuilds = {};
+    this.knownChannels = {};
+
+    // Config persistence
+    this.dataDir = null;
+    this.configPath = null;
+    this.config = {};
+
+    // Original broadcast (saved before wrapping)
+    this._originalBroadcast = null;
+  }
+
+  // --- Dependency Injection ---
+
+  setOrchestrator(orchestrator) { this.orchestrator = orchestrator; }
+  setAgentPool(agentPool) { this.agentPool = agentPool; }
+  setWebSocketManager(wsManager) {
+    this.webSocketManager = wsManager;
+    this._interceptBroadcasts(wsManager);
+  }
+  setFlowExecutor(flowExecutor) { this.flowExecutor = flowExecutor; }
+
+  // --- Config Persistence ---
+
+  async _ensureDataDir() {
+    if (!this.dataDir) {
+      await ensureUserDataDirs();
+      const paths = getUserDataPaths();
+      this.dataDir = path.join(paths.base, 'discord');
+      this.configPath = path.join(this.dataDir, 'discord-config.json');
+      await fs.mkdir(this.dataDir, { recursive: true });
+    }
+  }
+
+  async _loadConfig() {
+    await this._ensureDataDir();
+    try {
+      const data = await fs.readFile(this.configPath, 'utf8');
+      this.config = JSON.parse(data);
+      this.channelMappings = this.config.channelMappings || {};
+      this.knownGuilds = this.config.knownGuilds || {};
+      this.knownChannels = this.config.knownChannels || {};
+    } catch {
+      this.config = {};
+    }
+  }
+
+  async _saveConfig() {
+    await this._ensureDataDir();
+    this.config.channelMappings = this.channelMappings;
+    this.config.knownGuilds = this.knownGuilds;
+    this.config.knownChannels = this.knownChannels;
+    this.config.updatedAt = new Date().toISOString();
+    await fs.writeFile(this.configPath, JSON.stringify(this.config, null, 2), 'utf8');
+  }
+
+  // --- Lifecycle ---
+
+  async autoConnect() {
+    await this._loadConfig();
+    if (this.config.botToken) {
+      try {
+        await this.connect(this.config.botToken);
+      } catch (error) {
+        this.logger?.warn('[DiscordService] Auto-connect failed', { error: error.message });
+      }
+    }
+  }
+
+  async connect(botToken) {
+    if (this.status === DISCORD_STATUS.CONNECTED) {
+      await this.disconnect();
+    }
+
+    this.status = DISCORD_STATUS.CONNECTING;
+    this.logger?.info('[DiscordService] Connecting...');
+
+    try {
+      // Lazy import discord.js (optional dependency)
+      const { Client, GatewayIntentBits, ChannelType } = await import('discord.js');
+      this._ChannelType = ChannelType;
+
+      this.client = new Client({
+        intents: [
+          GatewayIntentBits.Guilds,
+          GatewayIntentBits.GuildMessages,
+          GatewayIntentBits.MessageContent
+        ]
+      });
+
+      // Wait for ready event
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error('Discord login timed out after 30s')), 30000);
+
+        this.client.once('ready', () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+
+        this.client.once('error', (err) => {
+          clearTimeout(timeout);
+          reject(err);
+        });
+
+        this.client.login(botToken).catch(reject);
+      });
+
+      const botUser = this.client.user;
+      this.logger?.info('[DiscordService] Connected', {
+        botName: botUser.username,
+        guildCount: this.client.guilds.cache.size
+      });
+
+      // Save config
+      this.config.botToken = botToken;
+      this.config.botUsername = botUser.username;
+      this.config.botId = botUser.id;
+      await this._saveConfig();
+
+      // Cache guild/channel metadata
+      this._cacheGuildMetadata();
+
+      // Setup event handlers
+      this._setupHandlers();
+
+      this.status = DISCORD_STATUS.CONNECTED;
+
+      return { username: botUser.username, id: botUser.id };
+    } catch (error) {
+      this.status = DISCORD_STATUS.FAILED;
+      this.logger?.error('[DiscordService] Connection failed', { error: error.message });
+      if (this.client) {
+        try { this.client.destroy(); } catch {}
+        this.client = null;
+      }
+      throw error;
+    }
+  }
+
+  async disconnect() {
+    if (this.client) {
+      try { this.client.destroy(); } catch {}
+      this.client = null;
+    }
+    this.status = DISCORD_STATUS.DISCONNECTED;
+    this.recentInteractions.clear();
+    this.stickyAgent.clear();
+    this.logger?.info('[DiscordService] Disconnected');
+  }
+
+  getStatus() {
+    return {
+      status: this.status,
+      connected: this.status === DISCORD_STATUS.CONNECTED,
+      botUsername: this.config.botUsername || null,
+      botId: this.config.botId || null,
+      guildCount: this.client?.guilds?.cache?.size || 0,
+      channelMappingCount: Object.keys(this.channelMappings).length
+    };
+  }
+
+  // --- Discord Event Handlers ---
+
+  _setupHandlers() {
+    if (!this.client) return;
+
+    this.client.on('messageCreate', async (message) => {
+      try {
+        await this._handleMessage(message);
+      } catch (error) {
+        this.logger?.error('[DiscordService] Message handling error', { error: error.message });
+      }
+    });
+
+    this.client.on('guildCreate', (guild) => {
+      this.logger?.info('[DiscordService] Added to guild', { guildName: guild.name, guildId: guild.id });
+      this._cacheGuildMetadata();
+    });
+
+    this.client.on('guildDelete', (guild) => {
+      this.logger?.info('[DiscordService] Removed from guild', { guildId: guild.id });
+      delete this.knownGuilds[guild.id];
+      // Clean up channel mappings for this guild
+      for (const key of Object.keys(this.channelMappings)) {
+        if (key.startsWith(`${guild.id}:`)) {
+          delete this.channelMappings[key];
+          delete this.knownChannels[key];
+        }
+      }
+      this._saveConfig().catch(() => {});
+    });
+
+    this.client.on('error', (error) => {
+      this.logger?.error('[DiscordService] Client error', { error: error.message });
+    });
+  }
+
+  _cacheGuildMetadata() {
+    if (!this.client) return;
+
+    for (const [guildId, guild] of this.client.guilds.cache) {
+      this.knownGuilds[guildId] = {
+        name: guild.name,
+        icon: guild.iconURL({ size: 64 }) || null
+      };
+
+      for (const [channelId, channel] of guild.channels.cache) {
+        if (channel.type === this._ChannelType?.GuildText || channel.type === 0) {
+          const key = `${guildId}:${channelId}`;
+          this.knownChannels[key] = {
+            name: channel.name,
+            guildId,
+            guildName: guild.name
+          };
+        }
+      }
+    }
+
+    this._saveConfig().catch(() => {});
+  }
+
+  // --- Message Routing ---
+
+  async _handleMessage(message) {
+    // Ignore bot messages (including self)
+    if (message.author.bot) return;
+    // Ignore DMs (only handle guild channels)
+    if (!message.guild) return;
+
+    const guildId = message.guild.id;
+    const channelId = message.channel.id;
+    const channelKey = `${guildId}:${channelId}`;
+
+    // Look up mapped agents for this channel
+    const mappedAgents = this.channelMappings[channelKey];
+    if (!mappedAgents || mappedAgents.length === 0) {
+      // No agents mapped to this channel — ignore silently
+      return;
+    }
+
+    const messageText = message.content.trim();
+    if (!messageText) return;
+
+    let targetAgentId = null;
+
+    if (mappedAgents.length === 1) {
+      // Single agent — route directly
+      targetAgentId = mappedAgents[0];
+    } else {
+      // Multiple agents — parse @agent-name mention
+      targetAgentId = await this._resolveAgentFromMention(messageText, mappedAgents);
+
+      if (!targetAgentId) {
+        // Try sticky agent for this channel
+        const sticky = this.stickyAgent.get(channelKey);
+        if (sticky && mappedAgents.includes(sticky)) {
+          targetAgentId = sticky;
+        }
+      }
+
+      if (!targetAgentId) {
+        // Prompt user — list available agents
+        const agentNames = [];
+        for (const aid of mappedAgents) {
+          const agent = this.agentPool ? await this.agentPool.getAgent(aid) : null;
+          agentNames.push(agent?.name || aid);
+        }
+        await message.reply(
+          `Multiple agents on this channel. Mention one by name:\n${agentNames.map(n => `\`@${n}\``).join(', ')}`
+        );
+        return;
+      }
+    }
+
+    // Remove @agent-name prefix from the message if present
+    const cleanedMessage = this._stripAgentMention(messageText, targetAgentId);
+
+    // Update sticky agent
+    this.stickyAgent.set(channelKey, targetAgentId);
+
+    // Route to agent
+    await this._routeToAgent(channelKey, targetAgentId, cleanedMessage, message);
+  }
+
+  async _resolveAgentFromMention(text, candidateAgentIds) {
+    if (!this.agentPool) return null;
+
+    // Check for @agent-name pattern at start of message
+    const mentionMatch = text.match(/^@(\S+)/);
+    if (!mentionMatch) return null;
+
+    const mentionName = mentionMatch[1].toLowerCase();
+
+    for (const agentId of candidateAgentIds) {
+      const agent = await this.agentPool.getAgent(agentId);
+      if (agent?.name?.toLowerCase() === mentionName) {
+        return agentId;
+      }
+    }
+
+    return null;
+  }
+
+  _stripAgentMention(text, agentId) {
+    // Remove @agent-name from the start of the message
+    return text.replace(/^@\S+\s*/, '').trim() || text;
+  }
+
+  async _routeToAgent(channelKey, agentId, text, discordMessage) {
+    const sessionId = `discord-${channelKey.replace(':', '-')}`;
+
+    // Record recent interaction for response targeting
+    this.recentInteractions.set(`${agentId}:${channelKey}`, {
+      channelKey,
+      channelId: discordMessage.channel.id,
+      guildId: discordMessage.guild.id,
+      timestamp: Date.now()
+    });
+
+    // Show typing indicator
+    try {
+      await discordMessage.channel.sendTyping();
+    } catch {}
+
+    const agent = this.agentPool ? await this.agentPool.getAgent(agentId) : null;
+    this.logger?.info('[DiscordService] Routing message to agent', {
+      agentId,
+      agentName: agent?.name,
+      channelKey,
+      messageLength: text.length
+    });
+
+    try {
+      if (this.orchestrator) {
+        await this.orchestrator.processRequest({
+          interface: INTERFACE_TYPES.DISCORD,
+          sessionId,
+          action: 'send_message',
+          payload: {
+            agentId,
+            message: text,
+            streamingEnabled: false
+          }
+        });
+      } else if (this.agentPool) {
+        // Fallback: direct message injection
+        await this.agentPool.addUserMessage(agentId, {
+          content: text,
+          sessionId
+        });
+      }
+    } catch (error) {
+      this.logger?.error('[DiscordService] Failed to route message', { error: error.message, agentId });
+      try {
+        await discordMessage.reply(`Failed to send message to agent: ${error.message}`);
+      } catch {}
+    }
+  }
+
+  // --- Broadcast Interception ---
+
+  _interceptBroadcasts(wsManager) {
+    if (!wsManager || this._originalBroadcast) return;
+
+    // Chain onto existing wrapper (Telegram may already be wrapping)
+    const currentBroadcast = wsManager.broadcastToSession.bind(wsManager);
+    this._originalBroadcast = currentBroadcast;
+
+    wsManager.broadcastToSession = (sessionId, message) => {
+      // Call previous wrapper (Telegram's or original)
+      currentBroadcast(sessionId, message);
+      // Discord handling
+      this._handleBroadcastEvent(sessionId, message);
+    };
+  }
+
+  async _handleBroadcastEvent(sessionId, message) {
+    if (!this.client || this.status !== DISCORD_STATUS.CONNECTED) return;
+
+    const type = message?.type;
+    if (!type) return;
+
+    // Relay completed agent responses
+    if (type === 'stream_complete') {
+      await this._relayAgentResponse(message);
+      return;
+    }
+
+    // Relay user prompt requests
+    if (type === 'user_prompt_request') {
+      await this._relayPromptRequest(message);
+      return;
+    }
+  }
+
+  async _relayAgentResponse(message) {
+    const agentId = message.agentId || message.data?.agentId;
+    if (!agentId) return;
+
+    const content = message.content || message.data?.content ||
+      message.message?.content || message.data?.message?.content;
+    if (!content) return;
+
+    // Skip tool-result messages and user messages
+    const role = message.role || message.data?.role || message.message?.role;
+    if (role === 'user' || role === 'tool') return;
+
+    // Find channels with recent interaction for this agent
+    const now = Date.now();
+    const channelsToRelay = [];
+
+    for (const [key, interaction] of this.recentInteractions) {
+      if (!key.startsWith(`${agentId}:`)) continue;
+      if (now - interaction.timestamp > INTERACTION_TTL_MS) {
+        this.recentInteractions.delete(key);
+        continue;
+      }
+      channelsToRelay.push(interaction);
+    }
+
+    if (channelsToRelay.length === 0) return;
+
+    const agent = this.agentPool ? await this.agentPool.getAgent(agentId) : null;
+    const agentName = agent?.name || agentId;
+
+    for (const interaction of channelsToRelay) {
+      try {
+        await this._sendFormattedResponse(interaction.channelId, agentName, content);
+      } catch (error) {
+        this.logger?.warn('[DiscordService] Failed to relay response', {
+          channelId: interaction.channelId,
+          error: error.message
+        });
+      }
+    }
+  }
+
+  async _relayPromptRequest(message) {
+    const agentId = message.data?.agentId || message.agentId;
+    if (!agentId) return;
+
+    const promptText = message.data?.prompt || message.data?.message || 'Agent is requesting input';
+
+    for (const [key, interaction] of this.recentInteractions) {
+      if (!key.startsWith(`${agentId}:`)) continue;
+      if (Date.now() - interaction.timestamp > INTERACTION_TTL_MS) continue;
+
+      try {
+        const channel = await this.client.channels.fetch(interaction.channelId);
+        if (channel) {
+          await channel.send(`**Input needed:**\n${promptText}`);
+        }
+      } catch {}
+    }
+  }
+
+  // --- Response Formatting ---
+
+  async _sendFormattedResponse(channelId, agentName, content) {
+    const channel = await this.client.channels.fetch(channelId);
+    if (!channel) return;
+
+    const header = `**${agentName}:**\n`;
+    const fullMessage = header + content;
+
+    // Split if needed
+    const parts = this._splitMessage(fullMessage);
+
+    for (const part of parts) {
+      await channel.send(part);
+    }
+  }
+
+  _splitMessage(text) {
+    if (text.length <= MAX_MESSAGE_LENGTH) return [text];
+
+    const parts = [];
+    let remaining = text;
+
+    while (remaining.length > 0) {
+      if (remaining.length <= MAX_MESSAGE_LENGTH) {
+        parts.push(remaining);
+        break;
+      }
+
+      // Try to split at code block boundary
+      let splitIndex = remaining.lastIndexOf('\n```', MAX_MESSAGE_LENGTH);
+      if (splitIndex > MAX_MESSAGE_LENGTH * 0.3) {
+        splitIndex += 1; // Include the newline
+      } else {
+        // Try newline
+        splitIndex = remaining.lastIndexOf('\n', MAX_MESSAGE_LENGTH);
+        if (splitIndex < MAX_MESSAGE_LENGTH * 0.3) {
+          // Try space
+          splitIndex = remaining.lastIndexOf(' ', MAX_MESSAGE_LENGTH);
+          if (splitIndex < MAX_MESSAGE_LENGTH * 0.3) {
+            // Hard split
+            splitIndex = MAX_MESSAGE_LENGTH;
+          }
+        }
+      }
+
+      parts.push(remaining.slice(0, splitIndex));
+      remaining = remaining.slice(splitIndex).trimStart();
+    }
+
+    return parts;
+  }
+
+  // --- Channel Mapping Management ---
+
+  async assignAgentToChannel(channelKey, agentId) {
+    if (!this.channelMappings[channelKey]) {
+      this.channelMappings[channelKey] = [];
+    }
+    if (!this.channelMappings[channelKey].includes(agentId)) {
+      this.channelMappings[channelKey].push(agentId);
+    }
+    await this._saveConfig();
+    this.logger?.info('[DiscordService] Agent assigned to channel', { channelKey, agentId });
+  }
+
+  async removeAgentFromChannel(channelKey, agentId) {
+    if (this.channelMappings[channelKey]) {
+      this.channelMappings[channelKey] = this.channelMappings[channelKey].filter(id => id !== agentId);
+      if (this.channelMappings[channelKey].length === 0) {
+        delete this.channelMappings[channelKey];
+      }
+    }
+    // Clean sticky if removed agent was sticky
+    if (this.stickyAgent.get(channelKey) === agentId) {
+      this.stickyAgent.delete(channelKey);
+    }
+    await this._saveConfig();
+    this.logger?.info('[DiscordService] Agent removed from channel', { channelKey, agentId });
+  }
+
+  getChannelMappings() {
+    return {
+      mappings: this.channelMappings,
+      knownGuilds: this.knownGuilds,
+      knownChannels: this.knownChannels
+    };
+  }
+
+  getAvailableChannels() {
+    if (!this.client || this.status !== DISCORD_STATUS.CONNECTED) {
+      // Return cached channels if disconnected
+      return Object.entries(this.knownChannels).map(([key, ch]) => ({
+        key,
+        channelId: key.split(':')[1],
+        guildId: key.split(':')[0],
+        name: ch.name,
+        guildName: ch.guildName
+      }));
+    }
+
+    const channels = [];
+    for (const [guildId, guild] of this.client.guilds.cache) {
+      for (const [channelId, channel] of guild.channels.cache) {
+        if (channel.type === this._ChannelType?.GuildText || channel.type === 0) {
+          const key = `${guildId}:${channelId}`;
+          channels.push({
+            key,
+            channelId,
+            guildId,
+            name: channel.name,
+            guildName: guild.name
+          });
+        }
+      }
+    }
+    return channels;
+  }
+}
+
+// Singleton pattern (matches Telegram)
+let instance = null;
+
+export function getDiscordService(logger) {
+  if (!instance) {
+    instance = new DiscordService(logger);
+  }
+  return instance;
+}
+
+export { DiscordService, DISCORD_STATUS };
+export default DiscordService;

package/src/services/promptService.js

@@ -303,6 +303,52 @@ class PromptService {
     return this.requestHistory.slice(-limit);
   }
 
+  /**
+   * Extend timeout for a pending request
+   * @param {string} requestId
+   * @param {number} additionalMs - Milliseconds to add
+   * @returns {Object}
+   */
+  extendTimeout(requestId, additionalMs) {
+    const request = this.pendingRequests.get(requestId);
+    if (!request) return { success: false, error: 'Request not found' };
+
+    const currentTimeout = new Date(request.requestInfo.timeoutAt).getTime();
+    request.requestInfo.timeoutAt = new Date(currentTimeout + additionalMs).toISOString();
+
+    // Reset the timeout handle
+    clearTimeout(request.timeout);
+    const newRemainingMs = new Date(request.requestInfo.timeoutAt).getTime() - Date.now();
+    request.timeout = setTimeout(() => {
+      this._handleTimeout(requestId);
+    }, Math.max(0, newRemainingMs));
+
+    this.logger?.info('[PromptService] Timeout extended', {
+      requestId,
+      additionalMs,
+      newTimeoutAt: request.requestInfo.timeoutAt
+    });
+
+    return { success: true, newTimeoutAt: request.requestInfo.timeoutAt };
+  }
+
+  /**
+   * Stop timeout for a pending request (no expiration)
+   * @param {string} requestId
+   * @returns {Object}
+   */
+  stopTimeout(requestId) {
+    const request = this.pendingRequests.get(requestId);
+    if (!request) return { success: false, error: 'Request not found' };
+
+    clearTimeout(request.timeout);
+    request.requestInfo.timeoutAt = null;
+
+    this.logger?.info('[PromptService] Timeout stopped', { requestId });
+
+    return { success: true };
+  }
+
   /**
    * Clear all pending requests (for shutdown)
    */