lazy-gravity 0.2.0 → 0.4.0

package/dist/bot/eventRouter.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventRouter = void 0;
+const logger_1 = require("../utils/logger");
+/**
+ * Routes events from multiple PlatformAdapters through auth check
+ * and dispatches to unified handlers.
+ */
+class EventRouter {
+    config;
+    handlers;
+    adapters = [];
+    constructor(config, handlers) {
+        this.config = config;
+        this.handlers = handlers;
+    }
+    /** Register an adapter. Stores it for later start/stop. */
+    registerAdapter(adapter) {
+        this.adapters.push(adapter);
+    }
+    /** Start all registered adapters. */
+    async startAll() {
+        await Promise.all(this.adapters.map((adapter) => {
+            const events = this.createAdapterEvents(adapter);
+            return adapter.start(events);
+        }));
+    }
+    /** Stop all registered adapters. */
+    async stopAll() {
+        await Promise.all(this.adapters.map((a) => a.stop()));
+    }
+    /** Check if a user is authorized on a given platform. */
+    isAuthorized(platform, userId) {
+        const allowed = this.config.allowedUsers.get(platform);
+        return allowed ? allowed.has(userId) : false;
+    }
+    createAdapterEvents(adapter) {
+        return {
+            onReady: () => {
+                logger_1.logger.info(`[EventRouter] ${adapter.platform} adapter ready`);
+            },
+            onMessage: async (msg) => {
+                if (msg.author.isBot)
+                    return;
+                if (!this.isAuthorized(msg.platform, msg.author.id))
+                    return;
+                await this.handlers.onMessage?.(msg);
+            },
+            onButtonInteraction: async (interaction) => {
+                if (!this.isAuthorized(interaction.platform, interaction.user.id))
+                    return;
+                await this.handlers.onButtonInteraction?.(interaction);
+            },
+            onSelectInteraction: async (interaction) => {
+                if (!this.isAuthorized(interaction.platform, interaction.user.id))
+                    return;
+                await this.handlers.onSelectInteraction?.(interaction);
+            },
+            onCommandInteraction: async (interaction) => {
+                if (!this.isAuthorized(interaction.platform, interaction.user.id))
+                    return;
+                await this.handlers.onCommandInteraction?.(interaction);
+            },
+            onError: (err) => {
+                logger_1.logger.error(`[EventRouter] ${adapter.platform} error:`, err);
+            },
+        };
+    }
+}
+exports.EventRouter = EventRouter;

package/dist/bot/index.js

@@ -43,11 +43,13 @@ const logger_1 = require("../utils/logger");
 const logBuffer_1 = require("../utils/logBuffer");
 const discord_js_1 = require("discord.js");
 const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const wrappers_1 = require("../platform/discord/wrappers");
 const config_1 = require("../utils/config");
 const slashCommandHandler_1 = require("../commands/slashCommandHandler");
 const registerSlashCommands_1 = require("../commands/registerSlashCommands");
 const modeService_1 = require("../services/modeService");
 const modelService_1 = require("../services/modelService");
+const defaultModelApplicator_1 = require("../services/defaultModelApplicator");
 const templateRepository_1 = require("../database/templateRepository");
 const workspaceBindingRepository_1 = require("../database/workspaceBindingRepository");
 const chatSessionRepository_1 = require("../database/chatSessionRepository");
