@link-assistant/hive-mind 0.42.2 → 0.42.3

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @link-assistant/hive-mind
 
+## 0.42.3
+
+### Patch Changes
+
+- 64d6cf8: Add experimental /top command to Telegram bot
+
+  - Added /top command to show live system monitor in Telegram
+  - Displays auto-updating `top` output in a single message (updates every 2 seconds)
+  - Owner-only access with chat authorization checks
+  - Session isolation per chat using GNU screen
+  - Clean stop button to terminate monitoring session
+  - Marked as EXPERIMENTAL feature with user warnings
+  - Not documented in /help as requested
+  - Requires GNU screen to be installed on the system
+
+  Fixes #500
+
 ## 0.42.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "0.42.2",
+  "version": "0.42.3",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/telegram-bot.mjs

@@ -1225,45 +1225,37 @@ bot.command(/^hive$/i, async (ctx) => {
   }
 });
 
+// Register /top command from separate module
+// This keeps telegram-bot.mjs under the 1500 line limit
+const { registerTopCommand } = await import('./telegram-top-command.lib.mjs');
+registerTopCommand(bot, {
+  VERBOSE,
+  isOldMessage,
+  isForwardedOrReply,
+  isGroupChat,
+  isChatAuthorized
+});
+
 // Add message listener for verbose debugging
-// This helps diagnose if bot is receiving messages at all
 if (VERBOSE) {
   bot.on('message', (ctx, next) => {
-    console.log('[VERBOSE] Message received:');
-    console.log('[VERBOSE]   Chat ID:', ctx.chat?.id);
-    console.log('[VERBOSE]   Chat type:', ctx.chat?.type);
-    console.log('[VERBOSE]   Is forum:', ctx.chat?.is_forum);
-    console.log('[VERBOSE]   Is topic message:', ctx.message?.is_topic_message);
-    console.log('[VERBOSE]   Message thread ID:', ctx.message?.message_thread_id);
-    console.log('[VERBOSE]   Message date:', ctx.message?.date);
-    console.log('[VERBOSE]   Message text:', ctx.message?.text?.substring(0, 100));
-    console.log('[VERBOSE]   From user:', ctx.from?.username || ctx.from?.id);
-    console.log('[VERBOSE]   Bot start time:', BOT_START_TIME);
-    console.log('[VERBOSE]   Is old message:', isOldMessage(ctx));
-
-    // Detailed forwarding/reply detection debug info
     const msg = ctx.message;
-    const isForwarded = isForwardedOrReply(ctx);
-    console.log('[VERBOSE]   Is forwarded/reply:', isForwarded);
+    console.log('[VERBOSE] Message:', {
+      chatId: ctx.chat?.id, chatType: ctx.chat?.type, isForum: ctx.chat?.is_forum,
+      isTopicMsg: msg?.is_topic_message, threadId: msg?.message_thread_id, date: msg?.date,
+      text: msg?.text?.substring(0, 100), user: ctx.from?.username || ctx.from?.id,
+      botStartTime: BOT_START_TIME, isOld: isOldMessage(ctx), isForwarded: isForwardedOrReply(ctx),
+      isAuthorized: isChatAuthorized(ctx.chat?.id)
+    });
     if (msg) {
-      // Log ALL message fields to diagnose what Telegram is actually sending
-      console.log('[VERBOSE]   Full message object keys:', Object.keys(msg));
-      console.log('[VERBOSE]     - forward_origin:', JSON.stringify(msg.forward_origin));
-      console.log('[VERBOSE]     - forward_origin type:', typeof msg.forward_origin);
-      console.log('[VERBOSE]     - forward_origin truthy?:', !!msg.forward_origin);
-      console.log('[VERBOSE]     - forward_origin.type:', msg.forward_origin?.type);
-      console.log('[VERBOSE]     - forward_from:', JSON.stringify(msg.forward_from));
-      console.log('[VERBOSE]     - forward_from_chat:', JSON.stringify(msg.forward_from_chat));
-      console.log('[VERBOSE]     - forward_date:', msg.forward_date);
-      console.log('[VERBOSE]     - reply_to_message:', JSON.stringify(msg.reply_to_message));
-      console.log('[VERBOSE]     - reply_to_message type:', typeof msg.reply_to_message);
-      console.log('[VERBOSE]     - reply_to_message truthy?:', !!msg.reply_to_message);
-      console.log('[VERBOSE]     - reply_to_message.message_id:', msg.reply_to_message?.message_id);
-      console.log('[VERBOSE]     - reply_to_message.forum_topic_created:', JSON.stringify(msg.reply_to_message?.forum_topic_created));
+      console.log('[VERBOSE] Msg fields:', Object.keys(msg));
+      console.log('[VERBOSE] Forward/reply:', {
+        forward_origin: msg.forward_origin, forward_from: msg.forward_from,
+        forward_from_chat: msg.forward_from_chat, forward_date: msg.forward_date,
+        reply_to_message: msg.reply_to_message, reply_id: msg.reply_to_message?.message_id,
+        forum_topic_created: msg.reply_to_message?.forum_topic_created
+      });
     }
-
-    console.log('[VERBOSE]   Is authorized:', isChatAuthorized(ctx.chat?.id));
-    // Continue to next handler
     return next();
   });
 }
