kernelbot 1.0.32 → 1.0.34

package/src/bot.js

@@ -16,6 +16,33 @@ import { TTSService } from './services/tts.js';
 import { STTService } from './services/stt.js';
 import { getClaudeAuthStatus, claudeLogout } from './claude-auth.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));
+}
+
 function splitMessage(text, maxLength = 4096) {
   if (text.length <= maxLength) return [text];
 
@@ -35,6 +62,83 @@ 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) {
+  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 {
+        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;
+  };
+}
+
+/**
+ * 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.
@@ -56,7 +160,13 @@ class ChatQueue {
 export function startBot(config, agent, conversationManager, jobManager, automationManager, lifeDeps = {}) {
   const { lifeEngine, memoryManager, journalManager, shareQueue, evolutionTracker, codebaseKnowledge } = lifeDeps;
   const logger = getLogger();
-  const bot = new TelegramBot(config.telegram.bot_token, { polling: true });
+  const bot = new TelegramBot(config.telegram.bot_token, {
+    polling: {
+      params: {
+        allowed_updates: ['message', 'callback_query', 'message_reaction'],
+      },
+    },
+  });
   const chatQueue = new ChatQueue();
   const batchWindowMs = config.telegram.batch_window_ms || 3000;
 
@@ -113,54 +223,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 };
     };
 
@@ -1574,70 +1638,21 @@ 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 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);
+        }, onUpdate, sendPhoto, { sendReaction, messageId: msg.message_id });
 
         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) {
@@ -1668,9 +1683,117 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     });
   });
 
+  // Handle message reactions (love, like, etc.)
+  bot.on('message_reaction', async (reaction) => {
+    const chatId = reaction.chat.id;
+    const userId = reaction.user?.id;
+    const username = reaction.user?.username || reaction.user?.first_name || 'unknown';
+
+    if (!userId || !isAllowedUser(userId, config)) return;
+
+    const newReactions = reaction.new_reaction || [];
+    const emojis = newReactions
+      .filter(r => r.type === 'emoji')
+      .map(r => r.emoji);
+
+    if (emojis.length === 0) return;
+
+    logger.info(`[Bot] Reaction from ${username} (${userId}) in chat ${chatId}: ${emojis.join(' ')}`);
+
+    const reactionText = `[User reacted with ${emojis.join(' ')} to your message]`;
+
+    chatQueue.enqueue(chatId, async () => {
+      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 });
+
+        if (reply && reply.trim()) {
+          const chunks = splitMessage(reply);
+          for (const chunk of chunks) {
+            try {
+              await bot.sendMessage(chatId, chunk, { parse_mode: 'Markdown' });
+            } catch {
+              await bot.sendMessage(chatId, chunk);
+            }
+          }
+        }
+      } catch (err) {
+        logger.error(`[Bot] Error processing reaction in chat ${chatId}: ${err.message}`);
+      }
+    });
+  });
+
   bot.on('polling_error', (err) => {
     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 lifeConfig = config.life || {};
+  const quietStart = lifeConfig.quiet_hours?.start ?? 2;
+  const quietEnd = lifeConfig.quiet_hours?.end ?? 6;
+
+  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
+      const hour = new Date().getHours();
+      if (hour >= quietStart && hour < quietEnd) {
+        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;
 }

package/src/conversation.js

@@ -1,22 +1,42 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import { getLogger } from './utils/logger.js';
 
+/**
+ * Resolve the file path for persisted conversations.
+ * Ensures the parent directory (~/.kernelbot/) exists.
+ * @returns {string} Absolute path to conversations.json.
+ */
 function getConversationsPath() {
   const dir = join(homedir(), '.kernelbot');
   mkdirSync(dir, { recursive: true });
   return join(dir, 'conversations.json');
 }
 
