fluxy-bot 0.13.6 → 0.15.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluxy-bot",
-  "version": "0.13.6",
+  "version": "0.15.1",
   "releaseNotes": [
     "1. react router implemented",
     "2. new workspace design",

package/scripts/install.ps1

@@ -244,6 +244,17 @@ function Install-Fluxy {
     } catch {}
     Pop-Location
 
+    # Install workspace dependencies (rebuilds native modules for this platform)
+    $wsDir = Join-Path $FLUXY_HOME "workspace"
+    if (Test-Path (Join-Path $wsDir "package.json")) {
+        Write-Down "Installing workspace dependencies..."
+        Push-Location $wsDir
+        try {
+            & $NPM install --omit=dev 2>$null
+        } catch {}
+        Pop-Location
+    }
+
     # Verify
     $cliPath = Join-Path $FLUXY_HOME "bin\cli.js"
     if (-not (Test-Path $cliPath)) {

package/scripts/install.sh

@@ -203,6 +203,12 @@ install_fluxy() {
   printf "  ${BLUE}↓${RESET}  Installing dependencies...\n"
   (cd "$FLUXY_HOME" && "$NPM" install --omit=dev 2>/dev/null)
 
+  # Install workspace dependencies (rebuilds native modules for this platform)
+  if [ -f "$FLUXY_HOME/workspace/package.json" ]; then
+    printf "  ${BLUE}↓${RESET}  Installing workspace dependencies...\n"
+    (cd "$FLUXY_HOME/workspace" && "$NPM" install --omit=dev 2>/dev/null)
+  fi
+
   # Verify
   if [ ! -f "$FLUXY_HOME/bin/cli.js" ]; then
     printf "  ${RED}✗${RESET}  Installation failed\n"

package/shared/config.ts

@@ -1,7 +1,13 @@
 import fs from 'fs';
 import { paths, DATA_DIR } from './paths.js';
 
-export type ChannelType = 'chat' | 'whatsapp' | 'telegram';
+export interface ChannelConfig {
+  enabled: boolean;
+  /** 'shared' = user's own number, 'dedicated' = Fluxy has its own number */
+  mode: 'shared' | 'dedicated';
+  /** The human/owner's phone number (used for role resolution in dedicated mode) */
+  humanPhone?: string;
+}
 
 export interface BotConfig {
   port: number;
@@ -27,17 +33,10 @@ export interface BotConfig {
     privateKey: string;
     address: string;
   };
-  tunnelUrl?: string;
   channels?: {
-    whatsapp?: { enabled: boolean };
-    telegram?: { enabled: boolean; botToken?: string };
-  };
-  customerMode?: {
-    enabled: boolean;
-    systemPromptFile?: string;
-    businessName?: string;
-    businessDescription?: string;
+    whatsapp?: ChannelConfig;
   };
+  tunnelUrl?: string;
 }
 
 const DEFAULTS: BotConfig = {

package/supervisor/channels/manager.ts

@@ -0,0 +1,393 @@
+/**
+ * Channel Manager — orchestrates multi-channel messaging.
+ *
+ * Responsibilities:
+ * - Manages channel providers (WhatsApp, Telegram, etc.)
+ * - Resolves sender role (human vs customer)
+ * - Routes inbound messages to the agent with appropriate system prompt
+ * - Routes outbound messages from agent/API back to channels
+ * - Manages parallel agent instances for customer conversations
+ */
+
+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 { startFluxyAgentQuery, type RecentMessage } from '../fluxy-agent.js';
+import { WhatsAppChannel } from './whatsapp.js';
+import type { ChannelConfig, ChannelProvider, ChannelStatus, ChannelType, InboundMessage, SenderRole } from './types.js';
+
+const MAX_CONCURRENT_AGENTS = 5;
+
+interface ChannelManagerOpts {
+  broadcastFluxy: (type: string, data: any) => void;
+  workerApi: (path: string, method?: string, body?: any) => Promise<any>;
+  restartBackend: () => void;
+  getModel: () => string;
+}
+
+interface ActiveAgentQuery {
+  sender: string;
+  channel: ChannelType;
+  abortController?: AbortController;
+}
+
+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)[] = [];
+
+  constructor(opts: ChannelManagerOpts) {
+    this.opts = opts;
+  }
+
+  /** Initialize channels based on config */
+  async init(): Promise<void> {
+    const config = loadConfig();
+    const channelConfigs = (config as any).channels as Record<string, ChannelConfig> | undefined;
+
+    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) => this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe),
+      (status) => this.handleStatusChange(status),
+    );
+    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) {
+      // Create provider on-demand if not initialized
+      const whatsapp = new WhatsAppChannel(
+        (sender, senderName, text, fromMe) => this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe),
+        (status) => this.handleStatusChange(status),
+      );
+      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);
+  }
+
+  /** 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);
+    }
+  }
+
+  /** Resolve sender role based on channel config */
+  private resolveRole(channel: ChannelType, sender: string, fromMe: boolean): SenderRole {
+    const config = loadConfig();
+    const channelConfigs = (config as any).channels as Record<string, ChannelConfig> | undefined;
+    const channelConfig = channelConfigs?.[channel];
+
+    if (!channelConfig) return 'customer';
+
+    if (channelConfig.mode === 'shared') {
+      // Shared number mode: fromMe messages are from the human
+      return fromMe ? 'human' : 'customer';
+    }
+
+    // Dedicated number mode: check if sender matches human's phone
+    if (channelConfig.humanPhone) {
+      const senderPhone = sender.replace(/@.*/, '').replace(/[^0-9]/g, '');
+      const humanPhone = channelConfig.humanPhone.replace(/[^0-9]/g, '');
+      if (senderPhone === humanPhone) return 'human';
+    }
+
+    return 'customer';
+  }
+
+  /** Handle an incoming message from any channel */
+  private async handleInboundMessage(
+    channel: ChannelType,
+    sender: string,
+    senderName: string | undefined,
+    text: string,
+    fromMe: boolean,
+  ) {
+    const role = this.resolveRole(channel, sender, fromMe);
+
+    const message: InboundMessage = {
+      channel,
+      sender: sender.replace(/@.*/, ''),
+      senderName,
+      role,
+      text,
+      rawSender: sender,
+    };
+
+    log.info(`[channels] Inbound ${channel} | ${message.sender} | role=${role} | "${text.slice(0, 60)}"`);
+
+    if (role === 'human') {
+      await this.handleHumanMessage(message);
+    } else {
+      await this.handleCustomerMessage(message);
+    }
+  }
+
+  /** Handle message from the human/owner — mirrors to chat conversation */
+  private async handleHumanMessage(msg: InboundMessage) {
+    const { workerApi, broadcastFluxy, getModel } = this.opts;
+    const model = getModel();
+
+    // Get or create the human's WhatsApp conversation (mirrored with chat)
+    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)
+    broadcastFluxy('chat:sync', {
+      conversationId: convId,
+      message: { role: 'user', content: msg.text, timestamp: new Date().toISOString() },
+    });
+
+    // Fetch agent/user names and recent messages
+    let botName = 'Fluxy', 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 || 'Fluxy';
+      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 {}
+
+    // Run agent with main system prompt (same as chat)
+    const channelContext = `[WhatsApp | ${msg.sender} | human]\n`;
+
+    startFluxyAgentQuery(
+      convId,
+      channelContext + msg.text,
+      model,
+      (type, eventData) => {
+        if (type === 'bot:response' && eventData.content) {
+          // Send response back via WhatsApp
+          this.sendMessage(msg.channel, msg.rawSender, eventData.content).catch((err) => {
+            log.warn(`[channels] Failed to send WhatsApp reply: ${err.message}`);
+          });
+
+          // Save 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') {
+          broadcastFluxy(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 */
+  private async handleCustomerMessage(msg: InboundMessage) {
+    const agentKey = `${msg.channel}:${msg.sender}`;
+
+    // Check concurrent limit
+    if (this.activeAgents.size >= MAX_CONCURRENT_AGENTS && !this.activeAgents.has(agentKey)) {
+      // Queue the message
+      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 support system prompt from skill
+    const supportPrompt = this.loadSupportPrompt();
+
+    // Fetch agent/user names
+    let botName = 'Fluxy', humanName = 'Human';
+    try {
+      const status = await workerApi('/api/onboard/status');
+      botName = status.agentName || 'Fluxy';
+      humanName = status.userName || 'Human';
+    } catch {}
+
+    // Build channel context
+    const channelContext = `[WhatsApp | ${msg.sender} | customer${msg.senderName ? ` | ${msg.senderName}` : ''}]\n`;
+    const convId = `channel-${agentKey}-${Date.now()}`;
+
+    this.activeAgents.set(agentKey, { sender: msg.sender, channel: msg.channel });
+
+    startFluxyAgentQuery(
+      convId,
+      channelContext + msg.text,
+      model,
+      (type, eventData) => {
+        if (type === 'bot:response' && eventData.content) {
+          // Send response back via WhatsApp
+          this.sendMessage(msg.channel, msg.rawSender, eventData.content).catch((err) => {
+            log.warn(`[channels] Failed to send customer reply: ${err.message}`);
+          });
+        }
+
+        if (type === 'bot:done') {
+          this.activeAgents.delete(agentKey);
+
+          if (eventData.usedFileTools) {
+            this.opts.restartBackend();
+          }
+
+          // Process queued messages
+          this.processQueue();
+        }
+      },
+      undefined,
+      undefined,
+      { botName, humanName },
+      undefined,
+      supportPrompt,
+    );
+  }
+
+  /** Load customer-facing system prompt from skills */
+  private loadSupportPrompt(): string | undefined {
+    // Look for SUPPORT.md in any skill directory
+    const skillsDir = path.join(WORKSPACE_DIR, 'skills');
+    try {
+      for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        const supportPath = path.join(skillsDir, entry.name, 'SUPPORT.md');
+        if (fs.existsSync(supportPath)) {
+          const content = fs.readFileSync(supportPath, 'utf-8').trim();
+          if (content) {
+            log.info(`[channels] Loaded support prompt from skill: ${entry.name}`);
+            return content;
+          }
+        }
+      }
+    } catch {}
+    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()!;
+      log.info(`[channels] Processing queued message from ${queued.sender}`);
+      this.handleCustomerMessage(queued);
+    }
+  }
+}

package/supervisor/channels/types.ts

@@ -1,55 +1,57 @@
 /**
- * Multi-channel communication types.
- * Defines the channel abstraction, message formats, and role system.
+ * Shared types for the multi-channel messaging system.
  */
 
-export type ChannelType = 'chat' | 'whatsapp' | 'telegram';
-export type SenderRole = 'owner' | 'admin' | 'customer';
+export type ChannelType = 'whatsapp' | 'telegram';
+export type SenderRole = 'human' | 'customer';
 
-export interface SenderIdentity {
-  channelType: ChannelType;
-  senderId: string;         // phone number, telegram ID, 'owner' for chat
-  displayName: string;
-  role: SenderRole;
-  conversationKey: string;  // "whatsapp:+5511999999999", "chat:owner"
+export interface ChannelConfig {
+  enabled: boolean;
+  /** 'shared' = user's own number, 'dedicated' = Fluxy has its own number */
+  mode: 'shared' | 'dedicated';
+  /** The human/owner's phone number (used for role resolution in dedicated mode) */
+  humanPhone?: string;
 }
 
-export interface IncomingMessage {
-  sender: SenderIdentity;
-  content: string;
-  timestamp: number;
-  attachments?: Array<{
-    type: 'image' | 'file' | 'audio';
-    name: string;
-    mediaType: string;
-    data: string; // base64
-  }>;
+export interface InboundMessage {
+  channel: ChannelType;
+  /** Sender identifier (phone number / JID) */
+  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) */
+  rawSender: string;
 }
 
-export interface OutgoingMessage {
-  content: string;
-  conversationKey: string;
+export interface OutboundMessage {
+  channel: ChannelType;
+  to: string;
+  text: string;
 }
 
-// Forward reference — ChannelRouter is imported by channel implementations
-export interface ChannelRouter {
-  handleIncoming(message: IncomingMessage): Promise<void>;
-  routePulseMessage(content: string, title?: string, priority?: string): Promise<void>;
-  getChannelForConversation(conversationKey: string): Channel | undefined;
+export interface ChannelStatus {
+  channel: ChannelType;
+  connected: boolean;
+  /** Additional info like phone number, QR state, etc. */
+  info?: Record<string, any>;
 }
 
-export interface Channel {
+export interface ChannelProvider {
   readonly type: ChannelType;
-
-  /** Initialize the channel (connect socket, start webhook listener, etc.) */
-  initialize(router: ChannelRouter): Promise<void>;
-
-  /** Send a message back through this channel */
-  sendMessage(to: string, message: OutgoingMessage): Promise<void>;
-
-  /** Check if this channel owns a given conversation key */
-  ownsConversation(conversationKey: string): boolean;
-
-  /** Graceful shutdown */
-  shutdown(): Promise<void>;
+  /** 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;
 }