lazy-gravity 0.2.0 → 0.3.0

package/dist/bot/telegramMessageHandler.js

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * Minimal Telegram message handler.
+ *
+ * Handles incoming PlatformMessage from Telegram:
+ *   1. Resolves workspace from TelegramBindingRepository
+ *   2. Connects to CDP
+ *   3. Injects the prompt into Antigravity
+ *   4. Monitors the response via ResponseMonitor
+ *   5. Relays the response text back via PlatformChannel.send()
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTelegramMessageHandler = createTelegramMessageHandler;
+const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const responseMonitor_1 = require("../services/responseMonitor");
+const processLogBuffer_1 = require("../utils/processLogBuffer");
+const discordFormatter_1 = require("../utils/discordFormatter");
+const telegramProjectCommand_1 = require("./telegramProjectCommand");
+const telegramCommands_1 = require("./telegramCommands");
+const defaultModelApplicator_1 = require("../services/defaultModelApplicator");
+const logger_1 = require("../utils/logger");
+const telegramImageHandler_1 = require("../utils/telegramImageHandler");
+const imageHandler_1 = require("../utils/imageHandler");
+/**
+ * Create a handler for Telegram messages.
+ * Returns an async function that processes a single PlatformMessage.
+ */
+function createTelegramMessageHandler(deps) {
+    // Per-workspace prompt queue to serialize messages
+    const workspaceQueues = new Map();
+    function enqueueForWorkspace(workspacePath, task) {
+        const current = (workspaceQueues.get(workspacePath) ?? Promise.resolve()).catch(() => { });
+        const next = current.then(async () => {
+            try {
+                await task();
+            }
+            catch (err) {
+                logger_1.logger.error('[TelegramQueue] task error:', err?.message || err);
+            }
+        });
+        workspaceQueues.set(workspacePath, next);
+        return next;
+    }
+    return async (message) => {
+        const handlerEntryTime = Date.now();
+        const chatId = message.channel.id;
+        const hasImageAttachments = message.attachments.length > 0
+            && message.attachments.some((att) => (att.contentType || '').startsWith('image/'));
+        const promptText = message.content.trim();
+        // Allow through if there's text OR image attachments
+        if (!promptText && !hasImageAttachments)
+            return;
+        logger_1.logger.debug(`[TelegramHandler] handler entered (chat=${chatId}, msgTime=${message.createdAt.toISOString()}, handlerDelay=${handlerEntryTime - message.createdAt.getTime()}ms)`);
+        // Intercept built-in commands (/help, /status, /stop, /ping, /start)
+        const cmd = (0, telegramCommands_1.parseTelegramCommand)(promptText);
+        if (cmd) {
+            await (0, telegramCommands_1.handleTelegramCommand)({
+                bridge: deps.bridge,
+                modeService: deps.modeService,
+                modelService: deps.modelService,
+                telegramBindingRepo: deps.telegramBindingRepo,
+                templateRepo: deps.templateRepo,
+                workspaceService: deps.workspaceService,
+                fetchQuota: deps.fetchQuota,
+                activeMonitors: deps.activeMonitors,
+            }, message, cmd);
+            return;
+        }
+        // Intercept /project command before CDP path
+        if (deps.workspaceService) {
+            const parsed = (0, telegramProjectCommand_1.parseTelegramProjectCommand)(promptText);
+            if (parsed) {
+                await (0, telegramProjectCommand_1.handleTelegramProjectCommand)({ workspaceService: deps.workspaceService, telegramBindingRepo: deps.telegramBindingRepo }, message, parsed);
+                return;
+            }
+        }
+        // Resolve workspace binding for this Telegram chat
+        const binding = deps.telegramBindingRepo.findByChatId(chatId);
+        if (!binding) {
+            await message.reply({
+                text: 'No project is linked to this chat. Use /project to bind a workspace.',
+            }).catch(logger_1.logger.error);
+            return;
+        }
+        // Resolve relative workspace name to absolute path (mirrors Discord handler behavior).
+        // Without this, CDP receives a bare name like "DemoLG" and Antigravity
+        // falls back to its default scratch directory.
+        const workspacePath = deps.workspaceService
+            ? deps.workspaceService.getWorkspacePath(binding.workspacePath)
+            : binding.workspacePath;
+        await enqueueForWorkspace(workspacePath, async () => {
+            const cdpStartTime = Date.now();
+            logger_1.logger.debug(`[TelegramHandler] getOrConnect start (elapsed=${cdpStartTime - handlerEntryTime}ms)`);
+            let cdp;
+            try {
+                cdp = await deps.bridge.pool.getOrConnect(workspacePath);
+            }
+            catch (e) {
+                await message.reply({
+                    text: `Failed to connect to workspace: ${e.message}`,
+                }).catch(logger_1.logger.error);
+                return;
+            }
+            logger_1.logger.debug(`[TelegramHandler] getOrConnect done (took=${Date.now() - cdpStartTime}ms)`);
+            const projectName = deps.bridge.pool.extractProjectName(workspacePath);
+            deps.bridge.lastActiveWorkspace = projectName;
+            deps.bridge.lastActiveChannel = message.channel;
+            (0, cdpBridgeManager_1.registerApprovalWorkspaceChannel)(deps.bridge, projectName, message.channel);
+            // Always push ModeService's mode to Antigravity on CDP connect.
+            // ModeService is the source of truth (what the user sees in /mode UI).
+            // Without this, Antigravity could be in a different mode (e.g. Planning)
+            // while the user believes they're in Fast mode.
+            if (deps.modeService) {
+                const currentMode = deps.modeService.getCurrentMode();
+                const syncRes = await cdp.setUiMode(currentMode);
+                if (syncRes.ok) {
+                    deps.modeService.markSynced();
+                    logger_1.logger.debug(`[TelegramHandler] Mode pushed to Antigravity: ${currentMode}`);
+                }
+                else {
+                    logger_1.logger.warn(`[TelegramHandler] Mode push failed: ${syncRes.error}`);
+                }
+            }
+            // Apply default model preference on CDP connect
+            if (deps.modelService) {
+                const modelResult = await (0, defaultModelApplicator_1.applyDefaultModel)(cdp, deps.modelService);
+                if (modelResult.stale && modelResult.staleMessage) {
+                    await message.reply({ text: modelResult.staleMessage }).catch(logger_1.logger.error);
+                }
+            }
+            // Start detectors (platform-agnostic now)
+            (0, cdpBridgeManager_1.ensureApprovalDetector)(deps.bridge, cdp, projectName);
+            (0, cdpBridgeManager_1.ensureErrorPopupDetector)(deps.bridge, cdp, projectName);
+            (0, cdpBridgeManager_1.ensurePlanningDetector)(deps.bridge, cdp, projectName);
+            // Acknowledge receipt
+            await message.react('\u{1F440}').catch(() => { });
+            // Download image attachments if present
+            let inboundImages = [];
+            if (hasImageAttachments && deps.botToken && deps.botApi) {
+                try {
+                    inboundImages = await (0, telegramImageHandler_1.downloadTelegramPhotos)(message.attachments, deps.botToken, deps.botApi);
+                }
+                catch (err) {
+                    logger_1.logger.warn('[TelegramHandler] Image download failed:', err?.message || err);
+                }
+                if (hasImageAttachments && inboundImages.length === 0) {
+                    await message.reply({
+                        text: 'Failed to retrieve attached images. Please wait and try again.',
+                    }).catch(logger_1.logger.error);
+                    return;
+                }
+            }
+            // Determine the prompt text — use default for image-only messages
+            const effectivePrompt = promptText || 'Please review the attached images and respond accordingly.';
+            // Inject prompt (with or without images) into Antigravity
+            logger_1.logger.prompt(effectivePrompt);
+            let injectResult;
+            try {
+                if (inboundImages.length > 0) {
+                    injectResult = await cdp.injectMessageWithImageFiles(effectivePrompt, inboundImages.map((img) => img.localPath));
+                    if (!injectResult.ok) {
+                        // Fallback: send text-only with image reference
+                        logger_1.logger.warn('[TelegramHandler] Image injection failed, falling back to text-only');
+                        injectResult = await cdp.injectMessage(effectivePrompt);
+                    }
+                }
+                else {
+                    injectResult = await cdp.injectMessage(effectivePrompt);
+                }
+            }
+            finally {
+                // Cleanup temp files regardless of outcome
+                if (inboundImages.length > 0) {
+                    await (0, imageHandler_1.cleanupInboundImageAttachments)(inboundImages).catch(() => { });
+                }
+            }
+            if (!injectResult.ok) {
+                await message.reply({
+                    text: `Failed to send message: ${injectResult.error}`,
+                }).catch(logger_1.logger.error);
+                return;
+            }
+            // Monitor the response
+            const channel = message.channel;
+            const startTime = Date.now();
+            const processLogBuffer = new processLogBuffer_1.ProcessLogBuffer({ maxChars: 3500, maxEntries: 120, maxEntryLength: 220 });
+            let lastActivityLogText = '';
+            let statusMsg = null;
+            // Send initial status message
+            statusMsg = await channel.send({ text: 'Processing...' }).catch(() => null);
+            await new Promise((resolve) => {
+                const TIMEOUT_MS = 300_000;
+                let settled = false;
+                const settle = () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(safetyTimer);
+                    deps.activeMonitors?.delete(projectName);
+                    resolve();
+                };
+                const monitor = new responseMonitor_1.ResponseMonitor({
+                    cdpService: cdp,
+                    pollIntervalMs: 2000,
+                    maxDurationMs: TIMEOUT_MS,
+                    stopGoneConfirmCount: 3,
+                    extractionMode: deps.extractionMode,
+                    onProcessLog: (logText) => {
+                        if (logText && logText.trim().length > 0) {
+                            lastActivityLogText = processLogBuffer.append(logText);
+                        }
+                        if (statusMsg && lastActivityLogText) {
+                            const elapsed = Math.round((Date.now() - startTime) / 1000);
+                            statusMsg.edit({
+                                text: `${lastActivityLogText}\n\n⏱️ ${elapsed}s`,
+                            }).catch(() => { });
+                        }
+                    },
+                    onComplete: async (finalText) => {
+                        try {
+                            const elapsed = Math.round((Date.now() - startTime) / 1000);
+                            // Console log output (mirroring Discord handler pattern)
+                            const finalLogText = lastActivityLogText || processLogBuffer.snapshot();
+                            if (finalLogText && finalLogText.trim().length > 0) {
+                                logger_1.logger.divider('Process Log');
+                                console.info(finalLogText);
+                            }
+                            const separated = (0, discordFormatter_1.splitOutputAndLogs)(finalText || '');
+                            const finalOutputText = separated.output || finalText || '';
+                            if (finalOutputText && finalOutputText.trim().length > 0) {
+                                logger_1.logger.divider(`Output (${finalOutputText.length} chars)`);
+                                console.info(finalOutputText);
+                            }
+                            logger_1.logger.divider();
+                            // Update status message with final activity log
+                            if (statusMsg && finalLogText && finalLogText.trim().length > 0) {
+                                await statusMsg.edit({
+                                    text: `${finalLogText}\n\n✅ Done in ${elapsed}s`,
+                                }).catch(() => { });
+                            }
+                            else if (statusMsg) {
+                                await statusMsg.delete().catch(() => { });
+                            }
+                            // Send the final response
+                            if (finalOutputText && finalOutputText.trim().length > 0) {
+                                await sendTextChunked(channel, finalOutputText);
+                            }
+                            else if (finalText && finalText.trim().length > 0) {
+                                await sendTextChunked(channel, finalText);
+                            }
+                            else {
+                                await channel.send({ text: '(Empty response from Antigravity)' }).catch(logger_1.logger.error);
+                            }
+                        }
+                        finally {
+                            settle();
+                        }
+                    },
+                    onTimeout: async (lastText) => {
+                        try {
+                            // Update status message on timeout
+                            if (statusMsg) {
+                                const elapsed = Math.round((Date.now() - startTime) / 1000);
+                                await statusMsg.edit({
+                                    text: `⏰ Timed out after ${elapsed}s`,
+                                }).catch(() => { });
+                            }
+                            if (lastText && lastText.trim().length > 0) {
+                                await sendTextChunked(channel, `(Timeout) ${lastText}`);
+                            }
+                            else {
+                                await channel.send({ text: 'Response timed out.' }).catch(logger_1.logger.error);
+                            }
+                        }
+                        finally {
+                            settle();
+                        }
+                    },
+                });
+                const safetyTimer = setTimeout(() => {
+                    logger_1.logger.warn(`[TelegramHandler:${projectName}] Safety timeout — releasing queue after 300s`);
+                    monitor.stop().catch(() => { });
+                    settle();
+                }, TIMEOUT_MS);
+                // Register the monitor so /stop can access and stop it
+                deps.activeMonitors?.set(projectName, monitor);
+                monitor.start().catch((err) => {
+                    logger_1.logger.error(`[TelegramHandler:${projectName}] monitor.start() failed:`, err?.message || err);
+                    settle();
+                });
+            });
+        });
+    };
+}
+/** Split long text into Telegram-safe chunks (max 4096 chars). */
+async function sendTextChunked(channel, text) {
+    const MAX_LENGTH = 4096;
+    let remaining = text;
+    while (remaining.length > 0) {
+        const chunk = remaining.slice(0, MAX_LENGTH);
+        remaining = remaining.slice(MAX_LENGTH);
+        await channel.send({ text: chunk }).catch(logger_1.logger.error);
+    }
+}

