fluxy-bot 0.15.0 → 0.15.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluxy-bot",
-  "version": "0.15.0",
+  "version": "0.15.2",
   "releaseNotes": [
     "1. react router implemented",
     "2. new workspace design",
@@ -55,6 +55,7 @@
     "@clack/prompts": "^1.1.0",
     "@tailwindcss/vite": "^4.2.0",
     "@vitejs/plugin-react": "^6.0.1",
+    "@whiskeysockets/baileys": "^7.0.0-rc.9",
     "better-sqlite3": "^12.6.2",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",

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,6 +1,14 @@
 import fs from 'fs';
 import { paths, DATA_DIR } from './paths.js';
 
+export interface ChannelConfig {
+  enabled: boolean;
+  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer support */
+  mode: 'channel' | 'business';
+  /** Phone numbers with admin access (owner, secretary, etc.) — business mode only */
+  admins?: string[];
+}
+
 export interface BotConfig {
   port: number;
   username: string;
@@ -25,6 +33,9 @@ export interface BotConfig {
     privateKey: string;
     address: string;
   };
+  channels?: {
+    whatsapp?: ChannelConfig;
+  };
   tunnelUrl?: string;
 }
 

package/supervisor/channels/manager.ts

@@ -0,0 +1,414 @@
+/**
+ * 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: Fluxy 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 { 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;
+}
+
+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.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) => 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) {
+      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);
+    }
+  }
+
+  /** 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 */
+  private async handleInboundMessage(
+    channel: ChannelType,
+    sender: string,
+    senderName: string | undefined,
+    text: string,
+    fromMe: boolean,
+  ) {
+    const channelConfig = this.getChannelConfig(channel);
+    if (!channelConfig) return;
+
+    const mode = channelConfig.mode || 'channel';
+
+    // ── Channel mode: only respond to self-chat (fromMe=true) ──
+    if (mode === 'channel') {
+      if (!fromMe) {
+        // Ignore messages from other people — this is the user's personal WhatsApp
+        return;
+      }
+
+      const message: InboundMessage = {
+        channel,
+        sender: sender.replace(/@.*/, ''),
+        senderName,
+        role: 'admin',
+        text,
+        rawSender: sender,
+      };
+
+      log.info(`[channels] Channel mode | self-chat | "${text.slice(0, 60)}"`);
+      await this.handleAdminMessage(message);
+      return;
+    }
+
+    // ── Business mode: resolve role based on admins array ──
+    const role = this.resolveBusinessRole(channelConfig, sender, fromMe);
+
+    const message: InboundMessage = {
+      channel,
+      sender: sender.replace(/@.*/, ''),
+      senderName,
+      role,
+      text,
+      rawSender: sender,
+    };
+
+    log.info(`[channels] Business mode | ${message.sender} | role=${role} | "${text.slice(0, 60)}"`);
+
+    if (role === 'admin') {
+      await this.handleAdminMessage(message);
+    } else {
+      await this.handleCustomerMessage(message);
+    }
+  }
+
+  /** Resolve role in business mode — check admins array */
+  private resolveBusinessRole(config: ChannelConfig, sender: string, fromMe: boolean): SenderRole {
+    // fromMe is always admin (the number Fluxy is connected with)
+    if (fromMe) return 'admin';
+
+    // Check admins array
+    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, broadcastFluxy, 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)
+    broadcastFluxy('chat:sync', {
+      conversationId: convId,
+      message: { role: 'user', content: msg.text, timestamp: new Date().toISOString() },
+    });
+
+    // Fetch 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 {}
+
+    // Channel context — tells the agent this is a WhatsApp message, respond naturally
+    const channelContext = `[WhatsApp | ${msg.sender} | admin]\n`;
+
+    startFluxyAgentQuery(
+      convId,
+      channelContext + msg.text,
+      model,
+      (type, eventData) => {
+        if (type === 'bot:response' && eventData.content) {
+          // Send agent's 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)) {
+      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 name
+    let botName = 'Fluxy', humanName = 'Human';
+    try {
+      const status = await workerApi('/api/onboard/status');
+      botName = status.agentName || 'Fluxy';
+      humanName = status.userName || 'Human';
+    } catch {}
+
+    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) {
+          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();
+          this.processQueue();
+        }
+      },
+      undefined,
+      undefined,
+      { botName, humanName },
+      undefined,
+      supportPrompt,
+    );
+  }
+
+  /** Load customer-facing system prompt from skills */
+  private loadSupportPrompt(): string | undefined {
+    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

@@ -0,0 +1,57 @@
+/**
+ * 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 support */
+  mode: 'channel' | 'business';
+  /** Phone numbers with admin access (owner, secretary, etc.) — business mode only */
+  admins?: 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;
+}