+/**
+ * Manages per-chat conversation history, including persistence to disk,
+ * summarization of older messages, and per-chat skill tracking.
+ */
 export class ConversationManager {
+  /**
+   * @param {object} config - Application config containing `conversation` settings.
+   * @param {number} config.conversation.max_history - Maximum messages to retain per chat.
+   * @param {number} [config.conversation.recent_window=10] - Number of recent messages kept verbatim in summarized history.
+   */
   constructor(config) {
     this.maxHistory = config.conversation.max_history;
     this.recentWindow = config.conversation.recent_window || 10;
     this.conversations = new Map();
     this.activeSkills = new Map();
     this.filePath = getConversationsPath();
+    this.logger = getLogger();
   }
 
+  /**
+   * Load persisted conversations and skills from disk.
+   * @returns {boolean} True if at least one conversation was restored.
+   */
   load() {
     if (!existsSync(this.filePath)) return false;
     try {
@@ -34,12 +54,18 @@ export class ConversationManager {
         if (chatId === '_skills') continue;
         this.conversations.set(String(chatId), messages);
       }
+      this.logger.debug(`Conversations loaded: ${this.conversations.size} chats, ${this.activeSkills.size} active skills`);
       return this.conversations.size > 0;
-    } catch {
+    } catch (err) {
+      this.logger.warn(`Failed to load conversations from ${this.filePath}: ${err.message}`);
       return false;
     }
   }
 
+  /**
+   * Persist all conversations and active skills to disk.
+   * Failures are logged but never thrown to avoid crashing the bot.
+   */
   save() {
     try {
       const data = {};
@@ -55,11 +81,16 @@ export class ConversationManager {
         data._skills = skills;
       }
       writeFileSync(this.filePath, JSON.stringify(data, null, 2));
-    } catch {
-      // Silent fail — don't crash the bot over persistence
+    } catch (err) {
+      this.logger.warn(`Failed to save conversations: ${err.message}`);
     }
   }
 
+  /**
+   * Retrieve the message history for a chat, initializing an empty array if none exists.
+   * @param {string|number} chatId - Telegram chat identifier.
+   * @returns {Array<{role: string, content: string, timestamp?: number}>} Message array (mutable reference).
+   */
   getHistory(chatId) {
     const key = String(chatId);
     if (!this.conversations.has(key)) {
@@ -68,6 +99,48 @@ export class ConversationManager {
     return this.conversations.get(key);
   }
 
+  /**
+   * Get the timestamp of the most recent message in a chat.
+   * Used by agent.js for time-gap detection before the current message is added.
+   */
+  getLastMessageTimestamp(chatId) {
+    const history = this.getHistory(chatId);
+    if (history.length === 0) return null;
+    return history[history.length - 1].timestamp || null;
+  }
+
+  /**
+   * Format a timestamp as a relative time marker.
+   * Returns null for missing timestamps (backward compat with old messages).
+   */
+  _formatRelativeTime(ts) {
+    if (!ts) return null;
+    const diff = Date.now() - ts;
+    const seconds = Math.floor(diff / 1000);
+    if (seconds < 60) return '[just now]';
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60) return `[${minutes}m ago]`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24) return `[${hours}h ago]`;
+    const days = Math.floor(hours / 24);
+    return `[${days}d ago]`;
+  }
+
+  /**
+   * Return a shallow copy of a message with a time marker prepended to string content.
+   * Skips tool_result arrays and messages without timestamps.
+   */
+  _annotateWithTime(msg) {
+    const marker = this._formatRelativeTime(msg.timestamp);
+    if (!marker || typeof msg.content !== 'string') return msg;
+    return { ...msg, content: `${marker} ${msg.content}` };
+  }
+
+  /** Strip internal metadata fields, returning only API-safe {role, content}. */
+  _sanitize(msg) {
+    return { role: msg.role, content: msg.content };
+  }
+
   /**
    * Get history with older messages compressed into a summary.
    * Keeps the last `recentWindow` messages verbatim and summarizes older ones.
@@ -76,18 +149,19 @@ export class ConversationManager {
     const history = this.getHistory(chatId);
 
     if (history.length <= this.recentWindow) {
-      return [...history];
+      return history.map(m => this._sanitize(this._annotateWithTime(m)));
     }
 
     const olderMessages = history.slice(0, history.length - this.recentWindow);
     const recentMessages = history.slice(history.length - this.recentWindow);
 
-    // Compress older messages into a single summary
+    // Compress older messages into a single summary (include time markers when available)
     const summaryLines = olderMessages.map((msg) => {
+      const timeTag = this._formatRelativeTime(msg.timestamp);
       const content = typeof msg.content === 'string'
         ? msg.content.slice(0, 200)
         : JSON.stringify(msg.content).slice(0, 200);
-      return `[${msg.role}]: ${content}`;
+      return `[${msg.role}]${timeTag ? ` ${timeTag}` : ''}: ${content}`;
     });
 
     const summaryMessage = {
@@ -95,17 +169,27 @@ export class ConversationManager {
       content: `[CONVERSATION SUMMARY - ${olderMessages.length} earlier messages]\n${summaryLines.join('\n')}`,
     };
 
+    // Annotate recent messages with time markers and strip metadata
+    const annotatedRecent = recentMessages.map(m => this._sanitize(this._annotateWithTime(m)));
+
     // Ensure result starts with user role
-    const result = [summaryMessage, ...recentMessages];
+    const result = [summaryMessage, ...annotatedRecent];
 
     // If the first real message after summary is assistant, that's fine since
     // our summary is role:user. But ensure recent starts correctly.
     return result;
   }
 
+  /**
+   * Append a message to a chat's history, trim to max length, and persist.
+   * Automatically ensures the conversation starts with a user message.
+   * @param {string|number} chatId - Telegram chat identifier.
+   * @param {'user'|'assistant'} role - Message role.
+   * @param {string} content - Message content.
+   */
   addMessage(chatId, role, content) {
     const history = this.getHistory(chatId);
-    history.push({ role, content });
+    history.push({ role, content, timestamp: Date.now() });
 
     // Trim to max history
     while (history.length > this.maxHistory) {
@@ -120,31 +204,60 @@ export class ConversationManager {
     this.save();
   }
 
+  /**
+   * Delete all history and active skill for a specific chat.
+   * @param {string|number} chatId - Telegram chat identifier.
+   */
   clear(chatId) {
     this.conversations.delete(String(chatId));
     this.activeSkills.delete(String(chatId));
+    this.logger.debug(`Conversation cleared for chat ${chatId}`);
     this.save();
   }
 
+  /**
+   * Delete all conversations across every chat.
+   */
   clearAll() {
+    const count = this.conversations.size;
     this.conversations.clear();
+    this.logger.info(`All conversations cleared (${count} chats removed)`);
     this.save();
   }
 
+  /**
+   * Return the number of messages stored for a chat.
+   * @param {string|number} chatId - Telegram chat identifier.
+   * @returns {number} Message count.
+   */
   getMessageCount(chatId) {
     const history = this.getHistory(chatId);
     return history.length;
   }
 
+  /**
+   * Activate a skill for a specific chat, persisted across restarts.
+   * @param {string|number} chatId - Telegram chat identifier.
+   * @param {string} skillId - Skill identifier to activate.
+   */
   setSkill(chatId, skillId) {
     this.activeSkills.set(String(chatId), skillId);
     this.save();
   }
 
+  /**
+   * Get the currently active skill for a chat.
+   * @param {string|number} chatId - Telegram chat identifier.
+   * @returns {string|null} Active skill identifier, or null if none.
+   */
   getSkill(chatId) {
     return this.activeSkills.get(String(chatId)) || null;
   }
 
+  /**
+   * Deactivate the active skill for a chat.
+   * @param {string|number} chatId - Telegram chat identifier.
+   */
   clearSkill(chatId) {
     this.activeSkills.delete(String(chatId));
     this.save();