@sarkar-ai/deskmate 0.2.0

package/dist/index.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const mode = process.argv[2] || "telegram";
+const BOT_NAME = process.env.BOT_NAME || "Deskmate";
+/** Parse ALLOWED_USERS (multi-client) and ALLOWED_USER_ID (legacy) into UserIdentity[] */
+function buildAllowedUsers() {
+    const users = [];
+    // New multi-client format: "telegram:123,discord:456,slack:U789"
+    const multiClient = process.env.ALLOWED_USERS;
+    if (multiClient) {
+        for (const entry of multiClient.split(",").map((s) => s.trim()).filter(Boolean)) {
+            const colonIdx = entry.indexOf(":");
+            if (colonIdx > 0) {
+                users.push({
+                    clientType: entry.slice(0, colonIdx),
+                    platformUserId: entry.slice(colonIdx + 1),
+                });
+            }
+        }
+    }
+    // Legacy single-user format
+    const legacyId = process.env.ALLOWED_USER_ID;
+    if (legacyId && legacyId !== "0") {
+        // Only add if not already covered by ALLOWED_USERS
+        const alreadyHas = users.some((u) => u.clientType === "telegram" && u.platformUserId === legacyId);
+        if (!alreadyHas) {
+            users.push({ clientType: "telegram", platformUserId: legacyId });
+        }
+    }
+    return users;
+}
+async function main() {
+    console.log(`🚀 Starting ${BOT_NAME} in ${mode} mode...`);
+    switch (mode) {
+        case "telegram":
+            // Telegram bot mode - natural language interface
+            const { startTelegramBot } = await Promise.resolve().then(() => __importStar(require("./telegram/bot")));
+            await startTelegramBot();
+            break;
+        case "mcp":
+            // MCP server mode - for Claude.ai / MCP clients
+            const { startMcpServer } = await Promise.resolve().then(() => __importStar(require("./mcp/server")));
+            await startMcpServer();
+            break;
+        case "both":
+            // Run both (MCP on stdio, Telegram in background)
+            console.log("Starting both Telegram bot and MCP server...");
+            const [{ startTelegramBot: startBot }, { startMcpServer: startMcp }] = await Promise.all([
+                Promise.resolve().then(() => __importStar(require("./telegram/bot"))),
+                Promise.resolve().then(() => __importStar(require("./mcp/server"))),
+            ]);
+            // Start Telegram in background (for approval notifications)
+            startBot().catch(console.error);
+            // Start MCP (this blocks on stdio)
+            await startMcp();
+            break;
+        case "gateway": {
+            const { Gateway } = await Promise.resolve().then(() => __importStar(require("./gateway")));
+            const { TelegramClient } = await Promise.resolve().then(() => __importStar(require("./clients/telegram")));
+            const allowedUsers = buildAllowedUsers();
+            if (allowedUsers.length === 0) {
+                throw new Error("No allowed users configured. Set ALLOWED_USERS or ALLOWED_USER_ID in your .env");
+            }
+            const gateway = new Gateway({
+                botName: BOT_NAME,
+                workingDir: process.env.WORKING_DIR || process.env.HOME || "/",
+                allowedUsers,
+                maxTurns: 10,
+            });
+            // Auto-register clients based on available env vars
+            if (process.env.TELEGRAM_BOT_TOKEN) {
+                gateway.registerClient(new TelegramClient(process.env.TELEGRAM_BOT_TOKEN));
+            }
+            // Future: Discord, Slack, etc.
+            await gateway.start();
+            break;
+        }
+        default:
+            console.error(`Unknown mode: ${mode}`);
+            console.error("Usage: npm start [telegram|mcp|both|gateway]");
+            process.exit(1);
+    }
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});
+// Graceful shutdown
+process.on("SIGINT", () => {
+    console.log("\n👋 Shutting down...");
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    console.log("\n👋 Shutting down...");
+    process.exit(0);
+});