@@ -78,6 +80,22 @@ const userPreferenceRepository_1 = require("../database/userPreferenceRepository
 const plainTextFormatter_1 = require("../utils/plainTextFormatter");
 const interactionCreateHandler_1 = require("../events/interactionCreateHandler");
 const messageCreateHandler_1 = require("../events/messageCreateHandler");
+// Telegram platform support
+const grammy_1 = require("grammy");
+const telegramAdapter_1 = require("../platform/telegram/telegramAdapter");
+const telegramBindingRepository_1 = require("../database/telegramBindingRepository");
+const telegramMessageHandler_1 = require("./telegramMessageHandler");
+const telegramProjectCommand_1 = require("./telegramProjectCommand");
+const eventRouter_1 = require("./eventRouter");
+const buttonHandler_1 = require("../handlers/buttonHandler");
+const selectHandler_1 = require("../handlers/selectHandler");
+const approvalButtonAction_1 = require("../handlers/approvalButtonAction");
+const planningButtonAction_1 = require("../handlers/planningButtonAction");
+const errorPopupButtonAction_1 = require("../handlers/errorPopupButtonAction");
+const modelButtonAction_1 = require("../handlers/modelButtonAction");
+const autoAcceptButtonAction_1 = require("../handlers/autoAcceptButtonAction");
+const templateButtonAction_1 = require("../handlers/templateButtonAction");
+const modeSelectAction_1 = require("../handlers/modeSelectAction");
 // =============================================================================
 // Embed color palette (color-coded by phase)
 // =============================================================================
@@ -286,6 +304,11 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
         signalCompletion('cdp-disconnected');
         return;
     }
+    // Apply default model preference on CDP connect
+    const defaultModelResult = await (0, defaultModelApplicator_1.applyDefaultModel)(cdp, modelService);
+    if (defaultModelResult.stale && defaultModelResult.staleMessage && channel) {
+        await channel.send(defaultModelResult.staleMessage).catch(() => { });
+    }
     const localMode = modeService.getCurrentMode();
     const modeName = modeService_1.MODE_UI_NAMES[localMode] || localMode;
     const currentModel = (await cdp.getCurrentModel()) || modelService.getCurrentModel();
