TelegramService.ts

/**
 * Telegram Service
 * Bot startup with command handling using MCP Telegram sampling
 */

import {
	type BaseSessionService,
	createSamplingHandler,
	type EnhancedRunner,
	extractTextFromContent,
	type LlmRequest,
	type MemoryService,
} from "@iqai/adk";
import { createClawdAgent } from "../agents/agent.js";
import { getTelegramAgent } from "../agents/telegram-agent/agent.js";
import { getConfig, getRawConfig } from "../config/index.js";
import { createLogger } from "../lib/logger.js";
import { createPendingPair, isAllowed } from "../lib/pairing.js";
import { setSchedulerDeps } from "../tools/scheduleTools.js";
import {
	broadcastToTelegram,
	initScheduler,
	stopScheduler,
} from "./SchedulerService.js";

const log = createLogger("Telegram");

/**
 * Parse Telegram message info from MCP sampling request content
 * MCP Telegram embeds user/chat info in key-value format:
 * "NEW TELEGRAM MESSAGE FROM:\nuser_id: 123\nchat_id: 456\n...\ncontent: message text"
 */
function parseTelegramMessage(content: string): {
	userId: string;
	chatId: string;
	messageText: string;
} {
	const lines = content.split("\n");
	let userId = "unknown";
	let chatId = "unknown";
	let messageText = "";
	let foundContent = false;

	for (const line of lines) {
		const trimmed = line.trim();

		if (trimmed.startsWith("user_id:")) {
			userId = trimmed.replace("user_id:", "").trim();
		} else if (trimmed.startsWith("chat_id:")) {
			chatId = trimmed.replace("chat_id:", "").trim();
		} else if (trimmed.startsWith("content:")) {
			const contentIndex = lines.indexOf(line);
			const firstLine = trimmed.replace("content:", "").trim();
			const remainingLines = lines.slice(contentIndex + 1);
			messageText = [firstLine, ...remainingLines].join("\n").trim();
			foundContent = true;
			break;
		}
	}

	// Fallback: if no content: field found, use blank-line separator format
	if (!foundContent) {
		let messageStartIndex = 0;
		for (let i = 0; i < lines.length; i++) {
			if (lines[i].trim() === "" && i > 0) {
				messageStartIndex = i + 1;
				break;
			}
		}
		messageText = lines.slice(messageStartIndex).join("\n").trim();
	}

	return { userId, chatId, messageText };
}

/**
 * Extract text from LlmRequest
 */
function getTextFromRequest(request: LlmRequest): string {
	const contents = request.contents || [];
	if (contents.length === 0) return "";
	const lastContent = contents[contents.length - 1];
	return extractTextFromContent(lastContent);
}

/**
 * Public bot commands visible to all users (including unapproved)
 */
const PUBLIC_BOT_COMMANDS = [
	{ command: "start", description: "Start the bot and pair" },
	{ command: "help", description: "Show available commands" },
];

/**
 * Full bot commands visible only to approved/paired users
 */
const FULL_BOT_COMMANDS = [
	{ command: "start", description: "Start the bot and pair" },
	{ command: "new", description: "Save session and start fresh" },
	{ command: "reset", description: "Clear session without saving" },
	{ command: "help", description: "Show available commands" },
];

/**
 * Track chatIds that have had full commands registered
 * so we only register once per session per chat
 */
const registeredChats = new Set<string>();

/**
 * Register bot commands with Telegram API at global scopes.
 * Called at startup with public commands so all users (including unapproved)
 * can see /start and /help in the command menu.
 */
async function registerBotCommands(
	botToken: string,
	commandList: typeof PUBLIC_BOT_COMMANDS = PUBLIC_BOT_COMMANDS,
): Promise<void> {
	const api = `https://api.telegram.org/bot${botToken}`;
	const headers = { "Content-Type": "application/json" };
	const scopes = [
		{ type: "default" },
		{ type: "all_private_chats" },
		{ type: "all_group_chats" },
	];
	try {
		// Delete commands at all scopes to clear stale cache
		for (const scope of scopes) {
			await fetch(`${api}/deleteMyCommands`, {
				method: "POST",
				headers,
				body: JSON.stringify({ scope }),
			});
		}

		// Set commands at all scopes
		for (const scope of scopes) {
			const response = await fetch(`${api}/setMyCommands`, {
				method: "POST",
				headers,
				body: JSON.stringify({ commands: commandList, scope }),
			});
			const result = (await response.json()) as {
				ok: boolean;
				description?: string;
			};
			if (!result.ok) {
				log.warn(
					`Failed to register commands for scope ${scope.type}: ${result.description}`,
				);
			}
		}
		log.info(
			`Registered ${commandList.length} bot commands: ${commandList.map((c) => `/${c.command}`).join(", ")}`,
		);
	} catch (error) {
		log.warn(`Could not register bot commands: ${error}`);
	}
}

