fluxy-bot 0.13.1 → 0.13.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluxy-bot",
-  "version": "0.13.1",
+  "version": "0.13.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/supervisor/channels/index.ts

@@ -7,6 +7,7 @@ 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,12 +31,17 @@ export async function initializeChannels(
   await chatChannel.initialize(router);
 
   // WhatsApp channel — registered if enabled in config
-  // The actual implementation is done by Fluxy as a skill.
-  // See docs/whatsapp-channel-guide.md for implementation details.
   if (config.channels?.whatsapp?.enabled) {
-    log.info('[channels] WhatsApp is enabled in config — waiting for channel implementation to register');
-    // The WhatsApp channel will self-register via router.registerChannel()
-    // when the skill implementation calls it during initialization.
+    try {
+      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}`);
+    }
   }
 
   // Telegram channel — placeholder for future implementation

package/supervisor/channels/whatsapp-channel.ts

@@ -0,0 +1,146 @@
+/**
+ * WhatsApp Channel — Baileys adapter for WhatsApp Web.
+ * Receives messages, routes through ChannelRouter, sends responses back.
+ * Session persisted in ~/.fluxy/whatsapp-session/.
+ */
+
+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');
+
+export class WhatsAppChannel implements Channel {
+  readonly type = 'whatsapp' as const;
+  private sock: WASocket | null = null;
+  private router: ChannelRouter | null = null;
+  private onQR?: (qr: string) => void;
+  private reconnecting = 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();
+  }
+
+  private async connect(): Promise<void> {
+    const { state, saveCreds } = await useMultiFileAuthState(SESSION_DIR);
+
+    this.sock = makeWASocket({
+      auth: state,
+      printQRInTerminal: true,
+    });
+
+    this.sock.ev.on('creds.update', saveCreds);
+
+    this.sock.ev.on('connection.update', (update) => {
+      const { connection, lastDisconnect, qr } = update;
+
+      // Surface QR to chat UI for scanning
+      if (qr && 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');
+        }
+      }
+
+      if (connection === 'open') {
+        log.ok('[whatsapp] Connected to WhatsApp');
+      }
+    });
+
+    this.sock.ev.on('messages.upsert', ({ messages, type }) => {
+      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 ||
+          msg.message?.imageMessage?.caption ||
+          '';
+
+        if (!content) continue;
+
+        const displayName = msg.pushName || senderId;
+        const conversationKey = `whatsapp:${senderId}`;
+
+        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
+            conversationKey,
+          },
+          content,
+          timestamp: (msg.messageTimestamp as number) * 1000 || Date.now(),
+        }).catch((err) => {
+          log.warn(`[whatsapp] Router error: ${err.message}`);
+        });
+      }
+    });
+  }
+
+  async sendMessage(to: string, message: OutgoingMessage): Promise<void> {
+    if (!this.sock) {
+      log.warn('[whatsapp] Cannot send — not connected');
+      return;
+    }
+
+    const jid = to.includes('@') ? to : `${to}@s.whatsapp.net`;
+    await this.sock.sendMessage(jid, { text: message.content });
+    log.info(`[whatsapp] Sent to ${to}: ${message.content.slice(0, 80)}`);
+  }
+
+  ownsConversation(conversationKey: string): boolean {
+    return conversationKey.startsWith('whatsapp:');
+  }
+
+  async shutdown(): Promise<void> {
+    if (this.sock) {
+      this.sock.end(undefined);
+      this.sock = null;
+    }
+  }
+}