bloby-bot 0.17.2

package/supervisor/channels/manager.ts

@@ -0,0 +1,618 @@
+/**
+ * Channel Manager — orchestrates multi-channel messaging.
+ *
+ * Responsibilities:
+ * - Manages channel providers (WhatsApp, Telegram, etc.)
+ * - Resolves sender role (admin vs customer) based on mode
+ * - Routes inbound messages to the agent with appropriate system prompt
+ * - Routes agent responses back to channels
+ * - Manages parallel agent instances for customer conversations (business mode)
+ *
+ * Modes:
+ * - channel: Just talk to me. Only self-chat (fromMe=true) triggers the agent.
+ *            All other messages are ignored — it's the user's personal WhatsApp.
+ * - business: Bloby has its own number. Numbers in the admins array get the main
+ *             system prompt. Everyone else gets the customer support prompt.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { loadConfig } from '../../shared/config.js';
+import { WORKSPACE_DIR } from '../../shared/paths.js';
+import { log } from '../../shared/logger.js';
+import { startBlobyAgentQuery, type RecentMessage } from '../bloby-agent.js';
+import { WhatsAppChannel } from './whatsapp.js';
+import type { ChannelConfig, ChannelProvider, ChannelStatus, ChannelType, InboundMessage, SenderRole } from './types.js';
+
+const MAX_CONCURRENT_AGENTS = 5;
+const MAX_BUFFER_MESSAGES = 30;
+const DEBOUNCE_MS = 4000; // 4s — wait for the user to finish typing
+
+interface ChannelManagerOpts {
+  broadcastBloby: (type: string, data: any) => void;
+  workerApi: (path: string, method?: string, body?: any) => Promise<any>;
+  restartBackend: () => void;
+  getModel: () => string;
+}
+
+interface ActiveAgentQuery {
+  sender: string;
+  channel: ChannelType;
+}
+
+interface BufferedMessage {
+  role: 'user' | 'assistant';
+  content: string;
+}
+
+interface DebounceEntry {
+  messages: string[];
+  timer: ReturnType<typeof setTimeout>;
+  channel: ChannelType;
+  sender: string;
+  senderName?: string;
+  fromMe: boolean;
+  isSelfChat: boolean;
+}
+
+export class ChannelManager {
+  private providers = new Map<ChannelType, ChannelProvider>();
+  private opts: ChannelManagerOpts;
+  private activeAgents = new Map<string, ActiveAgentQuery>();
+  private messageQueue: InboundMessage[] = [];
+  private statusListeners: ((status: ChannelStatus) => void)[] = [];
+  /** In-memory conversation history per customer (keyed by "channel:phone") */
+  private customerBuffers = new Map<string, BufferedMessage[]>();
+  /** Debounce buffers per sender (keyed by "channel:sender") */
+  private debounceBuffers = new Map<string, DebounceEntry>();
+
+  constructor(opts: ChannelManagerOpts) {
+    this.opts = opts;
+  }
+
+  /** Initialize channels based on config */
+  async init(): Promise<void> {
+    const config = loadConfig();
+    const channelConfigs = config.channels;
+
+    if (!channelConfigs?.whatsapp?.enabled) {
+      log.info('[channels] WhatsApp not enabled — skipping');
+      return;
+    }
+
+    log.info('[channels] Initializing WhatsApp channel...');
+    const whatsapp = new WhatsAppChannel(
+      (sender, senderName, text, fromMe, isSelfChat) => this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe, isSelfChat),
+      (status) => this.handleStatusChange(status),
+      (audioBase64) => this.transcribeAudio(audioBase64),
+    );
+    this.providers.set('whatsapp', whatsapp);
+
+    // Auto-connect if credentials exist (previously linked)
+    if (whatsapp.hasCredentials()) {
+      try {
+        await whatsapp.connect();
+      } catch (err: any) {
+        log.warn(`[channels] WhatsApp auto-connect failed: ${err.message}`);
+      }
+    }
+  }
+
+  /** Start WhatsApp connection (triggers QR flow if no credentials) */
+  async connectWhatsApp(): Promise<void> {
+    let provider = this.providers.get('whatsapp');
+    if (!provider) {
+      const whatsapp = new WhatsAppChannel(
+        (sender, senderName, text, fromMe, isSelfChat) => this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe, isSelfChat),
+        (status) => this.handleStatusChange(status),
+        (audioBase64) => this.transcribeAudio(audioBase64),
+      );
+      this.providers.set('whatsapp', whatsapp);
+      provider = whatsapp;
+    }
+    await provider.connect();
+  }
+
+  /** Disconnect a specific channel */
+  async disconnectChannel(type: ChannelType): Promise<void> {
+    const provider = this.providers.get(type);
+    if (provider) {
+      await provider.disconnect();
+      this.providers.delete(type);
+    }
+  }
+
+  /** Disconnect all channels */
+  async disconnectAll(): Promise<void> {
+    for (const [, provider] of this.providers) {
+      await provider.disconnect();
+    }
+    this.providers.clear();
+  }
+
+  /** Send a message via a specific channel */
+  async sendMessage(channel: ChannelType, to: string, text: string): Promise<void> {
+    const provider = this.providers.get(channel);
+    if (!provider) throw new Error(`Channel ${channel} not available`);
+    await provider.sendMessage(to, text);
+  }
+
+  /** Show "typing..." indicator in a chat */
+  startTyping(channel: ChannelType, jid: string): void {
+    const provider = this.providers.get(channel);
+    if (provider && 'startTyping' in provider) {
+      (provider as WhatsAppChannel).startTyping(jid);
+    }
+  }
+
+  /** Get status of all channels */
+  getStatuses(): ChannelStatus[] {
+    return Array.from(this.providers.values()).map((p) => p.getStatus());
+  }
+
+  /** Get status of a specific channel */
+  getStatus(type: ChannelType): ChannelStatus | null {
+    return this.providers.get(type)?.getStatus() || null;
+  }
+
+  /** Get QR code SVG for a channel */
+  getQrCode(type: ChannelType): string | null {
+    return this.providers.get(type)?.getQrCode() || null;
+  }
+
+  /** Register a listener for status changes (used for WS broadcasting) */
+  onStatusChange(listener: (status: ChannelStatus) => void) {
+    this.statusListeners.push(listener);
+  }
+
+  /** Delete WhatsApp credentials and disconnect */
+  async logoutWhatsApp(): Promise<void> {
+    const provider = this.providers.get('whatsapp') as WhatsAppChannel | undefined;
+    if (provider) {
+      await provider.disconnect();
+      await provider.deleteCredentials();
+      this.providers.delete('whatsapp');
+    }
+  }
+
+  // ── Internal ──
+
+  private handleStatusChange(status: ChannelStatus) {
+    for (const listener of this.statusListeners) {
+      listener(status);
+    }
+  }
+
+  /** Get the channel config, re-reading from disk each time */
+  private getChannelConfig(channel: ChannelType): ChannelConfig | undefined {
+    const config = loadConfig();
+    return config.channels?.[channel];
+  }
+
+  /** Handle an incoming message from any channel — debounces rapid messages from the same sender */
+  private async handleInboundMessage(
+    channel: ChannelType,
+    sender: string,
+    senderName: string | undefined,
+    text: string,
+    fromMe: boolean,
+    isSelfChat: boolean,
+  ) {
+    const channelConfig = this.getChannelConfig(channel);
+    if (!channelConfig) return;
+
+    const mode = channelConfig.mode || 'channel';
+
+    // ── Channel mode: ONLY respond to self-chat ──
+    if (mode === 'channel') {
+      if (!fromMe || !isSelfChat) return;
+    }
+
+    // ── Business mode: filter outgoing (except self-chat) ──
+    if (mode === 'business' && fromMe && !isSelfChat) return;
+
+    // Debounce: accumulate rapid messages from the same sender
+    const debounceKey = `${channel}:${sender}`;
+    const existing = this.debounceBuffers.get(debounceKey);
+
+    if (existing) {
+      // Another message from the same sender — reset timer, append text
+      clearTimeout(existing.timer);
+      existing.messages.push(text);
+      existing.senderName = senderName || existing.senderName;
+      existing.timer = setTimeout(() => this.flushDebounce(debounceKey), DEBOUNCE_MS);
+      log.info(`[channels] Debounce: buffered message ${existing.messages.length} from ${sender}`);
+      return;
+    }
+
+    // First message from this sender — start debounce timer
+    const entry: DebounceEntry = {
+      messages: [text],
+      channel,
+      sender,
+      senderName,
+      fromMe,
+      isSelfChat,
+      timer: setTimeout(() => this.flushDebounce(debounceKey), DEBOUNCE_MS),
+    };
+    this.debounceBuffers.set(debounceKey, entry);
+  }
+
+  /** Flush debounced messages — combine and route to the appropriate handler */
+  private async flushDebounce(key: string) {
+    const entry = this.debounceBuffers.get(key);
+    if (!entry) return;
+    this.debounceBuffers.delete(key);
+
+    const { channel, sender, senderName, fromMe, isSelfChat, messages } = entry;
+    const combinedText = messages.join('\n');
+
+    const channelConfig = this.getChannelConfig(channel);
+    if (!channelConfig) return;
+
+    const mode = channelConfig.mode || 'channel';
+
+    // Route based on mode and role
+    if (mode === 'channel' || (mode === 'business' && fromMe && isSelfChat)) {
+      // Admin (self-chat in either mode)
+      const message: InboundMessage = {
+        channel,
+        sender: sender.replace(/@.*/, ''),
+        senderName,
+        role: 'admin',
+        text: combinedText,
+        rawSender: sender,
+      };
+
+      const modeLabel = mode === 'channel' ? 'Channel mode | self-chat' : 'Business mode | self-chat | admin';
+      log.info(`[channels] ${modeLabel} | "${combinedText.slice(0, 60)}"`);
+      await this.handleAdminMessage(message);
+      return;
+    }
+
+    // Business mode — incoming message
+    const role = this.resolveBusinessRole(channelConfig, sender);
+
+    const message: InboundMessage = {
+      channel,
+      sender: sender.replace(/@.*/, ''),
+      senderName,
+      role,
+      text: combinedText,
+      rawSender: sender,
+    };
+
+    log.info(`[channels] Business mode | ${message.sender} | role=${role} | "${combinedText.slice(0, 60)}"`);
+
+    if (role === 'admin') {
+      await this.handleAdminMessage(message);
+    } else {
+      await this.handleCustomerMessage(message, channelConfig);
+    }
+  }
+
+  /** Resolve role in business mode — check admins array */
+  private resolveBusinessRole(config: ChannelConfig, sender: string): SenderRole {
+    if (config.admins?.length) {
+      const senderPhone = sender.replace(/@.*/, '').replace(/[^0-9]/g, '');
+      for (const admin of config.admins) {
+        const adminPhone = admin.replace(/[^0-9]/g, '');
+        if (senderPhone === adminPhone || senderPhone.endsWith(adminPhone) || adminPhone.endsWith(senderPhone)) {
+          return 'admin';
+        }
+      }
+    }
+
+    return 'customer';
+  }
+
+  /** Handle message from an admin — mirrors to chat conversation, uses main system prompt */
+  private async handleAdminMessage(msg: InboundMessage) {
+    const { workerApi, broadcastBloby, getModel } = this.opts;
+    const model = getModel();
+
+    // Get or create conversation (shared with chat for mirroring)
+    let convId: string | undefined;
+    try {
+      const ctx = await workerApi('/api/context/current');
+      if (ctx.conversationId) {
+        convId = ctx.conversationId;
+      } else {
+        const conv = await workerApi('/api/conversations', 'POST', { title: 'WhatsApp', model });
+        convId = conv.id;
+        await workerApi('/api/context/set', 'POST', { conversationId: convId });
+      }
+    } catch (err: any) {
+      log.warn(`[channels] Failed to get/create conversation: ${err.message}`);
+      return;
+    }
+
+    // Save user message to DB
+    try {
+      await workerApi(`/api/conversations/${convId}/messages`, 'POST', {
+        role: 'user',
+        content: msg.text,
+        meta: { model, channel: msg.channel },
+      });
+    } catch (err: any) {
+      log.warn(`[channels] DB persist error: ${err.message}`);
+    }
+
+    // Broadcast to chat clients (mirroring)
+    broadcastBloby('chat:sync', {
+      conversationId: convId,
+      message: { role: 'user', content: msg.text, timestamp: new Date().toISOString() },
+    });
+
+    // Fetch names and recent messages
+    let botName = 'Bloby', humanName = 'Human';
+    let recentMessages: RecentMessage[] = [];
+    try {
+      const [status, recentRaw] = await Promise.all([
+        workerApi('/api/onboard/status'),
+        workerApi(`/api/conversations/${convId}/messages/recent?limit=20`),
+      ]);
+      botName = status.agentName || 'Bloby';
+      humanName = status.userName || 'Human';
+      if (Array.isArray(recentRaw)) {
+        const filtered = recentRaw.filter((m: any) => m.role === 'user' || m.role === 'assistant');
+        if (filtered.length > 0) {
+          recentMessages = filtered.slice(0, -1).map((m: any) => ({
+            role: m.role as 'user' | 'assistant',
+            content: m.content,
+          }));
+        }
+      }
+    } catch {}
+
+    // Channel context — tells the agent this is a WhatsApp message, respond naturally
+    const channelContext = `[WhatsApp | ${msg.sender} | admin]\n`;
+
+    // Show "typing..." while the agent processes
+    this.startTyping(msg.channel, msg.rawSender);
+
+    // Track text chunks for WhatsApp — send intermediate chunks when agent pauses for tool use
+    let waChunkBuf = '';
+
+    startBlobyAgentQuery(
+      convId,
+      channelContext + msg.text,
+      model,
+      (type, eventData) => {
+        // Accumulate text tokens
+        if (type === 'bot:token' && eventData.token) {
+          waChunkBuf += eventData.token;
+        }
+
+        // Agent paused to use a tool — send accumulated text as an intermediate WhatsApp message
+        if (type === 'bot:tool' && waChunkBuf.trim()) {
+          this.sendMessage(msg.channel, msg.rawSender, waChunkBuf.trim()).catch((err) => {
+            log.warn(`[channels] Failed to send WhatsApp chunk: ${err.message}`);
+          });
+          waChunkBuf = '';
+        }
+
+        if (type === 'bot:response' && eventData.content) {
+          // Send remaining text after the last tool use (or the full response if no tools were used)
+          const remaining = waChunkBuf.trim();
+          if (remaining) {
+            this.sendMessage(msg.channel, msg.rawSender, remaining).catch((err) => {
+              log.warn(`[channels] Failed to send WhatsApp reply: ${err.message}`);
+            });
+            waChunkBuf = '';
+          }
+
+          // Save full response to DB
+          workerApi(`/api/conversations/${convId}/messages`, 'POST', {
+            role: 'assistant',
+            content: eventData.content,
+            meta: { model },
+          }).catch(() => {});
+        }
+
+        // Mirror streaming to chat clients
+        if (type === 'bot:token' || type === 'bot:response' || type === 'bot:typing' || type === 'bot:tool') {
+          broadcastBloby(type, eventData);
+        }
+
+        if (type === 'bot:done' && eventData.usedFileTools) {
+          this.opts.restartBackend();
+        }
+      },
+      undefined,
+      undefined,
+      { botName, humanName },
+      recentMessages,
+    );
+  }
+
+  /** Handle message from a customer — runs support agent in parallel with conversation context */
+  private async handleCustomerMessage(msg: InboundMessage, channelConfig: ChannelConfig) {
+    const agentKey = `${msg.channel}:${msg.sender}`;
+
+    // Check concurrent limit
+    if (this.activeAgents.size >= MAX_CONCURRENT_AGENTS && !this.activeAgents.has(agentKey)) {
+      log.info(`[channels] Max concurrent agents reached — queuing message from ${msg.sender}`);
+      this.messageQueue.push(msg);
+      return;
+    }
+
+    const { workerApi, getModel } = this.opts;
+    const model = getModel();
+
+    // Load the active skill's SCRIPT.md as the customer-facing system prompt
+    const scriptPrompt = this.loadActiveScript(channelConfig);
+
+    // Fetch agent name
+    let botName = 'Bloby', humanName = 'Human';
+    try {
+      const status = await workerApi('/api/onboard/status');
+      botName = status.agentName || 'Bloby';
+      humanName = status.userName || 'Human';
+    } catch {}
+
+    // Get or create conversation buffer for this customer
+    let buffer = this.customerBuffers.get(agentKey);
+    if (!buffer) {
+      buffer = [];
+      this.customerBuffers.set(agentKey, buffer);
+    }
+
+    // Add the new user message to the buffer
+    buffer.push({ role: 'user', content: msg.text });
+
+    // Trim buffer to max size
+    if (buffer.length > MAX_BUFFER_MESSAGES) {
+      buffer.splice(0, buffer.length - MAX_BUFFER_MESSAGES);
+    }
+
+    // Build recent messages for context (everything except the last one, which is the current message)
+    const recentMessages: RecentMessage[] = buffer.length > 1
+      ? buffer.slice(0, -1).map((m) => ({ role: m.role, content: m.content }))
+      : [];
+
+    // Load long-term memory from the skill's customer_data directory
+    let customerMemory = '';
+    try {
+      const customerDataDir = this.getSkillCustomerDataDir(channelConfig);
+      if (customerDataDir) {
+        const memoryPath = path.join(WORKSPACE_DIR, customerDataDir, `${msg.sender}.md`);
+        if (fs.existsSync(memoryPath)) {
+          customerMemory = fs.readFileSync(memoryPath, 'utf-8').trim();
+        }
+      }
+    } catch {}
+
+    const channelContext = `[WhatsApp | ${msg.sender} | customer${msg.senderName ? ` | ${msg.senderName}` : ''}]\n`;
+
+    // Stable convId per customer (not per message)
+    const convId = `channel-${agentKey}`;
+
+    this.activeAgents.set(agentKey, { sender: msg.sender, channel: msg.channel });
+
+    // Show "typing..." while the agent processes
+    this.startTyping(msg.channel, msg.rawSender);
+
+    // Build an enriched script prompt with customer memory if available
+    let enrichedScript = scriptPrompt;
+    if (customerMemory && enrichedScript) {
+      enrichedScript += `\n\n---\n# Customer History (${msg.sender})\n\n${customerMemory}`;
+    }
+
+    // Track text chunks for WhatsApp — send intermediate chunks when agent pauses for tool use
+    let waChunkBuf = '';
+
+    startBlobyAgentQuery(
+      convId,
+      channelContext + msg.text,
+      model,
+      (type, eventData) => {
+        // Accumulate text tokens
+        if (type === 'bot:token' && eventData.token) {
+          waChunkBuf += eventData.token;
+        }
+
+        // Agent paused to use a tool — send accumulated text as an intermediate WhatsApp message
+        if (type === 'bot:tool' && waChunkBuf.trim()) {
+          this.sendMessage(msg.channel, msg.rawSender, waChunkBuf.trim()).catch((err) => {
+            log.warn(`[channels] Failed to send WhatsApp chunk: ${err.message}`);
+          });
+          waChunkBuf = '';
+        }
+
+        if (type === 'bot:response' && eventData.content) {
+          // Add full response to the conversation buffer
+          buffer!.push({ role: 'assistant', content: eventData.content });
+          if (buffer!.length > MAX_BUFFER_MESSAGES) {
+            buffer!.splice(0, buffer!.length - MAX_BUFFER_MESSAGES);
+          }
+
+          // Send remaining text after the last tool use (or full response if no tools were used)
+          const remaining = waChunkBuf.trim();
+          if (remaining) {
+            this.sendMessage(msg.channel, msg.rawSender, remaining).catch((err) => {
+              log.warn(`[channels] Failed to send customer reply: ${err.message}`);
+            });
+            waChunkBuf = '';
+          }
+        }
+
+        if (type === 'bot:done') {
+          this.activeAgents.delete(agentKey);
+          if (eventData.usedFileTools) this.opts.restartBackend();
+          this.processQueue();
+        }
+      },
+      undefined,
+      undefined,
+      { botName, humanName },
+      recentMessages,
+      enrichedScript,
+    );
+  }
+
+  /** Transcribe audio via the existing whisper endpoint */
+  private async transcribeAudio(audioBase64: string): Promise<string | null> {
+    try {
+      const result = await this.opts.workerApi('/api/whisper/transcribe', 'POST', { audio: audioBase64 });
+      if (result.error) {
+        log.warn(`[channels] Whisper error: ${result.error}`);
+        return null;
+      }
+      return result.transcript || null;
+    } catch (err: any) {
+      log.warn(`[channels] Whisper transcription failed: ${err.message}`);
+      return null;
+    }
+  }
+
+  /** Read customer_data directory from a skill's skill.json */
+  private getSkillCustomerDataDir(channelConfig: ChannelConfig): string | undefined {
+    const skillName = channelConfig.skill;
+    if (!skillName) return undefined;
+
+    try {
+      const skillJsonPath = path.join(WORKSPACE_DIR, 'skills', skillName, 'skill.json');
+      if (fs.existsSync(skillJsonPath)) {
+        const skillJson = JSON.parse(fs.readFileSync(skillJsonPath, 'utf-8'));
+        if (skillJson.customer_data) return skillJson.customer_data;
+      }
+    } catch {}
+    return undefined;
+  }
+
+  /** Load SCRIPT.md from the active skill configured for this channel */
+  private loadActiveScript(channelConfig: ChannelConfig): string | undefined {
+    const skillName = channelConfig.skill;
+    if (!skillName) {
+      log.warn('[channels] No active skill configured — customer will get no script');
+      return undefined;
+    }
+
+    const scriptPath = path.join(WORKSPACE_DIR, 'skills', skillName, 'SCRIPT.md');
+    try {
+      if (fs.existsSync(scriptPath)) {
+        const content = fs.readFileSync(scriptPath, 'utf-8').trim();
+        if (content) {
+          log.info(`[channels] Loaded SCRIPT.md from skill: ${skillName}`);
+          return content;
+        }
+      }
+      log.warn(`[channels] SCRIPT.md not found in skill: ${skillName}`);
+    } catch (err: any) {
+      log.warn(`[channels] Failed to load SCRIPT.md from ${skillName}: ${err.message}`);
+    }
+    return undefined;
+  }
+
+  /** Process queued messages when an agent slot frees up */
+  private processQueue() {
+    while (this.messageQueue.length > 0 && this.activeAgents.size < MAX_CONCURRENT_AGENTS) {
+      const queued = this.messageQueue.shift()!;
+      const config = this.getChannelConfig(queued.channel);
+      if (!config) continue;
+      log.info(`[channels] Processing queued message from ${queued.sender}`);
+      this.handleCustomerMessage(queued, config);
+    }
+  }
+}

