@johpaz/hive 1.1.0

package/packages/core/src/channels/telegram.ts

@@ -0,0 +1,502 @@
+import { Bot, GrammyError, InputFile, 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");
+  private chatIdCache: Map<string, number> = new Map();
+  private messageIdCache: Map<string, number> = new Map();
+  // Deduplication: records recently processed message_ids to avoid double sends
+  private recentlyProcessed: Map<number, number> = new Map();
+
+  constructor(accountId: string, config: TelegramConfig) {
+    super();
+    this.accountId = accountId;
+    this.config = {
+      ...config,
+      dmPolicy: config.dmPolicy ?? "open",
+      allowFrom: config.allowFrom ?? [],
+      enabled: config.enabled ?? true,
+    };
+  }
+
+  async start(): Promise<void> {
+    if (this.running) {
+      this.log.warn("Telegram bot is already running, skipping start");
+      return;
+    }
+
+    if (!this.config.botToken) {
+      throw new Error("Telegram bot token not configured");
+    }
+
+    this.bot = new Bot(this.config.botToken);
+
+    this.bot.on("message", async (ctx: Context) => {
+      await this.handleTelegramMessage(ctx);
+    });
+
+    // Note: edited_message intentionally NOT handled — editing a message
+    // should not trigger a new agent response (was causing double sends).
+
+    this.bot.catch((err: Error) => {
+      this.log.error(`Telegram error: ${err.message}`);
+    });
+
+    this.bot.start({
+      onStart: () => {
+        this.running = true;
+        this.log.info(`Telegram bot started: @${this.bot?.botInfo?.username ?? "unknown"}`);
+      },
+    }).catch((error: Error) => {
+      this.log.error(`Telegram bot error: ${error.message}`);
+      this.running = false;
+    });
+  }
+
+  private async handleTelegramMessage(ctx: Context): Promise<void> {
+    const message = ctx.message;
+    if (!message) return;
+
+    const chatId = message.chat.id.toString();
+    const userId = message.from?.id?.toString() ?? "unknown";
+    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;
+    const messageId = message.message_id;
+
+    if (message.from?.is_bot) {
+      return;
+    }
+
+    // Deduplication: ignore message_ids already processed in the last 60 seconds
+    const now = Date.now();
+    if (this.recentlyProcessed.has(messageId)) {
+      this.log.debug(`Duplicate message_id ${messageId} ignored`);
+      return;
+    }
+    this.recentlyProcessed.set(messageId, now);
+    // Clean up old entries (> 60s) to prevent unbounded growth
+    for (const [id, ts] of this.recentlyProcessed) {
+      if (now - ts > 60_000) this.recentlyProcessed.delete(id);
+    }
+
+    const text = message.text;
+    const isCommand = text?.startsWith("/") ?? false;
+
+    if (text === "/myid" || text?.startsWith("/myid@")) {
+      await ctx.reply(
+        `🆔 Tu Telegram ID es: <code>${userId}</code>\n\n` +
+        `Para autorizarte, ejecuta:\n` +
+        `<code>hive config set channels.telegram.accounts.default.allowFrom.+ "tg:${userId}"</code>`,
+        { parse_mode: "HTML" }
+      );
+      return;
+    }
+
+    if (text === "/start" || text?.startsWith("/start@")) {
+      const agentName = "Bee";
+      await ctx.reply(
+        `¡Hola! Soy ${agentName}, tu asistente personal.\n\n` +
+        `Tu Telegram ID: <code>${userId}</code>\n\n` +
+        `Para empezar a usar el bot, asegúrate de estar autorizado.`,
+        { parse_mode: "HTML" }
+      );
+      return;
+    }
+
+    if (text === "/help" || text?.startsWith("/help@")) {
+      await ctx.reply(this.getHelpMessage(userId), { parse_mode: "HTML" });
+      return;
+    }
+
+    if (text === "/stop" || text?.startsWith("/stop@")) {
+      await ctx.reply("⏹ Detención actual cancelada.", { parse_mode: "HTML" });
+      return;
+    }
+
+    if (text === "/new" || text?.startsWith("/new@")) {
+      await ctx.reply("🔄 Sesión reiniciada.", { parse_mode: "HTML" });
+      return;
+    }
+
+    if (!isGroup && !this.isUserAllowed(chatId)) {
+      this.log.debug(`Message from unauthorized user: ${chatId}`);
+      const rejectMsg = this.config.dmPolicy === "allowlist"
+        ? `⛔ No estás autorizado.\n\n` +
+        `Tu Telegram ID: <code>${userId}</code>\n\n` +
+        `Para autorizarte:\n` +
+        `1. Ejecuta en el servidor: <code>hive config edit</code>\n` +
+        `2. Añade bajo channels.telegram.accounts.default.allowFrom:\n` +
+        `<pre>  - "tg:${userId}"</pre>\n` +
+        `3. Ejecuta: <code>hive reload</code>`
+        : `⛔ No estás autorizado para usar este bot.\n\n` +
+        `Tu Telegram ID: <code>${userId}</code>`;
+      await ctx.reply(rejectMsg, { parse_mode: "HTML" });
+      return;
+    }
+
+    if (isGroup && !(this.config.groups ?? false)) {
+      return;
+    }
+
+    let content = text;
+    let contentType = "text";
+
+    if (message.photo && !text) {
+      const caption = message.caption ?? "";
+      if (caption) {
+        content = `[📷 Foto] ${caption}`;
+        contentType = "photo";
+      } else {
+        await ctx.reply(
+          "📷 Recibí tu foto. Por favor, añade texto descriptivo para que pueda procesarla.",
+          { parse_mode: "HTML" }
+        );
+        return;
+      }
+    }
+
+    if (message.voice) {
+      const voice = message.voice;
+      const fileId = voice.file_id;
+
+      let audioBuffer: Buffer | undefined;
+      let audioUrl: string | undefined;
+
+      try {
+        const file = await this.bot!.api.getFile(fileId);
+        const filePath = file.file_path;
+        if (filePath) {
+          audioUrl = `https://api.telegram.org/file/bot${this.config.botToken}/${filePath}`;
+        }
+      } catch (error) {
+        this.log.error(`Failed to get voice file: ${(error as Error).message}`);
+      }
+
+      const msgSessionId = this.formatSessionId(peerId, kind);
+
+      const incomingMessage: IncomingMessage = {
+        sessionId: msgSessionId,
+        channel: "telegram",
+        accountId: this.accountId,
+        peerId,
+        peerKind: kind,
+        content: "",
+        audio: audioBuffer ? { buffer: audioBuffer } : audioUrl ? { url: audioUrl, mimeType: "audio/ogg" } : undefined,
+        metadata: {
+          telegram: {
+            chatId: message.chat.id,
+            userId: message.from?.id,
+            username: message.from?.username,
+            messageId,
+            chatType: message.chat.type,
+            contentType: "voice",
+          },
+        },
+        replyToId: message.reply_to_message
+          ? `tg:${message.reply_to_message.message_id}`
+          : undefined,
+      };
+
+      await this.handleMessage(incomingMessage);
+      return;
+    }
+
+    if (message.sticker) {
+      return;
+    }
+
+    if (message.document && !text) {
+      const docName = (message.document as any).file_name ?? "documento";
+      const caption = message.caption ?? "";
+      if (caption) {
+        content = `[📎 ${docName}] ${caption}`;
+        contentType = "document";
+      } else {
+        await ctx.reply(
+          "📎 Recibí tu documento. Por favor, añade texto descriptivo para que pueda procesarlo.",
+          { parse_mode: "HTML" }
+        );
+        return;
+      }
+    }
+
+    const sessionId = this.formatSessionId(peerId, kind);
+    this.chatIdCache.set(sessionId, message.chat.id);
+    this.messageIdCache.set(sessionId, messageId);
+
+    const incomingMessage: IncomingMessage = {
+      sessionId,
+      channel: "telegram",
+      accountId: this.accountId,
+      peerId,
+      peerKind: kind,
+      content: content ?? "",
+      metadata: {
+        telegram: {
+          chatId: message.chat.id,
+          userId: message.from?.id,
+          username: message.from?.username,
+          messageId,
+          chatType: message.chat.type,
+          contentType,
+        },
+      },
+      replyToId: message.reply_to_message
+        ? `tg:${message.reply_to_message.message_id}`
+        : undefined,
+    };
+
+    await this.handleMessage(incomingMessage);
+  }
+
+  private getHelpMessage(_userId: string): string {
+    return `📚 <b>Comandos disponibles:</b>
+
+<code>/myid</code> - Muestra tu Telegram ID
+<code>/start</code> - Iniciar conversación
+<code>/help</code> - Mostrar esta ayuda
+<code>/stop</code> - Detener tarea actual
+<code>/new</code> - Reiniciar sesión
+
+💡 <i>Envía un mensaje para comenzar.</i>`;
+  }
+
+  async stop(): Promise<void> {
+    if (this.bot) {
+      await this.bot.stop();
+      this.running = false;
+      this.log.info("Telegram bot stopped");
+    }
+  }
+
+  private getChatIdFromSession(sessionId: string): number {
+    const cached = this.chatIdCache.get(sessionId);
+    if (cached) return cached;
+
+    // Group format: "chatId:userId" (e.g. "-1001234567890:123456789")
+    // The chat ID is the first segment before the colon.
+    const colonIdx = sessionId.indexOf(":");
+    if (colonIdx > 0) {
+      const parsed = Number(sessionId.slice(0, colonIdx));
+      if (!isNaN(parsed) && parsed !== 0) return parsed;
+    }
+
+    // Direct format: sessionId is the raw chatId (e.g. stored in user_identities)
+    const direct = Number(sessionId);
+    if (!isNaN(direct) && direct !== 0) return direct;
+
+    return 0;
+  }
+
+  private getMessageIdFromSession(sessionId: string): number | undefined {
+    return this.messageIdCache.get(sessionId);
+  }
+
+  async startTyping(sessionId: string): Promise<void> {
+    if (!this.bot) return;
+
+    const chatId = this.getChatIdFromSession(sessionId);
+    if (isNaN(chatId)) return;
+
+    await this.bot.api.sendChatAction(chatId, "typing");
+
+    const interval = setInterval(async () => {
+      try {
+        await this.bot!.api.sendChatAction(chatId, "typing");
+      } catch {
+        this.stopTyping(sessionId);
+      }
+    }, 4000);
+
+    this.typingIntervals.set(sessionId, interval);
+  }
+
+  async stopTyping(sessionId: string): Promise<void> {
+    const interval = this.typingIntervals.get(sessionId);
+    if (interval) {
+      clearInterval(interval);
+      this.typingIntervals.delete(sessionId);
+    }
+  }
+
+  async send(sessionId: string, message: OutboundMessage): Promise<void> {
+    if (!this.bot) {
+      throw new Error("Telegram bot not started");
+    }
+
+    await this.stopTyping(sessionId);
+
+    const chatId = this.getChatIdFromSession(sessionId);
+
+    if (isNaN(chatId)) {
+      throw new Error(`Invalid chat ID from session: ${sessionId}`);
+    }
+
+    const content = message.content ?? "";
+
+    if (!content || content.trim().length === 0) {
+      this.log.warn(`Empty response from agent, skipping send`, { sessionId, chatId });
+      return;
+    }
+
+    const replyToId = this.getMessageIdFromSession(sessionId);
+    const maxLength = 4096;
+
+    try {
+      if (content.length <= maxLength) {
+        await this.sendWithRetry(chatId, content, replyToId);
+      } else {
+        const chunks = this.chunkMessage(content, maxLength);
+        for (let i = 0; i < chunks.length; i++) {
+          await this.sendWithRetry(chatId, chunks[i]!, i === 0 ? replyToId : undefined);
+          if (i < chunks.length - 1) {
+            await new Promise((resolve) => setTimeout(resolve, 300));
+          }
+        }
+      }
+    } catch (error: unknown) {
+      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}`);
+          return;
+        }
+      } else if (error instanceof Error) {
+        this.log.error(`Telegram send error: ${error.message}`);
+      } else {
+        this.log.error(`Telegram send error: ${String(error)}`);
+      }
+      throw error;
+    }
+  }
+
+  async sendAudio(sessionId: string, audio: Buffer, mimeType: string): Promise<void> {
+    if (!this.bot) {
+      throw new Error("Telegram bot not started");
+    }
+
+    const chatId = this.getChatIdFromSession(sessionId);
+
+    if (isNaN(chatId)) {
+      throw new Error(`Invalid chat ID from session: ${sessionId}`);
+    }
+
+    try {
+      const inputFile = new InputFile(audio, "voice.ogg");
+      await this.bot!.api.sendVoice(chatId, inputFile);
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        this.log.error(`Telegram sendAudio error: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+
+  private async sendWithRetry(
+    chatId: number,
+    text: string,
+    replyToId?: number
+  ): Promise<void> {
+    const maxRetries = 3;
+    const backoffMs = [1000, 2000, 4000];
+
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        const html = this.markdownToHTML(text);
+        const options: any = { parse_mode: "HTML" };
+        if (replyToId) {
+          options.reply_parameters = { message_id: replyToId };
+        }
+        await this.bot!.api.sendMessage(chatId, html, options);
+        return;
+      } catch (error: unknown) {
+        const err = error as Error & { error_code?: number; parameters?: { retry_after?: number } };
+
+        if (err.error_code === 400 && err.message.includes("can't parse entities")) {
+          this.log.warn(`Markdown parsing failed, falling back to plain text for chatId: ${chatId}`);
+          await this.bot!.api.sendMessage(chatId, text, {
+            reply_parameters: replyToId ? { message_id: replyToId } : undefined
+          });
+          return;
+        }
+
+        if (err.error_code === 400) {
+          this.log.error(`Bad Request: ${err.message}`);
+          throw error;
+        }
+
+        if (err.error_code === 429) {
+          const retryAfter = err.parameters?.retry_after ?? 1;
+          this.log.warn(`Rate limited, waiting ${retryAfter}s`);
+          await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
+          continue;
+        }
+
+        if (attempt < maxRetries - 1) {
+          this.log.warn(`Send failed, retrying in ${backoffMs[attempt]}ms (attempt ${attempt + 1}/${maxRetries})`);
+          await new Promise((resolve) => setTimeout(resolve, backoffMs[attempt]));
+        } else {
+          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\n", maxLength);
+      if (splitPoint === -1 || splitPoint < maxLength * 0.5) {
+        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;
+  }
+
+  private markdownToHTML(text: string): string {
+    return text
+      .replace(/&/g, "&amp;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/```([\s\S]*?)```/g, (match, code) => `<pre>${code.trim()}</pre>`)
+      .replace(/`([^`]+)`/g, "<code>$1</code>")
+      .replace(/\*\*([^*]+)\*\*/g, "<b>$1</b>")
+      .replace(/_([^_]+)_/g, "<i>$1</i>");
+  }
+}
+
+export function createTelegramChannel(accountId: string, config: TelegramConfig): TelegramChannel {
+  return new TelegramChannel(accountId, config);
+}

package/packages/core/src/channels/webchat.ts

@@ -0,0 +1,128 @@
+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 {
+  accountId?: string;
+  // 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: string;
+  config: WebChatConfig;
+
+  private connections: Map<string, ServerWebSocket<WebSocketData>> = new Map();
+  private log = logger.child("webchat");
+
+  constructor(config: WebChatConfig) {
+    super();
+    this.config = config;
+    this.accountId = config.accountId || process.env.HIVE_USER_ID || "webchat";
+  }
+
+  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 startTyping(sessionId: string): Promise<void> {
+    const ws = this.connections.get(sessionId);
+    if (!ws) return;
+
+    try {
+      ws.send(JSON.stringify({ type: "typing", isTyping: true }));
+    } catch {
+      // Connection closed
+    }
+  }
+
+  async stopTyping(sessionId: string): Promise<void> {
+    const ws = this.connections.get(sessionId);
+    if (!ws) return;
+
+    try {
+      ws.send(JSON.stringify({ type: "typing", isTyping: false }));
+    } catch {
+      // Connection closed
+    }
+  }
+
+  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}`);
+    }
+  }
+
+  async sendAudio(sessionId: string, audio: Buffer, mimeType: string): Promise<void> {
+    const ws = this.connections.get(sessionId);
+
+    if (!ws) {
+      this.log.warn(`No WebChat connection for session: ${sessionId}`);
+      return;
+    }
+
+    try {
+      const base64Audio = audio.toString("base64");
+      ws.send(JSON.stringify({
+        type: "audio",
+        sessionId,
+        audio: base64Audio,
+        mimeType,
+      }));
+    } catch (error) {
+      this.log.error(`Failed to send WebChat audio: ${(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);
+}