/**
 * Register full bot commands for a specific chat (approved user).
 * Uses Telegram's per-chat scope so the user sees all commands
 * including /new and /reset in their command menu.
 */
async function registerUserCommands(
	botToken: string,
	chatId: string,
): Promise<void> {
	const api = `https://api.telegram.org/bot${botToken}`;
	const headers = { "Content-Type": "application/json" };
	const scope = { type: "chat", chat_id: Number(chatId) };

	try {
		// Clear existing per-chat commands first
		await fetch(`${api}/deleteMyCommands`, {
			method: "POST",
			headers,
			body: JSON.stringify({ scope }),
		});

		// Set full command list for this specific chat
		const response = await fetch(`${api}/setMyCommands`, {
			method: "POST",
			headers,
			body: JSON.stringify({ commands: FULL_BOT_COMMANDS, scope }),
		});
		const result = (await response.json()) as {
			ok: boolean;
			description?: string;
		};
		if (!result.ok) {
			log.warn(
				`Failed to register user commands for chat ${chatId}: ${result.description}`,
			);
		} else {
			registeredChats.add(chatId);
			log.info(`Registered full commands for chat ${chatId}`);
		}
	} catch (error) {
		log.warn(`Could not register user commands for chat ${chatId}: ${error}`);
	}
}

/**
 * Command handlers
 */
type CommandHandler = (chatId: string, userId: string) => Promise<string>;

/**
 * Generate pairing response for unpaired users
 */
function getPairingResponse(
	userId: string,
	username: string | undefined,
	chatId: string,
): string {
	const code = createPendingPair("telegram", userId, username, chatId);

	if (!code) {
		return `⚠️ Too many pending pairing requests. Please try again later.

Contact the bot owner if this persists.`;
	}

	return `🔐 Pairing required!

Your code: ${code}

Ask the bot owner to run:
adk-claw pairing approve telegram ${code}

Code expires in 1 hour.`;
}

/**
 * Format duration between a unix timestamp (seconds) and now
 */
function formatDuration(startTimestamp: number): string {
	const diffMs = Date.now() - startTimestamp * 1000;
	const minutes = Math.floor(diffMs / 60000);
	const hours = Math.floor(minutes / 60);

	if (hours > 0) {
		return `${hours}h ${minutes % 60}m`;
	}
	return `${minutes}m`;
}

/**
 * Create command handlers bound to ADK session lifecycle.
 * Uses sessionService.createSession / deleteSession and runner.setSession
 * to properly create/destroy ADK sessions instead of local state.
 */
function createCommands(deps: {
	runner: EnhancedRunner;
	sessionService: BaseSessionService;
	memoryService?: MemoryService;
}): Record<string, CommandHandler> {
	const { runner, sessionService, memoryService } = deps;

	return {
		"/start": async (_chatId, userId) => {
			const config = getRawConfig();

			// Check if user is already allowed
			if (isAllowed("telegram", userId)) {
				return `👋 Welcome back!

I'm ${config.agent.name}, your personal AI assistant.

Commands:
/new - Save session & start fresh
/reset - Clear session without saving
/help - Show available commands`;
			}

			// User needs pairing
			return getPairingResponse(userId, undefined, _chatId);
		},

		"/new": async (_chatId, _userId) => {
			const currentSession = runner.getSession();

			// Save current session to memory if it has events
			if (memoryService && currentSession.events.length > 0) {
				await memoryService.addSessionToMemory(currentSession);
			}

			// Derive summary from ADK session events
			const eventCount = currentSession.events.length;
			let summary = "No conversation to save.";
			if (eventCount > 0) {
				const firstTimestamp = currentSession.events[0].timestamp;
				const duration = formatDuration(firstTimestamp);
				summary = `${eventCount} events over ${duration}`;
			}

			// Create a new ADK session and swap it into the runner
			const newSession = await sessionService.createSession(
				currentSession.appName,
				currentSession.userId,
			);
			runner.setSession(newSession);

			return `✅ Session saved to memory.

📝 Summary: ${summary}

🆕 New session started!`;
		},

		"/reset": async (_chatId, _userId) => {
			const currentSession = runner.getSession();

			// Delete the old session without saving to memory
			await sessionService.deleteSession(
				currentSession.appName,
				currentSession.userId,
				currentSession.id,
			);

			// Create a fresh ADK session
			const newSession = await sessionService.createSession(
				currentSession.appName,
				currentSession.userId,
			);
			runner.setSession(newSession);

			return "🔄 Session cleared (not saved). Fresh start!";
		},

		"/help": async (_chatId, _userId) => {
			return `📚 Available commands:

/start - Start the bot and pair
/new - Save session & start fresh
/reset - Clear session without saving
/help - Show this help message

Just send a message to chat with me!`;
		},
	};
}

