wingman-ai 1.0.0__py3-none-any.whl

share/wingman/node_listener/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "wingman-ai",
+  "version": "1.0.0",
+  "description": "WhatsApp listener component for Wingman AI - connects to WhatsApp Web using Baileys",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc && node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/metanoia-oss/wingman.git",
+    "directory": "node_listener"
+  },
+  "author": "Wingman Contributors",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/metanoia-oss/wingman/issues"
+  },
+  "homepage": "https://github.com/metanoia-oss/wingman#readme",
+  "keywords": [
+    "whatsapp",
+    "baileys",
+    "chatbot",
+    "ai",
+    "wingman",
+    "whatsapp-web",
+    "messaging"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "files": [
+    "dist/**/*",
+    "package.json",
+    "README.md"
+  ],
+  "dependencies": {
+    "@whiskeysockets/baileys": "^6.7.16",
+    "pino": "^8.16.0",
+    "qrcode-terminal": "^0.12.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.2"
+  }
+}

share/wingman/node_listener/src/index.ts

@@ -0,0 +1,108 @@
+import { createSocket, sendMessage, closeSocket } from './socket';
+import { setupStdinListener, sendToPython, log, IPCCommand } from './ipc';
+
+/**
+ * Handle commands from Python orchestrator
+ */
+async function handleCommand(cmd: IPCCommand): Promise<void> {
+    log('info', 'Received command', { action: cmd.action });
+
+    switch (cmd.action) {
+        case 'send_message':
+            if (cmd.payload?.jid && cmd.payload?.text) {
+                const success = await sendMessage(cmd.payload.jid, cmd.payload.text);
+                sendToPython({
+                    type: 'send_result',
+                    data: {
+                        success,
+                        jid: cmd.payload.jid,
+                        messageId: cmd.payload.messageId
+                    }
+                });
+            } else {
+                sendToPython({
+                    type: 'error',
+                    data: { message: 'send_message requires jid and text in payload' }
+                });
+            }
+            break;
+
+        case 'ping':
+            sendToPython({ type: 'pong' });
+            break;
+
+        case 'shutdown':
+            log('info', 'Shutdown requested');
+            sendToPython({ type: 'shutting_down' });
+            await closeSocket();
+            process.exit(0);
+            break;
+
+        default:
+            log('warn', 'Unknown command', { action: cmd.action });
+            sendToPython({
+                type: 'error',
+                data: { message: `Unknown action: ${cmd.action}` }
+            });
+    }
+}
+
+/**
+ * Main entry point
+ */
+async function main(): Promise<void> {
+    log('info', 'Starting WhatsApp listener...');
+    sendToPython({ type: 'starting' });
+
+    // Set up stdin listener for commands from Python
+    setupStdinListener(handleCommand);
+
+    // Handle graceful shutdown
+    process.on('SIGINT', async () => {
+        log('info', 'SIGINT received, shutting down');
+        sendToPython({ type: 'shutting_down' });
+        await closeSocket();
+        process.exit(0);
+    });
+
+    process.on('SIGTERM', async () => {
+        log('info', 'SIGTERM received, shutting down');
+        sendToPython({ type: 'shutting_down' });
+        await closeSocket();
+        process.exit(0);
+    });
+
+    // Handle uncaught errors
+    process.on('uncaughtException', (err) => {
+        log('error', 'Uncaught exception', { error: String(err), stack: err.stack });
+        sendToPython({
+            type: 'error',
+            data: { message: `Uncaught exception: ${err.message}` }
+        });
+    });
+
+    process.on('unhandledRejection', (reason) => {
+        log('error', 'Unhandled rejection', { reason: String(reason) });
+        sendToPython({
+            type: 'error',
+            data: { message: `Unhandled rejection: ${reason}` }
+        });
+    });
+
+    try {
+        await createSocket();
+        log('info', 'Socket created, waiting for connection...');
+    } catch (err) {
+        log('error', 'Failed to create socket', { error: String(err) });
+        sendToPython({
+            type: 'error',
+            data: { message: `Failed to create socket: ${err}` }
+        });
+        process.exit(1);
+    }
+}
+
+main().catch((err) => {
+    log('error', 'Fatal error in main', { error: String(err) });
+    process.exit(1);
+});

share/wingman/node_listener/src/ipc.ts

