@link-os/whatsapp 0.1.0 → 0.1.2

package/src/client.ts

@@ -10,12 +10,21 @@ import qrcode from 'qrcode-terminal';
 import pino from 'pino';
 
 import type { PlatformClient, UnifiedMessage, Platform } from '@link-os/types';
+import { normalizeWhatsAppTarget } from './normalize.js';
 
 const VERSION = '0.1.0';
 
+export interface AllowedContext {
+    allowedJid: string; // The JID is stored here
+    name: string;
+    type: string;
+    image?: string;
+}
+
 export interface WhatsAppClientOptions {
     sessionId: string;
     authDir?: string;
+    allowedContexts?: AllowedContext[];
 }
 
 export class WhatsAppClient implements PlatformClient {
@@ -27,12 +36,28 @@ export class WhatsAppClient implements PlatformClient {
     private messageHandler?: (message: UnifiedMessage) => Promise<void>;
     private statusHandler?: (status: { type: string; data?: any }) => void;
     private stopped = false;
+    private isStarting = false;
+    private reconnectAttempts = 0;
+    private maxReconnectAttempts = 3;
+    private resetTimeout: NodeJS.Timeout | null = null;
+    private allowedJids: string[] = [];
+    // TODO: Implement persistent storage to save contacts across restarts.
+    // Currently, contacts are only in-memory and lost on restart.
 
     constructor(options: WhatsAppClientOptions) {
         this.options = {
             authDir: options.authDir || `.auth/whatsapp/${options.sessionId}`,
             ...options
         };
+
+        // Initialize allowedJids from allowedContexts
+        if (options.allowedContexts && options.allowedContexts.length > 0) {
+            this.allowedJids = options.allowedContexts
+                .map(ctx => normalizeWhatsAppTarget(ctx.allowedJid))
+                .filter((jid): jid is string => !!jid);
+        } else {
+            this.allowedJids = [];
+        }
     }
 
     on(event: 'message' | 'status', handler: any): void {
@@ -44,78 +69,124 @@ export class WhatsAppClient implements PlatformClient {
     }
 
     async start(): Promise<void> {
+        if (this.isStarting) {
+            return;
+        }
+        this.isStarting = true;
         this.stopped = false;
-        const { state, saveCreds } = await useMultiFileAuthState(this.options.authDir!);
-        const { version } = await fetchLatestBaileysVersion();
-
-        console.log(`Using Baileys version: ${version.join('.')}`);
-
-        this.sock = (makeWASocket as any).default ? (makeWASocket as any).default({
-            auth: {
-                creds: state.creds,
-                keys: (makeCacheableSignalKeyStore as any)(state.keys, this.logger),
-            },
-            version,
-            logger: this.logger,
-            printQRInTerminal: false,
-            browser: ['linkos', 'cli', VERSION],
-            syncFullHistory: false,
-            markOnlineOnConnect: false,
-            shouldIgnoreJid: (jid: string) => jid.includes('@broadcast') || jid.includes('@newsletter')
-        }) : (makeWASocket as any)({
-            auth: {
-                creds: state.creds,
-                keys: (makeCacheableSignalKeyStore as any)(state.keys, this.logger),
-            },
-            version,
-            logger: this.logger,
-            printQRInTerminal: false,
-            browser: ['linkos', 'cli', VERSION],
-            syncFullHistory: false,
-            markOnlineOnConnect: false,
-            shouldIgnoreJid: (jid: string) => jid.includes('@broadcast') || jid.includes('@newsletter')
-        });
 
-        if (this.sock.ws && typeof this.sock.ws.on === 'function') {
-            this.sock.ws.on('error', (err: Error) => {
-                console.error('WebSocket error:', err.message);
-            });
+        // Clear any pending reset
+        if (this.resetTimeout) {
+            clearTimeout(this.resetTimeout);
+            this.resetTimeout = null;
         }
 
-        this.sock.ev.on('connection.update', async (update: any) => {
-            const { connection, lastDisconnect, qr } = update;
+        try {
+            console.log(`[WhatsAppClient] Initializing auth state for ${this.options.sessionId}...`);
+            const { state, saveCreds } = await useMultiFileAuthState(this.options.authDir!);
+            console.log(`[WhatsAppClient] Fetching latest Baileys version...`);
+            const { version } = await fetchLatestBaileysVersion();
 
-            if (qr) {
-                console.log('\n📱 Scan this QR code with WhatsApp (Linked Devices):\n');
-                qrcode.generate(qr, { small: true });
-                if (this.statusHandler) {
-                    this.statusHandler({ type: 'qr', data: qr });
-                }
+            console.log(`Using Baileys version: ${version.join('.')}`);
+            // ... (rest of start)
+            if (this.allowedJids.length > 0) {
+                console.log(`🔒 Allowlist enabled: ${this.allowedJids.length} IDs allowed.`);
             }
 
-            if (connection === 'close') {
-                const statusCode = (lastDisconnect?.error as Boom)?.output?.statusCode;
-                const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
+            const isDefaultImport = !!(makeWASocket as any).default;
+            const sockOptions = {
+                auth: {
+                    creds: state.creds,
+                    keys: makeCacheableSignalKeyStore(state.keys, this.logger),
+                },
+                version,
+                logger: this.logger,
+                printQRInTerminal: false,
+                browser: ['Linkos', 'Chrome', '121.0.6167.140'] as [string, string, string],
+                syncFullHistory: false,
+                markOnlineOnConnect: true,
+                connectTimeoutMs: 60000,
+                defaultQueryTimeoutMs: 60000,
+            };
+
+            this.sock = isDefaultImport ? (makeWASocket as any).default(sockOptions) : makeWASocket(sockOptions);
 
-                console.log(`Connection closed. Status: ${statusCode}, Will reconnect: ${shouldReconnect}`);
+            if (this.sock.ws && typeof this.sock.ws.on === 'function') {
+                this.sock.ws.on('error', (err: Error) => {
+                    console.error('WebSocket error:', err.message);
+                });
+            }
+
+            this.sock.ev.on('connection.update', async (update: any) => {
+                const { connection, lastDisconnect, qr } = update;
 
-                if (shouldReconnect && !this.reconnecting && !this.stopped) {
-                    this.reconnecting = true;
-                    console.log('Reconnecting in 5 seconds...');
-                    setTimeout(() => {
-                        this.reconnecting = false;
-                        this.start();
-                    }, 5000);
+                if (qr) {
+                    console.log('\n📱 Scan this QR code with WhatsApp (Linked Devices):\n');
+                    qrcode.generate(qr, { small: true });
+                    if (this.statusHandler) {
+                        this.statusHandler({ type: 'qr', data: qr });
+                    }
                 }
-            } else if (connection === 'open') {
-                console.log('✅ Connected to WhatsApp');
-                if (this.statusHandler) {
-                    this.statusHandler({ type: 'connected' });
+
+                if (connection === 'close') {
+                    const statusCode = (lastDisconnect?.error as Boom)?.output?.statusCode;
+                    const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
+
+                    console.log(`Connection closed. Status: ${statusCode}, Will reconnect: ${shouldReconnect}`);
+
+                    if (this.resetTimeout) {
+                        clearTimeout(this.resetTimeout);
+                        this.resetTimeout = null;
+                    }
+
+                    if (shouldReconnect && !this.reconnecting && !this.stopped) {
+                        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+                            this.reconnectAttempts++;
+                            this.reconnecting = true;
+                            if (this.statusHandler) {
+                                this.statusHandler({ type: 'reconnecting', data: { attempt: this.reconnectAttempts, max: this.maxReconnectAttempts } });
+                            }
+                            console.log(`Reconnecting (Attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts}) in 5 seconds...`);
+                            setTimeout(() => {
+                                this.reconnecting = false;
+                                this.start();
+                            }, 5000);
+                        } else {
+                            console.error(`[WhatsApp] Max reconnection attempts (${this.maxReconnectAttempts}) reached. Stopping.`);
+                            if (this.statusHandler) {
+                                this.statusHandler({ type: 'disconnected', data: { reason: 'max_retries' } });
+                            }
+                            this.stop();
+                        }
+                    } else if (this.statusHandler && !shouldReconnect) {
+                        this.statusHandler({ type: 'disconnected' });
+                    }
+                } else if (connection === 'open') {
+                    console.log('✅ Connected to WhatsApp');
+                    this.isStarting = false;
+
+                    // Only reset attempts after 10 seconds of stable connection
+                    if (this.resetTimeout) clearTimeout(this.resetTimeout);
+                    this.resetTimeout = setTimeout(() => {
+                        this.reconnectAttempts = 0;
+                        this.resetTimeout = null;
+                    }, 10000);
+
+                    if (this.statusHandler) {
+                        this.statusHandler({ type: 'connected' });
+                    }
                 }
-            }
-        });
+            });
+
+            this.sock.ev.on('creds.update', saveCreds);
 
-        this.sock.ev.on('creds.update', saveCreds);
+        } catch (error) {
+            this.isStarting = false;
+            console.error('[WhatsApp] Failed to start:', error);
+            if (this.statusHandler) {
+                this.statusHandler({ type: 'error', data: error });
+            }
+        }
 
         this.sock.ev.on('messages.upsert', async ({ messages, type }: { messages: any[]; type: string }) => {
             if (type !== 'notify') return;
@@ -124,28 +195,89 @@ export class WhatsAppClient implements PlatformClient {
                 if (msg.key.fromMe) continue;
                 if (msg.key.remoteJid === 'status@broadcast') continue;
 
+                const remoteJid = msg.key.remoteJid;
+                const participant = msg.key.participant || remoteJid;
+                const isGroup = remoteJid?.endsWith('@g.us') || false;
+
+                // Allowlist Check
+                if (this.allowedJids.length > 0) {
+                    const isAllowed = this.allowedJids.some(allowed =>
+                        remoteJid?.includes(allowed) || participant?.includes(allowed)
+                    );
+
+                    if (!isAllowed) {
+                        // console.log(`🚫 Ignoring message from unauthorized source: ${remoteJid}`);
+                        continue;
+                    }
+                }
+
+                // Group Mention Policy: Only respond if tagged
+                if (isGroup && this.sock?.user?.id) {
+                    const botJid = normalizeWhatsAppTarget(this.sock.user.id);
+                    const botLid = this.sock.user.lid ? normalizeWhatsAppTarget(this.sock.user.lid) : null;
+
+                    const message = msg.message;
+                    const contextInfo = message?.extendedTextMessage?.contextInfo ||
+                        message?.imageMessage?.contextInfo ||
+                        message?.videoMessage?.contextInfo ||
+                        message?.documentMessage?.contextInfo ||
+                        message?.audioMessage?.contextInfo ||
+                        (message as any)?.contextInfo;
+
+                    const mentions = contextInfo?.mentionedJid || [];
+
+                    // Normalize all mentions and the bot ID for comparison
+                    const isMentioned = mentions.some((m: string) => {
+                        const normM = normalizeWhatsAppTarget(m);
+                        const match = (botJid && normM === botJid) ||
+                            (botLid && normM === botLid) ||
+                            m === this.sock.user.id ||
+                            (this.sock.user.lid && m === this.sock.user.lid);
+
+                        return match;
+                    });
+
+                    // Check if it's a reply to the bot
+                    const quotedParticipant = contextInfo?.participant;
+                    const isReplyToBot = quotedParticipant && (
+                        normalizeWhatsAppTarget(quotedParticipant) === botJid ||
+                        normalizeWhatsAppTarget(quotedParticipant) === botLid ||
+                        quotedParticipant === this.sock.user.id ||
+                        (this.sock.user.lid && quotedParticipant === this.sock.user.lid)
+                    );
+
+                    if (!isMentioned && !isReplyToBot) {
+                        continue;
+                    }
+                }
+
                 const content = this.extractMessageContent(msg);
                 if (!content) continue;
 
                 if (!this.messageHandler) continue;
 
-                const isGroup = msg.key.remoteJid?.endsWith('@g.us') || false;
-
                 const unifiedMessage: UnifiedMessage = {
                     id: msg.key.id || `wa_${Date.now()}`,
                     platform: 'whatsapp',
-                    userId: msg.key.remoteJid?.replace('@s.whatsapp.net', '') || '',
+                    userId: remoteJid || '',
                     sessionId: this.options.sessionId,
                     content,
                     messageType: 'text',
                     timestamp: new Date((msg.messageTimestamp as number) * 1000),
                     metadata: {
-                        pushName: msg.pushName,
-                        jid: msg.key.remoteJid,
-                        isGroup
+                        pushName: msg.pushName || 'Unknown User',
+                        isGroup,
+                        participant: isGroup ? participant : undefined,
+                        jid: remoteJid
                     }
                 };
 
+                // Typing indicator (optional, but keep for UX if stable)
+                try {
+                    // Only start typing if jid is valid
+                    if (remoteJid) await this.startTyping(remoteJid);
+                } catch (e) { /* ignore */ }
+
                 await this.messageHandler(unifiedMessage);
             }
         });
@@ -167,15 +299,101 @@ export class WhatsAppClient implements PlatformClient {
 
     async sendMessage(to: string, text: string): Promise<void> {
         if (!this.sock) throw new Error('Not connected');
-        const jid = to.includes('@') ? to : `${to}@s.whatsapp.net`;
+
+        const jid = normalizeWhatsAppTarget(to);
+        if (!jid) {
+            console.error(`[WhatsApp] Invalid message target: ${to}`);
+            return;
+        }
+
         await this.sock.sendMessage(jid, { text });
     }
 
+    async startTyping(jid: string): Promise<void> {
+        if (!this.sock) return;
+        await this.sock.sendPresenceUpdate('composing', jid);
+    }
+
+    async stopTyping(jid: string): Promise<void> {
+        if (!this.sock) return;
+        await this.sock.sendPresenceUpdate('paused', jid);
+    }
+
+    async reactToMessage(jid: string, key: any, emoji: string): Promise<void> {
+        if (!this.sock) return;
+        await this.sock.sendMessage(jid, { react: { text: emoji, key } });
+    }
+
+    async markRead(jid: string, key: any): Promise<void> {
+        if (!this.sock) return;
+        await this.sock.readMessages([key]);
+    }
+
+    async updateConfiguration(config: Partial<WhatsAppClientOptions>): Promise<void> {
+        if (config.allowedContexts) {
+            this.allowedJids = config.allowedContexts
+                .map(ctx => normalizeWhatsAppTarget(ctx.allowedJid))
+                .filter((jid): jid is string => !!jid);
+            console.log(`🔄 Configuration updated: Allowlist now has ${this.allowedJids.length} normalized IDs.`);
+        }
+    }
+
     async stop(): Promise<void> {
         this.stopped = true;
+        this.isStarting = false;
+        if (this.resetTimeout) {
+            clearTimeout(this.resetTimeout);
+            this.resetTimeout = null;
+        }
         if (this.sock) {
             this.sock.end(undefined);
             this.sock = null;
         }
     }
+
+    async deleteSession(): Promise<void> {
+        await this.stop();
+        if (this.options.authDir) {
+            const fs = await import('fs/promises');
+            try {
+                await fs.rm(this.options.authDir, { recursive: true, force: true });
+                console.log(`Deleted session directory: ${this.options.authDir}`);
+            } catch (error: any) {
+                console.error(`Failed to delete session directory: ${error.message}`);
+            }
+        }
+    }
+
+    async getAvailableContexts(): Promise<{ id: string; name: string; type: 'group' | 'user'; image?: string }[]> {
+        if (!this.sock) return [];
+
+        const contexts: { id: string; name: string; type: 'group' | 'user'; image?: string }[] = [];
+
+        try {
+            // 1. Groups from direct fetch (most reliable for groups)
+            const groups = await this.sock.groupFetchAllParticipating();
+            for (const [id, metadata] of Object.entries(groups)) {
+                contexts.push({
+                    id,
+                    name: (metadata as any).subject || 'Unknown Group',
+                    type: 'group'
+                });
+            }
+        } catch (error) {
+            console.error('Failed to fetch contexts:', error);
+        }
+
+        // Fetch Profile Pictures (best effort, parallel)
+        await Promise.all(contexts.map(async (ctx) => {
+            try {
+                // Only fetch if we don't have one or to refresh
+                ctx.image = await this.sock.profilePictureUrl(ctx.id, 'preview');
+            } catch (e) {
+                // Ignore error (no profile pic or privacy restricted)
+                ctx.image = undefined;
+            }
+        }));
+
+        return contexts;
+    }
 }

package/src/normalize.ts

@@ -0,0 +1,70 @@
+
+/**
+ * WhatsApp JID Normalization following OpenClaw/Baileys patterns.
+ */
+
+const WHATSAPP_USER_JID_RE = /^(\d+)(?::\d+)?@s\.whatsapp\.net$/i;
+const WHATSAPP_LID_RE = /^(\d+)(?::\d+)?@lid$/i;
+
+/**
+ * Clean phone numbers to digits only.
+ */
+export function normalizeE164(value: string): string {
+    return value.replace(/\D/g, "");
+}
+
+function stripWhatsAppTargetPrefixes(value: string): string {
+    let candidate = value.trim();
+    for (; ;) {
+        const before = candidate;
+        candidate = candidate.replace(/^whatsapp:/i, "").trim();
+        if (candidate === before) {
+            return candidate;
+        }
+    }
+}
+
+/**
+ * Check if the JID belongs to a group.
+ */
+export function isWhatsAppGroupJid(value: string): boolean {
+    const candidate = stripWhatsAppTargetPrefixes(value);
+    const lower = candidate.toLowerCase();
+    return lower.endsWith("@g.us");
+}
+
+/**
+ * Normalize input string into a valid Baileys JID.
+ * Handles phone numbers, group IDs, and existing JIDs with device suffixes.
+ */
+export function normalizeWhatsAppTarget(value: string): string | null {
+    const candidate = stripWhatsAppTargetPrefixes(value);
+    if (!candidate) return null;
+
+    // Handle Groups
+    if (isWhatsAppGroupJid(candidate)) {
+        const localPart = candidate.slice(0, candidate.length - "@g.us".length);
+        return `${localPart}@g.us`;
+    }
+
+    // Handle standard user JIDs (strip device suffixes like :5)
+    if (WHATSAPP_USER_JID_RE.test(candidate)) {
+        const match = candidate.match(WHATSAPP_USER_JID_RE);
+        return `${match![1]}@s.whatsapp.net`;
+    }
+
+    // Handle LIDs
+    if (WHATSAPP_LID_RE.test(candidate)) {
+        const match = candidate.match(WHATSAPP_LID_RE);
+        return `${match![1]}@lid`;
+    }
+
+    // Handle raw phone numbers or strings without @
+    if (!candidate.includes("@")) {
+        const normalized = normalizeE164(candidate);
+        // Only accept if it has at least 5 digits (sanity check for phone numbers)
+        return normalized.length >= 5 ? `${normalized}@s.whatsapp.net` : null;
+    }
+
+    return null;
+}