nextclaw 0.1.0

package/bridge/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "nextclaw-whatsapp-bridge",
+  "version": "0.1.0",
+  "description": "WhatsApp bridge for nextclaw using Baileys",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc && node dist/index.js"
+  },
+  "dependencies": {
+    "@whiskeysockets/baileys": "7.0.0-rc.9",
+    "ws": "^8.17.1",
+    "qrcode-terminal": "^0.12.0",
+    "pino": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "@types/ws": "^8.5.10",
+    "typescript": "^5.4.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/bridge/src/index.ts

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+/**
+ * nextclaw WhatsApp Bridge
+ * 
+ * This bridge connects WhatsApp Web to nextclaw's backend
+ * via WebSocket. It handles authentication, message forwarding,
+ * and reconnection logic.
+ * 
+ * Usage:
+ *   npm run build && npm start
+ *   
+ * Or with custom settings:
+ *   BRIDGE_PORT=3001 AUTH_DIR=~/.nextclaw/whatsapp npm start
+ */
+
+// Polyfill crypto for Baileys in ESM
+import { webcrypto } from 'crypto';
+type CryptoLike = typeof webcrypto;
+const globalCrypto = globalThis as typeof globalThis & { crypto?: CryptoLike };
+if (!globalCrypto.crypto) {
+  globalCrypto.crypto = webcrypto;
+}
+
+import { BridgeServer } from './server.js';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const PORT = parseInt(process.env.BRIDGE_PORT || '3001', 10);
+const envHome = process.env.NEXTCLAW_HOME?.trim() || process.env.NEXTBOT_HOME?.trim();
+const defaultHome = (() => {
+  if (envHome) {
+    return envHome;
+  }
+  const primary = join(homedir(), '.nextclaw');
+  if (existsSync(primary)) {
+    return primary;
+  }
+  const legacy = join(homedir(), '.nextbot');
+  if (existsSync(legacy)) {
+    return legacy;
+  }
+  return primary;
+})();
+const AUTH_DIR = process.env.AUTH_DIR || join(defaultHome, 'whatsapp-auth');
+
+console.log('🤖 nextclaw WhatsApp Bridge');
+console.log('========================\n');
+
+const server = new BridgeServer(PORT, AUTH_DIR);
+
+// Handle graceful shutdown
+process.on('SIGINT', async () => {
+  console.log('\n\nShutting down...');
+  await server.stop();
+  process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+  await server.stop();
+  process.exit(0);
+});
+
+// Start the server
+server.start().catch((error) => {
+  console.error('Failed to start bridge:', error);
+  process.exit(1);
+});

package/bridge/src/server.ts

@@ -0,0 +1,104 @@
+/**
+ * WebSocket server for Python-Node.js bridge communication.
+ */
+
+import { WebSocketServer, WebSocket } from 'ws';
+import { WhatsAppClient } from './whatsapp.js';
+
+interface SendCommand {
+  type: 'send';
+  to: string;
+  text: string;
+}
+
+interface BridgeMessage {
+  type: 'message' | 'status' | 'qr' | 'error';
+  [key: string]: unknown;
+}
+
+export class BridgeServer {
+  private wss: WebSocketServer | null = null;
+  private wa: WhatsAppClient | null = null;
+  private clients: Set<WebSocket> = new Set();
+
+  constructor(private port: number, private authDir: string) {}
+
+  async start(): Promise<void> {
+    // Create WebSocket server
+    this.wss = new WebSocketServer({ port: this.port });
+    console.log(`🌉 Bridge server listening on ws://localhost:${this.port}`);
+
+    // Initialize WhatsApp client
+    this.wa = new WhatsAppClient({
+      authDir: this.authDir,
+      onMessage: (msg) => this.broadcast({ type: 'message', ...msg }),
+      onQR: (qr) => this.broadcast({ type: 'qr', qr }),
+      onStatus: (status) => this.broadcast({ type: 'status', status }),
+    });
+
+    // Handle WebSocket connections
+    this.wss.on('connection', (ws) => {
+      console.log('🔗 Python client connected');
+      this.clients.add(ws);
+
+      ws.on('message', async (data) => {
+        try {
+          const cmd = JSON.parse(data.toString()) as SendCommand;
+          await this.handleCommand(cmd);
+          ws.send(JSON.stringify({ type: 'sent', to: cmd.to }));
+        } catch (error) {
+          console.error('Error handling command:', error);
+          ws.send(JSON.stringify({ type: 'error', error: String(error) }));
+        }
+      });
+
+      ws.on('close', () => {
+        console.log('🔌 Python client disconnected');
+        this.clients.delete(ws);
+      });
+
+      ws.on('error', (error) => {
+        console.error('WebSocket error:', error);
+        this.clients.delete(ws);
+      });
+    });
+
+    // Connect to WhatsApp
+    await this.wa.connect();
+  }
+
+  private async handleCommand(cmd: SendCommand): Promise<void> {
+    if (cmd.type === 'send' && this.wa) {
+      await this.wa.sendMessage(cmd.to, cmd.text);
+    }
+  }
+
+  private broadcast(msg: BridgeMessage): void {
+    const data = JSON.stringify(msg);
+    for (const client of this.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data);
+      }
+    }
+  }
+
+  async stop(): Promise<void> {
+    // Close all client connections
+    for (const client of this.clients) {
+      client.close();
+    }
+    this.clients.clear();
+
+    // Close WebSocket server
+    if (this.wss) {
+      this.wss.close();
+      this.wss = null;
+    }
+
+    // Disconnect WhatsApp
+    if (this.wa) {
+      await this.wa.disconnect();
+      this.wa = null;
+    }
+  }
+}