@@ -0,0 +1,70 @@
+import * as readline from 'readline';
+
+export interface IPCMessage {
+    type: string;
+    data?: any;
+}
+
+export interface IPCCommand {
+    action: string;
+    payload?: any;
+}
+
+const NULL_CHAR = '\0';
+
+/**
+ * Send a message to Python via stdout using NULL-delimited JSON
+ */
+export function sendToPython(message: IPCMessage): void {
+    const json = JSON.stringify(message);
+    process.stdout.write(json + NULL_CHAR);
+}
+
+/**
+ * Set up stdin listener for commands from Python
+ */
+export function setupStdinListener(onCommand: (cmd: IPCCommand) => void): void {
+    let buffer = '';
+
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk: string) => {
+        buffer += chunk;
+
+        // Process all complete messages (NULL-delimited)
+        let nullIndex: number;
+        while ((nullIndex = buffer.indexOf(NULL_CHAR)) !== -1) {
+            const jsonStr = buffer.slice(0, nullIndex);
+            buffer = buffer.slice(nullIndex + 1);
+
+            if (jsonStr.trim()) {
+                try {
+                    const command = JSON.parse(jsonStr) as IPCCommand;
+                    onCommand(command);
+                } catch (err) {
+                    sendToPython({
+                        type: 'error',
+                        data: { message: `Failed to parse command: ${err}` }
+                    });
+                }
+            }
+        }
+    });
+
+    process.stdin.on('end', () => {
+        sendToPython({ type: 'stdin_closed' });
+        process.exit(0);
+    });
+}
+
+/**
+ * Log a message (goes to stderr to not interfere with IPC)
+ */
+export function log(level: 'info' | 'warn' | 'error', message: string, data?: any): void {
+    const logEntry = {
+        timestamp: new Date().toISOString(),
+        level,
+        message,
+        ...(data && { data })
+    };
+    process.stderr.write(JSON.stringify(logEntry) + '\n');
+}

share/wingman/node_listener/src/messageHandler.ts

@@ -0,0 +1,135 @@
+import { WAMessage, WASocket, proto } from '@whiskeysockets/baileys';
+import { sendToPython, log } from './ipc';
+
+export interface ProcessedMessage {
+    messageId: string;
+    chatId: string;
+    senderId: string;
+    senderName: string | null;
+    text: string;
+    timestamp: number;
+    isGroup: boolean;
+    isSelf: boolean;
+    quotedMessage?: {
+        text: string;
+        senderId: string;
+    };
+}
+
+/**
+ * Extract text content from various message types
+ */
+function extractText(message: proto.IMessage | null | undefined): string | null {
+    if (!message) return null;
+
+    // Direct text message
+    if (message.conversation) {
+        return message.conversation;
+    }
+
+    // Extended text (with mentions, links, etc.)
+    if (message.extendedTextMessage?.text) {
+        return message.extendedTextMessage.text;
+    }
+
+    // Image/video with caption
+    if (message.imageMessage?.caption) {
+        return message.imageMessage.caption;
+    }
+    if (message.videoMessage?.caption) {
+        return message.videoMessage.caption;
+    }
+
+    // Document with caption
+    if (message.documentMessage?.caption) {
+        return message.documentMessage.caption;
+    }
+
+    return null;
+}
+
+/**
+ * Process incoming WhatsApp message
+ */
+export function processMessage(
+    msg: WAMessage,
+    sock: WASocket
+): ProcessedMessage | null {
+    try {
+        const key = msg.key;
+        if (!key || !key.remoteJid) {
+            return null;
+        }
+
+        const chatId = key.remoteJid;
+        const isGroup = chatId.endsWith('@g.us');
+        const isSelf = key.fromMe || false;
+
+        // Get sender ID
+        let senderId: string;
+        if (isGroup) {
+            senderId = key.participant || chatId;
+        } else {
+            senderId = isSelf ? (sock.user?.id || 'self') : chatId;
+        }
+
+        // Extract text
+        const text = extractText(msg.message);
+        if (!text) {
+            return null; // Skip non-text messages
+        }
+
+        // Get sender name
+        const senderName = msg.pushName || null;
+
+        // Get timestamp
+        const timestamp = msg.messageTimestamp
+            ? (typeof msg.messageTimestamp === 'number'
+                ? msg.messageTimestamp
+                : Number(msg.messageTimestamp))
+            : Date.now() / 1000;
+
+        // Check for quoted message
+        let quotedMessage: ProcessedMessage['quotedMessage'];
+        const contextInfo = msg.message?.extendedTextMessage?.contextInfo;
+        if (contextInfo?.quotedMessage) {
+            const quotedText = extractText(contextInfo.quotedMessage);
+            if (quotedText) {
+                quotedMessage = {
+                    text: quotedText,
+                    senderId: contextInfo.participant || ''
+                };
+            }
+        }
+
+        return {
+            messageId: key.id || '',
+            chatId,
+            senderId,
+            senderName,
+            text,
+            timestamp,
+            isGroup,
+            isSelf,
+            quotedMessage
+        };
+    } catch (err) {
+        log('error', 'Failed to process message', { error: String(err) });
+        return null;
+    }
+}
+
+/**
+ * Handle incoming messages and emit to Python
+ */
+export function handleMessages(messages: WAMessage[], sock: WASocket): void {
+    for (const msg of messages) {
+        const processed = processMessage(msg, sock);
+        if (processed) {
+            sendToPython({
+                type: 'message',
+                data: processed
+            });
+        }
+    }
+}

