fluxy-bot 0.13.2 → 0.13.5

package/package.json

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

package/supervisor/channels/index.ts

@@ -7,7 +7,6 @@ import { log } from '../../shared/logger.js';
 import { initRoleResolver } from './role-resolver.js';
 import { ChannelRouter, type ChannelRouterOpts } from './router.js';
 import { ChatChannel } from './chat-channel.js';
-import { WhatsAppChannel } from './whatsapp-channel.js';
 
 export { ChannelRouter } from './router.js';
 export type { Channel, ChannelType, SenderRole, SenderIdentity, IncomingMessage, OutgoingMessage } from './types.js';
@@ -30,17 +29,20 @@ export async function initializeChannels(
   router.registerChannel(chatChannel);
   await chatChannel.initialize(router);
 
-  // WhatsApp channel — registered if enabled in config
+  // WhatsApp channel — dynamic import so supervisor starts even without baileys installed
   if (config.channels?.whatsapp?.enabled) {
     try {
+      const { WhatsAppChannel } = await import('./whatsapp-channel.js');
       const waChannel = new WhatsAppChannel((qr) => {
-        // Broadcast QR to chat UI so owner can scan from dashboard
         opts.broadcastFluxy('whatsapp:qr', { qr });
       });
       router.registerChannel(waChannel);
       await waChannel.initialize(router);
     } catch (err: any) {
       log.warn(`[channels] WhatsApp initialization failed: ${err.message}`);
+      if (err.code === 'ERR_MODULE_NOT_FOUND') {
+        log.warn('[channels] Install baileys: npm install @whiskeysockets/baileys');
+      }
     }
   }
 

package/supervisor/channels/whatsapp-channel.ts

@@ -2,95 +2,116 @@
  * WhatsApp Channel — Baileys adapter for WhatsApp Web.
  * Receives messages, routes through ChannelRouter, sends responses back.
  * Session persisted in ~/.fluxy/whatsapp-session/.
+ *
+ * Baileys is imported dynamically so the supervisor starts even if
+ * @whiskeysockets/baileys is not installed.
  */
 
-import makeWASocket, {
-  useMultiFileAuthState,
-  DisconnectReason,
-  type WASocket,
-} from '@whiskeysockets/baileys';
-import { Boom } from '@hapi/boom';
 import path from 'path';
 import { DATA_DIR } from '../../shared/paths.js';
 import { log } from '../../shared/logger.js';
 import type { Channel, ChannelRouter, OutgoingMessage } from './types.js';
 
 const SESSION_DIR = path.join(DATA_DIR, 'whatsapp-session');
+const MAX_RECONNECT_ATTEMPTS = 5;
+const RECONNECT_BASE_DELAY = 5_000; // 5s, doubles each retry
 
 export class WhatsAppChannel implements Channel {
   readonly type = 'whatsapp' as const;
-  private sock: WASocket | null = null;
+  private sock: any = null;
   private router: ChannelRouter | null = null;
   private onQR?: (qr: string) => void;
-  private reconnecting = false;
+  private reconnectAttempts = 0;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private shuttingDown = false;
 
-  /**
-   * @param onQR - Optional callback to surface QR code to the chat UI
-   */
   constructor(onQR?: (qr: string) => void) {
     this.onQR = onQR;
   }
 
   async initialize(router: ChannelRouter): Promise<void> {
     this.router = router;
-    await this.connect();
+    try {
+      await this.connect();
+    } catch (err: any) {
+      // Don't let baileys crash the supervisor — log and move on
+      log.warn(`[whatsapp] Initial connection failed: ${err.message}`);
+      log.warn('[whatsapp] WhatsApp will remain inactive. Restart Fluxy after scanning QR to retry.');
+    }
   }
 
   private async connect(): Promise<void> {
+    if (this.shuttingDown) return;
+
+    const baileys = await import('@whiskeysockets/baileys');
+    const makeWASocket = baileys.default;
+    const { useMultiFileAuthState, DisconnectReason } = baileys;
+
     const { state, saveCreds } = await useMultiFileAuthState(SESSION_DIR);
 
     this.sock = makeWASocket({
       auth: state,
-      printQRInTerminal: true,
+      // printQRInTerminal is deprecated in baileys v7 — we handle QR via connection.update
     });
 
     this.sock.ev.on('creds.update', saveCreds);
 
-    this.sock.ev.on('connection.update', (update) => {
+    this.sock.ev.on('connection.update', (update: any) => {
       const { connection, lastDisconnect, qr } = update;
 
-      // Surface QR to chat UI for scanning
-      if (qr && this.onQR) {
-        this.onQR(qr);
+      // Handle QR code — surface it to chat UI
+      if (qr) {
+        log.info('[whatsapp] QR code received — scan with your phone to link');
+        if (this.onQR) this.onQR(qr);
       }
 
       if (connection === 'close') {
-        const statusCode = (lastDisconnect?.error as Boom)?.output?.statusCode;
-        const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
-
-        log.warn(`[whatsapp] Connection closed: ${statusCode}. Reconnect: ${shouldReconnect}`);
-
-        if (shouldReconnect && !this.reconnecting) {
-          this.reconnecting = true;
-          setTimeout(() => {
-            this.reconnecting = false;
-            this.connect().catch((err) => {
-              log.warn(`[whatsapp] Reconnect failed: ${err.message}`);
-            });
-          }, 5000);
-        } else if (!shouldReconnect) {
-          log.warn('[whatsapp] Logged out — scan QR again to reconnect');
+        const statusCode = (lastDisconnect?.error as any)?.output?.statusCode;
+        const isLoggedOut = statusCode === DisconnectReason.loggedOut;
+
+        if (isLoggedOut) {
+          log.warn('[whatsapp] Logged out. Scan QR again to reconnect.');
+          this.sock = null;
+          return;
+        }
+
+        this.reconnectAttempts++;
+
+        if (this.reconnectAttempts > MAX_RECONNECT_ATTEMPTS) {
+          log.warn(`[whatsapp] Max reconnect attempts (${MAX_RECONNECT_ATTEMPTS}) reached. Giving up.`);
+          log.warn('[whatsapp] WhatsApp will remain inactive. Restart Fluxy to retry.');
+          this.sock = null;
+          return;
         }
+
+        // Exponential backoff: 5s, 10s, 20s, 40s, 80s
+        const delay = RECONNECT_BASE_DELAY * Math.pow(2, this.reconnectAttempts - 1);
+        log.warn(`[whatsapp] Connection closed (${statusCode}). Reconnecting in ${delay / 1000}s (attempt ${this.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
+
+        this.reconnectTimer = setTimeout(() => {
+          this.reconnectTimer = null;
+          this.connect().catch((err) => {
+            log.warn(`[whatsapp] Reconnect failed: ${err.message}`);
+          });
+        }, delay);
       }
 
       if (connection === 'open') {
         log.ok('[whatsapp] Connected to WhatsApp');
+        this.reconnectAttempts = 0; // Reset on successful connection
       }
     });
 
-    this.sock.ev.on('messages.upsert', ({ messages, type }) => {
+    this.sock.ev.on('messages.upsert', ({ messages, type }: any) => {
       if (type !== 'notify') return;
 
       for (const msg of messages) {
-        // Skip messages sent by us
         if (msg.key.fromMe) continue;
-        // Skip status broadcasts
         if (msg.key.remoteJid === 'status@broadcast') continue;
 
         const remoteJid = msg.key.remoteJid!;
         const senderId = remoteJid.replace('@s.whatsapp.net', '').replace('@g.us', '');
 
-        // Extract text content
         const content =
           msg.message?.conversation ||
           msg.message?.extendedTextMessage?.text ||
@@ -104,13 +125,12 @@ export class WhatsAppChannel implements Channel {
 
         log.info(`[whatsapp] Message from ${displayName} (${senderId}): ${content.slice(0, 80)}`);
 
-        // Route through the channel router
         this.router!.handleIncoming({
           sender: {
             channelType: 'whatsapp',
             senderId,
             displayName,
-            role: 'customer', // Router will resolve the actual role
+            role: 'customer',
             conversationKey,
           },
           content,
@@ -138,6 +158,11 @@ export class WhatsAppChannel implements Channel {
   }
 
   async shutdown(): Promise<void> {
+    this.shuttingDown = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
     if (this.sock) {
       this.sock.end(undefined);
       this.sock = null;