telegram-claude-mcp 1.6.1 → 2.0.2

package/src/daemon/progress-display.ts

@@ -0,0 +1,184 @@
+/**
+ * Progress Display Utilities
+ *
+ * Visual rendering for progress tracking in Telegram messages.
+ * Inspired by DnD-Books telegram-bot ProgressIndicator.
+ */
+
+export enum ProgressStage {
+  IDLE = 'idle',
+  THINKING = 'thinking',
+  TOOL_QUEUED = 'queued',
+  TOOL_RUNNING = 'running',
+  TOOL_COMPLETE = 'complete',
+  WAITING_USER = 'waiting',
+  FINISHED = 'finished',
+}
+
+interface StageDisplay {
+  emoji: string;
+  label: string;
+  progress: number;
+}
+
+export const stageDisplay: Record<ProgressStage, StageDisplay> = {
+  [ProgressStage.IDLE]: { emoji: '💤', label: 'Idle', progress: 0 },
+  [ProgressStage.THINKING]: { emoji: '🧠', label: 'Thinking', progress: 10 },
+  [ProgressStage.TOOL_QUEUED]: { emoji: '📋', label: 'Tool queued', progress: 20 },
+  [ProgressStage.TOOL_RUNNING]: { emoji: '🔧', label: 'Executing', progress: 50 },
+  [ProgressStage.TOOL_COMPLETE]: { emoji: '✅', label: 'Tool done', progress: 80 },
+  [ProgressStage.WAITING_USER]: { emoji: '💬', label: 'Waiting for you', progress: 90 },
+  [ProgressStage.FINISHED]: { emoji: '🏁', label: 'Finished', progress: 100 },
+};
+
+/**
+ * Build a visual progress bar using block characters.
+ */
+export function buildProgressBar(percent: number): string {
+  const total = 10;
+  const filled = Math.floor(percent / 10);
+  const empty = total - filled;
+
+  const filledChar = '▓';
+  const emptyChar = '░';
+
+  return `[${filledChar.repeat(filled)}${emptyChar.repeat(empty)}] ${percent}%`;
+}
+
+/**
+ * Format tool name for display.
+ */
+export function formatToolName(toolName: string): string {
+  // Shorten common tool names
+  const shortNames: Record<string, string> = {
+    'Read': 'Read',
+    'Write': 'Write',
+    'Edit': 'Edit',
+    'Bash': 'Bash',
+    'Glob': 'Glob',
+    'Grep': 'Grep',
+    'Task': 'Task',
+    'WebFetch': 'Web',
+    'WebSearch': 'Search',
+    'TodoWrite': 'Todo',
+    'AskUserQuestion': 'Ask',
+  };
+
+  return shortNames[toolName] || toolName;
+}
+
+/**
+ * Format elapsed time for display.
+ */
+export function formatElapsedTime(startTime: number): string {
+  const elapsed = Math.floor((Date.now() - startTime) / 1000);
+
+  if (elapsed < 60) {
+    return `${elapsed}s`;
+  }
+
+  const minutes = Math.floor(elapsed / 60);
+  const seconds = elapsed % 60;
+  return `${minutes}m ${seconds}s`;
+}
+
+/**
+ * Build tool statistics summary.
+ */
+export function buildToolStats(toolCounts: Map<string, number>): string {
+  if (toolCounts.size === 0) return '';
+
+  const entries = Array.from(toolCounts.entries())
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 5) // Top 5 tools
+    .map(([tool, count]) => `${formatToolName(tool)} (${count})`)
+    .join(', ');
+
+  return entries;
+}
+
+export interface ProgressMessageOptions {
+  sessionName: string;
+  stage: ProgressStage;
+  currentTool: string | null;
+  toolStack: string[];
+  startTime: number;
+  toolsExecuted: number;
+  toolCounts: Map<string, number>;
+  showDetails?: boolean;
+}
+
+/**
+ * Build the complete progress message text.
+ */
+export function buildProgressMessage(options: ProgressMessageOptions): string {
+  const {
+    sessionName,
+    stage,
+    currentTool,
+    toolStack,
+    startTime,
+    toolsExecuted,
+    toolCounts,
+    showDetails = true,
+  } = options;
+
+  const display = stageDisplay[stage];
+  const elapsed = formatElapsedTime(startTime);
+
+  let text = `[${sessionName}] Working...\n\n`;
+
+  // Current stage with emoji
+  text += `${display.emoji} *${display.label}*`;
+
+  // Current tool (if any)
+  if (currentTool) {
+    const toolDisplay = toolStack.length > 1
+      ? toolStack.map(formatToolName).join(' > ')
+      : formatToolName(currentTool);
+    text += `: \`${toolDisplay}\``;
+  }
+  text += '\n\n';
+
+  // Progress bar
+  text += buildProgressBar(display.progress) + '\n\n';
+
+  // Stats line
+  text += `⏱ ${elapsed}`;
+  if (toolsExecuted > 0) {
+    text += ` | Tools: ${toolsExecuted}`;
+  }
+
+  // Detailed tool breakdown (for finished state)
+  if (showDetails && stage === ProgressStage.FINISHED && toolCounts.size > 0) {
+    text += '\n\n---\n';
+    text += `Tools used: ${buildToolStats(toolCounts)}`;
+  }
+
+  return text;
+}
+
+/**
+ * Build a completion message.
+ */
+export function buildCompletionMessage(options: {
+  sessionName: string;
+  startTime: number;
+  toolsExecuted: number;
+  toolCounts: Map<string, number>;
+}): string {
+  const { sessionName, startTime, toolsExecuted, toolCounts } = options;
+  const elapsed = formatElapsedTime(startTime);
+
+  let text = `[${sessionName}] Task Complete\n\n`;
+  text += `🏁 *Finished*\n\n`;
+  text += buildProgressBar(100) + '\n\n';
+  text += `⏱ ${elapsed} | Tools: ${toolsExecuted}`;
+
+  if (toolCounts.size > 0) {
+    text += '\n\n---\n';
+    text += `Tools used: ${buildToolStats(toolCounts)}`;
+  }
+
+  return text;
+}

