lazy-gravity 0.6.2 → 0.7.1

package/dist/bot/telegramCommands.js

@@ -1,22 +1,4 @@
 "use strict";
-/**
- * Telegram command parser and handlers.
- *
- * Handles built-in bot commands that can be answered immediately
- * without routing through CDP/Antigravity:
- *   /start      — Welcome message
- *   /help       — List available commands
- *   /status     — Show bot connection status
- *   /stop       — Interrupt active LLM generation
- *   /ping       — Latency check
- *   /mode       — Switch execution mode
- *   /model      — Switch LLM model
- *   /screenshot — Capture Antigravity screenshot
- *   /autoaccept — Toggle auto-accept for approval dialogs
- *   /template   — List and execute prompt templates
- *   /logs       — Show recent log entries
- *   /new        — Start a new chat session
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -56,6 +38,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTelegramCommand = parseTelegramCommand;
 exports.handleTelegramCommand = handleTelegramCommand;
+const telegramJoinCommand_1 = require("./telegramJoinCommand");
+/**
+ * Telegram command parser and handlers.
+ *
+ * Handles built-in bot commands that can be answered immediately
+ * without routing through CDP/Antigravity:
+ *   /start      — Welcome message
+ *   /help       — List available commands
+ *   /status     — Show bot connection status
+ *   /stop       — Interrupt active LLM generation
+ *   /ping       — Latency check
+ *   /mode       — Switch execution mode
+ *   /model      — Switch LLM model
+ *   /screenshot — Capture Antigravity screenshot
+ *   /autoaccept — Toggle auto-accept for approval dialogs
+ *   /template   — List and execute prompt templates
+ *   /logs       — Show recent log entries
+ *   /new        — Start a new chat session
+ */
 const fs_1 = __importDefault(require("fs"));
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
 const modeUi_1 = require("../ui/modeUi");
@@ -63,13 +64,16 @@ const modelsUi_1 = require("../ui/modelsUi");
 const autoAcceptUi_1 = require("../ui/autoAcceptUi");
 const templateUi_1 = require("../ui/templateUi");
 const screenshotUi_1 = require("../ui/screenshotUi");
+const accountUi_1 = require("../ui/accountUi");
 const logBuffer_1 = require("../utils/logBuffer");
 const telegramFormatter_1 = require("../platform/telegram/telegramFormatter");
 const logger_1 = require("../utils/logger");
+const telegramProjectCommand_1 = require("./telegramProjectCommand");
+const accountUtils_1 = require("../utils/accountUtils");
 // ---------------------------------------------------------------------------
 // Known commands (used by both parser and /help output)
 // ---------------------------------------------------------------------------
