@johpaz/hive-core 0.1.1

package/src/channels/telegram.ts

@@ -0,0 +1,177 @@
+import { Bot, GrammyError, type Context } from "grammy";
+import { BaseChannel, type ChannelConfig, type IncomingMessage, type OutboundMessage } from "./base.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface TelegramConfig extends ChannelConfig {
+  botToken: string;
+  groups?: boolean;
+}
+
+export class TelegramChannel extends BaseChannel {
+  name = "telegram";
+  accountId: string;
+  config: TelegramConfig;
+  
+  private bot?: Bot;
+  private log = logger.child("telegram");
+
+  constructor(accountId: string, config: TelegramConfig) {
+    super();
+    this.accountId = accountId;
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    if (!this.config.botToken) {
+      throw new Error("Telegram bot token not configured");
+    }
+
+    this.bot = new Bot(this.config.botToken);
+
+    this.bot.on("message:text", async (ctx) => {
+      await this.handleTelegramMessage(ctx);
+    });
+
+    this.bot.on("edited_message:text", async (ctx) => {
+      await this.handleTelegramMessage(ctx);
+    });
+
+    this.bot.catch((err) => {
+      this.log.error(`Telegram error: ${err.message}`);
+    });
+
+    try {
+      await this.bot.init();
+      this.running = true;
+      
+      this.bot.start({
+        onStart: () => {
+          this.log.info(`Telegram bot started: @${this.bot?.botInfo?.username ?? "unknown"}`);
+        },
+      });
+    } catch (error) {
+      this.log.error(`Failed to start Telegram bot: ${(error as Error).message}`);
+      throw error;
+    }
+  }
+
+  private async handleTelegramMessage(ctx: Context): Promise<void> {
+    const message = ctx.message ?? ctx.editedMessage;
+    if (!message?.text) return;
+
+    const chatId = message.chat.id.toString();
+    const isGroup = message.chat.type === "group" || message.chat.type === "supergroup";
+    const kind = isGroup ? "group" : "direct";
+    const peerId = isGroup 
+      ? `${message.chat.id}:${message.from?.id ?? "unknown"}`
+      : chatId;
+
+    if (!isGroup && !this.isUserAllowed(chatId)) {
+      this.log.debug(`Message from unauthorized user: ${chatId}`);
+      await ctx.reply("Sorry, you are not authorized to use this bot.");
+      return;
+    }
+
+    if (isGroup && !this.config.groups) {
+      return;
+    }
+
+    const incomingMessage: IncomingMessage = {
+      sessionId: this.formatSessionId(peerId, kind),
+      channel: "telegram",
+      accountId: this.accountId,
+      peerId,
+      peerKind: kind,
+      content: message.text,
+      metadata: {
+        telegram: {
+          chatId: message.chat.id,
+          userId: message.from?.id,
+          username: message.from?.username,
+          messageId: message.message_id,
+          chatType: message.chat.type,
+        },
+      },
+      replyToId: message.reply_to_message 
+        ? `tg:${message.reply_to_message.message_id}` 
+        : undefined,
+    };
+
+    await this.handleMessage(incomingMessage);
+  }
+
+  async stop(): Promise<void> {
+    if (this.bot) {
+      this.bot.stop();
+      this.running = false;
+      this.log.info("Telegram bot stopped");
+    }
+  }
+
+  async send(sessionId: string, message: OutboundMessage): Promise<void> {
+    if (!this.bot) {
+      throw new Error("Telegram bot not started");
+    }
+
+    const parts = sessionId.split(":");
+    const peerPart = parts.slice(3).join(":");
+    const chatIdStr = peerPart?.split(":")[0] ?? peerPart;
+    const chatId = Number(chatIdStr);
+
+    if (isNaN(chatId)) {
+      throw new Error(`Invalid chat ID from session: ${sessionId}`);
+    }
+
+    const content = message.content ?? "";
+    const maxLength = 4096;
+
+    try {
+      if (content.length <= maxLength) {
+        await this.bot.api.sendMessage(chatId, content, { parse_mode: "Markdown" });
+      } else {
+        const chunks = this.chunkMessage(content, maxLength);
+        for (const chunk of chunks) {
+          await this.bot.api.sendMessage(chatId, chunk, { parse_mode: "Markdown" });
+        }
+      }
+    } catch (error) {
+      if (error instanceof GrammyError) {
+        this.log.error(`Telegram API error: ${error.description}`);
+        
+        if (error.error_code === 403) {
+          this.log.warn(`Bot was blocked by user: ${chatId}`);
+        }
+      }
+      throw error;
+    }
+  }
+
+  private chunkMessage(content: string, maxLength: number): string[] {
+    const chunks: string[] = [];
+    let remaining = content;
+
+    while (remaining.length > 0) {
+      if (remaining.length <= maxLength) {
+        chunks.push(remaining);
+        break;
+      }
+
+      let splitPoint = remaining.lastIndexOf("\n", maxLength);
+      if (splitPoint === -1 || splitPoint < maxLength * 0.5) {
+        splitPoint = remaining.lastIndexOf(" ", maxLength);
+      }
+      if (splitPoint === -1 || splitPoint < maxLength * 0.5) {
+        splitPoint = maxLength;
+      }
+
+      chunks.push(remaining.slice(0, splitPoint));
+      remaining = remaining.slice(splitPoint).trim();
+    }
+
+    return chunks;
+  }
+}
+
+export function createTelegramChannel(accountId: string, config: TelegramConfig): TelegramChannel {
+  return new TelegramChannel(accountId, config);
+}