package/src/daemon/progress-tracker.ts

@@ -0,0 +1,365 @@
+/**
+ * Progress Tracker
+ *
+ * Manages per-session progress state and updates Telegram messages
+ * in-place using editMessageText.
+ */
+
+import TelegramBot from 'node-telegram-bot-api';
+import type { SessionManager } from './session-manager.js';
+import {
+  ProgressStage,
+  buildProgressMessage,
+  buildCompletionMessage,
+} from './progress-display.js';
+
+export interface SessionProgress {
+  sessionId: string;
+  sessionName: string;
+
+  // Message tracking
+  progressMessageId: number | null;
+  lastUpdateTime: number;
+
+  // Progress state
+  stage: ProgressStage;
+  currentTool: string | null;
+  toolStack: string[];
+
+  // Statistics
+  startTime: number;
+  toolsExecuted: number;
+  toolCounts: Map<string, number>;
+
+  // Settings
+  isActive: boolean;
+  showProgress: boolean;
+}
+
+export interface ProgressEvent {
+  type: 'pre_tool' | 'post_tool' | 'notification' | 'stop' | 'start';
+  session_name: string;
+  timestamp: string;
+  tool_name?: string;
+  tool_input?: Record<string, unknown>;
+  success?: boolean;
+  error?: string;
+  transcript_path?: string;
+}
+
+export class ProgressTracker {
+  private sessions: Map<string, SessionProgress> = new Map();
+  private bot: TelegramBot;
+  private chatId: number;
+  private sessionManager: SessionManager;
+
+  // Rate limiting
+  private lastUpdate: Map<string, number> = new Map();
+  private pendingUpdates: Map<string, NodeJS.Timeout> = new Map();
+  private readonly MIN_UPDATE_INTERVAL = 1000; // 1 second minimum between updates
+
+  constructor(bot: TelegramBot, chatId: number, sessionManager: SessionManager) {
+    this.bot = bot;
+    this.chatId = chatId;
+    this.sessionManager = sessionManager;
+  }
+
+  /**
+   * Get or create progress state for a session.
+   */
+  private getOrCreateProgress(sessionName: string): SessionProgress {
+    let progress = this.sessions.get(sessionName);
+
+    if (!progress) {
+      const session = this.sessionManager.getByName(sessionName);
+      progress = {
+        sessionId: session?.sessionId || sessionName,
+        sessionName,
+        progressMessageId: null,
+        lastUpdateTime: 0,
+        stage: ProgressStage.IDLE,
+        currentTool: null,
+        toolStack: [],
+        startTime: Date.now(),
+        toolsExecuted: 0,
+        toolCounts: new Map(),
+        isActive: true,
+        showProgress: true,
+      };
+      this.sessions.set(sessionName, progress);
+    }
+
+    return progress;
+  }
+
+  /**
+   * Handle session start event.
+   */
+  async handleSessionStart(sessionName: string): Promise<void> {
+    const progress = this.getOrCreateProgress(sessionName);
+    progress.startTime = Date.now();
+    progress.stage = ProgressStage.THINKING;
+    progress.isActive = true;
+    progress.toolsExecuted = 0;
+    progress.toolCounts.clear();
+    progress.toolStack = [];
+    progress.currentTool = null;
+
+    await this.sendOrUpdateProgressMessage(progress);
+  }
+
+  /**
+   * Handle PreToolUse hook event.
+   */
+  async handlePreTool(sessionName: string, toolName: string, toolInput?: Record<string, unknown>): Promise<void> {
+    const progress = this.getOrCreateProgress(sessionName);
+
+    // Reset start time if this is the first tool
+    if (progress.stage === ProgressStage.IDLE) {
+      progress.startTime = Date.now();
+    }
+
+    // Push tool onto stack (for nested tool calls)
+    progress.toolStack.push(toolName);
+    progress.currentTool = toolName;
+    progress.stage = ProgressStage.TOOL_RUNNING;
+    progress.isActive = true;
+
+    await this.sendOrUpdateProgressMessage(progress);
+  }
+
+  /**
+   * Handle PostToolUse hook event.
+   */
+  async handlePostTool(sessionName: string, toolName: string, success: boolean = true): Promise<void> {
+    const progress = this.getOrCreateProgress(sessionName);
+
+    // Pop tool from stack
+    const poppedTool = progress.toolStack.pop();
+
+    // Update statistics
+    progress.toolsExecuted++;
+    const currentCount = progress.toolCounts.get(toolName) || 0;
+    progress.toolCounts.set(toolName, currentCount + 1);
+
+    // Update state
+    if (progress.toolStack.length > 0) {
+      // Still have parent tools running
+      progress.currentTool = progress.toolStack[progress.toolStack.length - 1];
+      progress.stage = ProgressStage.TOOL_RUNNING;
+    } else {
+      // All tools complete
+      progress.currentTool = null;
+      progress.stage = ProgressStage.TOOL_COMPLETE;
+    }
+
+    await this.sendOrUpdateProgressMessage(progress);
+  }
+
+  /**
+   * Handle Stop hook event.
+   */
+  async handleStop(sessionName: string): Promise<void> {
+    const progress = this.sessions.get(sessionName);
+
+    if (!progress) {
+      return;
+    }
+
+    progress.stage = ProgressStage.FINISHED;
+    progress.currentTool = null;
+    progress.toolStack = [];
+    progress.isActive = false;
+
+    // Send final completion message
+    await this.sendCompletionMessage(progress);
+
+    // Clean up pending updates
+    const pendingTimeout = this.pendingUpdates.get(sessionName);
+    if (pendingTimeout) {
+      clearTimeout(pendingTimeout);
+      this.pendingUpdates.delete(sessionName);
+    }
+  }
+
+  /**
+   * Handle notification event.
+   */
+  async handleNotification(sessionName: string, message: string): Promise<void> {
+    const progress = this.getOrCreateProgress(sessionName);
+
+    // Just update the timestamp, don't change stage
+    progress.lastUpdateTime = Date.now();
+
+    // Optionally could update the message with notification info
+  }
+
+  /**
+   * Toggle progress display for a session.
+   */
+  setShowProgress(sessionName: string, show: boolean): void {
+    const progress = this.sessions.get(sessionName);
+    if (progress) {
+      progress.showProgress = show;
+    }
+  }
+
+  /**
+   * Send or update the progress message with rate limiting.
+   */
+  private async sendOrUpdateProgressMessage(progress: SessionProgress): Promise<void> {
+    if (!progress.showProgress) {
+      return;
+    }
+
+    const now = Date.now();
+    const lastTime = this.lastUpdate.get(progress.sessionName) || 0;
+
+    if (now - lastTime < this.MIN_UPDATE_INTERVAL) {
+      // Schedule update for later if not already scheduled
+      if (!this.pendingUpdates.has(progress.sessionName)) {
+        const timeout = setTimeout(async () => {
+          this.pendingUpdates.delete(progress.sessionName);
+          await this.doUpdateProgressMessage(progress);
+        }, this.MIN_UPDATE_INTERVAL - (now - lastTime));
+
+        this.pendingUpdates.set(progress.sessionName, timeout);
+      }
+      return;
+    }
+
+    await this.doUpdateProgressMessage(progress);
+  }
+
+  /**
+   * Actually send or update the progress message.
+   */
+  private async doUpdateProgressMessage(progress: SessionProgress): Promise<void> {
+    this.lastUpdate.set(progress.sessionName, Date.now());
+
+    const messageText = buildProgressMessage({
+      sessionName: progress.sessionName,
+      stage: progress.stage,
+      currentTool: progress.currentTool,
+      toolStack: progress.toolStack,
+      startTime: progress.startTime,
+      toolsExecuted: progress.toolsExecuted,
+      toolCounts: progress.toolCounts,
+      showDetails: false,
+    });
+
+    try {
+      if (progress.progressMessageId) {
+        // Edit existing message
+        await this.bot.editMessageText(messageText, {
+          chat_id: this.chatId,
+          message_id: progress.progressMessageId,
+          parse_mode: 'Markdown',
+        });
+      } else {
+        // Send new message with mute button
+        const sent = await this.bot.sendMessage(this.chatId, messageText, {
+          parse_mode: 'Markdown',
+          reply_markup: {
+            inline_keyboard: [[
+              { text: '🔕 Mute', callback_data: `progress_mute:${progress.sessionName}` },
+            ]],
+          },
+        });
+        progress.progressMessageId = sent.message_id;
+      }
+    } catch (error) {
+      // Message might have been deleted or content unchanged
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+      // If message was deleted or not found, create a new one
+      if (errorMessage.includes('message to edit not found') ||
+          errorMessage.includes('message is not modified')) {
+        // Content unchanged is fine, just skip
+        if (!errorMessage.includes('message is not modified')) {
+          progress.progressMessageId = null;
+          // Don't retry immediately to avoid spam
+        }
+      } else {
+        console.error('[ProgressTracker] Error updating message:', errorMessage);
+      }
+    }
+  }
+
+  /**
+   * Send final completion message.
+   */
+  private async sendCompletionMessage(progress: SessionProgress): Promise<void> {
+    const messageText = buildCompletionMessage({
+      sessionName: progress.sessionName,
+      startTime: progress.startTime,
+      toolsExecuted: progress.toolsExecuted,
+      toolCounts: progress.toolCounts,
+    });
+
+    try {
+      if (progress.progressMessageId) {
+        // Edit existing message to show completion
+        await this.bot.editMessageText(messageText, {
+          chat_id: this.chatId,
+          message_id: progress.progressMessageId,
+          parse_mode: 'Markdown',
+          reply_markup: { inline_keyboard: [] }, // Remove mute button
+        });
+      } else {
+        // Send new completion message
+        await this.bot.sendMessage(this.chatId, messageText, {
+          parse_mode: 'Markdown',
+        });
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      if (!errorMessage.includes('message is not modified')) {
+        console.error('[ProgressTracker] Error sending completion:', errorMessage);
+      }
+    }
+
+    // Clean up session progress
+    this.sessions.delete(progress.sessionName);
+  }
+
+  /**
+   * Handle callback query for mute button.
+   */
+  async handleCallback(query: TelegramBot.CallbackQuery): Promise<boolean> {
+    if (!query.data?.startsWith('progress_mute:')) {
+      return false;
+    }
+
+    const sessionName = query.data.replace('progress_mute:', '');
+    this.setShowProgress(sessionName, false);
+
+    // Remove the progress message
+    const progress = this.sessions.get(sessionName);
+    if (progress?.progressMessageId && query.message) {
+      try {
+        await this.bot.deleteMessage(this.chatId, progress.progressMessageId);
+      } catch {
+        // Ignore deletion errors
+      }
+      progress.progressMessageId = null;
+    }
+
+    await this.bot.answerCallbackQuery(query.id, { text: 'Progress muted' });
+    return true;
+  }
+
+  /**
+   * Clean up inactive sessions.
+   */
+  cleanup(): void {
+    const now = Date.now();
+    const maxAge = 30 * 60 * 1000; // 30 minutes
+
+    for (const [sessionName, progress] of this.sessions) {
+      if (!progress.isActive && now - progress.lastUpdateTime > maxAge) {
+        this.sessions.delete(sessionName);
+      }
+    }
+  }
+}

package/src/daemon/session-manager.ts

@@ -0,0 +1,173 @@
+/**
+ * Session Manager for the Telegram Claude Daemon
+ *
+ * Tracks all connected Claude Code sessions and their state.
+ */
+
+import type { Socket } from 'net';
+import type { SessionInfo } from '../shared/protocol.js';
+
+export interface ConnectedSession extends SessionInfo {
+  socket: Socket;
+}
+
+export class SessionManager {
+  private sessions: Map<string, ConnectedSession> = new Map();
+
+  /**
+   * Register a new session
+   */
+  register(
+    sessionId: string,
+    sessionName: string,
+    socket: Socket,
+    projectPath?: string
+  ): ConnectedSession {
+    const session: ConnectedSession = {
+      sessionId,
+      sessionName,
+      projectPath,
+      socket,
+      connectedAt: new Date(),
+      lastActivity: new Date(),
+      activeChats: new Set(),
+    };
+
+    this.sessions.set(sessionId, session);
+    console.error(`[SessionManager] Registered session: ${sessionId} (${sessionName})`);
+
+    return session;
+  }
+
+  /**
+   * Unregister a session
+   */
+  unregister(sessionId: string): boolean {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      this.sessions.delete(sessionId);
+      console.error(`[SessionManager] Unregistered session: ${sessionId}`);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get session by ID
+   */
+  get(sessionId: string): ConnectedSession | undefined {
+    return this.sessions.get(sessionId);
+  }
+
+  /**
+   * Get session by name (returns first match)
+   */
+  getByName(sessionName: string): ConnectedSession | undefined {
+    for (const session of this.sessions.values()) {
+      if (session.sessionName === sessionName) {
+        return session;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Get all sessions
+   */
+  getAll(): ConnectedSession[] {
+    return Array.from(this.sessions.values());
+  }
+
+  /**
+   * Get count of active sessions
+   */
+  count(): number {
+    return this.sessions.size;
+  }
+
+  /**
+   * Update last activity timestamp
+   */
+  touch(sessionId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.lastActivity = new Date();
+    }
+  }
+
+  /**
+   * Add active chat to session
+   */
+  addChat(sessionId: string, chatId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.activeChats.add(chatId);
+    }
+  }
+
+  /**
+   * Remove active chat from session
+   */
+  removeChat(sessionId: string, chatId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.activeChats.delete(chatId);
+    }
+  }
+
+  /**
+   * Find session by socket
+   */
+  findBySocket(socket: Socket): ConnectedSession | undefined {
+    for (const session of this.sessions.values()) {
+      if (session.socket === socket) {
+        return session;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Get most recently active session
+   */
+  getMostRecentActive(): ConnectedSession | undefined {
+    let mostRecent: ConnectedSession | undefined;
+    let latestTime = 0;
+
+    for (const session of this.sessions.values()) {
+      const time = session.lastActivity.getTime();
+      if (time > latestTime) {
+        latestTime = time;
+        mostRecent = session;
+      }
+    }
+
+    return mostRecent;
+  }
+
+  /**
+   * Find session that should receive a hook event
+   * Priority: explicit session name > most recently active
+   */
+  findForHook(sessionName?: string): ConnectedSession | undefined {
+    if (sessionName) {
+      return this.getByName(sessionName);
+    }
+    return this.getMostRecentActive();
+  }
+
+  /**
+   * Clean up disconnected sessions
+   */
+  cleanup(): number {
+    let cleaned = 0;
+    for (const [sessionId, session] of this.sessions.entries()) {
+      if (session.socket.destroyed) {
+        this.sessions.delete(sessionId);
+        cleaned++;
+        console.error(`[SessionManager] Cleaned up dead session: ${sessionId}`);
+      }
+    }
+    return cleaned;
+  }
+}