ctb 1.0.0

package/src/formatting.ts

@@ -0,0 +1,309 @@
+/**
+ * Formatting module for Claude Telegram Bot.
+ *
+ * Markdown conversion and tool status display formatting.
+ */
+
+/**
+ * Escape HTML special characters.
+ */
+export function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+/**
+ * Convert standard markdown to Telegram-compatible HTML.
+ *
+ * HTML is more reliable than Telegram's Markdown which breaks on special chars.
+ * Telegram HTML supports: <b>, <i>, <code>, <pre>, <a href="">
+ */
+export function convertMarkdownToHtml(text: string): string {
+  // Store code blocks temporarily to avoid processing their contents
+  const codeBlocks: string[] = [];
+  const inlineCodes: string[] = [];
+
+  // Save code blocks first (```code```)
+  text = text.replace(/```(?:\w+)?\n?([\s\S]*?)```/g, (_, code) => {
+    codeBlocks.push(code);
+    return `\x00CODEBLOCK${codeBlocks.length - 1}\x00`;
+  });
+
+  // Save inline code (`code`)
+  text = text.replace(/`([^`]+)`/g, (_, code) => {
+    inlineCodes.push(code);
+    return `\x00INLINECODE${inlineCodes.length - 1}\x00`;
+  });
+
+  // Escape HTML entities in the remaining text
+  text = escapeHtml(text);
+
+  // Headers: ## Header -> <b>Header</b>
+  text = text.replace(/^#{1,6}\s+(.+)$/gm, "<b>$1</b>\n");
+
+  // Bold: **text** -> <b>text</b>
+  text = text.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
+
+  // Also handle *text* as bold (single asterisk)
+  text = text.replace(/(?<!\*)\*(.+?)\*(?!\*)/g, "<b>$1</b>");
+
+  // Double underscore: __text__ -> <b>text</b>
+  text = text.replace(/__([^_]+)__/g, "<b>$1</b>");
+
+  // Italic: _text_ -> <i>text</i> (but not __text__)
+  text = text.replace(/(?<!_)_([^_]+)_(?!_)/g, "<i>$1</i>");
+
+  // Blockquotes: &gt; text -> <blockquote>text</blockquote>
+  text = convertBlockquotes(text);
+
+  // Bullet lists: - item or * item -> • item
+  text = text.replace(/^[-*] /gm, "• ");
+
+  // Horizontal rules: --- or *** -> blank line
+  text = text.replace(/^[-*]{3,}$/gm, "");
+
+  // Links: [text](url) -> <a href="url">text</a>
+  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+
+  // Restore code blocks
+  for (let i = 0; i < codeBlocks.length; i++) {
+    const escapedCode = escapeHtml(codeBlocks[i]!);
+    text = text.replace(`\x00CODEBLOCK${i}\x00`, `<pre>${escapedCode}</pre>`);
+  }
+
+  // Restore inline code
+  for (let i = 0; i < inlineCodes.length; i++) {
+    const escapedCode = escapeHtml(inlineCodes[i]!);
+    text = text.replace(
+      `\x00INLINECODE${i}\x00`,
+      `<code>${escapedCode}</code>`
+    );
+  }
+
+  // Collapse multiple newlines
+  text = text.replace(/\n{3,}/g, "\n\n");
+
+  return text;
+}
+
+/**
+ * Convert blockquotes (handles multi-line).
+ */
+function convertBlockquotes(text: string): string {
+  const lines = text.split("\n");
+  const result: string[] = [];
+  let inBlockquote = false;
+  const blockquoteLines: string[] = [];
+
+  for (const line of lines) {
+    if (line.startsWith("&gt; ") || line === "&gt;") {
+      if (line === "&gt;") {
+        blockquoteLines.push("");
+      } else {
+        // Remove '&gt; ' and strip # from hashtags (Telegram mobile bug workaround)
+        const content = line.slice(5).replace(/#/g, "");
+        blockquoteLines.push(content);
+      }
+      inBlockquote = true;
+    } else {
+      if (inBlockquote) {
+        result.push(
+          "<blockquote>" + blockquoteLines.join("\n") + "</blockquote>"
+        );
+        blockquoteLines.length = 0;
+        inBlockquote = false;
+      }
+      result.push(line);
+    }
+  }
+
+  // Handle blockquote at end
+  if (inBlockquote) {
+    result.push("<blockquote>" + blockquoteLines.join("\n") + "</blockquote>");
+  }
+
+  return result.join("\n");
+}
+
+// Legacy alias
+export const convertMarkdownForTelegram = convertMarkdownToHtml;
+
+// ============== Tool Status Formatting ==============
+
+/**
+ * Shorten a file path for display (last 2 components).
+ */
+function shortenPath(path: string): string {
+  if (!path) return "file";
+  const parts = path.split("/");
+  if (parts.length >= 2) {
+    return parts.slice(-2).join("/");
+  }
+  return parts[parts.length - 1] || path;
+}
+
+/**
+ * Truncate text with ellipsis.
+ */
+function truncate(text: string, maxLen = 60): string {
+  if (!text) return "";
+  // Clean up newlines for display
+  const cleaned = text.replace(/\n/g, " ").trim();
+  if (cleaned.length <= maxLen) return cleaned;
+  return cleaned.slice(0, maxLen) + "...";
+}
+
+/**
+ * Wrap text in HTML code tags, escaping special chars.
+ */
+function code(text: string): string {
+  return `<code>${escapeHtml(text)}</code>`;
+}
+
+/**
+ * Format tool use for display in Telegram with HTML formatting.
+ */
+export function formatToolStatus(
+  toolName: string,
+  toolInput: Record<string, unknown>
+): string {
+  const emojiMap: Record<string, string> = {
+    Read: "📖",
+    Write: "📝",
+    Edit: "✏️",
+    Bash: "▶️",
+    Glob: "🔍",
+    Grep: "🔎",
+    WebSearch: "🔍",
+    WebFetch: "🌐",
+    Task: "🎯",
+    TodoWrite: "📋",
+    mcp__: "🔧",
+  };
+
+  // Find matching emoji
+  let emoji = "🔧";
+  for (const [key, val] of Object.entries(emojiMap)) {
+    if (toolName.includes(key)) {
+      emoji = val;
+      break;
+    }
+  }
+
+  // Format based on tool type
+  if (toolName === "Read") {
+    const filePath = String(toolInput.file_path || "file");
+    const shortPath = shortenPath(filePath);
+    const imageExtensions = [
+      ".jpg",
+      ".jpeg",
+      ".png",
+      ".gif",
+      ".webp",
+      ".bmp",
+      ".svg",
+      ".ico",
+    ];
+    if (imageExtensions.some((ext) => filePath.toLowerCase().endsWith(ext))) {
+      return "👀 Viewing";
+    }
+    return `${emoji} Reading ${code(shortPath)}`;
+  }
+
+  if (toolName === "Write") {
+    const filePath = String(toolInput.file_path || "file");
+    return `${emoji} Writing ${code(shortenPath(filePath))}`;
+  }
+
+  if (toolName === "Edit") {
+    const filePath = String(toolInput.file_path || "file");
+    return `${emoji} Editing ${code(shortenPath(filePath))}`;
+  }
+
+  if (toolName === "Bash") {
+    const cmd = String(toolInput.command || "");
+    const desc = String(toolInput.description || "");
+    if (desc) {
+      return `${emoji} ${escapeHtml(desc)}`;
+    }
+    return `${emoji} ${code(truncate(cmd, 50))}`;
+  }
+
+  if (toolName === "Grep") {
+    const pattern = String(toolInput.pattern || "");
+    const path = String(toolInput.path || "");
+    if (path) {
+      return `${emoji} Searching ${code(truncate(pattern, 30))} in ${code(
+        shortenPath(path)
+      )}`;
+    }
+    return `${emoji} Searching ${code(truncate(pattern, 40))}`;
+  }
+
+  if (toolName === "Glob") {
+    const pattern = String(toolInput.pattern || "");
+    return `${emoji} Finding ${code(truncate(pattern, 50))}`;
+  }
+
+  if (toolName === "WebSearch") {
+    const query = String(toolInput.query || "");
+    return `${emoji} Searching: ${escapeHtml(truncate(query, 50))}`;
+  }
+
+  if (toolName === "WebFetch") {
+    const url = String(toolInput.url || "");
+    return `${emoji} Fetching ${code(truncate(url, 50))}`;
+  }
+
+  if (toolName === "Task") {
+    const desc = String(toolInput.description || "");
+    if (desc) {
+      return `${emoji} Agent: ${escapeHtml(desc)}`;
+    }
+    return `${emoji} Running agent...`;
+  }
+
+  if (toolName === "Skill") {
+    const skillName = String(toolInput.skill || "");
+    if (skillName) {
+      return `💭 Using skill: ${escapeHtml(skillName)}`;
+    }
+    return `💭 Using skill...`;
+  }
+
+  if (toolName.startsWith("mcp__")) {
+    // Generic MCP tool formatting
+    const parts = toolName.split("__");
+    if (parts.length >= 3) {
+      const server = parts[1]!;
+      let action = parts[2]!;
+      // Remove redundant server prefix from action
+      if (action.startsWith(`${server}_`)) {
+        action = action.slice(server.length + 1);
+      }
+      action = action.replace(/_/g, " ");
+
+      // Try to get meaningful summary
+      const summary =
+        toolInput.title ||
+        toolInput.query ||
+        toolInput.content ||
+        toolInput.text ||
+        toolInput.id ||
+        "";
+
+      if (summary) {
+        return `🔧 ${server} ${action}: ${escapeHtml(
+          truncate(String(summary), 40)
+        )}`;
+      }
+      return `🔧 ${server}: ${action}`;
+    }
+    return `🔧 ${escapeHtml(toolName)}`;
+  }
+
+  return `${emoji} ${escapeHtml(toolName)}`;
+}

package/src/handlers/callback.ts

@@ -0,0 +1,248 @@
+/**
+ * Callback query handler for Claude Telegram Bot.
+ *
+ * Handles inline keyboard button presses (ask_user MCP integration, bookmarks).
+ */
+
+import { unlinkSync } from "node:fs";
+import type { Context } from "grammy";
+import { addBookmark, removeBookmark } from "../bookmarks";
+import { ALLOWED_USERS } from "../config";
+import { isAuthorized } from "../security";
+import { session } from "../session";
+import { auditLog, startTypingIndicator } from "../utils";
+import { createStatusCallback, StreamingState } from "./streaming";
+
+/**
+ * Handle callback queries from inline keyboards.
+ */
+export async function handleCallback(ctx: Context): Promise<void> {
+	const userId = ctx.from?.id;
+	const username = ctx.from?.username || "unknown";
+	const chatId = ctx.chat?.id;
+	const callbackData = ctx.callbackQuery?.data;
+
+	if (!userId || !chatId || !callbackData) {
+		await ctx.answerCallbackQuery();
+		return;
+	}
+
+	// 1. Authorization check
+	if (!isAuthorized(userId, ALLOWED_USERS)) {
+		await ctx.answerCallbackQuery({ text: "Unauthorized" });
+		return;
+	}
+
+	// 2. Handle bookmark callbacks
+	if (callbackData.startsWith("bookmark:")) {
+		await handleBookmarkCallback(ctx, callbackData);
+		return;
+	}
+
+	// 3. Parse callback data: askuser:{request_id}:{option_index}
+	if (!callbackData.startsWith("askuser:")) {
+		await ctx.answerCallbackQuery();
+		return;
+	}
+
+	const parts = callbackData.split(":");
+	const requestId = parts[1];
+	const optionPart = parts[2];
+	if (parts.length !== 3 || !requestId || !optionPart) {
+		await ctx.answerCallbackQuery({ text: "Invalid callback data" });
+		return;
+	}
+
+	const optionIndex = parseInt(optionPart, 10);
+
+	// 3. Load request file
+	const requestFile = `/tmp/ask-user-${requestId}.json`;
+	let requestData: {
+		question: string;
+		options: string[];
+		status: string;
+	};
+
+	try {
+		const file = Bun.file(requestFile);
+		const text = await file.text();
+		requestData = JSON.parse(text);
+	} catch (error) {
+		console.error(`Failed to load ask-user request ${requestId}:`, error);
+		await ctx.answerCallbackQuery({ text: "Request expired or invalid" });
+		return;
+	}
+
+	// 4. Get selected option
+	if (optionIndex < 0 || optionIndex >= requestData.options.length) {
+		await ctx.answerCallbackQuery({ text: "Invalid option" });
+		return;
+	}
+
+	const selectedOption = requestData.options[optionIndex];
+	if (!selectedOption) {
+		await ctx.answerCallbackQuery({ text: "Invalid option" });
+		return;
+	}
+
+	// 5. Update the message to show selection
+	try {
+		await ctx.editMessageText(`✓ ${selectedOption}`);
+	} catch (error) {
+		console.debug("Failed to edit callback message:", error);
+	}
+
+	// 6. Answer the callback
+	await ctx.answerCallbackQuery({
+		text: `Selected: ${selectedOption.slice(0, 50)}`,
+	});
+
+	// 7. Delete request file
+	try {
+		unlinkSync(requestFile);
+	} catch (error) {
+		console.debug("Failed to delete request file:", error);
+	}
+
+	// 8. Send the choice to Claude as a message
+	const message = selectedOption;
+
+	// Interrupt any running query - button responses are always immediate
+	if (session.isRunning) {
+		console.log("Interrupting current query for button response");
+		await session.stop();
+		// Small delay to ensure clean interruption
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	}
+
+	// Start typing
+	const typing = startTypingIndicator(ctx);
+
+	// Create streaming state
+	const state = new StreamingState();
+	const statusCallback = createStatusCallback(ctx, state);
+
+	try {
+		const response = await session.sendMessageStreaming(
+			message,
+			username,
+			userId,
+			statusCallback,
+			chatId,
+			ctx,
+		);
+
+		await auditLog(userId, username, "CALLBACK", message, response);
+	} catch (error) {
+		console.error("Error processing callback:", error);
+
+		for (const toolMsg of state.toolMessages) {
+			try {
+				await ctx.api.deleteMessage(toolMsg.chat.id, toolMsg.message_id);
+			} catch (error) {
+				console.debug("Failed to delete tool message:", error);
+			}
+		}
+
+		if (String(error).includes("abort") || String(error).includes("cancel")) {
+			// Only show "Query stopped" if it was an explicit stop, not an interrupt from a new message
+			const wasInterrupt = session.consumeInterruptFlag();
+			if (!wasInterrupt) {
+				await ctx.reply("🛑 Query stopped.");
+			}
+		} else {
+			await ctx.reply(`❌ Error: ${String(error).slice(0, 200)}`);
+		}
+	} finally {
+		typing.stop();
+	}
+}
+
+/**
+ * Handle bookmark-related callbacks.
+ */
+async function handleBookmarkCallback(
+	ctx: Context,
+	callbackData: string,
+): Promise<void> {
+	const parts = callbackData.split(":");
+	if (parts.length < 2) {
+		await ctx.answerCallbackQuery({ text: "Invalid bookmark action" });
+		return;
+	}
+
+	const action = parts[1];
+	const path = parts.slice(2).join(":"); // Path may contain colons
+
+	switch (action) {
+		case "noop":
+			await ctx.answerCallbackQuery({ text: "Already bookmarked" });
+			break;
+
+		case "add":
+			if (addBookmark(path)) {
+				await ctx.answerCallbackQuery({ text: "Bookmark added!" });
+				try {
+					await ctx.editMessageReplyMarkup({ reply_markup: undefined });
+				} catch {
+					// Message may have been deleted
+				}
+			} else {
+				await ctx.answerCallbackQuery({ text: "Already bookmarked" });
+			}
+			break;
+
+		case "new":
+			session.setWorkingDir(path);
+			await ctx.answerCallbackQuery({
+				text: `Changed to: ${path.slice(-30)}`,
+			});
+			await ctx.reply(
+				`📁 Changed to: <code>${path}</code>\n\nSession cleared. Next message starts fresh.`,
+				{ parse_mode: "HTML" },
+			);
+			break;
+
+		case "remove":
+			if (removeBookmark(path)) {
+				await ctx.answerCallbackQuery({ text: "Bookmark removed" });
+				// Remove the row from the keyboard by editing message
+				try {
+					// Re-fetch bookmarks and rebuild keyboard
+					const { loadBookmarks } = await import("../bookmarks");
+					const { InlineKeyboard } = await import("grammy");
+					const bookmarks = loadBookmarks();
+
+					if (bookmarks.length === 0) {
+						await ctx.editMessageText(
+							"📚 No bookmarks.\n\n" +
+								"Use <code>/cd /path/to/dir</code> and click 'Add to bookmarks'.",
+							{ parse_mode: "HTML" },
+						);
+					} else {
+						let message = "📚 <b>Bookmarks</b>\n\n";
+						const keyboard = new InlineKeyboard();
+						for (const bookmark of bookmarks) {
+							message += `📁 <code>${bookmark.path}</code>\n`;
+							keyboard
+								.text(`🆕 ${bookmark.name}`, `bookmark:new:${bookmark.path}`)
+								.text("🗑️", `bookmark:remove:${bookmark.path}`)
+								.row();
+						}
+						await ctx.editMessageText(message, {
+							parse_mode: "HTML",
+							reply_markup: keyboard,
+						});
+					}
+				} catch {
+					// Message may have been deleted
+				}
+			} else {
+				await ctx.answerCallbackQuery({ text: "Bookmark not found" });
+			}
+			break;
+
+		default:
+			await ctx.answerCallbackQuery({ text: "Unknown action" });
+	}
+}