clawbee 2.0.0 → 2.2.0

package/lib/index.js

@@ -0,0 +1,42 @@
+/**
+ * ClawBee - Your Personal AI, Endless Possibilities
+ * https://clawbee.pro
+ * 
+ * Main library entry point
+ * Exports all modules for programmatic use
+ */
+
+const { AIProvider, AVAILABLE_MODELS, DEFAULT_MODELS } = require('./ai/provider');
+const { SkillManager, builtInSkills } = require('./skills/manager');
+const { SystemCommands } = require('./automation/system');
+const { BrowserAutomation, scrapeUrl } = require('./automation/browser');
+const { TelegramBot } = require('./integrations/telegram');
+const { DiscordBot } = require('./integrations/discord');
+const { SlackBot } = require('./integrations/slack');
+const { WhatsAppBot, formatWhatsAppId } = require('./integrations/whatsapp');
+
+module.exports = {
+  // AI
+  AIProvider,
+  AVAILABLE_MODELS,
+  DEFAULT_MODELS,
+  
+  // Skills
+  SkillManager,
+  builtInSkills,
+  
+  // Automation
+  SystemCommands,
+  BrowserAutomation,
+  scrapeUrl,
+  
+  // Integrations
+  TelegramBot,
+  DiscordBot,
+  SlackBot,
+  WhatsAppBot,
+  formatWhatsAppId,
+  
+  // Version
+  version: '2.2.0'
+};

package/lib/integrations/discord.js

@@ -0,0 +1,85 @@
+/**
+ * ClawBee Discord Integration
+ * Real working Discord bot integration
+ */
+
+const { Client, GatewayIntentBits, Partials } = require('discord.js');
+
+class DiscordBot {
+  constructor(token) {
+    this.token = token;
+    this.client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+        GatewayIntentBits.DirectMessages
+      ],
+      partials: [Partials.Channel, Partials.Message]
+    });
+    this.messageHandler = null;
+  }
+
+  async start(messageHandler) {
+    this.messageHandler = messageHandler;
+
+    this.client.on('ready', () => {
+      console.log(`🐝 Discord bot logged in as ${this.client.user.tag}`);
+    });
+
+    this.client.on('messageCreate', async (message) => {
+      // Ignore bot messages
+      if (message.author.bot) return;
+      
+      // Check if bot is mentioned or in DM
+      const isMentioned = message.mentions.has(this.client.user);
+      const isDM = !message.guild;
+      
+      if (!isMentioned && !isDM) return;
+
+      // Remove mention from message
+      let content = message.content.replace(/<@!?\d+>/g, '').trim();
+      
+      if (!content) {
+        content = 'Hello!';
+      }
+
+      try {
+        await message.channel.sendTyping();
+        
+        const response = await this.messageHandler(content, {
+          platform: 'discord',
+          channelId: message.channel.id,
+          username: message.author.username,
+          userId: message.author.id,
+          guildId: message.guild?.id
+        });
+
+        // Split long messages
+        if (response.length > 2000) {
+          const chunks = response.match(/.{1,2000}/g);
+          for (const chunk of chunks) {
+            await message.reply(chunk);
+          }
+        } else {
+          await message.reply(response);
+        }
+      } catch (error) {
+        await message.reply(`❌ Error: ${error.message}`);
+      }
+    });
+
+    await this.client.login(this.token);
+  }
+
+  stop() {
+    this.client.destroy();
+  }
+
+  async sendMessage(channelId, content) {
+    const channel = await this.client.channels.fetch(channelId);
+    return channel.send(content);
+  }
+}
+
+module.exports = { DiscordBot };

package/lib/integrations/slack.js

@@ -0,0 +1,72 @@
+/**
+ * ClawBee Slack Integration
+ * Real working Slack bot integration
+ */
+
+const { App } = require('@slack/bolt');
+
+class SlackBot {
+  constructor(botToken, signingSecret, appToken) {
+    this.app = new App({
+      token: botToken,
+      signingSecret: signingSecret,
+      appToken: appToken,
+      socketMode: !!appToken
+    });
+    this.messageHandler = null;
+  }
+
+  async start(messageHandler) {
+    this.messageHandler = messageHandler;
+
+    // Listen for app mentions
+    this.app.event('app_mention', async ({ event, say }) => {
+      const text = event.text.replace(/<@[A-Z0-9]+>/g, '').trim();
+      
+      try {
+        const response = await this.messageHandler(text, {
+          platform: 'slack',
+          channelId: event.channel,
+          userId: event.user,
+          threadTs: event.thread_ts || event.ts
+        });
+
+        await say({
+          text: response,
+          thread_ts: event.thread_ts || event.ts
+        });
+      } catch (error) {
+        await say({
+          text: `❌ Error: ${error.message}`,
+          thread_ts: event.thread_ts || event.ts
+        });
+      }
+    });
+
+    // Listen for direct messages
+    this.app.event('message', async ({ event, say }) => {
+      if (event.channel_type !== 'im' || event.bot_id) return;
+
+      try {
+        const response = await this.messageHandler(event.text, {
+          platform: 'slack',
+          channelId: event.channel,
+          userId: event.user
+        });
+
+        await say(response);
+      } catch (error) {
+        await say(`❌ Error: ${error.message}`);
+      }
+    });
+
+    await this.app.start();
+    console.log('🐝 Slack bot started');
+  }
+
+  async stop() {
+    await this.app.stop();
+  }
+}
+
+module.exports = { SlackBot };

