lazy-gravity 0.6.2 → 0.7.0

package/dist/bot/telegramStartupTarget.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectTelegramStartupChatId = selectTelegramStartupChatId;
+function getBaseChatId(chatId) {
+    const sepIdx = chatId.indexOf('_');
+    return sepIdx > 0 ? chatId.slice(0, sepIdx) : chatId;
+}
+function normalizeTitle(title) {
+    return title.trim().replace(/^#/, '').toLowerCase();
+}
+function isGeneralChat(title) {
+    return normalizeTitle(title) === 'general';
+}
+async function selectTelegramStartupChatId(api, bindings) {
+    const candidates = [];
+    const seenResolvedIds = new Set();
+    for (const binding of bindings) {
+        const resolvedChatId = getBaseChatId(binding.chatId);
+        if (seenResolvedIds.has(resolvedChatId))
+            continue;
+        seenResolvedIds.add(resolvedChatId);
+        try {
+            const chat = await api.getChat(resolvedChatId);
+            candidates.push({
+                bindingChatId: binding.chatId,
+                resolvedChatId,
+                type: String(chat?.type ?? ''),
+                title: String(chat?.title ?? chat?.first_name ?? ''),
+                isDirectBinding: binding.chatId === resolvedChatId,
+            });
+        }
+        catch {
+            candidates.push({
+                bindingChatId: binding.chatId,
+                resolvedChatId,
+                type: '',
+                title: '',
+                isDirectBinding: binding.chatId === resolvedChatId,
+            });
+        }
+    }
+    if (candidates.length === 0)
+        return null;
+    const generalGroup = candidates.find((candidate) => candidate.type !== 'private' && isGeneralChat(candidate.title));
+    if (generalGroup)
+        return generalGroup.resolvedChatId;
+    const directGroup = candidates.find((candidate) => candidate.type !== 'private' && candidate.isDirectBinding);
+    if (directGroup)
+        return directGroup.resolvedChatId;
+    const privateChat = candidates.find((candidate) => candidate.type === 'private');
+    if (privateChat)
+        return privateChat.bindingChatId;
+    return candidates[0].resolvedChatId;
+}

package/dist/commands/chatCommandHandler.js

@@ -17,13 +17,15 @@ class ChatCommandHandler {
     channelManager;
     pool;
     workspaceService;
-    constructor(chatSessionService, chatSessionRepo, bindingRepo, channelManager, workspaceService, pool) {
+    resolveAccountForChannel;
+    constructor(chatSessionService, chatSessionRepo, bindingRepo, channelManager, workspaceService, pool, resolveAccountForChannel) {
         this.chatSessionService = chatSessionService;
         this.chatSessionRepo = chatSessionRepo;
         this.bindingRepo = bindingRepo;
         this.channelManager = channelManager;
         this.workspaceService = workspaceService;
         this.pool = pool ?? null;
+        this.resolveAccountForChannel = resolveAccountForChannel ?? null;
     }
     /**
      * /new -- Create a new session channel under the category and start a new chat in Antigravity
@@ -39,19 +41,11 @@ class ChatCommandHandler {
             await interaction.editReply({ content: (0, i18n_1.t)('⚠️ Please execute in a text channel.') });
             return;
         }
-        // Check if the current channel is under a project category
-        const parentId = 'parentId' in channel ? channel.parentId : null;
-        if (!parentId) {
-            await interaction.editReply({
-                content: (0, i18n_1.t)('⚠️ Please run in a project category channel.\nUse `/project` to create a project first.'),
-            });
-            return;
-        }
-        // Determine the project path
         const currentSession = this.chatSessionRepo.findByChannelId(interaction.channelId);
         const binding = this.bindingRepo.findByChannelId(interaction.channelId);
+        const parentId = currentSession?.categoryId ?? ('parentId' in channel ? channel.parentId : null);
         const workspaceName = currentSession?.workspacePath ?? binding?.workspacePath;
-        if (!workspaceName) {
+        if (!parentId || !workspaceName) {
             await interaction.editReply({
                 content: (0, i18n_1.t)('⚠️ Please run in a project category channel.\nUse `/project` to create a project first.'),
             });
@@ -61,9 +55,10 @@ class ChatCommandHandler {
         const workspacePath = this.workspaceService.getWorkspacePath(workspaceName);
         // Switch project (connect to the correct workbench page)
         let workspaceCdp;
+        const selectedAccount = this.resolveAccountForChannel?.(interaction.channelId, interaction.user.id) ?? 'default';
         if (this.pool) {
             try {
-                workspaceCdp = await this.pool.getOrConnect(workspacePath);
+                workspaceCdp = await this.pool.getOrConnect(workspacePath, { name: selectedAccount });
             }
             catch (e) {
                 await interaction.editReply({
@@ -94,6 +89,7 @@ class ChatCommandHandler {
             categoryId: parentId,
             workspacePath: workspaceName,
             sessionNumber,
+            activeAccountName: selectedAccount,
             guildId: guild.id,
         });
         const embed = new discord_js_1.EmbedBuilder()

package/dist/commands/joinCommandHandler.js

@@ -25,9 +25,10 @@ class JoinCommandHandler {
     client;
     extractionMode;
     responseTimeoutMs;
+    resolveAccountForChannel;
     /** Active ResponseMonitors per workspace (for AI response mirroring) */
     activeResponseMonitors = new Map();
-    constructor(chatSessionService, chatSessionRepo, bindingRepo, channelManager, pool, workspaceService, client, extractionMode, responseTimeoutMs) {
+    constructor(chatSessionService, chatSessionRepo, bindingRepo, channelManager, pool, workspaceService, client, extractionMode, responseTimeoutMs, resolveAccountForChannel) {
         this.chatSessionService = chatSessionService;
         this.chatSessionRepo = chatSessionRepo;
         this.bindingRepo = bindingRepo;
@@ -37,6 +38,7 @@ class JoinCommandHandler {
         this.client = client;
         this.extractionMode = extractionMode;
         this.responseTimeoutMs = responseTimeoutMs;
+        this.resolveAccountForChannel = resolveAccountForChannel ?? null;
     }
     /**
      * Resolve a project name (from DB) to its full absolute path.
@@ -59,9 +61,10 @@ class JoinCommandHandler {
             return;
         }
         const projectPath = this.resolveProjectPath(projectName);
+        const accountName = this.resolveAccountForChannel?.(interaction.channelId, interaction.user.id) ?? 'default';
         let cdp;
         try {
-            cdp = await this.pool.getOrConnect(projectPath);
+            cdp = await this.pool.getOrConnect(projectPath, { name: accountName });
         }
         catch (e) {
             await interaction.editReply({
@@ -96,6 +99,7 @@ class JoinCommandHandler {
             return;
         }
         const projectPath = this.resolveProjectPath(projectName);
+        const accountName = this.resolveAccountForChannel?.(interaction.channelId, interaction.user.id) ?? 'default';
         // Step 1: Check if a channel already exists for this session
         const existingSession = this.chatSessionRepo.findByDisplayName(projectName, selectedTitle);
         if (existingSession) {
@@ -119,7 +123,7 @@ class JoinCommandHandler {
         // Step 2: Connect to CDP
         let cdp;
         try {
-            cdp = await this.pool.getOrConnect(projectPath);
+            cdp = await this.pool.getOrConnect(projectPath, { name: accountName });
         }
         catch (e) {
             await interaction.editReply({ content: (0, i18n_1.t)(`⚠️ Failed to connect to project: ${e.message}`) });
@@ -149,11 +153,12 @@ class JoinCommandHandler {
             categoryId,
             workspacePath: projectName,
             sessionNumber,
+            activeAccountName: accountName,
             guildId: guild.id,
         });
         this.chatSessionRepo.updateDisplayName(newChannelId, selectedTitle);
         // Step 6: Start mirroring (routes dynamically to all bound session channels)
-        this.startMirroring(bridge, cdp, projectName);
+        this.startMirroring(bridge, cdp, projectName, accountName);
         const embed = new discord_js_1.EmbedBuilder()
             .setTitle((0, i18n_1.t)('🔗 Joined Session'))
             .setDescription((0, i18n_1.t)(`Connected to: **${selectedTitle}**\n→ <#${newChannelId}>\n\n` +
@@ -177,7 +182,8 @@ class JoinCommandHandler {
             return;
         }
         const projectPath = this.resolveProjectPath(projectName);
-        const detector = this.pool.getUserMessageDetector(projectName);
+        const accountName = this.resolveAccountForChannel?.(interaction.channelId, interaction.user.id) ?? 'default';
+        const detector = this.pool.getUserMessageDetector(projectName, accountName);
         if (detector?.isActive()) {
             // Turn OFF — stop user message detector and any active response monitor
             detector.stop();
@@ -197,7 +203,7 @@ class JoinCommandHandler {
             // Turn ON
             let cdp;
             try {
-                cdp = await this.pool.getOrConnect(projectPath);
+                cdp = await this.pool.getOrConnect(projectPath, { name: accountName });
             }
             catch (e) {
                 await interaction.editReply({
@@ -205,7 +211,7 @@ class JoinCommandHandler {
                 });
                 return;
             }
-            this.startMirroring(bridge, cdp, projectName);
+            this.startMirroring(bridge, cdp, projectName, accountName);
             const embed = new discord_js_1.EmbedBuilder()
                 .setTitle((0, i18n_1.t)('📡 Mirroring ON'))
                 .setDescription((0, i18n_1.t)('PC-to-Discord message mirroring is now active.\n' +
@@ -222,11 +228,11 @@ class JoinCommandHandler {
      * channel via chatSessionRepo.findByDisplayName. Only explicitly joined
      * sessions (with a displayName binding) receive mirrored messages.
      */
-    startMirroring(bridge, cdp, projectName) {
+    startMirroring(bridge, cdp, projectName, accountName) {
         // Force re-prime: stop existing detector so that ensureUserMessageDetector
         // creates a fresh one. This prevents the detector from treating the
         // new session's last message as a "new" user message after /join.
-        const existing = this.pool.getUserMessageDetector(projectName);
+        const existing = this.pool.getUserMessageDetector(projectName, accountName);
         if (existing?.isActive()) {
             existing.stop();
         }
@@ -235,7 +241,7 @@ class JoinCommandHandler {
                 .catch((err) => {
                 logger_1.logger.error('[Mirror] Error routing mirrored message:', err);
             });
-        });
+        }, accountName);
     }
     /**
      * Route a mirrored PC message to the correct Discord channel and

package/dist/commands/registerSlashCommands.js

@@ -79,7 +79,14 @@ const projectCommand = new discord_js_1.SlashCommandBuilder()
     .addStringOption((option) => option
     .setName('name')
     .setDescription((0, i18n_1.t)('Name of the project to create'))
-    .setRequired(true)));
+    .setRequired(true)))
+    .addSubcommand((sub) => sub
+    .setName('account')
+    .setDescription((0, i18n_1.t)('Display or change the Antigravity account bound to this project channel'))
+    .addStringOption((option) => option
+    .setName('name')
+    .setDescription((0, i18n_1.t)('Name of the account to bind to this project channel'))
+    .setRequired(false)));
 /** /new command definition (formerly /chat new, made into a standalone command) */
 const newCommand = new discord_js_1.SlashCommandBuilder()
     .setName('new')
@@ -118,6 +125,10 @@ const outputCommand = new discord_js_1.SlashCommandBuilder()
     .setName('format')
     .setDescription((0, i18n_1.t)('embed / plain (optional direct switch)'))
     .setRequired(false));
+/** /account command definition */
+const accountCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('account')
+    .setDescription((0, i18n_1.t)('Select the Antigravity account for the current session'));
 /** /logs command definition */
 const logsCommand = new discord_js_1.SlashCommandBuilder()
     .setName('logs')
@@ -153,6 +164,7 @@ exports.slashCommands = [
     cleanupCommand,
     joinCommand,
     mirrorCommand,
+    accountCommand,
     outputCommand,
     pingCommand,
     logsCommand,

package/dist/commands/workspaceCommandHandler.js

@@ -22,6 +22,7 @@ class WorkspaceCommandHandler {
     chatSessionRepo;
     workspaceService;
     channelManager;
+    onSessionChannelCreated;
     processingWorkspaces = new Set();
     /**
      * Filters out stale bindings where the Discord channel no longer exists.
@@ -58,11 +59,12 @@ class WorkspaceCommandHandler {
         }
         return validBindings;
     }
-    constructor(bindingRepo, chatSessionRepo, workspaceService, channelManager) {
+    constructor(bindingRepo, chatSessionRepo, workspaceService, channelManager, onSessionChannelCreated) {
         this.bindingRepo = bindingRepo;
         this.chatSessionRepo = chatSessionRepo;
         this.workspaceService = workspaceService;
         this.channelManager = channelManager;
+        this.onSessionChannelCreated = onSessionChannelCreated;
     }
     /**
      * /project list -- Display project list via select menu
@@ -87,9 +89,16 @@ class WorkspaceCommandHandler {
      * Creates a category + session-1 channel and binds them.
      */
     async handleSelectMenu(interaction, guild) {
+        const respond = async (payload) => {
+            if (typeof interaction.editReply === 'function') {
+                await interaction.editReply(payload);
+                return;
+            }
+            await interaction.update(payload);
+        };
         const workspacePath = interaction.values[0];
         if (!this.workspaceService.exists(workspacePath)) {
-            await interaction.update({
+            await respond({
                 content: (0, i18n_1.t)(`❌ Project \`${workspacePath}\` not found.`),
                 embeds: [],
                 components: [],
@@ -109,7 +118,7 @@ class WorkspaceCommandHandler {
                 `→ ${channelLinks}`)
                 .addFields({ name: (0, i18n_1.t)('Full Path'), value: `\`${fullPath}\`` })
                 .setTimestamp();
-            await interaction.update({
+            await respond({
                 embeds: [embed],
                 components: [],
             });
@@ -117,7 +126,7 @@ class WorkspaceCommandHandler {
         }
         // Lock project being processed (prevent rapid repeated clicks)
         if (this.processingWorkspaces.has(workspacePath)) {
-            await interaction.update({
+            await respond({
                 content: (0, i18n_1.t)(`⏳ **${workspacePath}** is being created. Please wait.`),
                 embeds: [],
                 components: [],
@@ -148,6 +157,7 @@ class WorkspaceCommandHandler {
                 sessionNumber,
                 guildId: guild.id,
             });
+            await this.onSessionChannelCreated?.(workspacePath, channelId, interaction.channelId, interaction.user.id);
             const fullPath = this.workspaceService.getWorkspacePath(workspacePath);
             const embed = new discord_js_1.EmbedBuilder()
                 .setTitle('📁 Projects')
@@ -156,7 +166,7 @@ class WorkspaceCommandHandler {
                 `→ <#${channelId}>`)
                 .addFields({ name: (0, i18n_1.t)('Full Path'), value: `\`${fullPath}\`` })
                 .setTimestamp();
-            await interaction.update({
+            await respond({
                 embeds: [embed],
                 components: [],
             });
@@ -231,6 +241,7 @@ class WorkspaceCommandHandler {
                 sessionNumber,
                 guildId: guild.id,
             });
+            await this.onSessionChannelCreated?.(name, channelId, interaction.channelId, interaction.user.id);
             const embed = new discord_js_1.EmbedBuilder()
                 .setTitle('📁 Project Created')
                 .setColor(0x00AA00)
@@ -249,9 +260,13 @@ class WorkspaceCommandHandler {
      */
     getWorkspaceForChannel(channelId) {
         const binding = this.bindingRepo.findByChannelId(channelId);
-        if (!binding)
+        if (binding) {
+            return this.workspaceService.getWorkspacePath(binding.workspacePath);
+        }
+        const session = this.chatSessionRepo.findByChannelId(channelId);
+        if (!session)
             return undefined;
-        return this.workspaceService.getWorkspacePath(binding.workspacePath);
+        return this.workspaceService.getWorkspacePath(session.workspacePath);
     }
 }
 exports.WorkspaceCommandHandler = WorkspaceCommandHandler;

package/dist/database/accountPreferenceRepository.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountPreferenceRepository = void 0;
+class AccountPreferenceRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS account_preferences (
+                user_id TEXT PRIMARY KEY,
+                account_name TEXT NOT NULL,
+                updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+            )
+        `);
+    }
+    getAccountName(userId) {
+        const row = this.db.prepare('SELECT account_name FROM account_preferences WHERE user_id = ?').get(userId);
+        return row?.account_name ?? null;
+    }
+    setAccountName(userId, accountName) {
+        this.db.prepare(`
+            INSERT INTO account_preferences (user_id, account_name)
+            VALUES (?, ?)
+            ON CONFLICT(user_id)
+            DO UPDATE SET account_name = excluded.account_name, updated_at = datetime('now')
+        `).run(userId, accountName);
+    }
+}
+exports.AccountPreferenceRepository = AccountPreferenceRepository;

package/dist/database/channelPreferenceRepository.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelPreferenceRepository = void 0;
+class ChannelPreferenceRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS channel_preferences (
+                channel_id TEXT PRIMARY KEY,
+                account_name TEXT,
+                updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+            )
+        `);
+    }
+    getAccountName(channelId) {
+        const row = this.db.prepare('SELECT account_name FROM channel_preferences WHERE channel_id = ?').get(channelId);
+        return row?.account_name ?? null;
+    }
+    setAccountName(channelId, accountName) {
+        this.db.prepare(`
+            INSERT INTO channel_preferences (channel_id, account_name)
+            VALUES (?, ?)
+            ON CONFLICT(channel_id)
+            DO UPDATE SET account_name = excluded.account_name, updated_at = datetime('now')
+        `).run(channelId, accountName);
+    }
+}
+exports.ChannelPreferenceRepository = ChannelPreferenceRepository;

package/dist/database/chatSessionRepository.js

@@ -19,25 +19,65 @@ class ChatSessionRepository {
                 category_id TEXT NOT NULL,
                 workspace_path TEXT NOT NULL,
                 session_number INTEGER NOT NULL,
+                conversation_id TEXT,
+                active_account_name TEXT,
+                origin_account_name TEXT,
                 display_name TEXT,
                 is_renamed INTEGER NOT NULL DEFAULT 0,
                 guild_id TEXT NOT NULL,
                 created_at TEXT NOT NULL DEFAULT (datetime('now'))
             )
         `);
+        const columns = this.db.prepare('PRAGMA table_info(chat_sessions)').all();
+        const hasActiveAccountName = columns.some((column) => column.name === 'active_account_name');
+        const hasConversationId = columns.some((column) => column.name === 'conversation_id');
+        if (!hasConversationId) {
+            this.db.exec('ALTER TABLE chat_sessions ADD COLUMN conversation_id TEXT');
+        }
+        if (!hasActiveAccountName) {
+            this.db.exec('ALTER TABLE chat_sessions ADD COLUMN active_account_name TEXT');
+        }
+        const hasOriginAccountName = columns.some((column) => column.name === 'origin_account_name');
+        if (!hasOriginAccountName) {
+            this.db.exec('ALTER TABLE chat_sessions ADD COLUMN origin_account_name TEXT');
+        }
+        const hasLegacyAccountName = columns.some((column) => column.name === 'account_name');
+        if (hasLegacyAccountName) {
+            this.db.exec(`
+                UPDATE chat_sessions
+                SET origin_account_name = account_name
+                WHERE origin_account_name IS NULL AND account_name IS NOT NULL
+            `);
+            this.db.exec(`
+                UPDATE chat_sessions
+                SET active_account_name = COALESCE(active_account_name, origin_account_name, account_name)
+                WHERE active_account_name IS NULL
+            `);
+        }
+        else {
+            this.db.exec(`
+                UPDATE chat_sessions
+                SET active_account_name = origin_account_name
+                WHERE active_account_name IS NULL AND origin_account_name IS NOT NULL
+            `);
+        }
     }
     create(input) {
+        const activeAccountName = input.activeAccountName ?? null;
         const stmt = this.db.prepare(`
-            INSERT INTO chat_sessions (channel_id, category_id, workspace_path, session_number, guild_id)
-            VALUES (?, ?, ?, ?, ?)
+            INSERT INTO chat_sessions (channel_id, category_id, workspace_path, session_number, active_account_name, origin_account_name, guild_id)
+            VALUES (?, ?, ?, ?, ?, NULL, ?)
         `);
-        const result = stmt.run(input.channelId, input.categoryId, input.workspacePath, input.sessionNumber, input.guildId);
+        const result = stmt.run(input.channelId, input.categoryId, input.workspacePath, input.sessionNumber, activeAccountName, input.guildId);
         return {
             id: result.lastInsertRowid,
             channelId: input.channelId,
             categoryId: input.categoryId,
             workspacePath: input.workspacePath,
             sessionNumber: input.sessionNumber,
+            conversationId: null,
+            activeAccountName,
+            originAccountName: null,
             displayName: null,
             isRenamed: false,
             guildId: input.guildId,
@@ -67,6 +107,26 @@ class ChatSessionRepository {
         const result = this.db.prepare('UPDATE chat_sessions SET display_name = ?, is_renamed = 1 WHERE channel_id = ?').run(displayName, channelId);
         return result.changes > 0;
     }
+    setActiveAccountName(channelId, accountName) {
+        const result = this.db.prepare('UPDATE chat_sessions SET active_account_name = ? WHERE channel_id = ?').run(accountName, channelId);
+        return result.changes > 0;
+    }
+    setOriginAccountName(channelId, accountName) {
+        const result = this.db.prepare('UPDATE chat_sessions SET origin_account_name = ? WHERE channel_id = ?').run(accountName, channelId);
+        return result.changes > 0;
+    }
+    setConversationId(channelId, conversationId) {
+        const result = this.db.prepare('UPDATE chat_sessions SET conversation_id = ? WHERE channel_id = ?').run(conversationId, channelId);
+        return result.changes > 0;
+    }
+    initializeConversationId(channelId, conversationId) {
+        const result = this.db.prepare('UPDATE chat_sessions SET conversation_id = ? WHERE channel_id = ? AND conversation_id IS NULL').run(conversationId, channelId);
+        return result.changes > 0;
+    }
+    initializeOriginAccountName(channelId, accountName) {
+        const result = this.db.prepare('UPDATE chat_sessions SET origin_account_name = ? WHERE channel_id = ? AND origin_account_name IS NULL').run(accountName, channelId);
+        return result.changes > 0;
+    }
     /**
      * Find a session by display name within a workspace.
      * Returns the first match (most recent).
@@ -88,6 +148,9 @@ class ChatSessionRepository {
             categoryId: row.category_id,
             workspacePath: row.workspace_path,
             sessionNumber: row.session_number,
+            conversationId: row.conversation_id ?? null,
+            activeAccountName: row.active_account_name ?? row.account_name ?? null,
+            originAccountName: row.origin_account_name ?? null,
             displayName: row.display_name,
             isRenamed: row.is_renamed === 1,
             guildId: row.guild_id,

package/dist/database/telegramBindingRepository.js

@@ -48,6 +48,19 @@ class TelegramBindingRepository {
             return undefined;
         return this.mapRow(row);
     }
+    /**
+     * Find binding by exact chat ID, or fall back to the base chat ID for topic-style IDs.
+     * Example: "12345_67" falls back to "12345" when the topic itself has no direct binding.
+     */
+    findByChatIdWithParentFallback(chatId) {
+        const exact = this.findByChatId(chatId);
+        if (exact)
+            return exact;
+        const underscoreIndex = chatId.indexOf('_');
+        if (underscoreIndex <= 0)
+            return undefined;
+        return this.findByChatId(chatId.slice(0, underscoreIndex));
+    }
     /**
      * Find bindings by workspace path
      */