package/dist/mcp/server.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startMcpServer = startMcpServer;
+// @ts-nocheck - Required due to MCP SDK type inference issue (TS2589)
+// See: https://github.com/modelcontextprotocol/sdk/issues - deep type instantiation with Zod schemas
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const executor_1 = require("../core/executor");
+const approval_1 = require("../core/approval");
+const logger_1 = require("../core/logger");
+const log = (0, logger_1.createStderrLogger)("MCP");
+async function startMcpServer() {
+    const executor = new executor_1.Executor();
+    const server = new mcp_js_1.McpServer({
+        name: "deskmate",
+        version: "1.0.0",
+    });
+    // Tool: Execute shell command
+    server.tool("execute_command", "Execute a shell command on the local machine. Requires approval for potentially dangerous commands.", {
+        command: zod_1.z.string().describe("The shell command to execute"),
+        working_dir: zod_1.z.string().optional().describe("Working directory (defaults to configured dir)"),
+    }, async ({ command, working_dir }) => {
+        log.info("Tool invoked: execute_command", { command, working_dir });
+        const approved = await approval_1.approvalManager.requestApproval("command", `Execute: ${command}`, { command, workingDir: working_dir || executor.getWorkingDir() }, { autoApprove: true });
+        if (!approved) {
+            log.warn("Command not approved", { command });
+            return {
+                content: [{ type: "text", text: "Command was not approved or timed out." }],
+            };
+        }
+        const result = await executor.executeCommand(command, working_dir);
+        log.debug("Tool completed: execute_command", { success: result.success, exitCode: result.exitCode });
+        return {
+            content: [{ type: "text", text: `Exit code: ${result.exitCode}\n\n${result.output}` }],
+            isError: !result.success,
+        };
+    });
+    // Tool: Read file
+    server.tool("read_file", "Read the contents of a file", {
+        path: zod_1.z.string().describe("Path to the file (absolute or relative to working dir)"),
+    }, async ({ path }) => {
+        log.info("Tool invoked: read_file", { path });
+        try {
+            const content = await executor.readFile(path);
+            log.debug("Tool completed: read_file", { path, size: content.length });
+            return {
+                content: [{ type: "text", text: content }],
+            };
+        }
+        catch (error) {
+            log.error("Tool failed: read_file", { path, error: error.message });
+            return {
+                content: [{ type: "text", text: `Error reading file: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+    // Tool: Write file
+    server.tool("write_file", "Write content to a file. Requires approval.", {
+        path: zod_1.z.string().describe("Path to the file (absolute or relative to working dir)"),
+        file_content: zod_1.z.string().describe("Content to write to the file"),
+    }, async ({ path, file_content }) => {
+        log.info("Tool invoked: write_file", { path, contentLength: file_content.length });
+        const approved = await approval_1.approvalManager.requestApproval("write_file", `Write to: ${path}`, { path, contentPreview: file_content.slice(0, 200) });
+        if (!approved) {
+            log.warn("File write not approved", { path });
+            return {
+                content: [{ type: "text", text: "File write was not approved or timed out." }],
+            };
+        }
+        try {
+            await executor.writeFile(path, file_content);
+            log.debug("Tool completed: write_file", { path, size: file_content.length });
+            return {
+                content: [{ type: "text", text: `Successfully wrote ${file_content.length} bytes to ${path}` }],
+            };
+        }
+        catch (error) {
+            log.error("Tool failed: write_file", { path, error: error.message });
+            return {
+                content: [{ type: "text", text: `Error writing file: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+    // Tool: List directory
+    server.tool("list_directory", "List files and directories in a path", {
+        path: zod_1.z.string().optional().describe("Path to list (defaults to working directory)"),
+    }, async ({ path }) => {
+        log.info("Tool invoked: list_directory", { path });
+        try {
+            const files = await executor.listDirectory(path);
+            const output = files
+                .map((f) => {
+                const type = f.isDirectory ? "dir" : "file";
+                const size = f.isDirectory ? "" : ` (${formatBytes(f.size)})`;
+                return `[${type}] ${f.name}${size}`;
+            })
+                .join("\n");
+            log.debug("Tool completed: list_directory", { path, itemCount: files.length });
+            return {
+                content: [{ type: "text", text: output || "(empty directory)" }],
+            };
+        }
+        catch (error) {
+            log.error("Tool failed: list_directory", { path, error: error.message });
+            return {
+                content: [{ type: "text", text: `Error listing directory: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+    // Tool: Get system info
+    server.tool("get_system_info", "Get information about the local system", {}, async () => {
+        log.info("Tool invoked: get_system_info");
+        const info = await executor.getSystemInfo();
+        const output = Object.entries(info)
+            .map(([key, value]) => `${key}: ${value}`)
+            .join("\n");
+        log.debug("Tool completed: get_system_info");
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    });
+    // Tool: List pending approvals
+    server.tool("list_pending_approvals", "List actions waiting for approval", {}, async () => {
+        log.info("Tool invoked: list_pending_approvals");
+        const pending = approval_1.approvalManager.getPendingActions();
+        log.debug("Tool completed: list_pending_approvals", { pendingCount: pending.length });
+        if (pending.length === 0) {
+            return {
+                content: [{ type: "text", text: "No pending approvals" }],
+            };
+        }
+        const output = pending
+            .map((a) => `[${a.id}] ${a.type}: ${a.description}`)
+            .join("\n");
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    });
+    // Connect via stdio
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    log.info("MCP Server started", { transport: "stdio" });
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}

package/dist/telegram/bot.js

@@ -0,0 +1,333 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startTelegramBot = startTelegramBot;
+const path = __importStar(require("path"));
+const grammy_1 = require("grammy");
+const executor_1 = require("../core/executor");
+const approval_1 = require("../core/approval");
+const agent_1 = require("../core/agent");
+const logger_1 = require("../core/logger");
+const platform_1 = require("../core/platform");
+const session_1 = require("../gateway/session");
+const log = (0, logger_1.createLogger)("TelegramBot");
+const BOT_NAME = process.env.BOT_NAME || "Deskmate";
+const SCREENSHOT_DIR = process.env.TMPDIR ? `${process.env.TMPDIR}deskmate-screenshots` : "/tmp/deskmate-screenshots";
+const SYSTEM_PROMPT = `You are a local machine assistant named ${BOT_NAME}. Users will ask you to perform tasks on their computer via Telegram.
+
+You have access to tools to execute commands, read/write files, and explore the filesystem. Use them to help users accomplish their tasks.
+
+SCREENSHOT CAPABILITY:
+When the user asks to see the screen, take a screenshot, or wants visual feedback, use this command:
+  ${(0, platform_1.getScreenshotHint)(SCREENSHOT_DIR)}
+The screenshot will automatically be sent to the user via Telegram after your response.
+
+IMPORTANT RULES:
+- Be concise in your responses (Telegram messages should be brief)
+- Use the available tools to accomplish tasks
+- For dangerous operations, explain what you're about to do before doing it
+- Never use sudo unless explicitly asked
+- Keep responses under 4000 characters (Telegram limit)
+- When asked for screenshots, always use the screenshot command above`;
+async function startTelegramBot() {
+    const token = process.env.TELEGRAM_BOT_TOKEN;
+    const allowedUserId = parseInt(process.env.ALLOWED_USER_ID || "0", 10);
+    if (!token || !allowedUserId) {
+        throw new Error("TELEGRAM_BOT_TOKEN and ALLOWED_USER_ID required for Telegram bot");
+    }
+    const bot = new grammy_1.Bot(token);
+    const executor = new executor_1.Executor();
+    const workingDir = process.env.WORKING_DIR || process.env.HOME || "/";
+    // Create the agent provider (abstracted - can be swapped)
+    const agentProvider = (0, agent_1.createAgentProvider)();
+    log.info("Using agent provider", { name: agentProvider.name, version: agentProvider.version });
+    // Verify provider is available
+    const providerAvailable = await agentProvider.isAvailable();
+    if (!providerAvailable) {
+        log.warn("Agent provider may not be fully available", { provider: agentProvider.name });
+    }
+    // Store session IDs per chat for context/memory (persisted to disk)
+    const chatSessions = new session_1.SessionManager({
+        storagePath: path.join(workingDir, "data", "sessions-telegram.json"),
+    });
+    // Register Telegram as an approval notifier
+    approval_1.approvalManager.addNotifier(async (action) => {
+        // This will be called when approval is needed
+        // We send a Telegram message for the user to approve/reject
+        try {
+            const keyboard = new grammy_1.InlineKeyboard()
+                .text("✅ Approve", `approve:${action.id}`)
+                .text("❌ Reject", `reject:${action.id}`);
+            let emoji = "🔐";
+            let details = "";
+            switch (action.type) {
+                case "command":
+                    emoji = "⚡";
+                    details = `\`\`\`bash\n${action.details.command}\n\`\`\``;
+                    break;
+                case "write_file":
+                    emoji = "📝";
+                    details = `Path: \`${action.details.path}\`\nPreview: ${(action.details.contentPreview || "").slice(0, 100)}...`;
+                    break;
+                case "folder_access":
+                    emoji = "📁";
+                    details = `Folder: \`${action.details.baseFolder}\`\nFile: \`${action.details.path}\``;
+                    break;
+                case "read_file":
+                    emoji = "👁️";
+                    details = `Path: \`${action.details.path}\``;
+                    break;
+                default:
+                    details = JSON.stringify(action.details, null, 2);
+            }
+            const timeLeft = Math.ceil((action.expiresAt.getTime() - Date.now()) / 1000);
+            await bot.api.sendMessage(allowedUserId, `${emoji} *Approval Required*\n\n` +
+                `Type: \`${action.type}\`\n` +
+                `${action.description}\n\n` +
+                `${details}\n\n` +
+                `⏱️ Expires in ${timeLeft}s`, { parse_mode: "Markdown", reply_markup: keyboard });
+            log.info("Approval notification sent to Telegram", { actionId: action.id, type: action.type });
+        }
+        catch (error) {
+            log.error("Failed to send Telegram notification", { error: error.message });
+        }
+    });
+    // Auth middleware
+    bot.use(async (ctx, next) => {
+        if (ctx.from?.id !== allowedUserId) {
+            console.log(`Unauthorized: ${ctx.from?.id}`);
+            return;
+        }
+        await next();
+    });
+    // Commands
+    bot.command("start", (ctx) => ctx.reply(`👋 *${BOT_NAME} Ready*\n\n` +
+        "Send me any task and I'll execute it on your local machine.\n\n" +
+        "I remember our conversation, so you can ask follow-up questions!\n\n" +
+        "*Examples:*\n" +
+        "• `list all docker containers`\n" +
+        "• `what's using port 3000?`\n" +
+        "• `show disk usage`\n" +
+        "• `take a screenshot`\n\n" +
+        "*Commands:*\n" +
+        "• /screenshot - Take a screenshot\n" +
+        "• /status - System info\n" +
+        "• /reset - Clear memory & start fresh", { parse_mode: "Markdown" }));
+    // Quick screenshot command
+    bot.command("screenshot", async (ctx) => {
+        const chatId = ctx.chat.id;
+        await ctx.reply("📸 Taking screenshot...");
+        try {
+            const { exec } = await Promise.resolve().then(() => __importStar(require("child_process")));
+            const { promisify } = await Promise.resolve().then(() => __importStar(require("util")));
+            const fs = await Promise.resolve().then(() => __importStar(require("fs/promises")));
+            const path = await Promise.resolve().then(() => __importStar(require("path")));
+            const execAsync = promisify(exec);
+            await fs.mkdir(SCREENSHOT_DIR, { recursive: true });
+            const filename = `screenshot-${Date.now()}.png`;
+            const filepath = path.join(SCREENSHOT_DIR, filename);
+            await execAsync((0, platform_1.getScreenshotCommand)(filepath));
+            await bot.api.sendPhoto(chatId, new grammy_1.InputFile(filepath), {
+                caption: "📸 Screenshot",
+            });
+            await fs.unlink(filepath).catch(() => { });
+            log.info("Screenshot command completed", { chatId });
+        }
+        catch (error) {
+            log.error("Screenshot command failed", { error: error.message });
+            await ctx.reply(`❌ Screenshot failed: ${error.message}`);
+        }
+    });
+    bot.command("status", async (ctx) => {
+        const pending = approval_1.approvalManager.getPendingActions();
+        const info = await executor.getSystemInfo();
+        const hasSession = chatSessions.has("telegram", String(ctx.chat.id));
+        await ctx.reply(`🖥️ *System Status*\n\n` +
+            `• Host: ${info.hostname || "unknown"}\n` +
+            `• Platform: ${info.platform}\n` +
+            `• Agent: ${agentProvider.name} v${agentProvider.version}\n` +
+            `• Pending approvals: ${pending.length}\n` +
+            `• Working dir: \`${executor.getWorkingDir()}\`\n` +
+            `• Session active: ${hasSession ? "Yes ✅" : "No"}`, { parse_mode: "Markdown" });
+    });
+    // Reset session - start fresh conversation
+    bot.command("reset", async (ctx) => {
+        const chatId = ctx.chat.id;
+        const hadSession = chatSessions.has("telegram", String(chatId));
+        chatSessions.delete("telegram", String(chatId));
+        log.info("Session reset", { chatId, hadSession });
+        await ctx.reply(hadSession
+            ? "🔄 Session cleared! Starting fresh conversation."
+            : "ℹ️ No active session to clear.");
+    });
+    // Approval callbacks
+    bot.callbackQuery(/^approve:(.+)$/, async (ctx) => {
+        const actionId = ctx.match[1];
+        const success = approval_1.approvalManager.approve(actionId);
+        await ctx.answerCallbackQuery({ text: success ? "Approved!" : "Action not found" });
+        if (success) {
+            await ctx.editMessageText("✅ *Approved* - executing...", { parse_mode: "Markdown" });
+        }
+    });
+    bot.callbackQuery(/^reject:(.+)$/, async (ctx) => {
+        const actionId = ctx.match[1];
+        approval_1.approvalManager.reject(actionId);
+        await ctx.answerCallbackQuery({ text: "Rejected" });
+        await ctx.editMessageText("❌ *Rejected*", { parse_mode: "Markdown" });
+    });
+    // Helper to send screenshots
+    async function sendScreenshots(chatId, since) {
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require("fs/promises")));
+            const path = await Promise.resolve().then(() => __importStar(require("path")));
+            await fs.mkdir(SCREENSHOT_DIR, { recursive: true }).catch(() => { });
+            const files = await fs.readdir(SCREENSHOT_DIR).catch(() => []);
+            let sent = 0;
+            for (const file of files) {
+                if (!file.endsWith(".png"))
+                    continue;
+                const filepath = path.join(SCREENSHOT_DIR, file);
+                const stats = await fs.stat(filepath).catch(() => null);
+                if (stats && stats.mtime >= since) {
+                    log.info("Sending screenshot", { filepath });
+                    await bot.api.sendPhoto(chatId, new grammy_1.InputFile(filepath), {
+                        caption: "📸 Screenshot",
+                    });
+                    // Clean up after sending
+                    await fs.unlink(filepath).catch(() => { });
+                    sent++;
+                }
+            }
+            return sent;
+        }
+        catch (error) {
+            log.error("Failed to send screenshots", { error: error.message });
+            return 0;
+        }
+    }
+    // Main message handler - uses abstract agent provider
+    bot.on("message:text", async (ctx) => {
+        const userMessage = ctx.message.text;
+        const chatId = ctx.chat.id;
+        const thinkingMsg = await ctx.reply("🤔 Thinking...");
+        // Record time before execution for screenshot detection
+        const executionStartTime = new Date();
+        // Get existing session for this chat (if any)
+        const existingSessionId = chatSessions.get("telegram", String(chatId));
+        log.info("Received message", {
+            userId: ctx.from?.id,
+            chatId,
+            hasSession: !!existingSessionId,
+            message: userMessage.slice(0, 100),
+        });
+        try {
+            let result = "";
+            let lastUpdate = Date.now();
+            let newSessionId;
+            // Use the abstract agent provider
+            for await (const event of agentProvider.queryStream(userMessage, {
+                systemPrompt: SYSTEM_PROMPT,
+                workingDir,
+                sessionId: existingSessionId,
+                maxTurns: 10,
+            })) {
+                log.debug("Agent event", { type: event.type });
+                switch (event.type) {
+                    case "text":
+                        if (event.text) {
+                            result = event.text;
+                        }
+                        break;
+                    case "tool_use":
+                        log.debug("Tool use", { tool: event.toolName });
+                        break;
+                    case "done":
+                        if (event.response) {
+                            result = event.response.text;
+                            newSessionId = event.response.sessionId;
+                        }
+                        break;
+                    case "error":
+                        throw new Error(event.error || "Unknown agent error");
+                }
+                // Update thinking message periodically to show progress
+                if (Date.now() - lastUpdate > 3000) {
+                    try {
+                        await ctx.api.editMessageText(chatId, thinkingMsg.message_id, "⏳ Working...");
+                        lastUpdate = Date.now();
+                    }
+                    catch {
+                        // Ignore edit errors
+                    }
+                }
+            }
+            // Store the session ID for future messages
+            if (newSessionId) {
+                chatSessions.set("telegram", String(chatId), newSessionId);
+                log.info("Session stored", { chatId, sessionId: newSessionId });
+            }
+            // Send final result
+            const finalMessage = result || "Task completed (no output)";
+            const truncated = finalMessage.slice(0, 4000); // Telegram limit
+            log.info("Agent completed", { resultLength: finalMessage.length, hasSession: !!newSessionId });
+            await ctx.api.editMessageText(chatId, thinkingMsg.message_id, truncated, {
+                parse_mode: "Markdown",
+            }).catch(async () => {
+                // If Markdown fails, try without
+                await ctx.api.editMessageText(chatId, thinkingMsg.message_id, truncated);
+            });
+            // Check for and send any screenshots taken during execution
+            const screenshotsSent = await sendScreenshots(chatId, executionStartTime);
+            if (screenshotsSent > 0) {
+                log.info("Screenshots sent", { count: screenshotsSent });
+            }
+        }
+        catch (error) {
+            log.error("Agent error", { error: error.message });
+            // If session error, clear the session and retry might help
+            if (error.message?.includes("session")) {
+                chatSessions.delete("telegram", String(chatId));
+                log.warn("Cleared invalid session", { chatId });
+            }
+            await ctx.api.editMessageText(chatId, thinkingMsg.message_id, `❌ Error: ${error.message}`);
+        }
+    });
+    // Start polling
+    console.log("🤖 Starting Telegram bot...");
+    bot.start({
+        drop_pending_updates: true, // Don't process old updates on restart
+        onStart: (info) => console.log(`✅ Telegram bot @${info.username} running (${agentProvider.name})`),
+    });
+}