package/src/channels/webchat.ts

@@ -0,0 +1,83 @@
+import type { ServerWebSocket } from "bun";
+import { BaseChannel, type ChannelConfig, type IncomingMessage, type OutboundMessage } from "./base.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface WebChatConfig extends ChannelConfig {
+  // WebChat doesn't need extra config, it's served from the gateway
+}
+
+interface WebSocketData {
+  sessionId: string;
+  peerId: string;
+  authenticatedAt: number;
+}
+
+export class WebChatChannel extends BaseChannel {
+  name = "webchat";
+  accountId = "default";
+  config: WebChatConfig;
+  
+  private connections: Map<string, ServerWebSocket<WebSocketData>> = new Map();
+  private log = logger.child("webchat");
+
+  constructor(config: WebChatConfig) {
+    super();
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    this.running = true;
+    this.log.info("WebChat channel ready");
+  }
+
+  async stop(): Promise<void> {
+    this.connections.clear();
+    this.running = false;
+    this.log.info("WebChat channel stopped");
+  }
+
+  registerConnection(ws: ServerWebSocket<WebSocketData>): void {
+    const data = ws.data as WebSocketData;
+    this.connections.set(data.sessionId, ws);
+    this.log.debug(`WebChat connection registered: ${data.sessionId}`);
+  }
+
+  unregisterConnection(sessionId: string): void {
+    this.connections.delete(sessionId);
+    this.log.debug(`WebChat connection unregistered: ${sessionId}`);
+  }
+
+  async send(sessionId: string, message: OutboundMessage): Promise<void> {
+    const ws = this.connections.get(sessionId);
+    
+    if (!ws) {
+      this.log.warn(`No WebChat connection for session: ${sessionId}`);
+      return;
+    }
+
+    try {
+      ws.send(JSON.stringify(message));
+    } catch (error) {
+      this.log.error(`Failed to send WebChat message: ${(error as Error).message}`);
+    }
+  }
+
+  createIncomingMessage(
+    sessionId: string,
+    content: string,
+    peerId: string
+  ): IncomingMessage {
+    return {
+      sessionId,
+      channel: "webchat",
+      accountId: this.accountId,
+      peerId,
+      peerKind: "direct",
+      content,
+    };
+  }
+}
+
+export function createWebChatChannel(config: WebChatConfig): WebChatChannel {
+  return new WebChatChannel(config);
+}

package/src/channels/whatsapp.ts