package/dist/bot/telegramProjectCommand.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * Telegram /project command handler.
+ *
+ * Allows users to bind a Telegram chat to an Antigravity workspace
+ * via inline keyboard buttons, similar to Discord's /project slash command.
+ *
+ * User flow:
+ *   /project        → show workspace list as buttons → user taps → chat bound
+ *   /project list   → show workspace list (same as bare /project)
+ *   /project unbind → remove current binding
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TG_PROJECT_SELECT_ID = void 0;
+exports.parseTelegramProjectCommand = parseTelegramProjectCommand;
+exports.handleTelegramProjectCommand = handleTelegramProjectCommand;
+exports.handleTelegramProjectSelect = handleTelegramProjectSelect;
+exports.createTelegramSelectHandler = createTelegramSelectHandler;
+const logger_1 = require("../utils/logger");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+exports.TG_PROJECT_SELECT_ID = 'tg_project_select';
+/**
+ * Parse a Telegram message text for the /project command.
+ * Returns null if the text is not a /project command.
+ *
+ * Accepted formats:
+ *   /project
+ *   /project list
+ *   /project unbind
+ *   /project@BotName
+ *   /project@BotName list
+ */
+function parseTelegramProjectCommand(text) {
+    const trimmed = text.trim();
+    // Match /project optionally followed by @BotName and an optional subcommand
+    const match = trimmed.match(/^\/project(?:@\S+)?(?:\s+(\S+))?$/i);
+    if (!match)
+        return null;
+    const sub = match[1]?.toLowerCase();
+    if (sub === 'unbind') {
+        return { subcommand: 'unbind' };
+    }
+    // Default (no subcommand or "list") → show workspace list
+    return { subcommand: 'list' };
+}
+// ---------------------------------------------------------------------------
+// Command handler
+// ---------------------------------------------------------------------------
+/**
+ * Handle a /project command from Telegram.
+ */
+async function handleTelegramProjectCommand(deps, message, parsed) {
+    const chatId = message.channel.id;
+    if (parsed.subcommand === 'unbind') {
+        const deleted = deps.telegramBindingRepo.deleteByChatId(chatId);
+        if (deleted) {
+            await message.reply({ text: 'Workspace binding removed.' }).catch(logger_1.logger.error);
+        }
+        else {
+            await message.reply({ text: 'No workspace is bound to this chat.' }).catch(logger_1.logger.error);
+        }
+        return;
+    }
+    // subcommand === 'list'
+    const workspaces = deps.workspaceService.scanWorkspaces();
+    if (workspaces.length === 0) {
+        await message.reply({
+            text: 'No workspaces found. Create a workspace directory first.',
+        }).catch(logger_1.logger.error);
+        return;
+    }
+    const currentBinding = deps.telegramBindingRepo.findByChatId(chatId);
+    const currentPath = currentBinding?.workspacePath;
+    const selectMenu = {
+        type: 'selectMenu',
+        customId: exports.TG_PROJECT_SELECT_ID,
+        placeholder: 'Select a workspace',
+        options: workspaces.map((name) => ({
+            label: name === currentPath ? `${name} (current)` : name,
+            value: name,
+        })),
+    };
+    const header = currentPath
+        ? `Current workspace: <b>${currentPath}</b>\nSelect a workspace to switch:`
+        : 'Select a workspace to bind to this chat:';
+    await message.reply({
+        text: header,
+        components: [{ components: [selectMenu] }],
+    }).catch(logger_1.logger.error);
+}
+// ---------------------------------------------------------------------------
+// Select interaction handler
+// ---------------------------------------------------------------------------
+/**
+ * Handle a workspace selection callback from inline keyboard.
+ */
+async function handleTelegramProjectSelect(deps, interaction) {
+    const selectedWorkspace = interaction.values[0];
+    if (!selectedWorkspace)
+        return;
+    const chatId = interaction.channel.id;
+    // Validate workspace exists
+    const workspaces = deps.workspaceService.scanWorkspaces();
+    if (!workspaces.includes(selectedWorkspace)) {
+        await interaction.reply({
+            text: `Workspace "${selectedWorkspace}" not found.`,
+        }).catch(logger_1.logger.error);
+        return;
+    }
+    deps.telegramBindingRepo.upsert({
+        chatId,
+        workspacePath: selectedWorkspace,
+    });
+    await interaction.update({
+        text: `Workspace bound: <b>${selectedWorkspace}</b>\nSend a message to start chatting with Antigravity.`,
+    }).catch(logger_1.logger.error);
+    logger_1.logger.info(`[TelegramProject] Chat ${chatId} bound to workspace: ${selectedWorkspace}`);
+}
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create a select interaction handler that routes by customId.
+ * Returns a function suitable for EventRouter's onSelectInteraction.
+ */
+function createTelegramSelectHandler(deps) {
+    return async (interaction) => {
+        if (interaction.customId === exports.TG_PROJECT_SELECT_ID) {
+            await handleTelegramProjectSelect(deps, interaction);
+            return;
+        }
+        // Unknown select interaction — ignore
+        logger_1.logger.debug(`[TelegramSelect] Unhandled customId: ${interaction.customId}`);
+    };
+}