share/wingman/node_listener/src/socket.ts

@@ -0,0 +1,244 @@
+import makeWASocket, {
+    DisconnectReason,
+    useMultiFileAuthState,
+    WASocket,
+    ConnectionState,
+    fetchLatestBaileysVersion
+} from '@whiskeysockets/baileys';
+import { Boom } from '@hapi/boom';
+import * as qrcode from 'qrcode-terminal';
+import * as path from 'path';
+import * as fs from 'fs';
+import { sendToPython, log } from './ipc';
+import { handleMessages } from './messageHandler';
+import pino from 'pino';
+
+const AUTH_DIR = path.join(__dirname, '..', '..', 'auth_state');
+const STARTUP_DELAY_FILE = path.join(__dirname, '..', '..', '.last_disconnect');
+
+let sock: WASocket | null = null;
+let reconnectAttempts = 0;
+const MAX_RECONNECT_ATTEMPTS = 10;
+let isConnecting = false;  // Prevent concurrent connection attempts
+const MIN_RESTART_DELAY_MS = 5000;  // Minimum time between sessions
+
+/**
+ * Close existing socket connection gracefully
+ */
+async function closeExistingSocket(): Promise<void> {
+    if (sock) {
+        log('info', 'Closing existing socket connection');
+        try {
+            sock.ev.removeAllListeners('connection.update');
+            sock.ev.removeAllListeners('creds.update');
+            sock.ev.removeAllListeners('messages.upsert');
+            await sock.logout().catch(() => {});  // Ignore logout errors
+            sock.end(undefined);
+        } catch (err) {
+            log('warn', 'Error closing socket', { error: String(err) });
+        }
+        sock = null;
+        // Give WhatsApp servers time to register the disconnect
+        await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+}
+
+/**
+ * Check if we need to wait before connecting (to avoid 440 errors)
+ */
+async function enforceStartupDelay(): Promise<void> {
+    try {
+        if (fs.existsSync(STARTUP_DELAY_FILE)) {
+            const lastDisconnect = parseInt(fs.readFileSync(STARTUP_DELAY_FILE, 'utf-8'), 10);
+            const elapsed = Date.now() - lastDisconnect;
+            const waitTime = MIN_RESTART_DELAY_MS - elapsed;
+
+            if (waitTime > 0) {
+                log('info', `Waiting ${waitTime}ms before connecting (anti-440 delay)`);
+                await new Promise(resolve => setTimeout(resolve, waitTime));
+            }
+        }
+    } catch (err) {
+        // Ignore errors reading the file
+    }
+}
+
+/**
+ * Record disconnect time for anti-440 protection
+ */
+function recordDisconnectTime(): void {
+    try {
+        fs.writeFileSync(STARTUP_DELAY_FILE, Date.now().toString());
+    } catch (err) {
+        // Ignore errors writing the file
+    }
+}
+
+/**
+ * Create and initialize WhatsApp socket connection
+ */
+export async function createSocket(): Promise<WASocket> {
+    // Prevent concurrent connection attempts
+    if (isConnecting) {
+        log('warn', 'Connection already in progress, skipping');
+        return sock!;
+    }
+
+    isConnecting = true;
+
+    try {
+        // Wait if we disconnected recently (anti-440 protection)
+        await enforceStartupDelay();
+
+        // Close any existing connection first
+        await closeExistingSocket();
+
+        const { state, saveCreds } = await useMultiFileAuthState(AUTH_DIR);
+        const { version } = await fetchLatestBaileysVersion();
+
+        // Create silent logger for Baileys
+        const logger = pino({ level: 'silent' });
+
+        log('info', 'Creating socket with auth state', { authDir: AUTH_DIR });
+
+        sock = makeWASocket({
+            version,
+            auth: state,
+            logger,
+            browser: ['WhatsApp Agent', 'Chrome', '120.0.0'],
+            connectTimeoutMs: 60000,
+            keepAliveIntervalMs: 30000,
+            retryRequestDelayMs: 2000,
+            markOnlineOnConnect: false,  // Don't mark online to reduce conflicts
+            syncFullHistory: false,      // Don't sync history to reduce footprint
+        });
+
+        // Handle connection updates
+        sock.ev.on('connection.update', (update: Partial<ConnectionState>) => {
+            handleConnectionUpdate(update, saveCreds);
+        });
+
+        // Save credentials on update
+        sock.ev.on('creds.update', saveCreds);
+
+        // Handle incoming messages
+        sock.ev.on('messages.upsert', async (m) => {
+            if (m.type === 'notify' && sock) {
+                handleMessages(m.messages, sock);
+            }
+        });
+
+        return sock;
+    } finally {
+        isConnecting = false;
+    }
+}
+
+/**
+ * Handle connection state changes
+ */
+function handleConnectionUpdate(
+    update: Partial<ConnectionState>,
+    saveCreds: () => Promise<void>
+): void {
+    const { connection, lastDisconnect, qr } = update;
+
+    // Display QR code for scanning
+    if (qr) {
+        log('info', 'QR Code received, display in terminal');
+        process.stderr.write('\n=== Scan this QR code with WhatsApp ===\n\n');
+        qrcode.generate(qr, { small: true }, (qrString) => {
+            process.stderr.write(qrString + '\n');
+        });
+        sendToPython({ type: 'qr_code', data: { qr } });
+    }
+
+    if (connection === 'close') {
+        const statusCode = (lastDisconnect?.error as Boom)?.output?.statusCode;
+        const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
+
+        log('warn', 'Connection closed', { statusCode, shouldReconnect });
+        sendToPython({
+            type: 'disconnected',
+            data: { statusCode, shouldReconnect }
+        });
+
+        if (statusCode === DisconnectReason.loggedOut) {
+            log('info', 'Logged out, reconnecting for new QR code...');
+            sendToPython({ type: 'logged_out' });
+            // Reconnect to get a new QR code
+            setTimeout(() => {
+                createSocket().catch((err) => {
+                    log('error', 'Reconnection failed', { error: String(err) });
+                });
+            }, 2000);
+        } else if (shouldReconnect && reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+            reconnectAttempts++;
+            const delay = Math.min(1000 * Math.pow(2, reconnectAttempts), 30000);
+            log('info', `Reconnecting in ${delay}ms (attempt ${reconnectAttempts})`);
+
+            setTimeout(() => {
+                createSocket().catch((err) => {
+                    log('error', 'Reconnection failed', { error: String(err) });
+                });
+            }, delay);
+        } else {
+            log('error', 'Max reconnection attempts reached');
+            sendToPython({ type: 'max_reconnect_reached' });
+            process.exit(1);
+        }
+    } else if (connection === 'open') {
+        reconnectAttempts = 0;
+        log('info', 'Connection established');
+        sendToPython({
+            type: 'connected',
+            data: { user: sock?.user }
+        });
+    }
+}
+
+/**
+ * Send a text message
+ */
+export async function sendMessage(jid: string, text: string): Promise<boolean> {
+    if (!sock) {
+        log('error', 'Cannot send message: socket not initialized');
+        return false;
+    }
+
+    try {
+        await sock.sendMessage(jid, { text });
+        log('info', 'Message sent', { jid, textLength: text.length });
+        return true;
+    } catch (err) {
+        log('error', 'Failed to send message', { jid, error: String(err) });
+        return false;
+    }
+}
+
+/**
+ * Get the current socket instance
+ */
+export function getSocket(): WASocket | null {
+    return sock;
+}
+
+/**
+ * Gracefully close the socket connection
+ */
+export async function closeSocket(): Promise<void> {
+    if (sock) {
+        log('info', 'Gracefully closing socket');
+        try {
+            sock.ev.removeAllListeners('connection.update');
+            sock.ev.removeAllListeners('creds.update');
+            sock.ev.removeAllListeners('messages.upsert');
+            sock.end(undefined);
+        } catch (err) {
+            log('warn', 'Error during socket close', { error: String(err) });
+        }
+        sock = null;
+        // Record disconnect time for anti-440 protection on next startup
+        recordDisconnectTime();
+    }
+}

share/wingman/node_listener/src/types.d.ts

@@ -0,0 +1,13 @@
+declare module 'qrcode-terminal' {
+    interface QRCodeOptions {
+        small?: boolean;
+    }
+
+    export function generate(
+        text: string,
+        options?: QRCodeOptions,
+        callback?: (qrcode: string) => void
+    ): void;
+
+    export function setErrorLevel(level: string): void;
+}

share/wingman/node_listener/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

wingman/__init__.py

@@ -0,0 +1,4 @@
+"""Wingman - AI-powered personal chat agent for WhatsApp and iMessage."""
+
+__version__ = "1.0.0"
+__all__ = ["__version__"]

wingman/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for python -m wingman."""
+
+from wingman.cli.main import app
+
+if __name__ == "__main__":
+    app()

wingman/cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI module for Wingman."""
+
+from .main import app
+
+__all__ = ["app"]

wingman/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI commands for Wingman."""