telegram-claude-mcp 1.2.3 → 1.3.0

package/hooks/stop-hook.sh

@@ -0,0 +1,93 @@
+#!/bin/bash
+#
+# Claude Code Interactive Stop Hook
+#
+# When Claude stops, this sends a message to Telegram and waits for your reply.
+# If you reply with instructions, Claude continues working on them.
+# If you reply "done" or don't reply, Claude stops.
+#
+
+SESSION_DIR="/tmp/telegram-claude-sessions"
+
+# Function to find the most recent active session
+find_active_session() {
+  local latest_file=""
+  local latest_time=0
+
+  [ -d "$SESSION_DIR" ] || return
+
+  for info_file in "$SESSION_DIR"/*.info; do
+    [ -e "$info_file" ] || continue
+
+    local pid
+    pid=$(jq -r '.pid // empty' "$info_file" 2>/dev/null)
+    if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+      local file_time
+      file_time=$(stat -f %m "$info_file" 2>/dev/null || stat -c %Y "$info_file" 2>/dev/null)
+      if [ "$file_time" -gt "$latest_time" ]; then
+        latest_time=$file_time
+        latest_file=$info_file
+      fi
+    fi
+  done
+
+  echo "$latest_file"
+}
+
+# Read hook input
+INPUT=$(cat)
+
+# Check if stop_hook_active - if true, we already continued once, don't loop
+STOP_HOOK_ACTIVE=$(echo "$INPUT" | jq -r '.stop_hook_active // false')
+if [ "$STOP_HOOK_ACTIVE" = "true" ]; then
+  echo "[stop-hook] Already continued once, allowing stop" >&2
+  exit 0
+fi
+
+# Find active session
+INFO_FILE=$(find_active_session)
+
+if [ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ]; then
+  echo "[stop-hook] No active session found" >&2
+  exit 0
+fi
+
+# Read port from session info
+HOOK_PORT=$(jq -r '.port' "$INFO_FILE")
+HOOK_HOST=$(jq -r '.host // "localhost"' "$INFO_FILE")
+HOOK_URL="http://${HOOK_HOST}:${HOOK_PORT}/stop"
+
+echo "[stop-hook] Using session: $INFO_FILE (port $HOOK_PORT)" >&2
+
+# Extract transcript path to get context
+TRANSCRIPT_PATH=$(echo "$INPUT" | jq -r '.transcript_path // empty')
+
+# Build request payload
+PAYLOAD=$(jq -n \
+  --arg transcript_path "$TRANSCRIPT_PATH" \
+  '{transcript_path: $transcript_path}')
+
+# Send to server and wait for response (blocking - waits for user reply)
+RESPONSE=$(curl -s -X POST "$HOOK_URL" \
+  -H "Content-Type: application/json" \
+  -d "$PAYLOAD" \
+  --max-time 300)
+
+if [ $? -ne 0 ]; then
+  echo "[stop-hook] Failed to connect to server" >&2
+  exit 0
+fi
+
+echo "[stop-hook] Response: $RESPONSE" >&2
+
+# Check if user wants to continue
+DECISION=$(echo "$RESPONSE" | jq -r '.decision // empty')
+REASON=$(echo "$RESPONSE" | jq -r '.reason // empty')
+
+if [ "$DECISION" = "block" ] && [ -n "$REASON" ]; then
+  # User provided instructions - continue with them
+  echo "$RESPONSE"
+else
+  # User said done or no response - allow stop
+  exit 0
+fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "telegram-claude-mcp",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "description": "MCP server that lets Claude message you on Telegram with hooks support",
   "author": "Geravant",
   "license": "MIT",

package/src/index.ts

@@ -153,14 +153,18 @@ async function main() {
           tool_input || {}
         );
 
+        const responseDecision: Record<string, unknown> = {
+          behavior: decision.behavior,
+        };
+        if (decision.message) {
+          responseDecision.message = decision.message;
+        }
+
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({
           hookSpecificOutput: {
             hookEventName: 'PermissionRequest',
-            decision: {
-              behavior: decision.behavior,
-              message: decision.message,
-            },
+            decision: responseDecision,
           },
         }));
         return;
@@ -186,6 +190,19 @@ async function main() {
         return;
       }
 
+      // Handle interactive stop (waits for user reply)
+      if (url === '/stop' || url === '/hooks/stop') {
+        const { transcript_path } = data;
+
+        console.error(`[HTTP] Interactive stop request`);
+
+        const result = await telegram.handleInteractiveStop(transcript_path);
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(result));
+        return;
+      }
+
       // Unknown endpoint
       res.writeHead(404, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ error: 'Not found' }));

package/src/telegram.ts

@@ -241,6 +241,74 @@ export class TelegramManager {
     await this.bot.sendMessage(this.config.chatId, message);
   }
 
+  /**
+   * Handle interactive stop - send message and wait for user to reply with instructions
+   * Returns { decision: "block", reason: "..." } if user wants to continue
+   * Returns {} if user is done
+   */
+  async handleInteractiveStop(transcriptPath?: string): Promise<Record<string, unknown>> {
+    // Try to get last assistant message from transcript
+    let lastMessage = 'Claude has finished working.';
+    if (transcriptPath) {
+      try {
+        const fs = await import('fs');
+        if (fs.existsSync(transcriptPath)) {
+          const content = fs.readFileSync(transcriptPath, 'utf-8');
+          const lines = content.trim().split('\n');
+          // Find last assistant message
+          for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+              const entry = JSON.parse(lines[i]);
+              if (entry.type === 'assistant' && entry.message?.content) {
+                const textContent = entry.message.content.find((c: any) => c.type === 'text');
+                if (textContent?.text) {
+                  lastMessage = textContent.text.slice(0, 500);
+                  if (textContent.text.length > 500) lastMessage += '...';
+                  break;
+                }
+              }
+            } catch {
+              // Skip invalid JSON lines
+            }
+          }
+        }
+      } catch (err) {
+        console.error('[Telegram] Error reading transcript:', err);
+      }
+    }
+
+    const message = `🏁 [${this.config.sessionName}] Claude stopped\n\n${lastMessage}\n\n💬 Reply with instructions to continue, or "done" to finish.`;
+
+    const sent = await this.bot.sendMessage(this.config.chatId, message);
+
+    // Update session state
+    this.updateSessionState({
+      waitingForResponse: true,
+      messageIds: [...this.getSessionState().messageIds, sent.message_id],
+    });
+
+    // Wait for response with longer timeout for interactive stop
+    try {
+      const response = await this.waitForResponse(sent.message_id);
+
+      // Check if user wants to stop
+      const lowerResponse = response.toLowerCase().trim();
+      if (lowerResponse === 'done' || lowerResponse === 'stop' || lowerResponse === 'finish' || lowerResponse === 'ok') {
+        return {};
+      }
+
+      // User provided instructions - continue
+      return {
+        decision: 'block',
+        reason: response,
+      };
+    } catch (err) {
+      // Timeout or error - allow stop
+      console.error('[Telegram] Interactive stop timeout or error:', err);
+      return {};
+    }
+  }
+
   /**
    * Format tool input for display
    */