-const KNOWN_COMMANDS = ['start', 'help', 'status', 'stop', 'ping', 'mode', 'model', 'screenshot', 'autoaccept', 'template', 'template_add', 'template_delete', 'project_create', 'logs', 'new'];
+const KNOWN_COMMANDS = ['start', 'help', 'status', 'stop', 'ping', 'mode', 'model', 'screenshot', 'autoaccept', 'account', 'project_reopen', 'template', 'template_add', 'template_delete', 'project_create', 'logs', 'new', 'join', 'mirror'];
 /**
  * Parse a Telegram command from message text.
  *
@@ -133,6 +137,12 @@ async function handleTelegramCommand(deps, message, parsed) {
         case 'autoaccept':
             await handleAutoAccept(deps, message, parsed.args);
             break;
+        case 'account':
+            await handleAccount(deps, message, parsed.args);
+            break;
+        case 'project_reopen':
+            await handleProjectReopen(deps, message);
+            break;
         case 'template':
             await handleTemplate(deps, message);
             break;
@@ -151,6 +161,12 @@ async function handleTelegramCommand(deps, message, parsed) {
         case 'new':
             await handleNew(deps, message);
             break;
+        case 'join':
+            await (0, telegramJoinCommand_1.handleJoin)(deps, message);
+            break;
+        case 'mirror':
+            await (0, telegramJoinCommand_1.handleMirror)(deps, message);
+            break;
         default:
             // Should not happen — parser filters unknowns
             break;
@@ -183,11 +199,15 @@ async function handleHelp(message) {
         '/model — Switch LLM model',
         '/screenshot — Capture Antigravity screenshot',
         '/autoaccept — Toggle auto-accept mode',
+        '/account — Show and switch Antigravity account',
+        '/project_reopen — Reopen the bound project in the selected Antigravity account',
         '/template — List prompt templates',
         '/template_add — Add a prompt template',
         '/template_delete — Delete a prompt template',
         '/project_create — Create a new workspace',
         '/new — Start a new chat session',
+        '/join — Take over an existing Antigravity session',
+        '/mirror — Toggle PC-to-Telegram message mirroring',
         '/logs — Show recent log entries',
         '/stop — Interrupt active LLM generation',
         '/ping — Check bot latency',
@@ -316,6 +336,52 @@ async function handleAutoAccept(deps, message, args) {
     const payload = (0, autoAcceptUi_1.buildAutoAcceptPayload)(deps.bridge.autoAccept.isEnabled());
     await message.reply(payload).catch(logger_1.logger.error);
 }
+async function handleAccount(deps, message, args) {
+    if (!deps.accountPrefRepo) {
+        await message.reply({ text: 'Account preference service not available.' }).catch(logger_1.logger.error);
+        return;
+    }
+    const names = (0, accountUtils_1.listAccountNames)(deps.antigravityAccounts);
+    const chatId = message.channel.id;
+    const userId = message.author.id;
+    const applySelection = (selectedAccount) => {
+        deps.accountPrefRepo?.setAccountName(userId, selectedAccount);
+        deps.channelPrefRepo?.setAccountName(chatId, selectedAccount);
+        deps.bridge.selectedAccountByChannel?.set(chatId, selectedAccount);
+        const channelBinding = deps.telegramBindingRepo?.findByChatId(chatId);
+        const workspacePath = channelBinding
+            ? (deps.workspaceService
+                ? deps.workspaceService.getWorkspacePath(channelBinding.workspacePath)
+                : channelBinding.workspacePath)
+            : null;
+        const selectedPort = deps.antigravityAccounts?.find((a) => a.name === selectedAccount)?.cdpPort;
+        logger_1.logger.info(`[AccountSwitch] source=telegram_command channel=${chatId} user=${userId} ` +
+            `account=${selectedAccount} port=${selectedPort ?? 'unknown'} ` +
+            `workspace=${workspacePath ?? 'unbound'}`);
+    };
+    const requested = args.trim();
+    if (requested) {
+        if (!names.includes(requested)) {
+            await message.reply({
+                text: `⚠️ Unknown account: <b>${(0, telegramFormatter_1.escapeHtml)(requested)}</b>\nAvailable: ${names.map(telegramFormatter_1.escapeHtml).join(', ')}`,
+            }).catch(logger_1.logger.error);
+            return;
+        }
+        applySelection(requested);
+        await message.reply({ text: `✅ Switched account to <b>${(0, telegramFormatter_1.escapeHtml)(requested)}</b>.` }).catch(logger_1.logger.error);
+        return;
+    }
+    const current = (0, accountUtils_1.resolveScopedAccountName)({
+        channelId: chatId,
+        userId,
+        selectedAccountByChannel: deps.bridge.selectedAccountByChannel,
+        channelPrefRepo: deps.channelPrefRepo,
+        accountPrefRepo: deps.accountPrefRepo,
+        accounts: deps.antigravityAccounts,
+    });
+    const payload = (0, accountUi_1.buildAccountPayload)(current, names);
+    await message.reply(payload).catch(logger_1.logger.error);
+}
 async function handleTemplate(deps, message) {
     if (!deps.templateRepo) {
         await message.reply({ text: 'Template service not available.' }).catch(logger_1.logger.error);
@@ -415,48 +481,50 @@ async function handleLogs(message, args) {
     await message.reply({ text: truncated }).catch(logger_1.logger.error);
 }
 async function handleNew(deps, message) {
-    if (!deps.chatSessionService) {
-        await message.reply({ text: 'Chat session service not available.' }).catch(logger_1.logger.error);
-        return;
-    }
-    // Resolve workspace binding for this chat
-    const chatId = message.channel.id;
-    const binding = deps.telegramBindingRepo?.findByChatId(chatId);
+    const originalChannelId = message.channel.id;
+    const binding = deps.telegramBindingRepo?.findByChatIdWithParentFallback(originalChannelId);
     if (!binding) {
-        await message.reply({
-            text: 'No project is linked to this chat. Use /project to bind a workspace first.',
-        }).catch(logger_1.logger.error);
-        return;
-    }
-    // Resolve workspace path and connect to CDP
-    let cdp;
-    try {
-        const workspacePath = deps.workspaceService
-            ? deps.workspaceService.getWorkspacePath(binding.workspacePath)
-            : binding.workspacePath;
-        cdp = await deps.bridge.pool.getOrConnect(workspacePath);
-    }
-    catch (err) {
-        logger_1.logger.error('[TelegramCommand:new] CDP connection failed:', err?.message || err);
-        await message.reply({ text: 'Failed to connect to Antigravity.' }).catch(logger_1.logger.error);
+        await message.reply({ text: '⚠️ No project is linked to this chat. Use /project first, or /project_reopen if this is a previously used session.' }).catch(logger_1.logger.error);
         return;
     }
-    // Start a new chat session
+    const resolvedWorkspacePath = deps.workspaceService
+        ? deps.workspaceService.getWorkspacePath(binding.workspacePath)
+        : binding.workspacePath;
+    let targetChannelId = originalChannelId;
+    if (deps.botApi && deps.bridge && deps.telegramBindingRepo) {
+        targetChannelId = await (0, telegramProjectCommand_1.tryCreateTopicAndBind)(deps.botApi, originalChannelId, binding.workspacePath, deps.telegramBindingRepo, deps.bridge.pool);
+    }
+    if (targetChannelId !== originalChannelId) {
+        await message.reply({ text: `✅ Created a new topic for the session.` }).catch(() => { });
+    }
+    const selectedAccount = (0, accountUtils_1.resolveScopedAccountName)({
+        channelId: originalChannelId,
+        userId: message.author.id,
+        selectedAccountByChannel: deps.bridge.selectedAccountByChannel,
+        channelPrefRepo: deps.channelPrefRepo,
+        accountPrefRepo: deps.accountPrefRepo,
+        accounts: deps.antigravityAccounts,
+    });
     try {
+        const cdp = await deps.bridge.pool.getOrConnect(resolvedWorkspacePath, { name: selectedAccount });
+        if (!deps.chatSessionService) {
+            await message.reply({ text: 'Chat session service not available.' }).catch(logger_1.logger.error);
+            return;
+        }
         const result = await deps.chatSessionService.startNewChat(cdp);
         if (result.ok) {
-            await message.reply({ text: 'New chat session started.' }).catch(logger_1.logger.error);
+            if (targetChannelId === originalChannelId) {
+                await message.reply({ text: '✅ New chat session started.' }).catch(logger_1.logger.error);
+            }
         }
         else {
             logger_1.logger.warn('[TelegramCommand:new] startNewChat failed:', result.error);
-            await message.reply({
-                text: `Failed to start new chat: ${(0, telegramFormatter_1.escapeHtml)(result.error || 'unknown error')}`,
-            }).catch(logger_1.logger.error);
+            await message.reply({ text: `❌ Failed to start new chat: ${result.error}` }).catch(logger_1.logger.error);
         }
     }
     catch (err) {
         logger_1.logger.error('[TelegramCommand:new] startNewChat threw:', err?.message || err);
-        await message.reply({ text: 'Failed to start new chat.' }).catch(logger_1.logger.error);
+        await message.reply({ text: '❌ Failed to connect to Antigravity. Is it running?' }).catch(logger_1.logger.error);
     }
 }
 // ---------------------------------------------------------------------------
@@ -476,3 +544,62 @@ async function sendFilePayload(message, payload) {
         await message.reply({ text: 'Screenshot captured but file sending failed.' }).catch(logger_1.logger.error);
     }
 }
+async function handleProjectReopen(deps, message) {
+    const chatId = message.channel.id;
+    const channelBinding = deps.telegramBindingRepo?.findByChatIdWithParentFallback(chatId);
+    if (!channelBinding) {
+        await message.reply({ text: '⚠️ No project is bound to this chat. Use /project first, or /project_reopen if this is a previously used session.' }).catch(logger_1.logger.error);
+        return;
+    }
+    const workspacePath = deps.workspaceService
+        ? deps.workspaceService.getWorkspacePath(channelBinding.workspacePath)
+        : channelBinding.workspacePath;
+    if (!fs_1.default.existsSync(workspacePath) || !fs_1.default.statSync(workspacePath).isDirectory()) {
+        await message.reply({ text: `❌ Project folder does not exist: <code>${(0, telegramFormatter_1.escapeHtml)(workspacePath)}</code>` }).catch(logger_1.logger.error);
+        return;
+    }
+    const selectedAccount = (0, accountUtils_1.resolveScopedAccountName)({
+        channelId: chatId,
+        userId: message.author.id,
+        selectedAccountByChannel: deps.bridge.selectedAccountByChannel,
+        channelPrefRepo: deps.channelPrefRepo,
+        accountPrefRepo: deps.accountPrefRepo,
+        accounts: deps.antigravityAccounts,
+    });
+    const accountPorts = Object.fromEntries((deps.antigravityAccounts ?? []).map((account) => [account.name, account.cdpPort]));
+    const accountUserDataDirs = Object.fromEntries((deps.antigravityAccounts ?? [])
+        .filter((account) => typeof account.userDataDir === 'string' && account.userDataDir.trim().length > 0)
+        .map((account) => [account.name, account.userDataDir.trim()]));
+    const port = accountPorts[selectedAccount] ?? null;
+    const projectName = deps.bridge.pool.extractProjectName(workspacePath);
+    logger_1.logger.info(`[ProjectReopenCommand] channel=${chatId} user=${message.author.id} ` +
+        `project=${projectName} account=${selectedAccount} ` +
+        `port=${port ?? 'unknown'} workspacePath=${workspacePath}`);
+    try {
+        const { CdpService } = await Promise.resolve().then(() => __importStar(require('../services/cdpService')));
+        const cdp = new CdpService({
+            accountName: selectedAccount,
+            accountPorts,
+            accountUserDataDirs,
+            cdpCallTimeout: 15000,
+            maxReconnectAttempts: 0,
+        });
+        try {
+            await cdp.openWorkspace(workspacePath);
+        }
+        finally {
+            await cdp.disconnect().catch(() => { });
+        }
+        deps.bridge.selectedAccountByChannel?.set(chatId, selectedAccount);
+        deps.bridge.pool.setPreferredAccountForWorkspace(workspacePath, selectedAccount);
+        await message.reply({
+            text: `✅ Reopened <b>${(0, telegramFormatter_1.escapeHtml)(projectName)}</b> in account <b>${(0, telegramFormatter_1.escapeHtml)(selectedAccount)}</b>${port ? ` (CDP ${port})` : ''}.`,
+        }).catch(logger_1.logger.error);
+    }
+    catch (error) {
+        logger_1.logger.error('[ProjectReopenCommand] Failed to reopen workspace:', error);
+        await message.reply({
+            text: `❌ Failed to reopen project in account <b>${(0, telegramFormatter_1.escapeHtml)(selectedAccount)}</b>: ${(0, telegramFormatter_1.escapeHtml)(error?.message || String(error))}`,
+        }).catch(logger_1.logger.error);
+    }
+}

package/dist/bot/telegramJoinCommand.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleJoin = handleJoin;
+exports.handleTelegramJoinSelect = handleTelegramJoinSelect;
+exports.handleMirror = handleMirror;
+const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const responseMonitor_1 = require("../services/responseMonitor");
+const sessionPickerUi_1 = require("../ui/sessionPickerUi");
+const logger_1 = require("../utils/logger");
+const telegramFormatter_1 = require("../platform/telegram/telegramFormatter");
+const telegramProjectCommand_1 = require("./telegramProjectCommand");
+const accountUtils_1 = require("../utils/accountUtils");
+const activeResponseMonitors = new Map();
+function resolveAccount(deps, chatId, userId) {
+    return (0, accountUtils_1.resolveScopedAccountName)({
+        channelId: chatId,
+        userId,
+        selectedAccountByChannel: deps.bridge.selectedAccountByChannel,
+        channelPrefRepo: deps.channelPrefRepo,
+        accountPrefRepo: deps.accountPrefRepo,
+        accounts: deps.antigravityAccounts,
+    });
+}
+async function handleJoin(deps, message) {
+    const binding = deps.telegramBindingRepo?.findByChatIdWithParentFallback(message.channel.id);
+    if (!binding) {
+        await message.reply({ text: '⚠️ No project is linked to this chat. Use /project first, or /project_reopen if this is a previously used session.' }).catch(logger_1.logger.error);
+        return;
+    }
+    const resolvedWorkspacePath = deps.workspaceService
+        ? deps.workspaceService.getWorkspacePath(binding.workspacePath)
+        : binding.workspacePath;
+    const account = resolveAccount(deps, message.channel.id, message.author.id);
+    try {
+        const cdp = await deps.bridge.pool.getOrConnect(resolvedWorkspacePath, { name: account });
+        if (!deps.chatSessionService) {
+            await message.reply({ text: 'Chat session service not available.' }).catch(logger_1.logger.error);
+            return;
+        }
+        const sessions = await deps.chatSessionService.listAllSessions(cdp);
+        if (sessions.length === 0) {
+            await message.reply({ text: 'No active sessions found in this project.' }).catch(logger_1.logger.error);
+            return;
+        }
+        const ui = (0, sessionPickerUi_1.buildSessionPickerPayload)(sessions);
+        await message.reply(ui).catch(logger_1.logger.error);
+    }
+    catch (e) {
+        await message.reply({ text: `⚠️ Failed to connect to project: ${e.message}` }).catch(logger_1.logger.error);
+    }
+}
+async function handleTelegramJoinSelect(deps, interaction) {
+    const selectedTitle = interaction.values[0];
+    const originalChannelId = interaction.channel.id;
+    const binding = deps.telegramBindingRepo?.findByChatId(originalChannelId);
+    if (!binding) {
+        await interaction.update({ text: '⚠️ No project is bound to this chat.' }).catch(logger_1.logger.error);
+        return;
+    }
+    const resolvedWorkspacePath = deps.workspaceService
+        ? deps.workspaceService.getWorkspacePath(binding.workspacePath)
+        : binding.workspacePath;
+    const account = resolveAccount(deps, interaction.channel.id, interaction.user.id);
+    let cdp;
+    try {
+        cdp = await deps.bridge.pool.getOrConnect(resolvedWorkspacePath, { name: account });
+    }
+    catch (e) {
+        await interaction.update({ text: `⚠️ Failed to connect to project: ${e.message}` }).catch(logger_1.logger.error);
+        return;
+    }
+    if (!deps.chatSessionService) {
+        await interaction.update({ text: 'Chat session service not available.' }).catch(logger_1.logger.error);
+        return;
+    }
+    const activateResult = await deps.chatSessionService.activateSessionByTitle(cdp, selectedTitle);
+    if (!activateResult.ok) {
+        await interaction.update({ text: `⚠️ Failed to join session: ${activateResult.error}` }).catch(logger_1.logger.error);
+        return;
+    }
+    let targetChannelId = originalChannelId;
+    if (deps.botApi && deps.bridge && deps.telegramBindingRepo) {
+        targetChannelId = await (0, telegramProjectCommand_1.tryCreateTopicAndBind)(deps.botApi, originalChannelId, binding.workspacePath, deps.telegramBindingRepo, deps.bridge.pool);
+    }
+    const replyMsg = targetChannelId !== originalChannelId
+        ? `✅ Joined session in new topic: <b>${(0, telegramFormatter_1.escapeHtml)(selectedTitle)}</b>\nUse /mirror if you want to forward PC messages here.`
+        : `✅ Joined session: <b>${(0, telegramFormatter_1.escapeHtml)(selectedTitle)}</b>\nUse /mirror if you want to forward PC messages here.`;
+    await interaction.update({ text: replyMsg }).catch(logger_1.logger.error);
+}
+async function handleMirror(deps, message) {
+    const binding = deps.telegramBindingRepo?.findByChatIdWithParentFallback(message.channel.id);
+    if (!binding) {
+        await message.reply({ text: '⚠️ No project is linked to this chat. Use /project first, or /project_reopen if this is a previously used session.' }).catch(logger_1.logger.error);
+        return;
+    }
+    const resolvedWorkspacePath = deps.workspaceService
+        ? deps.workspaceService.getWorkspacePath(binding.workspacePath)
+        : binding.workspacePath;
+    const projectName = deps.bridge.pool.extractProjectName(resolvedWorkspacePath);
+    const account = resolveAccount(deps, message.channel.id, message.author.id);
+    const detector = deps.bridge.pool.getUserMessageDetector(projectName, account);
+    if (detector?.isActive()) {
+        detector.stop();
+        const responseMonitor = activeResponseMonitors.get(resolvedWorkspacePath);
+        if (responseMonitor?.isActive()) {
+            await responseMonitor.stop();
+            activeResponseMonitors.delete(resolvedWorkspacePath);
+        }
+        await message.reply({ text: '📡 Mirroring OFF\nPC-to-Telegram message mirroring has been stopped.' }).catch(logger_1.logger.error);
+    }
+    else {
+        let cdp;
+        try {
+            cdp = await deps.bridge.pool.getOrConnect(resolvedWorkspacePath, { name: account });
+        }
+        catch (e) {
+            await message.reply({ text: `⚠️ Failed to connect to project: ${e.message}` }).catch(logger_1.logger.error);
+            return;
+        }
+        const existing = deps.bridge.pool.getUserMessageDetector(projectName, account);
+        if (existing?.isActive()) {
+            existing.stop();
+        }
+        (0, cdpBridgeManager_1.ensureUserMessageDetector)(deps.bridge, cdp, projectName, (info) => {
+            routeMirroredMessage(deps, cdp, resolvedWorkspacePath, info, message.channel).catch((err) => {
+                logger_1.logger.error('[TelegramMirror] Error routing mirrored message:', err);
+            });
+        }, account);
+        await message.reply({ text: '📡 Mirroring ON\nMessages typed in Antigravity on your PC will now appear here.' }).catch(logger_1.logger.error);
+    }
+}
+async function routeMirroredMessage(deps, cdp, workspacePath, info, channel) {
+    const chatTitle = await (0, cdpBridgeManager_1.getCurrentChatTitle)(cdp);
+    await channel.send({
+        text: `🖥️ <b>User typed in Antigravity:</b>\n<pre>${(0, telegramFormatter_1.escapeHtml)(info.text)}</pre>\n<i>Session: ${(0, telegramFormatter_1.escapeHtml)(chatTitle || 'Unknown')}</i>`
+    }).catch((err) => logger_1.logger.error('[TelegramMirror] Failed to send user message:', err));
+    startResponseMirror(deps, cdp, workspacePath, channel, chatTitle || 'Unknown');
+}
+function startResponseMirror(deps, cdp, workspacePath, channel, chatTitle) {
+    const prev = activeResponseMonitors.get(workspacePath);
+    if (prev?.isActive()) {
+        prev.stop().catch(() => { });
+    }
+    const monitor = new responseMonitor_1.ResponseMonitor({
+        cdpService: cdp,
+        pollIntervalMs: 2000,
+        maxDurationMs: 300000,
+        extractionMode: deps.extractionMode,
+        onComplete: (finalText) => {
+            activeResponseMonitors.delete(workspacePath);
+            if (!finalText || finalText.trim().length === 0)
+                return;
+            const maxLen = 3000;
+            const text = finalText.length > maxLen
+                ? finalText.slice(0, maxLen) + '\n...(truncated)'
+                : finalText;
+            channel.send({
+                text: `🤖 <b>Antigravity Response:</b>\n${(0, telegramFormatter_1.escapeHtml)(text)}\n\n<i>Session: ${(0, telegramFormatter_1.escapeHtml)(chatTitle)}</i>`
+            }).catch((err) => logger_1.logger.error('[TelegramMirror] Failed to send AI response:', err));
+        },
+        onTimeout: () => {
+            activeResponseMonitors.delete(workspacePath);
+        },
+    });
+    activeResponseMonitors.set(workspacePath, monitor);
+    monitor.startPassive().catch((err) => {
+        logger_1.logger.error('[TelegramMirror] Failed to start response monitor:', err);
+        activeResponseMonitors.delete(workspacePath);
+    });
+}

package/dist/bot/telegramMessageHandler.js

@@ -22,6 +22,7 @@ const defaultModelApplicator_1 = require("../services/defaultModelApplicator");
 const logger_1 = require("../utils/logger");
 const telegramImageHandler_1 = require("../utils/telegramImageHandler");
 const imageHandler_1 = require("../utils/imageHandler");
+const accountUtils_1 = require("../utils/accountUtils");
 /**
  * Create a handler for Telegram messages.
  * Returns an async function that processes a single PlatformMessage.
@@ -29,6 +30,16 @@ const imageHandler_1 = require("../utils/imageHandler");
 function createTelegramMessageHandler(deps) {
     // Per-workspace prompt queue to serialize messages
     const workspaceQueues = new Map();
+    function resolveAccount(chatId, userId) {
+        return (0, accountUtils_1.resolveScopedAccountName)({
+            channelId: chatId,
+            userId,
+            selectedAccountByChannel: deps.bridge.selectedAccountByChannel,
+            channelPrefRepo: deps.channelPrefRepo,
+            accountPrefRepo: deps.accountPrefRepo,
+            accounts: deps.antigravityAccounts,
+        });
+    }
     function enqueueForWorkspace(workspacePath, task) {
         const current = (workspaceQueues.get(workspacePath) ?? Promise.resolve()).catch(() => { });
         const next = current.then(async () => {
@@ -65,6 +76,10 @@ function createTelegramMessageHandler(deps) {
                 fetchQuota: deps.fetchQuota,
                 activeMonitors: deps.activeMonitors,
                 chatSessionService: deps.chatSessionService,
+                accountPrefRepo: deps.accountPrefRepo,
+                channelPrefRepo: deps.channelPrefRepo,
+                antigravityAccounts: deps.antigravityAccounts,
+                botApi: deps.botApi,
             }, message, cmd);
             return;
         }
@@ -77,10 +92,10 @@ function createTelegramMessageHandler(deps) {
             }
         }
         // Resolve workspace binding for this Telegram chat
-        const binding = deps.telegramBindingRepo.findByChatId(chatId);
+        const binding = deps.telegramBindingRepo.findByChatIdWithParentFallback(chatId);
         if (!binding) {
             await message.reply({
-                text: 'No project is linked to this chat. Use /project to bind a workspace.',
+                text: 'No project is linked to this chat. Use /project to bind a workspace, or /project_reopen if this is a previously used session.',
             }).catch(logger_1.logger.error);
             return;
         }
@@ -91,11 +106,13 @@ function createTelegramMessageHandler(deps) {
             ? deps.workspaceService.getWorkspacePath(binding.workspacePath)
             : binding.workspacePath;
         await enqueueForWorkspace(workspacePath, async () => {
+            const selectedAccount = resolveAccount(chatId, message.author.id);
+            deps.bridge.selectedAccountByChannel?.set(chatId, selectedAccount);
             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);
+                cdp = await deps.bridge.pool.getOrConnect(workspacePath, { name: selectedAccount });
             }
             catch (e) {
                 await message.reply({
@@ -131,10 +148,10 @@ function createTelegramMessageHandler(deps) {
                 }
             }
             // 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);
-            (0, cdpBridgeManager_1.ensureRunCommandDetector)(deps.bridge, cdp, projectName);
+            (0, cdpBridgeManager_1.ensureApprovalDetector)(deps.bridge, cdp, projectName, selectedAccount);
+            (0, cdpBridgeManager_1.ensureErrorPopupDetector)(deps.bridge, cdp, projectName, selectedAccount);
+            (0, cdpBridgeManager_1.ensurePlanningDetector)(deps.bridge, cdp, projectName, selectedAccount);
+            (0, cdpBridgeManager_1.ensureRunCommandDetector)(deps.bridge, cdp, projectName, selectedAccount);
             // Acknowledge receipt
             await message.react('\u{1F440}').catch(() => { });
             // Download image attachments if present

package/dist/bot/telegramProjectCommand.js

@@ -1,19 +1,9 @@
 "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.tryCreateTopicAndBind = tryCreateTopicAndBind;
 exports.handleTelegramProjectSelect = handleTelegramProjectSelect;
 exports.createTelegramSelectHandler = createTelegramSelectHandler;
 const logger_1 = require("../utils/logger");
@@ -45,6 +35,7 @@ function parseTelegramProjectCommand(text) {
     // Default (no subcommand or "list") → show workspace list
     return { subcommand: 'list' };
 }
+const telegramFormatter_1 = require("../platform/telegram/telegramFormatter");
 // ---------------------------------------------------------------------------
 // Command handler
 // ---------------------------------------------------------------------------
@@ -96,6 +87,55 @@ async function handleTelegramProjectCommand(deps, message, parsed) {
 /**
  * Handle a workspace selection callback from inline keyboard.
  */