package/supervisor/channels/types.ts

@@ -0,0 +1,59 @@
+/**
+ * Shared types for the multi-channel messaging system.
+ */
+
+export type ChannelType = 'whatsapp' | 'telegram';
+export type SenderRole = 'admin' | 'customer';
+
+export interface ChannelConfig {
+  enabled: boolean;
+  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer mode */
+  mode: 'channel' | 'business';
+  /** Phone numbers with admin access (owner, secretary, etc.) — business mode only */
+  admins?: string[];
+  /** Active skill for customer-facing mode (folder name in workspace/skills/) */
+  skill?: string;
+}
+
+export interface InboundMessage {
+  channel: ChannelType;
+  /** Sender identifier (phone number) */
+  sender: string;
+  /** Sender display name if available */
+  senderName?: string;
+  /** Resolved role of the sender */
+  role: SenderRole;
+  /** Message text content */
+  text: string;
+  /** Raw sender JID (channel-specific format, used for replies) */
+  rawSender: string;
+}
+
+export interface OutboundMessage {
+  channel: ChannelType;
+  to: string;
+  text: string;
+}
+
+export interface ChannelStatus {
+  channel: ChannelType;
+  connected: boolean;
+  /** Additional info like phone number, QR state, etc. */
+  info?: Record<string, any>;
+}
+
+export interface ChannelProvider {
+  readonly type: ChannelType;
+  /** Start the channel connection (may trigger QR flow) */
+  connect(): Promise<void>;
+  /** Disconnect and clean up */
+  disconnect(): Promise<void>;
+  /** Send a text message */
+  sendMessage(to: string, text: string): Promise<void>;
+  /** Get current connection status */
+  getStatus(): ChannelStatus;
+  /** Get current QR code data (base64 SVG) or null if not in QR state */
+  getQrCode(): string | null;
+  /** Whether auth credentials exist (previously connected) */
+  hasCredentials(): boolean;
+}