@@ -1391,9 +1383,9 @@ bot.telegram.deleteWebhook({ drop_pending_updates: true })
       });
     }
     return bot.launch({
-      // Only receive message updates (commands, text messages)
-      // This ensures the bot receives all message types including commands
-      allowedUpdates: ['message'],
+      // Receive message updates (commands, text messages) and callback queries (button clicks)
+      // This ensures the bot receives all message types including commands and button interactions
+      allowedUpdates: ['message', 'callback_query'],
       // Drop any pending updates that were sent before the bot started
       // This ensures we only process new messages sent after this bot instance started
       dropPendingUpdates: true

package/src/telegram-top-command.lib.mjs

@@ -0,0 +1,325 @@
+/**
+ * Telegram /top command implementation
+ *
+ * This module provides the /top command functionality for the Telegram bot,
+ * allowing chat owners to view live system monitor output in an auto-updating message.
+ *
+ * Features:
+ * - Live system monitoring using GNU screen and top command
+ * - Auto-updates every 2 seconds
+ * - Owner-only access control
+ * - Session management per chat
+ * - Clean cleanup on stop
+ *
+ * @experimental This feature is marked as experimental
+ */
+
+import { promisify } from 'util';
+import { exec as execCallback } from 'child_process';
+
+const exec = promisify(execCallback);
+
+// Store active top sessions: Map<chatId, { messageId, screenName, intervalId }>
+const activeTopSessions = new Map();
+
+/**
+ * Captures top output from the file for a given chat
+ * @param {number} chatId - The chat ID
+ * @returns {Promise<string|null>} The formatted top output or null on error
+ */
+async function captureTopOutput(chatId) {
+  try {
+    const outputFile = `/tmp/top-output-${chatId}.txt`;
+    const { readFile } = await import('fs/promises');
+    const output = await readFile(outputFile, 'utf-8');
+
+    // Format output for Telegram (limit to first 30 lines to fit in message)
+    const lines = output.split('\n').slice(0, 30);
+    return lines.join('\n');
+  } catch (error) {
+    console.error('[ERROR] Failed to capture top output:', error);
+    return null;
+  }
+}
+
+/**
+ * Registers the /top command handler with the bot
+ * @param {Object} bot - The Telegraf bot instance
+ * @param {Object} options - Options object
+ * @param {boolean} options.VERBOSE - Whether to enable verbose logging
+ * @param {Function} options.isOldMessage - Function to check if message is old
+ * @param {Function} options.isForwardedOrReply - Function to check if message is forwarded/reply
+ * @param {Function} options.isGroupChat - Function to check if chat is a group
+ * @param {Function} options.isChatAuthorized - Function to check if chat is authorized
+ */
+export function registerTopCommand(bot, options) {
+  const {
+    VERBOSE = false,
+    isOldMessage,
+    isForwardedOrReply,
+    isGroupChat,
+    isChatAuthorized
+  } = options;
+
+  // /top command - show system top output in an auto-updating message (EXPERIMENTAL)
+  // Only accessible by chat owner
+  // Not documented in /help as requested in issue #500
+  bot.command('top', async (ctx) => {
+    if (VERBOSE) {
+      console.log('[VERBOSE] /top command received');
+    }
+
+    // Ignore messages sent before bot started
+    if (isOldMessage(ctx)) {
+      if (VERBOSE) {
+        console.log('[VERBOSE] /top ignored: old message');
+      }
+      return;
+    }
+
+    // Ignore forwarded or reply messages
+    if (isForwardedOrReply(ctx)) {
+      if (VERBOSE) {
+        console.log('[VERBOSE] /top ignored: forwarded or reply');
+      }
+      return;
+    }
+
+    if (!isGroupChat(ctx)) {
+      if (VERBOSE) {
+        console.log('[VERBOSE] /top ignored: not a group chat');
+      }
+      await ctx.reply('❌ The /top command only works in group chats.', { reply_to_message_id: ctx.message.message_id });
+      return;
+    }
+
+    const chatId = ctx.chat.id;
+    if (!isChatAuthorized(chatId)) {
+      if (VERBOSE) {
+        console.log('[VERBOSE] /top ignored: chat not authorized');
+      }
+      await ctx.reply(`❌ This chat (ID: ${chatId}) is not authorized to use this bot.`, { reply_to_message_id: ctx.message.message_id });
+      return;
+    }
+
+    // Check if user is chat owner
+    try {
+      const chatMember = await ctx.telegram.getChatMember(chatId, ctx.from.id);
+      if (chatMember.status !== 'creator') {
+        if (VERBOSE) {
+          console.log('[VERBOSE] /top ignored: user is not chat owner');
+        }
+        await ctx.reply('❌ This command is only available to the chat owner.', { reply_to_message_id: ctx.message.message_id });
+        return;
+      }
+    } catch (error) {
+      console.error('[ERROR] Failed to check chat member status:', error);
+      await ctx.reply('❌ Failed to verify permissions.', { reply_to_message_id: ctx.message.message_id });
+      return;
+    }
+
+    if (VERBOSE) {
+      console.log('[VERBOSE] /top passed all checks, starting...');
+    }
+
+    // Show experimental feature warning
+    await ctx.reply('🧪 *EXPERIMENTAL FEATURE*\n\nThis command is experimental and may have issues. Use with caution.', {
+      parse_mode: 'Markdown',
+      reply_to_message_id: ctx.message.message_id
+    });
+
+    // Check if there's already an active top session for this chat
+    if (activeTopSessions.has(chatId)) {
+      await ctx.reply('❌ A top session is already running for this chat. Stop it first using the button.', { reply_to_message_id: ctx.message.message_id });
+      return;
+    }
+
+    // Generate screen session name with chat ID
+    const screenName = `top-chat-${chatId}`;
+
+    // Check if screen session already exists
+    let sessionExists = false;
+    try {
+      const { stdout } = await exec('screen -ls');
+      sessionExists = stdout.includes(screenName);
+    } catch {
+      // screen -ls returns non-zero when no sessions exist
+      sessionExists = false;
+    }
+
+    // Create screen session if it doesn't exist
+    // We'll use a different approach: run top in batch mode with output redirected to a file
+    // that we continuously read instead of using screen hardcopy
+    const outputFile = `/tmp/top-output-${chatId}.txt`;
+
+    if (!sessionExists) {
+      try {
+        // Start top in a screen session with batch mode, outputting to a file
+        // -b: batch mode, -d 2: 2 second delay between updates, -n: number of iterations (unlimited)
+        await exec(`screen -dmS ${screenName} bash -c 'while true; do top -b -n 1 > ${outputFile}; sleep 2; done'`);
+        if (VERBOSE) {
+          console.log(`[VERBOSE] Created screen session: ${screenName}`);
+        }
+        // Give top a moment to start and produce first output
+        await new Promise(resolve => setTimeout(resolve, 1500));
+      } catch (error) {
+        console.error('[ERROR] Failed to create screen session:', error);
+        await ctx.reply('❌ Failed to start top command.', { reply_to_message_id: ctx.message.message_id });
+        return;
+      }
+    }
+
+    // Send initial message with loading indicator
+    const initialMessage = await ctx.reply('🧪 📊 Loading system monitor... (EXPERIMENTAL)', {
+      reply_to_message_id: ctx.message.message_id,
+      reply_markup: {
+        inline_keyboard: [[
+          { text: '🛑 Stop', callback_data: `stop_top_${chatId}` }
+        ]]
+      }
+    });
+
+    // Capture and display first output
+    const firstOutput = await captureTopOutput(chatId);
+    if (firstOutput) {
+      try {
+        await ctx.telegram.editMessageText(
+          chatId,
+          initialMessage.message_id,
+          undefined,
+          `\`\`\`\n${firstOutput}\n\`\`\``,
+          {
+            parse_mode: 'Markdown',
+            reply_markup: {
+              inline_keyboard: [[
+                { text: '🛑 Stop', callback_data: `stop_top_${chatId}` }
+              ]]
+            }
+          }
+        );
+      } catch (error) {
+        console.error('[ERROR] Failed to update message:', error);
+      }
+    }
+
+    // Set up periodic update (every 2 seconds)
+    const intervalId = setInterval(async () => {
+      const output = await captureTopOutput(chatId);
+      if (output) {
+        try {
+          await ctx.telegram.editMessageText(
+            chatId,
+            initialMessage.message_id,
+            undefined,
+            `\`\`\`\n${output}\n\`\`\``,
+            {
+              parse_mode: 'Markdown',
+              reply_markup: {
+                inline_keyboard: [[
+                  { text: '🛑 Stop', callback_data: `stop_top_${chatId}` }
+                ]]
+              }
+            }
+          );
+        } catch (error) {
+          // Ignore "message is not modified" errors
+          if (!error.message?.includes('message is not modified')) {
+            console.error('[ERROR] Failed to update message:', error);
+          }
+        }
+      }
+    }, 2000);
+
+    // Store session info
+    activeTopSessions.set(chatId, {
+      messageId: initialMessage.message_id,
+      screenName,
+      intervalId
+    });
+
+    if (VERBOSE) {
+      console.log(`[VERBOSE] Top session started for chat ${chatId}`);
+    }
+  });
+
+  // Handle stop button callback
+  bot.action(/^stop_top_(.+)$/, async (ctx) => {
+    const chatId = parseInt(ctx.match[1]);
+
+    if (VERBOSE) {
+      console.log(`[VERBOSE] Stop top callback received for chat ${chatId}`);
+    }
+
+    // Check if user is chat owner
+    try {
+      const chatMember = await ctx.telegram.getChatMember(chatId, ctx.from.id);
+      if (chatMember.status !== 'creator') {
+        await ctx.answerCbQuery('❌ Only the chat owner can stop the top session.');
+        return;
+      }
+    } catch (error) {
+      console.error('[ERROR] Failed to check chat member status:', error);
+      await ctx.answerCbQuery('❌ Failed to verify permissions.');
+      return;
+    }
+
+    const session = activeTopSessions.get(chatId);
+    if (!session) {
+      await ctx.answerCbQuery('❌ No active top session found.');
+      return;
+    }
+
+    // Stop the update interval
+    clearInterval(session.intervalId);
+
+    // Kill the screen session
+    try {
+      await exec(`screen -S ${session.screenName} -X quit`);
+      if (VERBOSE) {
+        console.log(`[VERBOSE] Killed screen session: ${session.screenName}`);
+      }
+    } catch (error) {
+      console.error('[ERROR] Failed to kill screen session:', error);
+    }
+
+    // Clean up the output file
+    try {
+      const { unlink } = await import('fs/promises');
+      await unlink(`/tmp/top-output-${chatId}.txt`);
+      if (VERBOSE) {
+        console.log(`[VERBOSE] Cleaned up output file for chat ${chatId}`);
+      }
+    } catch (error) {
+      // Ignore file cleanup errors
+      if (VERBOSE) {
+        console.log(`[VERBOSE] Could not clean up output file: ${error.message}`);
+      }
+    }
+
+    // Remove from active sessions
+    activeTopSessions.delete(chatId);
+
+    // Update the message to show it's stopped
+    try {
+      await ctx.editMessageText('🛑 Top session stopped.', {
+        parse_mode: 'Markdown'
+      });
+    } catch (error) {
+      console.error('[ERROR] Failed to edit message:', error);
+    }
+
+    await ctx.answerCbQuery('✅ Top session stopped successfully.');
+
+    if (VERBOSE) {
+      console.log(`[VERBOSE] Top session stopped for chat ${chatId}`);
+    }
+  });
+}
+
+/**
+ * Gets information about active top sessions
+ * @returns {Map} Map of active sessions
+ */
+export function getActiveTopSessions() {
+  return activeTopSessions;
+}