+async function tryCreateTopicAndBind(botApi, originalChannelId, workspacePath, telegramBindingRepo, pool) {
+    const baseChatId = originalChannelId.split('_')[0];
+    const isExistingTopic = originalChannelId.includes('_');
+    if (isExistingTopic) {
+        telegramBindingRepo.upsert({
+            chatId: originalChannelId,
+            workspacePath,
+        });
+        return originalChannelId;
+    }
+    try {
+        const chat = await botApi.getChat(baseChatId);
+        logger_1.logger.debug(`[Telegram] getChat(${baseChatId}) returned:`, chat);
+        if (chat?.is_forum) {
+            const projectName = pool.extractProjectName(workspacePath) || 'Project';
+            const topicName = `[Session] ${projectName}`.substring(0, 128);
+            const topic = await botApi.createForumTopic(baseChatId, topicName);
+            const threadId = topic.message_thread_id;
+            const newChannelId = `${baseChatId}_${threadId}`;
+            telegramBindingRepo.upsert({
+                chatId: newChannelId,
+                workspacePath,
+            });
+            await botApi.sendMessage(baseChatId, `✅ <b>${(0, telegramFormatter_1.escapeHtml)(projectName)}</b> session started in this topic.`, {
+                message_thread_id: threadId,
+                parse_mode: 'HTML'
+            }).catch((e) => logger_1.logger.warn('Failed to send welcome message to new topic', e));
+            return newChannelId;
+        }
+    }
+    catch (error) {
+        logger_1.logger.debug(`[Telegram] Could not create forum topic for chat ${baseChatId}`, error);
+        // If the error is specifically a permissions error for creating topics
+        const errStr = String(error);
+        if (errStr.includes('not enough rights') || errStr.includes('400')) {
+            await botApi.sendMessage(baseChatId, '⚠️ <b>Permission Error:</b> I do not have permission to create a Topic (Forum) in this group.\n\n' +
+                'Please follow these steps to fix:\n' +
+                '1. Go to Group Info -> Edit -> Administrators\n' +
+                '2. Select this bot (<code>@' + (botApi.me?.username || 'bot') + '</code>)\n' +
+                '3. Enable the <b>"Manage Topics"</b> (or "Change Group Info") permission\n' +
+                '4. Try binding the project or using /new again.', { parse_mode: 'HTML' }).catch((e) => logger_1.logger.warn('Failed to send permission error message', e));
+        }
+    }
+    telegramBindingRepo.upsert({
+        chatId: originalChannelId,
+        workspacePath,
+    });
+    return originalChannelId;
+}
 async function handleTelegramProjectSelect(deps, interaction) {
     const selectedWorkspace = interaction.values[0];
     if (!selectedWorkspace)
@@ -109,13 +149,26 @@ async function handleTelegramProjectSelect(deps, interaction) {
         }).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);
+    let finalChannelId = chatId;
+    if (deps.botApi && deps.bridge) {
+        finalChannelId = await tryCreateTopicAndBind(deps.botApi, chatId, selectedWorkspace, deps.telegramBindingRepo, deps.bridge.pool);
+    }
+    else {
+        deps.telegramBindingRepo.upsert({
+            chatId,
+            workspacePath: selectedWorkspace,
+        });
+    }
+    if (finalChannelId !== chatId) {
+        await interaction.update({
+            text: `✅ Workspace bound to new topic: <b>${(0, telegramFormatter_1.escapeHtml)(selectedWorkspace)}</b>`,
+        }).catch(logger_1.logger.error);
+    }
+    else {
+        await interaction.update({
+            text: `Workspace bound: <b>${(0, telegramFormatter_1.escapeHtml)(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}`);
 }
 // ---------------------------------------------------------------------------