/**
 * Start the Telegram bot with MCP sampling
 */
export async function startTelegramBot(): Promise<void> {
	const config = getConfig();

	if (!config.telegramEnabled) {
		throw new Error("Telegram is not enabled in config");
	}

	log.info(`Starting ${config.agentName} Telegram bot...`);

	// Create the agent with Telegram channel context
	const { runner, sessionService, session, memoryService } =
		await createClawdAgent({
			channel: "telegram",
		});

	// Create command handlers bound to ADK session lifecycle
	const commands = createCommands({ runner, sessionService, memoryService });

	// Create sampling handler with command detection
	const samplingHandler = createSamplingHandler(
		async (request: LlmRequest): Promise<string> => {
			const rawContent = getTextFromRequest(request);
			const { userId, chatId, messageText } = parseTelegramMessage(rawContent);

			log.info(
				`Message from userId=${userId} chatId=${chatId}: "${messageText.slice(0, 50)}..."`,
			);

			// Check for commands
			const trimmed = messageText.trim();
			if (trimmed.startsWith("/")) {
				const cmd = trimmed.split(" ")[0].split("@")[0].toLowerCase();
				const handler = commands[cmd];
				if (handler) {
					return await handler(chatId, userId);
				}
				return `Unknown command: ${cmd}\n\nType /help for available commands.`;
			}

			// Check pairing for non-command messages
			if (!isAllowed("telegram", userId)) {
				return getPairingResponse(userId, undefined, chatId);
			}

			// Register full commands for newly approved users on first message
			if (!registeredChats.has(chatId)) {
				registerUserCommands(config.telegramBotToken, chatId);
			}

			// Get response from agent (ADK tracks events in session automatically)
			try {
				const response = await runner.ask(messageText);
				return response;
			} catch (error) {
				log.error(
					`Failed to get response for chatId=${chatId}: ${error instanceof Error ? error.message : error}`,
				);
				return "⚠️ Sorry, I'm having trouble right now. Please try again in a moment.";
			}
		},
	);

	// Initialize Telegram agent with sampling
	await getTelegramAgent(samplingHandler);

	// Register commands after MCP init so they aren't overwritten
	await registerBotCommands(config.telegramBotToken);

	// Initialize scheduler with the same runner
	const scheduler = await initScheduler(
		runner,
		sessionService,
		session.appName,
	);

	// Bind scheduler deps so schedule tools can dynamically manage jobs
	setSchedulerDeps({
		scheduler,
		runner,
		sessionService,
		appName: session.appName,
		broadcastToTelegram,
	});

	log.info(`${config.agentName} is now listening on Telegram`);
	log.info("DM your bot to start chatting. Press Ctrl+C to stop");

	// Keep process alive
	await keepAlive();
}

/**
 * Keep the process alive
 */
async function keepAlive(): Promise<void> {
	const shutdown = async (signal: string) => {
		log.info(`Shutting down (${signal})...`);
		await stopScheduler();
		process.exit(0);
	};

	process.on("SIGINT", () => shutdown("SIGINT"));
	process.on("SIGTERM", () => shutdown("SIGTERM"));

	await new Promise(() => {
		setInterval(() => {}, 1000);
	});
}