package/lib/integrations/telegram.js

@@ -0,0 +1,95 @@
+/**
+ * ClawBee Telegram Integration
+ * Real working Telegram bot integration
+ */
+
+const axios = require('axios');
+
+class TelegramBot {
+  constructor(token) {
+    this.token = token;
+    this.baseUrl = `https://api.telegram.org/bot${token}`;
+    this.offset = 0;
+    this.running = false;
+  }
+
+  async getMe() {
+    const response = await axios.get(`${this.baseUrl}/getMe`);
+    return response.data.result;
+  }
+
+  async sendMessage(chatId, text, options = {}) {
+    const response = await axios.post(`${this.baseUrl}/sendMessage`, {
+      chat_id: chatId,
+      text: text,
+      parse_mode: options.parseMode || 'Markdown',
+      ...options
+    });
+    return response.data.result;
+  }
+
+  async getUpdates(timeout = 30) {
+    try {
+      const response = await axios.get(`${this.baseUrl}/getUpdates`, {
+        params: {
+          offset: this.offset,
+          timeout: timeout,
+          allowed_updates: ['message', 'callback_query']
+        },
+        timeout: (timeout + 10) * 1000
+      });
+      
+      const updates = response.data.result;
+      if (updates.length > 0) {
+        this.offset = updates[updates.length - 1].update_id + 1;
+      }
+      return updates;
+    } catch (error) {
+      if (error.code !== 'ETIMEDOUT') {
+        throw error;
+      }
+      return [];
+    }
+  }
+
+  async startPolling(messageHandler) {
+    this.running = true;
+    console.log('🐝 Telegram bot started polling...');
+
+    while (this.running) {
+      try {
+        const updates = await this.getUpdates();
+        
+        for (const update of updates) {
+          if (update.message && update.message.text) {
+            const chatId = update.message.chat.id;
+            const text = update.message.text;
+            const username = update.message.from.username || update.message.from.first_name;
+            
+            try {
+              const response = await messageHandler(text, { 
+                platform: 'telegram',
+                chatId,
+                username,
+                messageId: update.message.message_id
+              });
+              
+              await this.sendMessage(chatId, response);
+            } catch (error) {
+              await this.sendMessage(chatId, `❌ Error: ${error.message}`);
+            }
+          }
+        }
+      } catch (error) {
+        console.error('Telegram polling error:', error.message);
+        await new Promise(resolve => setTimeout(resolve, 5000));
+      }
+    }
+  }
+
+  stop() {
+    this.running = false;
+  }
+}
+
+module.exports = { TelegramBot };

package/lib/integrations/whatsapp.js

