@johpaz/hive-core 1.0.6 → 1.0.7

package/src/channels/manager.ts

@@ -25,7 +25,8 @@ export class ChannelManager {
     const channelConfigs = this.config.channels ?? {};
 
     for (const [channelName, channelConfig] of Object.entries(channelConfigs)) {
-      if (!channelConfig.enabled) {
+      // If enabled is explicitly false, skip
+      if (channelConfig.enabled === false) {
         this.log.debug(`Channel ${channelName} is disabled`);
         continue;
       }
@@ -61,7 +62,7 @@ export class ChannelManager {
           channel = createTelegramChannel(accountId, {
             enabled: true,
             botToken: config.botToken as string,
-            dmPolicy: (config.dmPolicy as "open" | "pairing" | "allowlist") ?? "pairing",
+            dmPolicy: (config.dmPolicy as "open" | "pairing" | "allowlist") ?? "open",
             allowFrom: (config.allowFrom as string[]) ?? [],
             groups: (config.groups as boolean) ?? false,
           } as TelegramConfig);
@@ -173,6 +174,95 @@ export class ChannelManager {
     return undefined;
   }
 
+  async removeChannel(channelName: string, accountId: string): Promise<void> {
+    const key = `${channelName}:${accountId}`;
+    await this.stopChannel(channelName, accountId);
+    this.channels.delete(key);
+    this.log.info(`Removed channel: ${key}`);
+  }
+
+  getAccountConfig(channelName: string, accountId: string): any {
+    const channelConfigs = (this.config.channels ?? {}) as Record<string, any>;
+    const channelConfig = channelConfigs[channelName];
+    if (!channelConfig) return null;
+
+    const accounts = channelConfig.accounts ?? { default: channelConfig };
+    return accounts[accountId] || null;
+  }
+
+  async startChannel(channelName: string, accountId: string): Promise<void> {
+    const key = `${channelName}:${accountId}`;
+    let channel = this.channels.get(key);
+
+    if (!channel) {
+      const channelConfigs = (this.config.channels ?? {}) as Record<string, any>;
+      const channelConfig = channelConfigs[channelName];
+      if (!channelConfig) {
+        throw new Error(`Channel configuration not found: ${channelName}`);
+      }
+
+      const accounts = channelConfig.accounts ?? { default: channelConfig };
+      const accountConfig = accounts[accountId];
+      if (!accountConfig && accountId !== "default") {
+        throw new Error(`Account configuration not found: ${accountId} for channel ${channelName}`);
+      }
+
+      const fullConfig = { ...channelConfig, ...(accountConfig ?? {}) };
+      await this.createChannel(channelName, accountId, fullConfig as any);
+      channel = this.channels.get(key);
+    }
+
+    if (!channel) {
+      throw new Error(`Failed to instantiate channel: ${key}`);
+    }
+
+    if (channel.isRunning()) {
+      this.log.info(`Channel ${key} is already running`);
+      return;
+    }
+
+    await channel.start();
+    this.log.info(`Started channel: ${key}`);
+  }
+
+  async stopChannel(channelName: string, accountId: string): Promise<void> {
+    const key = `${channelName}:${accountId}`;
+    const channel = this.channels.get(key);
+
+    if (!channel) {
+      this.log.warn(`Channel ${key} not found or not instantiated`);
+      return;
+    }
+
+    if (!channel.isRunning()) {
+      this.log.info(`Channel ${key} is not running`);
+      return;
+    }
+
+    await channel.stop();
+    this.log.info(`Stopped channel: ${key}`);
+  }
+
+  listAllAvailableChannels(): Array<{ name: string; accountId: string; running: boolean; enabled: boolean }> {
+    const available: Array<{ name: string; accountId: string; running: boolean; enabled: boolean }> = [];
+    const channelConfigs = (this.config.channels ?? {}) as Record<string, any>;
+
+    for (const [channelName, channelConfig] of Object.entries(channelConfigs)) {
+      const accounts = channelConfig.accounts ?? { default: channelConfig };
+      for (const accountId of Object.keys(accounts)) {
+        const key = `${channelName}:${accountId}`;
+        const channel = this.channels.get(key);
+        available.push({
+          name: channelName,
+          accountId: accountId,
+          running: channel ? channel.isRunning() : false,
+          enabled: channelConfig.enabled !== false,
+        });
+      }
+    }
+    return available;
+  }
+
   listChannels(): Array<{ name: string; accountId: string; running: boolean }> {
     return Array.from(this.channels.entries()).map(([key, channel]) => {
       const [name, accountId] = key.split(":");
@@ -190,13 +280,34 @@ export class ChannelManager {
     message: unknown
   ): Promise<void> {
     const channel = this.getChannel(channelName);
-    
+
     if (!channel) {
       throw new Error(`Channel not found: ${channelName}`);
     }
 
     await channel.send(sessionId, message as any);
   }
+
+  async startTyping(channelName: string, sessionId: string): Promise<void> {
+    const channel = this.getChannel(channelName);
+    if (channel?.startTyping) {
+      await channel.startTyping(sessionId);
+    }
+  }
+
+  async stopTyping(channelName: string, sessionId: string): Promise<void> {
+    const channel = this.getChannel(channelName);
+    if (channel?.stopTyping) {
+      await channel.stopTyping(sessionId);
+    }
+  }
+
+  async markAsRead(channelName: string, sessionId: string, messageId?: string): Promise<void> {
+    const channel = this.getChannel(channelName);
+    if (channel?.markAsRead) {
+      await channel.markAsRead(sessionId, messageId);
+    }
+  }
 }
 
 export function createChannelManager(config: Config): ChannelManager {

package/src/channels/slack.ts

@@ -25,6 +25,7 @@ export class SlackChannel extends BaseChannel {
     status: "disconnected",
   };
   private log = logger.child("slack");
+  private pendingMessages: Map<string, { ts: string; channel: string }> = new Map();
 
   constructor(config: SlackConfig) {
     super();
@@ -171,6 +172,29 @@ export class SlackChannel extends BaseChannel {
     await this.handleMessage(incoming);
   }
 
+  async startTyping(sessionId: string): Promise<void> {
+    if (!this.app) return;
+
+    const peerId = this.extractPeerId(sessionId);
+
+    try {
+      const result = await this.app.client.chat.postMessage({
+        channel: peerId,
+        text: "⏳ Procesando...",
+      });
+
+      if (result.ts && result.channel) {
+        this.pendingMessages.set(sessionId, { ts: result.ts as string, channel: result.channel as string });
+      }
+    } catch (error) {
+      this.log.debug(`Could not send typing placeholder: ${(error as Error).message}`);
+    }
+  }
+
+  async stopTyping(_sessionId: string): Promise<void> {
+    // No-op for Slack - we edit the message in send()
+  }
+
   async send(sessionId: string, message: OutboundMessage): Promise<void> {
     if (!this.app) {
       throw new Error("Slack not connected");
@@ -180,12 +204,22 @@ export class SlackChannel extends BaseChannel {
     if (!text) return;
 
     const peerId = this.extractPeerId(sessionId);
+    const pending = this.pendingMessages.get(sessionId);
 
     try {
-      await this.app.client.chat.postMessage({
-        channel: peerId,
-        text,
-      });
+      if (pending) {
+        await this.app.client.chat.update({
+          channel: pending.channel,
+          ts: pending.ts,
+          text,
+        });
+        this.pendingMessages.delete(sessionId);
+      } else {
+        await this.app.client.chat.postMessage({
+          channel: peerId,
+          text,
+        });
+      }
 
       this.log.debug(`Sent message to ${peerId}`);
     } catch (error) {

package/src/channels/telegram.ts

@@ -11,14 +11,21 @@ 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();
 
   constructor(accountId: string, config: TelegramConfig) {
     super();
     this.accountId = accountId;
-    this.config = config;
+    this.config = {
+      ...config,
+      dmPolicy: config.dmPolicy ?? "open",
+      allowFrom: config.allowFrom ?? [],
+      enabled: config.enabled ?? true,
+    };
   }
 
   async start(): Promise<void> {
@@ -28,121 +35,331 @@ export class TelegramChannel extends BaseChannel {
 
     this.bot = new Bot(this.config.botToken);
 
-    this.bot.on("message:text", async (ctx) => {
+    this.bot.on("message", async (ctx: Context) => {
       await this.handleTelegramMessage(ctx);
     });
 
-    this.bot.on("edited_message:text", async (ctx) => {
+    this.bot.on("edited_message", async (ctx: Context) => {
       await this.handleTelegramMessage(ctx);
     });
 
-    this.bot.catch((err) => {
+    this.bot.catch((err: Error) => {
       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;
-    }
+    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 ?? ctx.editedMessage;
-    if (!message?.text) return;
+    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 
+    const peerId = isGroup
       ? `${message.chat.id}:${message.from?.id ?? "unknown"}`
       : chatId;
+    const messageId = message.message_id;
+
+    
+    if (message.from?.is_bot) {
+      return;
+    }
+
+    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, añade esto a ~/.hive/hive.yaml:\n` +
+        `<pre>channels:\n  telegram:\n    accounts:\n      default:\n        allowFrom:\n          - "tg:${userId}"</pre>\n\n` +
+        `O 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}`);
-      await ctx.reply("Sorry, you are not authorized to use this bot.");
+      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) {
+    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) {
+      await ctx.reply(
+        "🎤 Recibí tu mensaje de voz. El procesamiento de audio no está disponible todavía.",
+        { parse_mode: "HTML" }
+      );
+      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: this.formatSessionId(peerId, kind),
+      sessionId,
       channel: "telegram",
       accountId: this.accountId,
       peerId,
       peerKind: kind,
-      content: message.text,
+      content: content ?? "",
       metadata: {
         telegram: {
           chatId: message.chat.id,
           userId: message.from?.id,
           username: message.from?.username,
-          messageId: message.message_id,
+          messageId,
           chatType: message.chat.type,
+          contentType,
         },
       },
-      replyToId: message.reply_to_message 
-        ? `tg:${message.reply_to_message.message_id}` 
+      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) {
-      this.bot.stop();
+      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;
+
+    const parts = sessionId.split(":");
+    const peerId = parts.slice(4).join(":");
+    const chatIdStr = peerId.split(":")[0];
+    return Number(chatIdStr);
+  }
+
+  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");
     }
 
-    const parts = sessionId.split(":");
-    const peerPart = parts.slice(3).join(":");
-    const chatIdStr = peerPart?.split(":")[0] ?? peerPart;
-    const chatId = Number(chatIdStr);
+    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.bot.api.sendMessage(chatId, content, { parse_mode: "Markdown" });
+        await this.sendWithRetry(chatId, content, replyToId);
       } else {
         const chunks = this.chunkMessage(content, maxLength);
-        for (const chunk of chunks) {
-          await this.bot.api.sendMessage(chatId, chunk, { parse_mode: "Markdown" });
+        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) {
-      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}`);
+    }
+  } 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;
+  }
+}
+
+  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 options: any = { parse_mode: "Markdown" };
+        if (replyToId) {
+          options.reply_parameters = { message_id: replyToId };
+        }
+        await this.bot!.api.sendMessage(chatId, text, options);
+        return;
+      } catch (error: unknown) {
+        const err = error as Error & { error_code?: number; parameters?: { retry_after?: number } };
+
+        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;
         }
       }
-      throw error;
     }
   }
 
@@ -156,7 +373,10 @@ export class TelegramChannel extends BaseChannel {
         break;
       }
 
-      let splitPoint = remaining.lastIndexOf("\n", maxLength);
+      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);
       }

package/src/channels/webchat.ts

@@ -47,6 +47,28 @@ export class WebChatChannel extends BaseChannel {
     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);