package/dist/bot/workspaceQueue.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceQueue = void 0;
+const logger_1 = require("../utils/logger");
+/**
+ * Per-workspace prompt queue.
+ * Serializes tasks per workspace path to prevent concurrent sends
+ * to the same Antigravity workspace.
+ */
+class WorkspaceQueue {
+    queues = new Map();
+    depths = new Map();
+    /**
+     * Enqueue a task for a given workspace. Tasks for the same workspace
+     * execute serially; tasks for different workspaces run concurrently.
+     */
+    enqueue(workspacePath, task) {
+        // .catch: ensure a prior rejection never stalls the chain
+        const current = (this.queues.get(workspacePath) ?? Promise.resolve()).catch(() => { });
+        const next = current.then(async () => {
+            try {
+                await task();
+            }
+            catch (err) {
+                logger_1.logger.error('[WorkspaceQueue] task error:', err?.message || err);
+            }
+        }).finally(() => {
+            // Clean up if this is still the latest promise in the chain
+            if (this.queues.get(workspacePath) === next) {
+                this.queues.delete(workspacePath);
+            }
+        });
+        this.queues.set(workspacePath, next);
+        return next;
+    }
+    /** Get current queue depth for a workspace. */
+    getDepth(workspacePath) {
+        return this.depths.get(workspacePath) ?? 0;
+    }
+    /** Increment queue depth. Returns the new depth. */
+    incrementDepth(workspacePath) {
+        const current = this.depths.get(workspacePath) ?? 0;
+        const next = current + 1;
+        this.depths.set(workspacePath, next);
+        return next;
+    }
+    /** Decrement queue depth. Returns the new depth (min 0). Cleans up Map entries when depth reaches 0. */
+    decrementDepth(workspacePath) {
+        const current = this.depths.get(workspacePath) ?? 1;
+        const next = Math.max(0, current - 1);
+        if (next === 0) {
+            this.depths.delete(workspacePath);
+            this.queues.delete(workspacePath);
+        }
+        else {
+            this.depths.set(workspacePath, next);
+        }
+        return next;
+    }
+}
+exports.WorkspaceQueue = WorkspaceQueue;