@@ -0,0 +1,247 @@
+/**
+ * ClawBee WhatsApp Integration
+ * Real working WhatsApp integration using whatsapp-web.js
+ * Connects via QR code scanning
+ */
+
+const qrcode = require('qrcode-terminal');
+const fs = require('fs');
+const path = require('os').homedir();
+
+// Session directory for persistent login
+const SESSION_DIR = `${path}/.local/share/clawbee/integrations/whatsapp`;
+
+class WhatsAppBot {
+  constructor() {
+    this.client = null;
+    this.isReady = false;
+    this.messageHandler = null;
+    this.qrHandler = null;
+    this.statusHandler = null;
+  }
+
+  /**
+   * Initialize the WhatsApp client
+   */
+  async initialize() {
+    // Dynamic import for whatsapp-web.js (ES module compatibility)
+    const { Client, LocalAuth } = await import('whatsapp-web.js');
+
+    // Ensure session directory exists
+    if (!fs.existsSync(SESSION_DIR)) {
+      fs.mkdirSync(SESSION_DIR, { recursive: true });
+    }
+
+    this.client = new Client({
+      authStrategy: new LocalAuth({
+        dataPath: SESSION_DIR
+      }),
+      puppeteer: {
+        headless: true,
+        args: [
+          '--no-sandbox',
+          '--disable-setuid-sandbox',
+          '--disable-dev-shm-usage',
+          '--disable-accelerated-2d-canvas',
+          '--no-first-run',
+          '--no-zygote',
+          '--disable-gpu'
+        ]
+      }
+    });
+
+    return this;
+  }
+
+  /**
+   * Start the WhatsApp bot
+   * @param {Function} messageHandler - Function to handle incoming messages
+   * @param {Object} options - Additional options
+   */
+  async start(messageHandler, options = {}) {
+    if (!this.client) {
+      await this.initialize();
+    }
+
+    this.messageHandler = messageHandler;
+    this.qrHandler = options.onQR || null;
+    this.statusHandler = options.onStatus || null;
+
+    // QR Code event - display for scanning
+    this.client.on('qr', (qr) => {
+      console.log('\n🐝 Scan this QR code with WhatsApp:\n');
+      qrcode.generate(qr, { small: true });
+      console.log('\nOpen WhatsApp > Settings > Linked Devices > Link a Device\n');
+      
+      if (this.qrHandler) {
+        this.qrHandler(qr);
+      }
+    });
+
+    // Ready event - successfully connected
+    this.client.on('ready', () => {
+      this.isReady = true;
+      console.log('🐝 WhatsApp client is ready!');
+      
+      if (this.statusHandler) {
+        this.statusHandler('ready', 'WhatsApp connected successfully');
+      }
+    });
+
+    // Authentication success
+    this.client.on('authenticated', () => {
+      console.log('🐝 WhatsApp authenticated');
+      
+      if (this.statusHandler) {
+        this.statusHandler('authenticated', 'Authentication successful');
+      }
+    });
+
+    // Authentication failure
+    this.client.on('auth_failure', (msg) => {
+      console.error('🐝 WhatsApp authentication failed:', msg);
+      
+      if (this.statusHandler) {
+        this.statusHandler('auth_failure', msg);
+      }
+    });
+
+    // Disconnected event
+    this.client.on('disconnected', (reason) => {
+      this.isReady = false;
+      console.log('🐝 WhatsApp disconnected:', reason);
+      
+      if (this.statusHandler) {
+        this.statusHandler('disconnected', reason);
+      }
+    });
+
+    // Message received event
+    this.client.on('message', async (message) => {
+      // Skip status updates and own messages
+      if (message.isStatus || message.fromMe) return;
+
+      const chat = await message.getChat();
+      const contact = await message.getContact();
+
+      const context = {
+        platform: 'whatsapp',
+        chatId: message.from,
+        chatName: chat.name || contact.pushname || contact.number,
+        username: contact.pushname || contact.name || contact.number,
+        isGroup: chat.isGroup,
+        messageId: message.id._serialized,
+        timestamp: message.timestamp,
+        hasMedia: message.hasMedia
+      };
+
+      // Only process text messages for now
+      if (message.body && this.messageHandler) {
+        try {
+          // Show typing indicator
+          await chat.sendStateTyping();
+
+          // Get AI response
+          const response = await this.messageHandler(message.body, context);
+
+          // Send response
+          await message.reply(response);
+        } catch (error) {
+          console.error('WhatsApp message handling error:', error);
+          await message.reply(`❌ Error: ${error.message}`);
+        }
+      }
+    });
+
+    // Initialize client
+    console.log('🐝 Initializing WhatsApp connection...');
+    await this.client.initialize();
+  }
+
+  /**
+   * Send a message to a specific chat
+   * @param {string} chatId - WhatsApp chat ID (number@c.us for contacts, number-id@g.us for groups)
+   * @param {string} content - Message content
+   */
+  async sendMessage(chatId, content) {
+    if (!this.isReady) {
+      throw new Error('WhatsApp client is not ready');
+    }
+
+    return this.client.sendMessage(chatId, content);
+  }
+
+  /**
+   * Get all chats
+   */
+  async getChats() {
+    if (!this.isReady) {
+      throw new Error('WhatsApp client is not ready');
+    }
+
+    return this.client.getChats();
+  }
+
+  /**
+   * Get contact info
+   * @param {string} contactId - Contact ID
+   */
+  async getContact(contactId) {
+    if (!this.isReady) {
+      throw new Error('WhatsApp client is not ready');
+    }
+
+    return this.client.getContactById(contactId);
+  }
+
+  /**
+   * Get current connection state
+   */
+  getState() {
+    return {
+      isReady: this.isReady,
+      state: this.client?.info?.wid ? 'connected' : 'disconnected',
+      phoneNumber: this.client?.info?.wid?.user || null,
+      platform: this.client?.info?.platform || null
+    };
+  }
+
+  /**
+   * Logout and clear session
+   */
+  async logout() {
+    if (this.client) {
+      await this.client.logout();
+      this.isReady = false;
+      
+      // Clear session files
+      if (fs.existsSync(SESSION_DIR)) {
+        fs.rmSync(SESSION_DIR, { recursive: true, force: true });
+      }
+    }
+  }
+
+  /**
+   * Destroy client connection
+   */
+  async stop() {
+    if (this.client) {
+      await this.client.destroy();
+      this.client = null;
+      this.isReady = false;
+    }
+  }
+}
+
+/**
+ * Format phone number to WhatsApp ID
+ * @param {string} phoneNumber - Phone number with country code
+ * @returns {string} WhatsApp chat ID
+ */
+function formatWhatsAppId(phoneNumber) {
+  // Remove any non-digit characters
+  const cleaned = phoneNumber.replace(/\D/g, '');
+  return `${cleaned}@c.us`;
+}
+
+module.exports = { WhatsAppBot, formatWhatsAppId };