@@ -450,6 +473,7 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
         }
     }, `upsert-activity:${opts?.source ?? 'unknown'}`);
     try {
+        logger_1.logger.prompt(prompt);
         let injectResult;
         if (inboundImages.length > 0) {
             injectResult = await cdp.injectMessageWithImageFiles(prompt, inboundImages.map((image) => image.localPath));
@@ -476,6 +500,7 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
             pollIntervalMs: 2000,
             maxDurationMs: 300000,
             stopGoneConfirmCount: 3,
+            extractionMode: options?.extractionMode,
             onPhaseChange: (_phase, _text) => {
                 // Phase transitions are already logged inside ResponseMonitor.setPhase()
             },
@@ -602,7 +627,7 @@ async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService
                                         ? bridge.pool.extractProjectName(session.workspacePath)
                                         : cdp.getCurrentWorkspaceName();
                                     if (projectName) {
-                                        (0, cdpBridgeManager_1.registerApprovalSessionChannel)(bridge, projectName, sessionInfo.title, message.channel);
+                                        (0, cdpBridgeManager_1.registerApprovalSessionChannel)(bridge, projectName, sessionInfo.title, (0, wrappers_1.wrapDiscordChannel)(message.channel));
                                     }
                                     const newName = options.titleGenerator.sanitizeForChannelName(sessionInfo.title);
                                     if (session && session.displayName !== sessionInfo.title) {
@@ -700,6 +725,17 @@ const startBot = async (cliLogLevel) => {
     const modelService = new modelService_1.ModelService();
     const templateRepo = new templateRepository_1.TemplateRepository(db);
     const userPrefRepo = new userPreferenceRepository_1.UserPreferenceRepository(db);
+    // Eagerly load default model from DB (single-user bot optimization)
+    try {
+        const firstUser = db.prepare('SELECT user_id FROM user_preferences LIMIT 1').get();
+        if (firstUser) {
+            const savedDefault = userPrefRepo.getDefaultModel(firstUser.user_id);
+            modelService.loadDefaultModel(savedDefault);
+        }
+    }
+    catch {
+        // DB may not have user_preferences yet — safe to ignore
+    }
     const workspaceBindingRepo = new workspaceBindingRepository_1.WorkspaceBindingRepository(db);
     const chatSessionRepo = new chatSessionRepository_1.ChatSessionRepository(db);
     const workspaceService = new workspaceService_1.WorkspaceService(config.workspaceBaseDir);
@@ -722,165 +758,337 @@ const startBot = async (cliLogLevel) => {
     const chatHandler = new chatCommandHandler_1.ChatCommandHandler(chatSessionService, chatSessionRepo, workspaceBindingRepo, channelManager, workspaceService, bridge.pool);
     const cleanupHandler = new cleanupCommandHandler_1.CleanupCommandHandler(chatSessionRepo, workspaceBindingRepo);
     const slashCommandHandler = new slashCommandHandler_1.SlashCommandHandler(templateRepo);
-    const client = new discord_js_1.Client({
-        intents: [
-            discord_js_1.GatewayIntentBits.Guilds,
-            discord_js_1.GatewayIntentBits.GuildMessages,
-            discord_js_1.GatewayIntentBits.MessageContent,
-        ]
-    });
-    const joinHandler = new joinCommandHandler_1.JoinCommandHandler(chatSessionService, chatSessionRepo, workspaceBindingRepo, channelManager, bridge.pool, workspaceService, client);
-    client.once(discord_js_1.Events.ClientReady, async (readyClient) => {
-        logger_1.logger.info(`Ready! Logged in as ${readyClient.user.tag} | extractionMode=${config.extractionMode}`);
-        try {
-            await (0, registerSlashCommands_1.registerSlashCommands)(config.discordToken, config.clientId, config.guildId);
-        }
-        catch (error) {
-            logger_1.logger.warn('Failed to register slash commands, but text commands remain available.');
+    // Discord platform — only initialise the Discord client when the platform is enabled
+    if (config.platforms.includes('discord')) {
+        if (!config.discordToken || !config.clientId) {
+            logger_1.logger.error('Discord platform enabled but discordToken or clientId is missing. Skipping Discord initialization.');
         }
-        // Startup dashboard embed
-        try {
-            const os = await Promise.resolve().then(() => __importStar(require('os')));
-            const pkg = await Promise.resolve().then(() => __importStar(require('../../package.json')));
-            const version = pkg.default?.version ?? pkg.version ?? 'unknown';
-            const projects = workspaceService.scanWorkspaces();
-            // Check CDP connection status
-            const activeWorkspaces = bridge.pool.getActiveWorkspaceNames();
-            const cdpStatus = activeWorkspaces.length > 0
-                ? `Connected (${activeWorkspaces.join(', ')})`
-                : 'Not connected';
-            const dashboardEmbed = new discord_js_1.EmbedBuilder()
-                .setTitle('LazyGravity Online')
-                .setColor(0x57F287)
-                .addFields({ name: 'Version', value: version, inline: true }, { name: 'Node.js', value: process.versions.node, inline: true }, { name: 'OS', value: `${os.platform()} ${os.release()}`, inline: true }, { name: 'CDP', value: cdpStatus, inline: true }, { name: 'Model', value: modelService.getCurrentModel(), inline: true }, { name: 'Mode', value: modeService.getCurrentMode(), inline: true }, { name: 'Projects', value: `${projects.length} registered`, inline: true }, { name: 'Extraction', value: config.extractionMode, inline: true })
-                .setFooter({ text: `Started at ${new Date().toLocaleString()}` })
-                .setTimestamp();
-            // Send to the first available text channel in the guild
-            const guild = readyClient.guilds.cache.first();
-            if (guild) {
-                const channel = guild.channels.cache.find((ch) => ch.isTextBased() && !ch.isVoiceBased() && ch.permissionsFor(readyClient.user)?.has('SendMessages'));
-                if (channel && channel.isTextBased()) {
-                    await channel.send({ embeds: [dashboardEmbed] });
-                    logger_1.logger.info('Startup dashboard embed sent.');
+        else {
+            const discordToken = config.discordToken;
+            const discordClientId = config.clientId;
+            const client = new discord_js_1.Client({
+                intents: [
+                    discord_js_1.GatewayIntentBits.Guilds,
+                    discord_js_1.GatewayIntentBits.GuildMessages,
+                    discord_js_1.GatewayIntentBits.MessageContent,
+                ]
+            });
+            const joinHandler = new joinCommandHandler_1.JoinCommandHandler(chatSessionService, chatSessionRepo, workspaceBindingRepo, channelManager, bridge.pool, workspaceService, client, config.extractionMode);
+            client.once(discord_js_1.Events.ClientReady, async (readyClient) => {
+                logger_1.logger.info(`Ready! Logged in as ${readyClient.user.tag} | extractionMode=${config.extractionMode}`);
+                try {
+                    await (0, registerSlashCommands_1.registerSlashCommands)(discordToken, discordClientId, config.guildId);
                 }
-            }
-        }
-        catch (error) {
-            logger_1.logger.warn('Failed to send startup dashboard embed:', error);
-        }
-    });
-    // [Discord Interactions API] Slash command interaction handler
-    client.on(discord_js_1.Events.InteractionCreate, (0, interactionCreateHandler_1.createInteractionCreateHandler)({
-        config,
-        bridge,
-        cleanupHandler,
-        modeService,
-        modelService,
-        slashCommandHandler,
-        wsHandler,
-        chatHandler,
-        client,
-        sendModeUI: modeUi_1.sendModeUI,
-        sendModelsUI: modelsUi_1.sendModelsUI,
-        sendAutoAcceptUI: autoAcceptUi_1.sendAutoAcceptUI,
-        getCurrentCdp: cdpBridgeManager_1.getCurrentCdp,
-        parseApprovalCustomId: cdpBridgeManager_1.parseApprovalCustomId,
-        parseErrorPopupCustomId: cdpBridgeManager_1.parseErrorPopupCustomId,
-        parsePlanningCustomId: cdpBridgeManager_1.parsePlanningCustomId,
-        joinHandler,
-        userPrefRepo,
-        handleSlashInteraction: async (interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg) => handleSlashInteraction(interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, promptDispatcher, templateRepo, joinHandler, userPrefRepo),
-        handleTemplateUse: async (interaction, templateId) => {
-            const template = templateRepo.findById(templateId);
-            if (!template) {
-                await interaction.followUp({
-                    content: 'Template not found. It may have been deleted.',
-                    flags: discord_js_1.MessageFlags.Ephemeral,
-                });
-                return;
-            }
-            // Resolve CDP via workspace binding (same flow as text messages)
-            const channelId = interaction.channelId;
-            const workspacePath = wsHandler.getWorkspaceForChannel(channelId);
-            let cdp = null;
-            if (workspacePath) {
+                catch (error) {
+                    logger_1.logger.warn('Failed to register slash commands, but text commands remain available.');
+                }
+                // Startup dashboard embed
                 try {
-                    cdp = await bridge.pool.getOrConnect(workspacePath);
-                    const projectName = bridge.pool.extractProjectName(workspacePath);
-                    bridge.lastActiveWorkspace = projectName;
-                    bridge.lastActiveChannel = interaction.channel;
-                    (0, cdpBridgeManager_1.registerApprovalWorkspaceChannel)(bridge, projectName, interaction.channel);
-                    const session = chatSessionRepo.findByChannelId(channelId);
-                    if (session?.displayName) {
-                        (0, cdpBridgeManager_1.registerApprovalSessionChannel)(bridge, projectName, session.displayName, interaction.channel);
+                    const os = await Promise.resolve().then(() => __importStar(require('os')));
+                    const pkg = await Promise.resolve().then(() => __importStar(require('../../package.json')));
+                    const version = pkg.default?.version ?? pkg.version ?? 'unknown';
+                    const projects = workspaceService.scanWorkspaces();
+                    // Check CDP connection status
+                    const activeWorkspaces = bridge.pool.getActiveWorkspaceNames();
+                    const cdpStatus = activeWorkspaces.length > 0
+                        ? `Connected (${activeWorkspaces.join(', ')})`
+                        : 'Not connected';
+                    const dashboardEmbed = new discord_js_1.EmbedBuilder()
+                        .setTitle('LazyGravity Online')
+                        .setColor(0x57F287)
+                        .addFields({ name: 'Version', value: version, inline: true }, { name: 'Node.js', value: process.versions.node, inline: true }, { name: 'OS', value: `${os.platform()} ${os.release()}`, inline: true }, { name: 'CDP', value: cdpStatus, inline: true }, { name: 'Model', value: modelService.getCurrentModel(), inline: true }, { name: 'Mode', value: modeService.getCurrentMode(), inline: true }, { name: 'Projects', value: `${projects.length} registered`, inline: true }, { name: 'Extraction', value: config.extractionMode, inline: true })
+                        .setFooter({ text: `Started at ${new Date().toLocaleString()}` })
+                        .setTimestamp();
+                    // Send to the first available text channel in the guild
+                    const guild = readyClient.guilds.cache.first();
+                    if (guild) {
+                        const channel = guild.channels.cache.find((ch) => ch.isTextBased() && !ch.isVoiceBased() && ch.permissionsFor(readyClient.user)?.has('SendMessages'));
+                        if (channel && channel.isTextBased()) {
+                            await channel.send({ embeds: [dashboardEmbed] });
+                            logger_1.logger.info('Startup dashboard embed sent.');
+                        }
                     }
-                    (0, cdpBridgeManager_1.ensureApprovalDetector)(bridge, cdp, projectName, client);
-                    (0, cdpBridgeManager_1.ensureErrorPopupDetector)(bridge, cdp, projectName, client);
-                    (0, cdpBridgeManager_1.ensurePlanningDetector)(bridge, cdp, projectName, client);
                 }
-                catch (e) {
-                    await interaction.followUp({
-                        content: `Failed to connect to workspace: ${e.message}`,
-                        flags: discord_js_1.MessageFlags.Ephemeral,
+                catch (error) {
+                    logger_1.logger.warn('Failed to send startup dashboard embed:', error);
+                }
+            });
+            // [Discord Interactions API] Slash command interaction handler
+            client.on(discord_js_1.Events.InteractionCreate, (0, interactionCreateHandler_1.createInteractionCreateHandler)({
+                config,
+                bridge,
+                cleanupHandler,
+                modeService,
+                modelService,
+                slashCommandHandler,
+                wsHandler,
+                chatHandler,
+                client,
+                sendModeUI: modeUi_1.sendModeUI,
+                sendModelsUI: modelsUi_1.sendModelsUI,
+                sendAutoAcceptUI: autoAcceptUi_1.sendAutoAcceptUI,
+                getCurrentCdp: cdpBridgeManager_1.getCurrentCdp,
+                parseApprovalCustomId: cdpBridgeManager_1.parseApprovalCustomId,
+                parseErrorPopupCustomId: cdpBridgeManager_1.parseErrorPopupCustomId,
+                parsePlanningCustomId: cdpBridgeManager_1.parsePlanningCustomId,
+                joinHandler,
+                userPrefRepo,
+                handleSlashInteraction: async (interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg) => handleSlashInteraction(interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, promptDispatcher, templateRepo, joinHandler, userPrefRepo),
+                handleTemplateUse: async (interaction, templateId) => {
+                    const template = templateRepo.findById(templateId);
+                    if (!template) {
+                        await interaction.followUp({
+                            content: 'Template not found. It may have been deleted.',
+                            flags: discord_js_1.MessageFlags.Ephemeral,
+                        });
+                        return;
+                    }
+                    // Resolve CDP via workspace binding (same flow as text messages)
+                    const channelId = interaction.channelId;
+                    const workspacePath = wsHandler.getWorkspaceForChannel(channelId);
+                    let cdp = null;
+                    if (workspacePath) {
+                        try {
+                            cdp = await bridge.pool.getOrConnect(workspacePath);
+                            const projectName = bridge.pool.extractProjectName(workspacePath);
+                            bridge.lastActiveWorkspace = projectName;
+                            const platformCh = (0, wrappers_1.wrapDiscordChannel)(interaction.channel);
+                            bridge.lastActiveChannel = platformCh;
+                            (0, cdpBridgeManager_1.registerApprovalWorkspaceChannel)(bridge, projectName, platformCh);
+                            const session = chatSessionRepo.findByChannelId(channelId);
+                            if (session?.displayName) {
+                                (0, cdpBridgeManager_1.registerApprovalSessionChannel)(bridge, projectName, session.displayName, platformCh);
+                            }
+                            (0, cdpBridgeManager_1.ensureApprovalDetector)(bridge, cdp, projectName);
+                            (0, cdpBridgeManager_1.ensureErrorPopupDetector)(bridge, cdp, projectName);
+                            (0, cdpBridgeManager_1.ensurePlanningDetector)(bridge, cdp, projectName);
+                        }
+                        catch (e) {
+                            await interaction.followUp({
+                                content: `Failed to connect to workspace: ${e.message}`,
+                                flags: discord_js_1.MessageFlags.Ephemeral,
+                            });
+                            return;
+                        }
+                    }
+                    else {
+                        cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+                    }
+                    if (!cdp) {
+                        await interaction.followUp({
+                            content: 'Not connected to CDP. Please connect to a project first.',
+                            flags: discord_js_1.MessageFlags.Ephemeral,
+                        });
+                        return;
+                    }
+                    const followUp = await interaction.followUp({
+                        content: `Executing template **${template.name}**...`,
                     });
+                    if (followUp instanceof discord_js_1.Message) {
+                        await promptDispatcher.send({
+                            message: followUp,
+                            prompt: template.prompt,
+                            cdp,
+                            inboundImages: [],
+                            options: {
+                                chatSessionService,
+                                chatSessionRepo,
+                                channelManager,
+                                titleGenerator,
+                                userPrefRepo,
+                                extractionMode: config.extractionMode,
+                            },
+                        });
+                    }
+                },
+            }));
+            // [Text message handler]
+            client.on(discord_js_1.Events.MessageCreate, (0, messageCreateHandler_1.createMessageCreateHandler)({
+                config,
+                bridge,
+                modeService,
+                modelService,
+                slashCommandHandler,
+                wsHandler,
+                chatSessionService,
+                chatSessionRepo,
+                channelManager,
+                titleGenerator,
+                client,
+                sendPromptToAntigravity: async (_bridge, message, prompt, cdp, _modeService, _modelService, inboundImages = [], options) => promptDispatcher.send({
+                    message,
+                    prompt,
+                    cdp,
+                    inboundImages,
+                    options,
+                }),
+                autoRenameChannel,
+                handleScreenshot: screenshotUi_1.handleScreenshot,
+                userPrefRepo,
+            }));
+            await client.login(discordToken);
+        } // end: else (credentials present)
+    } // end: Discord platform gate
+    // Telegram platform
+    if (config.platforms.includes('telegram') && config.telegramToken) {
+        try {
+            const telegramBot = new grammy_1.Bot(config.telegramToken);
+            // Attach toInputFile so wrappers can convert Buffer to grammY InputFile
+            telegramBot.toInputFile = (data, filename) => new grammy_1.InputFile(data, filename);
+            // Retry getMe() up to 3 times to handle transient network failures
+            const botInfo = await (async () => {
+                for (let attempt = 1; attempt <= 3; attempt++) {
+                    try {
+                        return await telegramBot.api.getMe();
+                    }
+                    catch (err) {
+                        if (attempt === 3)
+                            throw err;
+                        logger_1.logger.warn(`[Telegram] getMe() failed (attempt ${attempt}/3): ${err?.message ?? err}. Retrying in 3s...`);
+                        await new Promise(r => setTimeout(r, 3000));
+                    }
+                }
+                throw new Error('getMe() failed after 3 attempts');
+            })();
+            const telegramBindingRepo = new telegramBindingRepository_1.TelegramBindingRepository(db);
+            const telegramAdapter = new telegramAdapter_1.TelegramAdapter(telegramBot, String(botInfo.id));
+            const activeMonitors = new Map();
+            const telegramHandler = (0, telegramMessageHandler_1.createTelegramMessageHandler)({
+                bridge,
+                telegramBindingRepo,
+                workspaceService,
+                modeService,
+                modelService,
+                extractionMode: config.extractionMode,
+                templateRepo,
+                fetchQuota: () => bridge.quota.fetchQuota(),
+                activeMonitors,
+                botToken: config.telegramToken,
+                botApi: telegramBot.api,
+                chatSessionService,
+            });
+            // Compose select handlers: project select + mode select
+            const projectSelectHandler = (0, telegramProjectCommand_1.createTelegramSelectHandler)({
+                workspaceService,
+                telegramBindingRepo,
+            });
+            const modeSelectAction = (0, modeSelectAction_1.createModeSelectAction)({ bridge, modeService });
+            const telegramSelectHandler = (0, selectHandler_1.createPlatformSelectHandler)({
+                actions: [
+                    modeSelectAction,
+                ],
+            });
+            // Composite handler that routes to the right handler
+            const compositeSelectHandler = async (interaction) => {
+                if (interaction.customId === 'mode_select') {
+                    await telegramSelectHandler(interaction);
                     return;
                 }
+                await projectSelectHandler(interaction);
+            };
+            const allowedUsers = new Map();
+            if (config.telegramAllowedUserIds && config.telegramAllowedUserIds.length > 0) {
+                allowedUsers.set('telegram', new Set(config.telegramAllowedUserIds));
             }
             else {
-                cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
-            }
-            if (!cdp) {
-                await interaction.followUp({
-                    content: 'Not connected to CDP. Please connect to a project first.',
-                    flags: discord_js_1.MessageFlags.Ephemeral,
-                });
-                return;
+                logger_1.logger.warn('Telegram platform enabled but TELEGRAM_ALLOWED_USER_IDS is empty — all users will be denied access.');
             }
-            const followUp = await interaction.followUp({
-                content: `Executing template **${template.name}**...`,
+            const telegramButtonHandler = (0, buttonHandler_1.createPlatformButtonHandler)({
+                actions: [
+                    (0, approvalButtonAction_1.createApprovalButtonAction)({ bridge }),
+                    (0, planningButtonAction_1.createPlanningButtonAction)({ bridge }),
+                    (0, errorPopupButtonAction_1.createErrorPopupButtonAction)({ bridge }),
+                    (0, modelButtonAction_1.createModelButtonAction)({ bridge, fetchQuota: () => bridge.quota.fetchQuota(), modelService, userPrefRepo }),
+                    (0, autoAcceptButtonAction_1.createAutoAcceptButtonAction)({ autoAcceptService: bridge.autoAccept }),
+                    (0, templateButtonAction_1.createTemplateButtonAction)({ bridge, templateRepo }),
+                ],
             });
-            if (followUp instanceof discord_js_1.Message) {
-                await promptDispatcher.send({
-                    message: followUp,
-                    prompt: template.prompt,
-                    cdp,
-                    inboundImages: [],
-                    options: {
-                        chatSessionService,
-                        chatSessionRepo,
-                        channelManager,
-                        titleGenerator,
-                        userPrefRepo,
-                    },
-                });
+            const eventRouter = new eventRouter_1.EventRouter({ allowedUsers }, {
+                onMessage: telegramHandler,
+                onButtonInteraction: telegramButtonHandler,
+                onSelectInteraction: compositeSelectHandler,
+            });
+            // Register bot commands BEFORE starting polling so Telegram shows "/" suggestions
+            await telegramBot.api.setMyCommands([
+                { command: 'start', description: 'Welcome message' },
+                { command: 'project', description: 'Manage workspace bindings' },
+                { command: 'status', description: 'Show bot status and connections' },
+                { command: 'mode', description: 'Switch execution mode' },
+                { command: 'model', description: 'Switch LLM model' },
+                { command: 'screenshot', description: 'Capture Antigravity screenshot' },
+                { command: 'autoaccept', description: 'Toggle auto-accept mode' },
+                { command: 'template', description: 'List prompt templates' },
+                { command: 'template_add', description: 'Add a prompt template' },
+                { command: 'template_delete', description: 'Delete a prompt template' },
+                { command: 'project_create', description: 'Create a new workspace' },
+                { command: 'new', description: 'Start a new chat session' },
+                { command: 'logs', description: 'Show recent log entries' },
+                { command: 'stop', description: 'Interrupt active LLM generation' },
+                { command: 'help', description: 'Show available commands' },
+                { command: 'ping', description: 'Check bot latency' },
+            ]).catch((e) => {
+                logger_1.logger.warn('Failed to register Telegram commands:', e instanceof Error ? e.message : e);
+            });
+            eventRouter.registerAdapter(telegramAdapter);
+            await eventRouter.startAll();
+            logger_1.logger.info(`Telegram bot started: @${botInfo.username} (${config.telegramAllowedUserIds?.length ?? 0} allowed users)`);
+            // Send startup message to all bound Telegram chats
+            const bindings = telegramBindingRepo.findAll();
+            if (bindings.length > 0) {
+                const os = await Promise.resolve().then(() => __importStar(require('os')));
+                const pkg = await Promise.resolve().then(() => __importStar(require('../../package.json')));
+                const version = pkg.default?.version ?? pkg.version ?? 'unknown';
+                const projects = workspaceService.scanWorkspaces();
+                const activeWorkspaces = bridge.pool.getActiveWorkspaceNames();
+                const cdpStatus = activeWorkspaces.length > 0
+                    ? `Connected (${activeWorkspaces.join(', ')})`
+                    : 'Not connected';
+                const startupText = [
+                    '<b>LazyGravity Online</b>',
+                    '',
+                    `Version: ${version}`,
+                    `Node.js: ${process.versions.node}`,
+                    `OS: ${os.platform()} ${os.release()}`,
+                    `CDP: ${cdpStatus}`,
+                    `Model: ${modelService.getCurrentModel()}`,
+                    `Mode: ${modeService.getCurrentMode()}`,
+                    `Projects: ${projects.length} registered`,
+                    `Extraction: ${config.extractionMode}`,
+                    '',
+                    `<i>Started at ${new Date().toLocaleString()}</i>`,
+                ].join('\n');
+                const sendWithRetry = async (chatId, text, retries = 3, delayMs = 2000) => {
+                    for (let attempt = 1; attempt <= retries; attempt++) {
+                        try {
+                            await telegramBot.api.sendMessage(chatId, text, { parse_mode: 'HTML' });
+                            return;
+                        }
+                        catch (err) {
+                            if (attempt < retries) {
+                                logger_1.logger.debug(`[Telegram] Startup message attempt ${attempt}/${retries} failed, retrying in ${delayMs}ms...`);
+                                await new Promise((r) => setTimeout(r, delayMs));
+                            }
+                            else {
+                                throw err;
+                            }
+                        }
+                    }
+                };
+                const results = await Promise.allSettled(bindings.map((binding) => sendWithRetry(binding.chatId, startupText)));
+                const failed = results.filter((r) => r.status === 'rejected');
+                if (failed.length > 0) {
+                    logger_1.logger.warn(`[Telegram] Startup message failed for ${failed.length}/${bindings.length} chat(s) after retries: ${failed[0].reason?.message ?? 'unknown error'}`);
+                }
+                else {
+                    logger_1.logger.info(`Telegram startup message sent to ${bindings.length} bound chat(s).`);
+                }
             }
-        },
-    }));
-    // [Text message handler]
-    client.on(discord_js_1.Events.MessageCreate, (0, messageCreateHandler_1.createMessageCreateHandler)({
-        config,
-        bridge,
-        modeService,
-        modelService,
-        slashCommandHandler,
-        wsHandler,
-        chatSessionService,
-        chatSessionRepo,
-        channelManager,
-        titleGenerator,
-        client,
-        sendPromptToAntigravity: async (_bridge, message, prompt, cdp, _modeService, _modelService, inboundImages = [], options) => promptDispatcher.send({
-            message,
-            prompt,
-            cdp,
-            inboundImages,
-            options,
-        }),
-        autoRenameChannel,
-        handleScreenshot: screenshotUi_1.handleScreenshot,
-        userPrefRepo,
-    }));
-    await client.login(config.discordToken);
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            logger_1.logger.error('Failed to start Telegram adapter:', message);
+        }
+    }
 };
 exports.startBot = startBot;
 /**