kernelbot 1.0.33 → 1.0.35

package/src/bot.js

@@ -1,6 +1,6 @@
 import TelegramBot from 'node-telegram-bot-api';
 import { createReadStream, readFileSync } from 'fs';
-import { isAllowedUser, getUnauthorizedMessage } from './security/auth.js';
+import { isAllowedUser, getUnauthorizedMessage, alertAdmin } from './security/auth.js';
 import { getLogger } from './utils/logger.js';
 import { PROVIDERS } from './providers/models.js';
 import {
@@ -15,6 +15,55 @@ import {
 import { TTSService } from './services/tts.js';
 import { STTService } from './services/stt.js';
 import { getClaudeAuthStatus, claudeLogout } from './claude-auth.js';
+import { isQuietHours } from './utils/timeUtils.js';
+
+/**
+ * Simulate a human-like typing delay based on response length.
+ * Short replies (casual chat) get a brief pause; longer replies get more.
+ * Keeps the typing indicator alive during the delay so the user sees "typing...".
+ *
+ * @param {TelegramBot} bot - Telegram bot instance
+ * @param {number} chatId - Chat to show typing in
+ * @param {string} text - The reply text (used to calculate delay)
+ * @returns {Promise<void>}
+ */
+async function simulateTypingDelay(bot, chatId, text) {
+  const length = (text || '').length;
+
+  // ~25ms per character, clamped between 0.4s and 4s
+  // Short "hey ❤️" (~6 chars) → 0.4s | Medium reply (~120 chars) → 3s | Long reply → 4s cap
+  const delay = Math.min(4000, Math.max(400, length * 25));
+
+  // Add a small random jitter (±15%) so it doesn't feel mechanical
+  const jitter = delay * (0.85 + Math.random() * 0.3);
+  const finalDelay = Math.round(jitter);
+
+  // Keep the typing indicator alive during the delay
+  bot.sendChatAction(chatId, 'typing').catch(() => {});
+
+  return new Promise((resolve) => setTimeout(resolve, finalDelay));
+}
+
+/**
+ * Simulate a brief pause between consecutive message chunks.
+ * When a long reply is split into multiple Telegram messages, firing them
+ * all instantly feels robotic. This adds a short, natural delay with a
+ * typing indicator so multi-part replies feel more human.
+ *
+ * @param {TelegramBot} bot - Telegram bot instance
+ * @param {number} chatId - Chat to show typing in
+ * @param {string} nextChunk - The upcoming chunk (used to scale the pause)
+ * @returns {Promise<void>}
+ */
+async function simulateInterChunkDelay(bot, chatId, nextChunk) {
+  // Shorter than the initial typing delay: 0.3s – 1.5s based on chunk length
+  const length = (nextChunk || '').length;
+  const base = Math.min(1500, Math.max(300, length * 8));
+  const jitter = base * (0.85 + Math.random() * 0.3);
+
+  bot.sendChatAction(chatId, 'typing').catch(() => {});
+  return new Promise((resolve) => setTimeout(resolve, Math.round(jitter)));
+}
 
 function splitMessage(text, maxLength = 4096) {
   if (text.length <= maxLength) return [text];
@@ -35,9 +84,90 @@ function splitMessage(text, maxLength = 4096) {
   return chunks;
 }
 
+/**
+ * Create an onUpdate callback that sends or edits Telegram messages.
+ * Tries Markdown first, falls back to plain text.
+ */
+function createOnUpdate(bot, chatId) {
+  const logger = getLogger();
+  return async (update, opts = {}) => {
+    if (opts.editMessageId) {
+      try {
+        const edited = await bot.editMessageText(update, {
+          chat_id: chatId,
+          message_id: opts.editMessageId,
+          parse_mode: 'Markdown',
+        });
+        return edited.message_id;
+      } catch (mdErr) {
+        logger.debug(`[Bot] Markdown edit failed for chat ${chatId}, retrying plain: ${mdErr.message}`);
+        try {
+          const edited = await bot.editMessageText(update, {
+            chat_id: chatId,
+            message_id: opts.editMessageId,
+          });
+          return edited.message_id;
+        } catch (plainErr) {
+          logger.debug(`[Bot] Plain-text edit also failed for chat ${chatId}, sending new message: ${plainErr.message}`);
+        }
+      }
+    }
+    const parts = splitMessage(update);
+    let lastMsgId = null;
+    for (const part of parts) {
+      try {
+        const sent = await bot.sendMessage(chatId, part, { parse_mode: 'Markdown' });
+        lastMsgId = sent.message_id;
+      } catch (mdErr) {
+        logger.debug(`[Bot] Markdown send failed for chat ${chatId}, falling back to plain: ${mdErr.message}`);
+        const sent = await bot.sendMessage(chatId, part);
+        lastMsgId = sent.message_id;
+      }
+    }
+    return lastMsgId;
+  };
+}
+
+/**
+ * Create a sendPhoto callback that sends a photo with optional caption.
+ * Tries Markdown caption first, falls back to plain caption.
+ */
+function createSendPhoto(bot, chatId, logger) {
+  return async (filePath, caption) => {
+    const fileOpts = { contentType: 'image/png' };
+    try {
+      await bot.sendPhoto(chatId, createReadStream(filePath), {
+        caption: caption || '',
+        parse_mode: 'Markdown',
+      }, fileOpts);
+    } catch {
+      try {
+        await bot.sendPhoto(chatId, createReadStream(filePath), {
+          caption: caption || '',
+        }, fileOpts);
+      } catch (err) {
+        logger.error(`Failed to send photo: ${err.message}`);
+      }
+    }
+  };
+}
+
+/**
+ * Create a sendReaction callback for reacting to messages with emoji.
+ */
+function createSendReaction(bot) {
+  return async (targetChatId, targetMsgId, emoji, isBig = false) => {
+    await bot.setMessageReaction(targetChatId, targetMsgId, {
+      reaction: [{ type: 'emoji', emoji }],
+      is_big: isBig,
+    });
+  };
+}
+
 /**
  * Simple per-chat queue to serialize agent processing.
  * Each chat gets its own promise chain so messages are processed in order.
+ * Automatically cleans up finished queues to avoid unbounded Map growth.
  */
 class ChatQueue {
   constructor() {
@@ -45,9 +175,21 @@ class ChatQueue {
   }
 
   enqueue(chatId, fn) {
+    const logger = getLogger();
     const key = String(chatId);
     const prev = this.queues.get(key) || Promise.resolve();
-    const next = prev.then(() => fn()).catch(() => {});
+    const next = prev
+      .then(() => fn())
+      .catch((err) => {
+        logger.error(`[ChatQueue] Error processing message for chat ${key}: ${err.message}`);
+      })
+      .finally(() => {
+        // Clean up the queue entry once this is the last item in the chain,
+        // preventing the Map from growing unboundedly over long-running sessions.
+        if (this.queues.get(key) === next) {
+          this.queues.delete(key);
+        }
+      });
     this.queues.set(key, next);
     return next;
   }
@@ -119,54 +261,8 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     const sendAction = (chatId, action) => bot.sendChatAction(chatId, action).catch(() => {});
 
     const agentFactory = (chatId) => {
-      const onUpdate = async (update, opts = {}) => {
-        if (opts.editMessageId) {
-          try {
-            const edited = await bot.editMessageText(update, {
-              chat_id: chatId,
-              message_id: opts.editMessageId,
-              parse_mode: 'Markdown',
-            });
-            return edited.message_id;
-          } catch {
-            try {
-              const edited = await bot.editMessageText(update, {
-                chat_id: chatId,
-                message_id: opts.editMessageId,
-              });
-              return edited.message_id;
-            } catch {
-              // Edit failed — fall through to send new message
-            }
-          }
-        }
-        const parts = splitMessage(update);
-        let lastMsgId = null;
-        for (const part of parts) {
-          try {
-            const sent = await bot.sendMessage(chatId, part, { parse_mode: 'Markdown' });
-            lastMsgId = sent.message_id;
-          } catch {
-            const sent = await bot.sendMessage(chatId, part);
-            lastMsgId = sent.message_id;
-          }
-        }
-        return lastMsgId;
-      };
-
-      const sendPhoto = async (filePath, caption) => {
-        const fileOpts = { contentType: 'image/png' };
-        try {
-          await bot.sendPhoto(chatId, createReadStream(filePath), { caption: caption || '', parse_mode: 'Markdown' }, fileOpts);
-        } catch {
-          try {
-            await bot.sendPhoto(chatId, createReadStream(filePath), { caption: caption || '' }, fileOpts);
-          } catch (err) {
-            logger.error(`[Automation] Failed to send photo: ${err.message}`);
-          }
-        }
-      };
-
+      const onUpdate = createOnUpdate(bot, chatId);
+      const sendPhoto = createSendPhoto(bot, chatId, logger);
       return { agent, onUpdate, sendPhoto };
     };
 
@@ -194,6 +290,13 @@ export function startBot(config, agent, conversationManager, jobManager, automat
 
     if (!isAllowedUser(query.from.id, config)) {
       await bot.answerCallbackQuery(query.id, { text: 'Unauthorized' });
+      await alertAdmin(bot, {
+        userId: query.from.id,
+        username: query.from.username,
+        firstName: query.from.first_name,
+        text: `🔘 زر: ${query.data || 'unknown'}`,
+        type: 'callback',
+      });
       return;
     }
 
@@ -683,6 +786,13 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       if (msg.text || msg.document) {
         logger.warn(`Unauthorized access attempt from ${username} (${userId})`);
         await bot.sendMessage(chatId, getUnauthorizedMessage());
+        await alertAdmin(bot, {
+          userId,
+          username: msg.from.username,
+          firstName: msg.from.first_name,
+          text: msg.text || (msg.document ? `📎 ملف: ${msg.document.file_name || 'unknown'}` : undefined),
+          type: 'رسالة',
+        });
       }
       return;
     }
@@ -748,6 +858,37 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       }
     }
 
+    // Handle photo messages — download, convert to base64, and pass to LLM for vision analysis
+    let imageAttachment = null;
+    if (msg.photo && msg.photo.length > 0) {
+      logger.info(`[Bot] Photo message from ${username} (${userId}) in chat ${chatId}`);
+      try {
+        // Use highest resolution (last item in array)
+        const photo = msg.photo[msg.photo.length - 1];
+        const fileLink = await bot.getFileLink(photo.file_id);
+        const response = await fetch(fileLink);
+        if (!response.ok) throw new Error(`Failed to download photo: ${response.statusText}`);
+        const buffer = Buffer.from(await response.arrayBuffer());
+        const base64Data = buffer.toString('base64');
+
+        // Determine media type from URL extension, default to jpeg
+        const ext = fileLink.split('.').pop().split('?')[0].toLowerCase();
+        const extToMime = { jpg: 'image/jpeg', jpeg: 'image/jpeg', png: 'image/png', gif: 'image/gif', webp: 'image/webp' };
+        const mediaType = extToMime[ext] || 'image/jpeg';
+
+        imageAttachment = { type: 'base64', media_type: mediaType, data: base64Data };
+        // Use caption as text, or default prompt
+        if (!msg.text) {
+          msg.text = msg.caption || 'What do you see in this image? Describe it in detail.';
+        }
+        logger.info(`[Bot] Photo downloaded and encoded (${Math.round(base64Data.length / 1024)}KB base64, ${mediaType})`);
+      } catch (err) {
+        logger.error(`[Bot] Photo processing failed: ${err.message}`);
+        await bot.sendMessage(chatId, 'Failed to process the image. Please try again.');
+        return;
+      }
+    }
+
     if (!msg.text) return; // ignore non-text (and non-document) messages
 
     let text = msg.text.trim();
@@ -1580,90 +1721,38 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       bot.sendChatAction(chatId, 'typing').catch(() => {});
 
       try {
-        const onUpdate = async (update, opts = {}) => {
-          // Edit an existing message instead of sending a new one
-          if (opts.editMessageId) {
-            try {
-              const edited = await bot.editMessageText(update, {
-                chat_id: chatId,
-                message_id: opts.editMessageId,
-                parse_mode: 'Markdown',
-              });
-              return edited.message_id;
-            } catch {
-              try {
-                const edited = await bot.editMessageText(update, {
-                  chat_id: chatId,
-                  message_id: opts.editMessageId,
-                });
-                return edited.message_id;
-              } catch {
-                // Edit failed — fall through to send new message
-              }
-            }
-          }
-
-          // Send new message(s) — also reached when edit fails
-          const parts = splitMessage(update);
-          let lastMsgId = null;
-          for (const part of parts) {
-            try {
-              const sent = await bot.sendMessage(chatId, part, { parse_mode: 'Markdown' });
-              lastMsgId = sent.message_id;
-            } catch {
-              const sent = await bot.sendMessage(chatId, part);
-              lastMsgId = sent.message_id;
-            }
-          }
-          return lastMsgId;
-        };
-
-        const sendPhoto = async (filePath, caption) => {
-          const fileOpts = { contentType: 'image/png' };
-          try {
-            await bot.sendPhoto(chatId, createReadStream(filePath), {
-              caption: caption || '',
-              parse_mode: 'Markdown',
-            }, fileOpts);
-          } catch {
-            try {
-              await bot.sendPhoto(chatId, createReadStream(filePath), {
-                caption: caption || '',
-              }, fileOpts);
-            } catch (err) {
-              logger.error(`Failed to send photo: ${err.message}`);
-            }
-          }
-        };
-
-        const sendReaction = async (targetChatId, targetMsgId, emoji, isBig = false) => {
-          await bot.setMessageReaction(targetChatId, targetMsgId, {
-            reaction: [{ type: 'emoji', emoji }],
-            is_big: isBig,
-          });
-        };
+        const onUpdate = createOnUpdate(bot, chatId);
+        const sendPhoto = createSendPhoto(bot, chatId, logger);
+        const sendReaction = createSendReaction(bot);
 
         logger.debug(`[Bot] Sending to orchestrator: chat ${chatId}, text="${mergedText.slice(0, 80)}"`);
         const reply = await agent.processMessage(chatId, mergedText, {
           id: userId,
           username,
-        }, onUpdate, sendPhoto, { sendReaction, messageId: msg.message_id });
+        }, onUpdate, sendPhoto, { sendReaction, messageId: msg.message_id, imageAttachment });
 
         clearInterval(typingInterval);
 
+        // Simulate human-like typing delay before sending the reply
+        await simulateTypingDelay(bot, chatId, reply || '');
+
         logger.info(`[Bot] Reply for chat ${chatId}: ${(reply || '').length} chars`);
         const chunks = splitMessage(reply || 'Done.');
-        for (const chunk of chunks) {
+        for (let i = 0; i < chunks.length; i++) {
+          // Brief pause between consecutive chunks so multi-part replies feel natural
+          if (i > 0) await simulateInterChunkDelay(bot, chatId, chunks[i]);
           try {
-            await bot.sendMessage(chatId, chunk, { parse_mode: 'Markdown' });
+            await bot.sendMessage(chatId, chunks[i], { parse_mode: 'Markdown' });
           } catch {
             // Fallback to plain text if Markdown fails
-            await bot.sendMessage(chatId, chunk);
+            await bot.sendMessage(chatId, chunks[i]);
           }
         }
 
-        // Send voice reply if TTS is available and the reply isn't too short
-        if (ttsService.isAvailable() && reply && reply.length > 5) {
+        // Send voice reply only when the user explicitly requests it
+        const voiceKeywords = ['صوت', 'صوتك', 'صوتية', 'صوتي', 'voice', 'speak', 'hear you'];
+        const wantsVoice = voiceKeywords.some((kw) => mergedText.toLowerCase().includes(kw));
+        if (wantsVoice && ttsService.isAvailable() && reply && reply.length > 5) {
           try {
             const audioPath = await ttsService.synthesize(reply);
             if (audioPath) {
@@ -1687,7 +1776,18 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     const userId = reaction.user?.id;
     const username = reaction.user?.username || reaction.user?.first_name || 'unknown';
 
-    if (!userId || !isAllowedUser(userId, config)) return;
+    if (!userId || !isAllowedUser(userId, config)) {
+      if (userId) {
+        await alertAdmin(bot, {
+          userId,
+          username: reaction.user?.username,
+          firstName: reaction.user?.first_name,
+          text: `${(reaction.new_reaction || []).filter(r => r.type === 'emoji').map(r => r.emoji).join(' ') || 'reaction'}`,
+          type: 'تفاعل',
+        });
+      }
+      return;
+    }
 
     const newReactions = reaction.new_reaction || [];
     const emojis = newReactions
@@ -1701,65 +1801,39 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     const reactionText = `[User reacted with ${emojis.join(' ')} to your message]`;
 
     chatQueue.enqueue(chatId, async () => {
-      try {
-        const onUpdate = async (update, opts = {}) => {
-          if (opts.editMessageId) {
-            try {
-              const edited = await bot.editMessageText(update, {
-                chat_id: chatId,
-                message_id: opts.editMessageId,
-                parse_mode: 'Markdown',
-              });
-              return edited.message_id;
-            } catch {
-              try {
-                const edited = await bot.editMessageText(update, {
-                  chat_id: chatId,
-                  message_id: opts.editMessageId,
-                });
-                return edited.message_id;
-              } catch {
-                // fall through
-              }
-            }
-          }
-          const parts = splitMessage(update);
-          let lastMsgId = null;
-          for (const part of parts) {
-            try {
-              const sent = await bot.sendMessage(chatId, part, { parse_mode: 'Markdown' });
-              lastMsgId = sent.message_id;
-            } catch {
-              const sent = await bot.sendMessage(chatId, part);
-              lastMsgId = sent.message_id;
-            }
-          }
-          return lastMsgId;
-        };
+      // Show typing indicator while processing the reaction
+      const typingInterval = setInterval(() => {
+        bot.sendChatAction(chatId, 'typing').catch(() => {});
+      }, 4000);
+      bot.sendChatAction(chatId, 'typing').catch(() => {});
 
-        const sendReaction = async (targetChatId, targetMsgId, emoji, isBig = false) => {
-          await bot.setMessageReaction(targetChatId, targetMsgId, {
-            reaction: [{ type: 'emoji', emoji }],
-            is_big: isBig,
-          });
-        };
+      try {
+        const onUpdate = createOnUpdate(bot, chatId);
+        const sendReaction = createSendReaction(bot);
 
         const reply = await agent.processMessage(chatId, reactionText, {
           id: userId,
           username,
         }, onUpdate, null, { sendReaction, messageId: reaction.message_id });
 
+        clearInterval(typingInterval);
+
         if (reply && reply.trim()) {
+          // Simulate human-like typing delay before responding to the reaction
+          await simulateTypingDelay(bot, chatId, reply);
+
           const chunks = splitMessage(reply);
-          for (const chunk of chunks) {
+          for (let i = 0; i < chunks.length; i++) {
+            if (i > 0) await simulateInterChunkDelay(bot, chatId, chunks[i]);
             try {
-              await bot.sendMessage(chatId, chunk, { parse_mode: 'Markdown' });
+              await bot.sendMessage(chatId, chunks[i], { parse_mode: 'Markdown' });
             } catch {
-              await bot.sendMessage(chatId, chunk);
+              await bot.sendMessage(chatId, chunks[i]);
             }
           }
         }
       } catch (err) {
+        clearInterval(typingInterval);
         logger.error(`[Bot] Error processing reaction in chat ${chatId}: ${err.message}`);
       }
     });
@@ -1769,5 +1843,63 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     logger.error(`Telegram polling error: ${err.message}`);
   });
 
+  // ── Resume active chats after restart ────────────────────────
+  setTimeout(async () => {
+    const sendMsg = async (chatId, text) => {
+      try {
+        await bot.sendMessage(chatId, text, { parse_mode: 'Markdown' });
+      } catch {
+        await bot.sendMessage(chatId, text);
+      }
+    };
+    try {
+      await agent.resumeActiveChats(sendMsg);
+    } catch (err) {
+      logger.error(`[Bot] Resume active chats failed: ${err.message}`);
+    }
+  }, 5000);
+
+  // ── Proactive share delivery (randomized, self-rearming) ────
+  const armShareDelivery = (delivered) => {
+    // If we just delivered something, wait longer (1–4h) before next check
+    // If nothing was delivered, check again sooner (10–45min) in case new shares appear
+    const minMin = delivered ? 60 : 10;
+    const maxMin = delivered ? 240 : 45;
+    const delayMs = (minMin + Math.random() * (maxMin - minMin)) * 60_000;
+
+    logger.debug(`[Bot] Next share check in ${Math.round(delayMs / 60_000)}m`);
+
+    setTimeout(async () => {
+      // Respect quiet hours (env vars → YAML config → defaults 02:00–06:00)
+      if (isQuietHours(config.life)) {
+        armShareDelivery(false);
+        return;
+      }
+
+      const sendMsg = async (chatId, text) => {
+        try {
+          await bot.sendMessage(chatId, text, { parse_mode: 'Markdown' });
+        } catch {
+          await bot.sendMessage(chatId, text);
+        }
+      };
+
+      let didDeliver = false;
+      try {
+        const before = shareQueue ? shareQueue.getPending(null, 1).length : 0;
+        await agent.deliverPendingShares(sendMsg);
+        const after = shareQueue ? shareQueue.getPending(null, 1).length : 0;
+        didDeliver = before > 0 && after < before;
+      } catch (err) {
+        logger.error(`[Bot] Proactive share delivery failed: ${err.message}`);
+      }
+
+      armShareDelivery(didDeliver);
+    }, delayMs);
+  };
+
+  // Start the first check after a random 10–30 min
+  armShareDelivery(false);
+
   return bot;
 }