package/dist/commands/joinCommandHandler.js

@@ -23,9 +23,10 @@ class JoinCommandHandler {
     pool;
     workspaceService;
     client;
+    extractionMode;
     /** Active ResponseMonitors per workspace (for AI response mirroring) */
     activeResponseMonitors = new Map();
-    constructor(chatSessionService, chatSessionRepo, bindingRepo, channelManager, pool, workspaceService, client) {
+    constructor(chatSessionService, chatSessionRepo, bindingRepo, channelManager, pool, workspaceService, client, extractionMode) {
         this.chatSessionService = chatSessionService;
         this.chatSessionRepo = chatSessionRepo;
         this.bindingRepo = bindingRepo;
@@ -33,6 +34,7 @@ class JoinCommandHandler {
         this.pool = pool;
         this.workspaceService = workspaceService;
         this.client = client;
+        this.extractionMode = extractionMode;
     }
     /**
      * Resolve a project name (from DB) to its full absolute path.
@@ -272,6 +274,7 @@ class JoinCommandHandler {
             cdpService: cdp,
             pollIntervalMs: 2000,
             maxDurationMs: 300000,
+            extractionMode: this.extractionMode,
             onComplete: (finalText) => {
                 this.activeResponseMonitors.delete(projectName);
                 if (!finalText || finalText.trim().length === 0)

package/dist/database/telegramBindingRepository.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramBindingRepository = void 0;
+/**
+ * Repository for persisting Telegram chat to workspace directory bindings in SQLite.
+ * Only one workspace can be bound per chat (UNIQUE constraint).
+ */
+class TelegramBindingRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initialize();
+    }
+    /**
+     * Initialize table (create if not exists)
+     */
+    initialize() {
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS telegram_bindings (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                chat_id TEXT NOT NULL UNIQUE,
+                workspace_path TEXT NOT NULL,
+                created_at TEXT NOT NULL DEFAULT (datetime('now'))
+            )
+        `);
+    }
+    /**
+     * Create a new binding
+     */
+    create(input) {
+        const stmt = this.db.prepare(`
+            INSERT INTO telegram_bindings (chat_id, workspace_path)
+            VALUES (?, ?)
+        `);
+        const result = stmt.run(input.chatId, input.workspacePath);
+        return {
+            id: result.lastInsertRowid,
+            chatId: input.chatId,
+            workspacePath: input.workspacePath,
+        };
+    }
+    /**
+     * Find binding by chat ID
+     */
+    findByChatId(chatId) {
+        const row = this.db.prepare('SELECT * FROM telegram_bindings WHERE chat_id = ?').get(chatId);
+        if (!row)
+            return undefined;
+        return this.mapRow(row);
+    }
+    /**
+     * Find bindings by workspace path
+     */
+    findByWorkspacePath(workspacePath) {
+        const rows = this.db.prepare('SELECT * FROM telegram_bindings WHERE workspace_path = ? ORDER BY id ASC').all(workspacePath);
+        return rows.map(this.mapRow);
+    }
+    /**
+     * Get all bindings
+     */
+    findAll() {
+        const rows = this.db.prepare('SELECT * FROM telegram_bindings ORDER BY id ASC').all();
+        return rows.map(this.mapRow);
+    }
+    /**
+     * Delete binding by chat ID
+     */
+    deleteByChatId(chatId) {
+        const result = this.db.prepare('DELETE FROM telegram_bindings WHERE chat_id = ?').run(chatId);
+        return result.changes > 0;
+    }
+    /**
+     * Create or update a chat binding (upsert)
+     */
+    upsert(input) {
+        const stmt = this.db.prepare(`
+            INSERT INTO telegram_bindings (chat_id, workspace_path)
+            VALUES (?, ?)
+            ON CONFLICT(chat_id) DO UPDATE SET
+                workspace_path = excluded.workspace_path
+        `);
+        stmt.run(input.chatId, input.workspacePath);
+        return this.findByChatId(input.chatId);
+    }
+    /**
+     * Map a DB row to TelegramBindingRecord
+     */
+    mapRow(row) {
+        return {
+            id: row.id,
+            chatId: row.chat_id,
+            workspacePath: row.workspace_path,
+            createdAt: row.created_at,
+        };
+    }
+}
+exports.TelegramBindingRepository = TelegramBindingRepository;