package/bridge/src/types.d.ts

@@ -0,0 +1,3 @@
+declare module 'qrcode-terminal' {
+  export function generate(text: string, options?: { small?: boolean }): void;
+}

package/bridge/src/whatsapp.ts

@@ -0,0 +1,187 @@
+/**
+ * WhatsApp client wrapper using Baileys.
+ * Based on OpenClaw's working implementation.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import makeWASocket, {
+  DisconnectReason,
+  useMultiFileAuthState,
+  fetchLatestBaileysVersion,
+  makeCacheableSignalKeyStore,
+} from '@whiskeysockets/baileys';
+
+import type { Boom } from '@hapi/boom';
+import qrcode from 'qrcode-terminal';
+import pino from 'pino';
+
+const VERSION = '0.1.0';
+
+export interface InboundMessage {
+  id: string;
+  sender: string;
+  pn: string;
+  content: string;
+  timestamp: number;
+  isGroup: boolean;
+}
+
+export interface WhatsAppClientOptions {
+  authDir: string;
+  onMessage: (msg: InboundMessage) => void;
+  onQR: (qr: string) => void;
+  onStatus: (status: string) => void;
+}
+
+export class WhatsAppClient {
+  private sock: any = null;
+  private options: WhatsAppClientOptions;
+  private reconnecting = false;
+
+  constructor(options: WhatsAppClientOptions) {
+    this.options = options;
+  }
+
+  async connect(): Promise<void> {
+    const logger = pino({ level: 'silent' });
+    const { state, saveCreds } = await useMultiFileAuthState(this.options.authDir);
+    const { version } = await fetchLatestBaileysVersion();
+
+    console.log(`Using Baileys version: ${version.join('.')}`);
+
+    // Create socket following OpenClaw's pattern
+    this.sock = makeWASocket({
+      auth: {
+        creds: state.creds,
+        keys: makeCacheableSignalKeyStore(state.keys, logger),
+      },
+      version,
+      logger,
+      printQRInTerminal: false,
+      browser: ['nextclaw', 'cli', VERSION],
+      syncFullHistory: false,
+      markOnlineOnConnect: false,
+    });
+
+    // Handle WebSocket errors
+    if (this.sock.ws && typeof this.sock.ws.on === 'function') {
+      this.sock.ws.on('error', (err: Error) => {
+        console.error('WebSocket error:', err.message);
+      });
+    }
+
+    // Handle connection updates
+    this.sock.ev.on('connection.update', async (update: any) => {
+      const { connection, lastDisconnect, qr } = update;
+
+      if (qr) {
+        // Display QR code in terminal
+        console.log('\n📱 Scan this QR code with WhatsApp (Linked Devices):\n');
+        qrcode.generate(qr, { small: true });
+        this.options.onQR(qr);
+      }
+
+      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}`);
+        this.options.onStatus('disconnected');
+
+        if (shouldReconnect && !this.reconnecting) {
+          this.reconnecting = true;
+          console.log('Reconnecting in 5 seconds...');
+          setTimeout(() => {
+            this.reconnecting = false;
+            this.connect();
+          }, 5000);
+        }
+      } else if (connection === 'open') {
+        console.log('✅ Connected to WhatsApp');
+        this.options.onStatus('connected');
+      }
+    });
+
+    // Save credentials on update
+    this.sock.ev.on('creds.update', saveCreds);
+
+    // Handle incoming messages
+    this.sock.ev.on('messages.upsert', async ({ messages, type }: { messages: any[]; type: string }) => {
+      if (type !== 'notify') return;
+
+      for (const msg of messages) {
+        // Skip own messages
+        if (msg.key.fromMe) continue;
+
+        // Skip status updates
+        if (msg.key.remoteJid === 'status@broadcast') continue;
+
+        const content = this.extractMessageContent(msg);
+        if (!content) continue;
+
+        const isGroup = msg.key.remoteJid?.endsWith('@g.us') || false;
+
+        this.options.onMessage({
+          id: msg.key.id || '',
+          sender: msg.key.remoteJid || '',
+          pn: msg.key.remoteJidAlt || '',
+          content,
+          timestamp: msg.messageTimestamp as number,
+          isGroup,
+        });
+      }
+    });
+  }
+
+  private extractMessageContent(msg: any): string | null {
+    const message = msg.message;
+    if (!message) return null;
+
+    // Text message
+    if (message.conversation) {
+      return message.conversation;
+    }
+
+    // Extended text (reply, link preview)
+    if (message.extendedTextMessage?.text) {
+      return message.extendedTextMessage.text;
+    }
+
+    // Image with caption
+    if (message.imageMessage?.caption) {
+      return `[Image] ${message.imageMessage.caption}`;
+    }
+
+    // Video with caption
+    if (message.videoMessage?.caption) {
+      return `[Video] ${message.videoMessage.caption}`;
+    }
+
+    // Document with caption
+    if (message.documentMessage?.caption) {
+      return `[Document] ${message.documentMessage.caption}`;
+    }
+
+    // Voice/Audio message
+    if (message.audioMessage) {
+      return `[Voice Message]`;
+    }
+
+    return null;
+  }
+
+  async sendMessage(to: string, text: string): Promise<void> {
+    if (!this.sock) {
+      throw new Error('Not connected');
+    }
+
+    await this.sock.sendMessage(to, { text });
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.sock) {
+      this.sock.end(undefined);
+      this.sock = null;
+    }
+  }
+}

package/bridge/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}