@@ -0,0 +1,305 @@
+import makeWASocket, {
+  DisconnectReason,
+  useMultiFileAuthState,
+  type WASocket,
+  type ConnectionState,
+} from "@whiskeysockets/baileys";
+import type { ChannelConfig, IncomingMessage, OutboundMessage } from "./base.ts";
+import { BaseChannel } from "./base.ts";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { logger } from "../utils/logger.ts";
+
+export interface WhatsAppConfig extends ChannelConfig {
+  accountId: string;
+  agentId: string;
+  reconnectMaxAttempts?: number;
+  reconnectBaseDelayMs?: number;
+}
+
+export interface WhatsAppConnectionState {
+  status: "connecting" | "connected" | "disconnected" | "qr" | "error";
+  qrCode?: string;
+  lastConnected?: Date;
+  reconnectAttempts: number;
+  error?: string;
+}
+
+export class WhatsAppChannel extends BaseChannel {
+  name = "whatsapp";
+  accountId: string;
+  config: WhatsAppConfig;
+  
+  private socket: WASocket | null = null;
+  private connectionState: WhatsAppConnectionState = {
+    status: "disconnected",
+    reconnectAttempts: 0,
+  };
+  private authPath: string;
+  private reconnectTimeout: Timer | null = null;
+  private log = logger.child("whatsapp");
+
+  constructor(config: WhatsAppConfig) {
+    super();
+    this.config = config;
+    this.accountId = config.accountId;
+    this.authPath = this.getAuthPath(config.agentId, config.accountId);
+  }
+
+  private getAuthPath(agentId: string, accountId: string): string {
+    const baseDir = process.env.HOME ?? "";
+    const authDir = path.join(baseDir, ".hive", "agents", agentId, "whatsapp", accountId);
+    
+    if (!fs.existsSync(authDir)) {
+      fs.mkdirSync(authDir, { recursive: true });
+    }
+    
+    return authDir;
+  }
+
+  async start(): Promise<void> {
+    this.running = true;
+    await this.connect();
+  }
+
+  async stop(): Promise<void> {
+    this.running = false;
+    
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+
+    if (this.socket) {
+      try {
+        await this.socket.end(undefined);
+      } catch {
+        // Ignore close errors
+      }
+      this.socket = null;
+    }
+
+    this.connectionState.status = "disconnected";
+    this.log.info("WhatsApp channel stopped");
+  }
+
+  private async connect(): Promise<void> {
+    if (!this.running) return;
+
+    this.connectionState.status = "connecting";
+    this.log.info("Connecting to WhatsApp...");
+
+    try {
+      const { state, saveCreds } = await useMultiFileAuthState(this.authPath);
+
+      this.socket = makeWASocket({
+        auth: state,
+        printQRInTerminal: false,
+        logger: this.createBaileysLogger(),
+        getMessage: async () => ({ conversation: "" }),
+      });
+
+      this.socket.ev.on("connection.update", async (update) => {
+        await this.handleConnectionUpdate(update, saveCreds);
+      });
+
+      this.socket.ev.on("messages.upsert", async (update) => {
+        await this.handleMessages(update);
+      });
+
+      this.socket.ev.on("creds.update", saveCreds);
+
+    } catch (error) {
+      this.connectionState.status = "error";
+      this.connectionState.error = (error as Error).message;
+      this.log.error(`WhatsApp connection error: ${(error as Error).message}`);
+      this.scheduleReconnect();
+    }
+  }
+
+  private createBaileysLogger(): undefined {
+    return undefined;
+  }
+
+  private async handleConnectionUpdate(
+    update: Partial<ConnectionState>,
+    saveCreds: () => Promise<void>
+  ): Promise<void> {
+    const { connection, lastDisconnect, qr } = update;
+
+    if (qr) {
+      this.connectionState.status = "qr";
+      this.connectionState.qrCode = qr;
+      this.printQR(qr);
+      this.log.info("Scan the QR code above with WhatsApp");
+    }
+
+    if (connection === "close") {
+      const statusCode = (lastDisconnect?.error as { output?: { statusCode: number } })?.output?.statusCode;
+      const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
+
+      this.connectionState.status = "disconnected";
+      this.log.warn(`WhatsApp disconnected: ${statusCode}`);
+
+      if (statusCode === DisconnectReason.loggedOut) {
+        this.log.error("WhatsApp logged out - session invalidated. Need to re-scan QR.");
+        fs.rmSync(this.authPath, { recursive: true, force: true });
+        fs.mkdirSync(this.authPath, { recursive: true });
+      }
+
+      if (shouldReconnect && this.running) {
+        this.scheduleReconnect();
+      }
+    }
+
+    if (connection === "open") {
+      this.connectionState.status = "connected";
+      this.connectionState.lastConnected = new Date();
+      this.connectionState.reconnectAttempts = 0;
+      this.connectionState.qrCode = undefined;
+      void saveCreds();
+      this.log.info("WhatsApp connected successfully");
+    }
+  }
+
+  private printQR(qr: string): void {
+    console.log("\n" + "=".repeat(50));
+    console.log("  WHATSAPP QR CODE - Scan with your phone");
+    console.log("=".repeat(50) + "\n");
+    
+    const qrcode = require("qrcode-terminal");
+    qrcode.generate(qr, { small: false }, (qrString: string) => {
+      console.log(qrString);
+    });
+
+    console.log("\n" + "=".repeat(50));
+    console.log("  Open WhatsApp > Settings > Linked Devices");
+    console.log("=".repeat(50) + "\n");
+  }
+
+  private async handleMessages(update: { messages: unknown[]; type: string }): Promise<void> {
+    if (update.type !== "notify") return;
+
+    for (const msg of update.messages) {
+      const typedMsg = msg as {
+        key: { fromMe?: boolean; remoteJid?: string; id?: string };
+        message?: Record<string, unknown>;
+        messageTimestamp?: number;
+        pushName?: string;
+      };
+      
+      if (typedMsg.key.fromMe) continue;
+
+      const from = typedMsg.key.remoteJid;
+      if (!from) continue;
+
+      const content = this.extractMessageContent(typedMsg.message);
+      if (!content) continue;
+
+      const isGroup = from.includes("@g.us");
+      const peerId = isGroup ? from : from.replace("@s.whatsapp.net", "");
+
+      const incoming: IncomingMessage = {
+        sessionId: this.formatSessionId(peerId, isGroup ? "group" : "direct"),
+        channel: "whatsapp",
+        accountId: this.accountId,
+        peerId,
+        peerKind: isGroup ? "group" : "direct",
+        content,
+        metadata: {
+          messageId: typedMsg.key.id,
+          timestamp: typedMsg.messageTimestamp,
+          pushName: typedMsg.pushName,
+        },
+      };
+
+      await this.handleMessage(incoming);
+    }
+  }
+
+  private extractMessageContent(message?: Record<string, unknown>): string | null {
+    if (!message) return null;
+
+    if (message.conversation) {
+      return message.conversation as string;
+    }
+
+    const extendedText = message.extendedTextMessage as { text?: string } | undefined;
+    if (extendedText?.text) {
+      return extendedText.text;
+    }
+
+    const imageMsg = message.imageMessage as { caption?: string } | undefined;
+    if (imageMsg?.caption) {
+      return `[Image] ${imageMsg.caption}`;
+    }
+
+    const videoMsg = message.videoMessage as { caption?: string } | undefined;
+    if (videoMsg?.caption) {
+      return `[Video] ${videoMsg.caption}`;
+    }
+
+    const docMsg = message.documentMessage as { caption?: string } | undefined;
+    if (docMsg?.caption) {
+      return `[Document] ${docMsg.caption}`;
+    }
+
+    if (message.audioMessage) {
+      return "[Audio message]";
+    }
+
+    return null;
+  }
+
+  private scheduleReconnect(): void {
+    if (!this.running) return;
+
+    const maxAttempts = this.config.reconnectMaxAttempts ?? 10;
+    const baseDelay = this.config.reconnectBaseDelayMs ?? 5000;
+    const attempts = this.connectionState.reconnectAttempts;
+
+    if (attempts >= maxAttempts) {
+      this.log.error(`Max reconnection attempts (${maxAttempts}) reached`);
+      this.connectionState.status = "error";
+      this.connectionState.error = "Max reconnection attempts reached";
+      return;
+    }
+
+    const delay = Math.min(baseDelay * Math.pow(2, attempts), 60000);
+    this.connectionState.reconnectAttempts++;
+
+    this.log.info(`Reconnecting in ${delay / 1000}s (attempt ${attempts + 1}/${maxAttempts})`);
+
+    this.reconnectTimeout = setTimeout(async () => {
+      await this.connect();
+    }, delay);
+  }
+
+  async send(sessionId: string, message: OutboundMessage): Promise<void> {
+    if (!this.socket || this.connectionState.status !== "connected") {
+      throw new Error("WhatsApp not connected");
+    }
+
+    const text = message.content ?? message.chunk ?? "";
+    if (!text) return;
+
+    const peerId = this.extractPeerId(sessionId);
+    const jid = peerId.includes("@") ? peerId : `${peerId}@s.whatsapp.net`;
+
+    await this.socket.sendMessage(jid, { text });
+    this.log.debug(`Sent message to ${peerId}`);
+  }
+
+  private extractPeerId(sessionId: string): string {
+    const parts = sessionId.split(":");
+    return parts[parts.length - 1] ?? "";
+  }
+
+  getState(): WhatsAppConnectionState {
+    return { ...this.connectionState };
+  }
+}
+
+export function createWhatsAppChannel(config: WhatsAppConfig): WhatsAppChannel {
+  return new WhatsAppChannel(config);
+}

package/src/config/index.ts

@@ -0,0 +1 @@
+export * from "./loader.ts";