lazy-gravity 0.0.2 → 0.0.3

package/dist/database/templateRepository.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateRepository = void 0;
+/**
+ * Repository class for SQLite persistence of frequently used prompt templates.
+ * Handles template creation, retrieval, updating, and deletion.
+ */
+class TemplateRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initialize();
+    }
+    /**
+     * Initialize table (create if not exists)
+     */
+    initialize() {
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS templates (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL UNIQUE,
+                prompt TEXT NOT NULL,
+                created_at TEXT NOT NULL DEFAULT (datetime('now'))
+            )
+        `);
+    }
+    /**
+     * Create a new template
+     */
+    create(input) {
+        const stmt = this.db.prepare(`
+            INSERT INTO templates (name, prompt)
+            VALUES (?, ?)
+        `);
+        const result = stmt.run(input.name, input.prompt);
+        return {
+            id: result.lastInsertRowid,
+            name: input.name,
+            prompt: input.prompt,
+        };
+    }
+    /**
+     * Get all templates
+     */
+    findAll() {
+        const rows = this.db.prepare('SELECT * FROM templates ORDER BY id ASC').all();
+        return rows.map(this.mapRow);
+    }
+    /**
+     * Find by ID
+     */
+    findById(id) {
+        const row = this.db.prepare('SELECT * FROM templates WHERE id = ?').get(id);
+        if (!row)
+            return undefined;
+        return this.mapRow(row);
+    }
+    /**
+     * Find by template name
+     */
+    findByName(name) {
+        const row = this.db.prepare('SELECT * FROM templates WHERE name = ?').get(name);
+        if (!row)
+            return undefined;
+        return this.mapRow(row);
+    }
+    /**
+     * Delete by template name
+     */
+    deleteByName(name) {
+        const result = this.db.prepare('DELETE FROM templates WHERE name = ?').run(name);
+        return result.changes > 0;
+    }
+    /**
+     * Partially update by template name
+     */
+    updateByName(name, input) {
+        const sets = [];
+        const values = [];
+        if (input.prompt !== undefined) {
+            sets.push('prompt = ?');
+            values.push(input.prompt);
+        }
+        if (sets.length === 0)
+            return false;
+        values.push(name);
+        const sql = `UPDATE templates SET ${sets.join(', ')} WHERE name = ?`;
+        const result = this.db.prepare(sql).run(...values);
+        return result.changes > 0;
+    }
+    /**
+     * Map a DB row to TemplateRecord
+     */
+    mapRow(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            prompt: row.prompt,
+            createdAt: row.created_at,
+        };
+    }
+}
+exports.TemplateRepository = TemplateRepository;

package/dist/database/workspaceBindingRepository.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceBindingRepository = void 0;
+/**
+ * Repository for persisting Discord channel to workspace directory bindings in SQLite.
+ * Only one workspace can be bound per channel (UNIQUE constraint).
+ */
+class WorkspaceBindingRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initialize();
+    }
+    /**
+     * Initialize table (create if not exists)
+     */
+    initialize() {
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS workspace_bindings (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                channel_id TEXT NOT NULL UNIQUE,
+                workspace_path TEXT NOT NULL,
+                guild_id TEXT NOT NULL,
+                created_at TEXT NOT NULL DEFAULT (datetime('now'))
+            )
+        `);
+    }
+    /**
+     * Create a new binding
+     */
+    create(input) {
+        const stmt = this.db.prepare(`
+            INSERT INTO workspace_bindings (channel_id, workspace_path, guild_id)
+            VALUES (?, ?, ?)
+        `);
+        const result = stmt.run(input.channelId, input.workspacePath, input.guildId);
+        return {
+            id: result.lastInsertRowid,
+            channelId: input.channelId,
+            workspacePath: input.workspacePath,
+            guildId: input.guildId,
+        };
+    }
+    /**
+     * Find binding by channel ID
+     */
+    findByChannelId(channelId) {
+        const row = this.db.prepare('SELECT * FROM workspace_bindings WHERE channel_id = ?').get(channelId);
+        if (!row)
+            return undefined;
+        return this.mapRow(row);
+    }
+    /**
+     * Find bindings by workspace path and guild ID
+     * Used to prevent duplicate workspace creation
+     */
+    findByWorkspacePathAndGuildId(workspacePath, guildId) {
+        const rows = this.db.prepare('SELECT * FROM workspace_bindings WHERE workspace_path = ? AND guild_id = ? ORDER BY id ASC').all(workspacePath, guildId);
+        return rows.map(this.mapRow);
+    }
+    /**
+     * Find all bindings by guild ID
+     */
+    findByGuildId(guildId) {
+        const rows = this.db.prepare('SELECT * FROM workspace_bindings WHERE guild_id = ? ORDER BY id ASC').all(guildId);
+        return rows.map(this.mapRow);
+    }
+    /**
+     * Get all bindings
+     */
+    findAll() {
+        const rows = this.db.prepare('SELECT * FROM workspace_bindings ORDER BY id ASC').all();
+        return rows.map(this.mapRow);
+    }
+    /**
+     * Delete binding by channel ID
+     */
+    deleteByChannelId(channelId) {
+        const result = this.db.prepare('DELETE FROM workspace_bindings WHERE channel_id = ?').run(channelId);
+        return result.changes > 0;
+    }
+    /**
+     * Create or update a channel binding (upsert)
+     */
+    upsert(input) {
+        const stmt = this.db.prepare(`
+            INSERT INTO workspace_bindings (channel_id, workspace_path, guild_id)
+            VALUES (?, ?, ?)
+            ON CONFLICT(channel_id) DO UPDATE SET
+                workspace_path = excluded.workspace_path,
+                guild_id = excluded.guild_id
+        `);
+        stmt.run(input.channelId, input.workspacePath, input.guildId);
+        return this.findByChannelId(input.channelId);
+    }
+    /**
+     * Map a DB row to WorkspaceBindingRecord
+     */
+    mapRow(row) {
+        return {
+            id: row.id,
+            channelId: row.channel_id,
+            workspacePath: row.workspace_path,
+            guildId: row.guild_id,
+            createdAt: row.created_at,
+        };
+    }
+}
+exports.WorkspaceBindingRepository = WorkspaceBindingRepository;

package/dist/events/interactionCreateHandler.js

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInteractionCreateHandler = createInteractionCreateHandler;
+const discord_js_1 = require("discord.js");
+const i18n_1 = require("../utils/i18n");
+const logger_1 = require("../utils/logger");
+const templateUi_1 = require("../ui/templateUi");
+const autoAcceptUi_1 = require("../ui/autoAcceptUi");
+const cleanupCommandHandler_1 = require("../commands/cleanupCommandHandler");
+const workspaceCommandHandler_1 = require("../commands/workspaceCommandHandler");
+const modeService_1 = require("../services/modeService");
+function createInteractionCreateHandler(deps) {
+    return async (interaction) => {
+        if (interaction.isButton()) {
+            if (!deps.config.allowedUserIds.includes(interaction.user.id)) {
+                await interaction.reply({ content: (0, i18n_1.t)('You do not have permission.'), flags: discord_js_1.MessageFlags.Ephemeral }).catch(logger_1.logger.error);
+                return;
+            }
+            try {
+                const approvalAction = deps.parseApprovalCustomId(interaction.customId);
+                if (approvalAction) {
+                    if (approvalAction.channelId && approvalAction.channelId !== interaction.channelId) {
+                        await interaction.reply({
+                            content: (0, i18n_1.t)('This approval action is linked to a different session channel.'),
+                            flags: discord_js_1.MessageFlags.Ephemeral,
+                        }).catch(logger_1.logger.error);
+                        return;
+                    }
+                    const workspaceDirName = approvalAction.workspaceDirName ?? deps.bridge.lastActiveWorkspace;
+                    const detector = workspaceDirName
+                        ? deps.bridge.pool.getApprovalDetector(workspaceDirName)
+                        : undefined;
+                    if (!detector) {
+                        try {
+                            await interaction.reply({ content: (0, i18n_1.t)('Approval detector not found.'), flags: discord_js_1.MessageFlags.Ephemeral });
+                        }
+                        catch { /* ignore */ }
+                        return;
+                    }
+                    let success = false;
+                    let actionLabel = '';
+                    if (approvalAction.action === 'approve') {
+                        success = await detector.approveButton();
+                        actionLabel = (0, i18n_1.t)('Allow');
+                    }
+                    else if (approvalAction.action === 'always_allow') {
+                        success = await detector.alwaysAllowButton();
+                        actionLabel = (0, i18n_1.t)('Allow Chat');
+                    }
+                    else {
+                        success = await detector.denyButton();
+                        actionLabel = (0, i18n_1.t)('Deny');
+                    }
+                    try {
+                        if (success) {
+                            const originalEmbed = interaction.message.embeds[0];
+                            const updatedEmbed = originalEmbed
+                                ? discord_js_1.EmbedBuilder.from(originalEmbed)
+                                : new discord_js_1.EmbedBuilder().setTitle('Approval Request');
+                            const historyText = `${actionLabel} by <@${interaction.user.id}> (${new Date().toLocaleString('ja-JP')})`;
+                            updatedEmbed
+                                .setColor(approvalAction.action === 'deny' ? 0xE74C3C : 0x2ECC71)
+                                .addFields({ name: 'Action History', value: historyText, inline: false })
+                                .setTimestamp();
+                            const disabledRows = interaction.message.components
+                                .map((row) => {
+                                const rowAny = row;
+                                if (!Array.isArray(rowAny.components))
+                                    return null;
+                                const nextRow = new discord_js_1.ActionRowBuilder();
+                                const disabledButtons = rowAny.components
+                                    .map((component) => {
+                                    const componentType = component?.type ?? component?.data?.type;
+                                    if (componentType !== 2)
+                                        return null;
+                                    const payload = typeof component?.toJSON === 'function'
+                                        ? component.toJSON()
+                                        : component;
+                                    return discord_js_1.ButtonBuilder.from(payload).setDisabled(true);
+                                })
+                                    .filter((button) => button !== null);
+                                if (disabledButtons.length === 0)
+                                    return null;
+                                nextRow.addComponents(...disabledButtons);
+                                return nextRow;
+                            })
+                                .filter((row) => row !== null);
+                            await interaction.update({
+                                embeds: [updatedEmbed],
+                                components: disabledRows,
+                            });
+                        }
+                        else {
+                            await interaction.reply({ content: 'Approval button not found.', flags: discord_js_1.MessageFlags.Ephemeral });
+                        }
+                    }
+                    catch (interactionError) {
+                        if (interactionError?.code === 10062 || interactionError?.code === 40060) {
+                            logger_1.logger.warn('[Approval] Interaction expired. Responding directly in the channel.');
+                            if (interaction.channel && 'send' in interaction.channel) {
+                                const fallbackMessage = success
+                                    ? `${actionLabel} completed.`
+                                    : 'Approval button not found.';
+                                await interaction.channel.send(fallbackMessage).catch(logger_1.logger.error);
+                            }
+                        }
+                        else {
+                            throw interactionError;
+                        }
+                    }
+                    return;
+                }
+                if (interaction.customId === cleanupCommandHandler_1.CLEANUP_ARCHIVE_BTN) {
+                    await deps.cleanupHandler.handleArchive(interaction);
+                    return;
+                }
+                if (interaction.customId === cleanupCommandHandler_1.CLEANUP_DELETE_BTN) {
+                    await deps.cleanupHandler.handleDelete(interaction);
+                    return;
+                }
+                if (interaction.customId === cleanupCommandHandler_1.CLEANUP_CANCEL_BTN) {
+                    await deps.cleanupHandler.handleCancel(interaction);
+                    return;
+                }
+                if (interaction.customId === 'model_refresh_btn') {
+                    await interaction.deferUpdate();
+                    await deps.sendModelsUI({ editReply: async (data) => await interaction.editReply(data) }, {
+                        getCurrentCdp: () => deps.getCurrentCdp(deps.bridge),
+                        fetchQuota: async () => deps.bridge.quota.fetchQuota(),
+                    });
+                    return;
+                }
+                if (interaction.customId.startsWith('model_btn_')) {
+                    await interaction.deferUpdate();
+                    const modelName = interaction.customId.replace('model_btn_', '');
+                    const cdp = deps.getCurrentCdp(deps.bridge);
+                    if (!cdp) {
+                        await interaction.followUp({ content: 'Not connected to CDP.', flags: discord_js_1.MessageFlags.Ephemeral });
+                        return;
+                    }
+                    const res = await cdp.setUiModel(modelName);
+                    if (!res.ok) {
+                        await interaction.followUp({ content: res.error || 'Failed to change model.', flags: discord_js_1.MessageFlags.Ephemeral });
+                    }
+                    else {
+                        await deps.sendModelsUI({ editReply: async (data) => await interaction.editReply(data) }, {
+                            getCurrentCdp: () => deps.getCurrentCdp(deps.bridge),
+                            fetchQuota: async () => deps.bridge.quota.fetchQuota(),
+                        });
+                        await interaction.followUp({ content: `Model changed to **${res.model}**!`, flags: discord_js_1.MessageFlags.Ephemeral });
+                    }
+                    return;
+                }
+                if (interaction.customId === autoAcceptUi_1.AUTOACCEPT_BTN_REFRESH) {
+                    await interaction.deferUpdate();
+                    await deps.sendAutoAcceptUI({ editReply: async (data) => await interaction.editReply(data) }, deps.bridge.autoAccept);
+                    return;
+                }
+                if (interaction.customId === autoAcceptUi_1.AUTOACCEPT_BTN_ON || interaction.customId === autoAcceptUi_1.AUTOACCEPT_BTN_OFF) {
+                    await interaction.deferUpdate();
+                    const action = interaction.customId === autoAcceptUi_1.AUTOACCEPT_BTN_ON ? 'on' : 'off';
+                    const result = deps.bridge.autoAccept.handle(action);
+                    await deps.sendAutoAcceptUI({ editReply: async (data) => await interaction.editReply(data) }, deps.bridge.autoAccept);
+                    await interaction.followUp({
+                        content: result.message,
+                        flags: discord_js_1.MessageFlags.Ephemeral,
+                    });
+                    return;
+                }
+                if (interaction.customId.startsWith(templateUi_1.TEMPLATE_BTN_PREFIX)) {
+                    await interaction.deferUpdate();
+                    const templateId = (0, templateUi_1.parseTemplateButtonId)(interaction.customId);
+                    if (!isNaN(templateId) && deps.handleTemplateUse) {
+                        await deps.handleTemplateUse(interaction, templateId);
+                    }
+                    return;
+                }
+            }
+            catch (error) {
+                logger_1.logger.error('Error during button interaction handling:', error);
+                try {
+                    if (!interaction.replied && !interaction.deferred) {
+                        await interaction.reply({ content: 'An error occurred while processing the button action.', flags: discord_js_1.MessageFlags.Ephemeral });
+                    }
+                    else {
+                        await interaction.followUp({ content: 'An error occurred while processing the button action.', flags: discord_js_1.MessageFlags.Ephemeral }).catch(logger_1.logger.error);
+                    }
+                }
+                catch (e) {
+                    logger_1.logger.error('Failed to send error message as well:', e);
+                }
+            }
+        }
+        if (interaction.isStringSelectMenu() && interaction.customId === 'mode_select') {
+            if (!deps.config.allowedUserIds.includes(interaction.user.id)) {
+                await interaction.reply({ content: (0, i18n_1.t)('You do not have permission.'), flags: discord_js_1.MessageFlags.Ephemeral }).catch(logger_1.logger.error);
+                return;
+            }
+            try {
+                await interaction.deferUpdate();
+            }
+            catch (deferError) {
+                if (deferError?.code === 10062 || deferError?.code === 40060) {
+                    logger_1.logger.warn('[Mode] deferUpdate expired. Skipping.');
+                    return;
+                }
+                logger_1.logger.error('[Mode] deferUpdate failed:', deferError);
+                return;
+            }
+            try {
+                const selectedMode = interaction.values[0];
+                deps.modeService.setMode(selectedMode);
+                const cdp = deps.getCurrentCdp(deps.bridge);
+                if (cdp) {
+                    const res = await cdp.setUiMode(selectedMode);
+                    if (!res.ok) {
+                        logger_1.logger.warn(`[Mode] UI mode switch failed: ${res.error}`);
+                    }
+                }
+                await deps.sendModeUI({ editReply: async (data) => await interaction.editReply(data) }, deps.modeService);
+                await interaction.followUp({ content: `Mode changed to **${modeService_1.MODE_DISPLAY_NAMES[selectedMode] || selectedMode}**!`, flags: discord_js_1.MessageFlags.Ephemeral });
+            }
+            catch (error) {
+                logger_1.logger.error('Error during mode dropdown handling:', error);
+                try {
+                    if (interaction.deferred || interaction.replied) {
+                        await interaction.followUp({ content: 'An error occurred while changing the mode.', flags: discord_js_1.MessageFlags.Ephemeral }).catch(logger_1.logger.error);
+                    }
+                }
+                catch (e) {
+                    logger_1.logger.error('Failed to send error message:', e);
+                }
+            }
+            return;
+        }
+        if (interaction.isStringSelectMenu() && (interaction.customId === workspaceCommandHandler_1.PROJECT_SELECT_ID || interaction.customId === workspaceCommandHandler_1.WORKSPACE_SELECT_ID)) {
+            if (!deps.config.allowedUserIds.includes(interaction.user.id)) {
+                await interaction.reply({ content: (0, i18n_1.t)('You do not have permission.'), flags: discord_js_1.MessageFlags.Ephemeral }).catch(logger_1.logger.error);
+                return;
+            }
+            if (!interaction.guild) {
+                await interaction.reply({ content: 'This can only be used in a server.', flags: discord_js_1.MessageFlags.Ephemeral }).catch(logger_1.logger.error);
+                return;
+            }
+            try {
+                await deps.wsHandler.handleSelectMenu(interaction, interaction.guild);
+            }
+            catch (error) {
+                logger_1.logger.error('Workspace selection error:', error);
+            }
+            return;
+        }
+        if (!interaction.isChatInputCommand())
+            return;
+        const commandInteraction = interaction;
+        if (!deps.config.allowedUserIds.includes(interaction.user.id)) {
+            await commandInteraction.reply({
+                content: 'You do not have permission to use this command.',
+                flags: discord_js_1.MessageFlags.Ephemeral,
+            }).catch(logger_1.logger.error);
+            return;
+        }
+        try {
+            await commandInteraction.deferReply();
+        }
+        catch (deferError) {
+            if (deferError?.code === 10062) {
+                logger_1.logger.warn('[SlashCommand] Interaction expired (deferReply failed). Skipping.');
+                return;
+            }
+            throw deferError;
+        }
+        try {
+            await deps.handleSlashInteraction(commandInteraction, deps.slashCommandHandler, deps.bridge, deps.wsHandler, deps.chatHandler, deps.cleanupHandler, deps.modeService, deps.modelService, deps.bridge.autoAccept, deps.client);
+        }
+        catch (error) {
+            logger_1.logger.error('Error during slash command handling:', error);
+            try {
+                await commandInteraction.editReply({ content: 'An error occurred while processing the command.' });
+            }
+            catch (replyError) {
+                logger_1.logger.error('Failed to send error response:', replyError);
+            }
+        }
+    };
+}

package/dist/events/messageCreateHandler.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessageCreateHandler = createMessageCreateHandler;
+const discord_js_1 = require("discord.js");
+const messageParser_1 = require("../commands/messageParser");
+const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const modeService_1 = require("../services/modeService");
+const imageHandler_1 = require("../utils/imageHandler");
+const logger_1 = require("../utils/logger");
+function createMessageCreateHandler(deps) {
+    const getCurrentCdp = deps.getCurrentCdp ?? cdpBridgeManager_1.getCurrentCdp;
+    const ensureApprovalDetector = deps.ensureApprovalDetector ?? cdpBridgeManager_1.ensureApprovalDetector;
+    const registerApprovalWorkspaceChannel = deps.registerApprovalWorkspaceChannel ?? cdpBridgeManager_1.registerApprovalWorkspaceChannel;
+    const registerApprovalSessionChannel = deps.registerApprovalSessionChannel ?? cdpBridgeManager_1.registerApprovalSessionChannel;
+    const downloadInboundImageAttachments = deps.downloadInboundImageAttachments ?? imageHandler_1.downloadInboundImageAttachments;
+    const cleanupInboundImageAttachments = deps.cleanupInboundImageAttachments ?? imageHandler_1.cleanupInboundImageAttachments;
+    const isImageAttachment = deps.isImageAttachment ?? imageHandler_1.isImageAttachment;
+    return async (message) => {
+        if (message.author.bot)
+            return;
+        if (!deps.config.allowedUserIds.includes(message.author.id)) {
+            return;
+        }
+        const parsed = (0, messageParser_1.parseMessageContent)(message.content);
+        if (parsed.isCommand && parsed.commandName) {
+            if (parsed.commandName === 'autoaccept') {
+                const result = deps.bridge.autoAccept.handle(parsed.args?.[0]);
+                await message.reply({ content: result.message }).catch(logger_1.logger.error);
+                return;
+            }
+            if (parsed.commandName === 'screenshot') {
+                await deps.handleScreenshot(message, getCurrentCdp(deps.bridge));
+                await message.reply({ content: '💡 You can also use the slash command `/screenshot`.' }).catch(() => { });
+                return;
+            }
+            if (parsed.commandName === 'status') {
+                const activeNames = deps.bridge.pool.getActiveWorkspaceNames();
+                const currentMode = deps.modeService.getCurrentMode();
+                const embed = new discord_js_1.EmbedBuilder()
+                    .setTitle('🔧 Bot Status')
+                    .setColor(activeNames.length > 0 ? 0x00CC88 : 0x888888)
+                    .addFields({ name: 'CDP Connection', value: activeNames.length > 0 ? `🟢 ${activeNames.length} project(s) connected` : '⚪ Disconnected', inline: true }, { name: 'Mode', value: modeService_1.MODE_DISPLAY_NAMES[currentMode] || currentMode, inline: true }, { name: 'Auto Approve', value: deps.bridge.autoAccept.isEnabled() ? '🟢 ON' : '⚪ OFF', inline: true })
+                    .setFooter({ text: '💡 Use the slash command /status for more detailed information' })
+                    .setTimestamp();
+                if (activeNames.length > 0) {
+                    const lines = activeNames.map((name) => {
+                        const cdp = deps.bridge.pool.getConnected(name);
+                        const contexts = cdp ? cdp.getContexts().length : 0;
+                        const detectorActive = deps.bridge.pool.getApprovalDetector(name)?.isActive() ? ' [Detecting]' : '';
+                        return `• **${name}** — Contexts: ${contexts}${detectorActive}`;
+                    });
+                    embed.setDescription(`**Connected Projects:**\n${lines.join('\n')}`);
+                }
+                else {
+                    embed.setDescription('Send a message to auto-connect to a project.');
+                }
+                await message.reply({ embeds: [embed] });
+                return;
+            }
+            const slashOnlyCommands = ['help', 'stop', 'model', 'mode', 'project', 'chat', 'new', 'cleanup'];
+            if (slashOnlyCommands.includes(parsed.commandName)) {
+                await message.reply({
+                    content: `💡 Please use \`/${parsed.commandName}\` as a slash command.\nType \`/${parsed.commandName}\` in the Discord input field to see suggestions.`,
+                }).catch(logger_1.logger.error);
+                return;
+            }
+            const result = await deps.slashCommandHandler.handleCommand(parsed.commandName, parsed.args || []);
+            await message.reply({
+                content: result.message,
+            }).catch(logger_1.logger.error);
+            if (result.prompt) {
+                const cdp = getCurrentCdp(deps.bridge);
+                if (cdp) {
+                    await deps.sendPromptToAntigravity(deps.bridge, message, result.prompt, cdp, deps.modeService, deps.modelService, [], {
+                        chatSessionService: deps.chatSessionService,
+                        chatSessionRepo: deps.chatSessionRepo,
+                        channelManager: deps.channelManager,
+                        titleGenerator: deps.titleGenerator,
+                    });
+                }
+                else {
+                    await message.reply('Not connected to CDP. Send a message first to connect to a project.');
+                }
+            }
+            return;
+        }
+        const hasImageAttachments = Array.from(message.attachments.values())
+            .some((attachment) => isImageAttachment(attachment.contentType, attachment.name));
+        if (message.content.trim() || hasImageAttachments) {
+            const promptText = message.content.trim() || 'Please review the attached images and respond accordingly.';
+            const inboundImages = await downloadInboundImageAttachments(message);
+            if (hasImageAttachments && inboundImages.length === 0) {
+                await message.reply('Failed to retrieve attached images. Please wait and try again.').catch(() => { });
+                return;
+            }
+            const workspacePath = deps.wsHandler.getWorkspaceForChannel(message.channelId);
+            try {
+                if (workspacePath) {
+                    try {
+                        const cdp = await deps.bridge.pool.getOrConnect(workspacePath);
+                        const dirName = deps.bridge.pool.extractDirName(workspacePath);
+                        deps.bridge.lastActiveWorkspace = dirName;
+                        deps.bridge.lastActiveChannel = message.channel;
+                        registerApprovalWorkspaceChannel(deps.bridge, dirName, message.channel);
+                        ensureApprovalDetector(deps.bridge, cdp, dirName, deps.client);
+                        const session = deps.chatSessionRepo.findByChannelId(message.channelId);
+                        if (session?.displayName) {
+                            registerApprovalSessionChannel(deps.bridge, dirName, session.displayName, message.channel);
+                        }
+                        if (session?.isRenamed && session.displayName) {
+                            const activationResult = await deps.chatSessionService.activateSessionByTitle(cdp, session.displayName);
+                            if (!activationResult.ok) {
+                                const reason = activationResult.error ? ` (${activationResult.error})` : '';
+                                await message.reply(`⚠️ Could not route this message to the bound session (${session.displayName}). ` +
+                                    `Please open /chat and verify the session${reason}.`).catch(() => { });
+                                return;
+                            }
+                        }
+                        else if (session && !session.isRenamed) {
+                            try {
+                                const chatResult = await deps.chatSessionService.startNewChat(cdp);
+                                if (!chatResult.ok) {
+                                    logger_1.logger.warn('[MessageCreate] Failed to start new chat in Antigravity:', chatResult.error);
+                                    message.channel.send(`⚠️ Could not open a new chat in Antigravity. Sending to existing chat.`).catch(() => { });
+                                }
+                            }
+                            catch (err) {
+                                logger_1.logger.error('[MessageCreate] startNewChat error:', err);
+                                message.channel.send(`⚠️ Could not open a new chat in Antigravity. Sending to existing chat.`).catch(() => { });
+                            }
+                        }
+                        await deps.autoRenameChannel(message, deps.chatSessionRepo, deps.titleGenerator, deps.channelManager, cdp);
+                        await deps.sendPromptToAntigravity(deps.bridge, message, promptText, cdp, deps.modeService, deps.modelService, inboundImages, {
+                            chatSessionService: deps.chatSessionService,
+                            chatSessionRepo: deps.chatSessionRepo,
+                            channelManager: deps.channelManager,
+                            titleGenerator: deps.titleGenerator,
+                        });
+                    }
+                    catch (e) {
+                        await message.reply(`Failed to connect to workspace: ${e.message}`);
+                        return;
+                    }
+                }
+                else {
+                    await message.reply('No project is configured for this channel. Please create or select one with `/project`.');
+                }
+            }
+            finally {
+                await cleanupInboundImageAttachments(inboundImages);
+            }
+        }
+    };
+}

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("./utils/logger");
+const bot_1 = require("./bot");
+const lockfile_1 = require("./utils/lockfile");
+const logo_1 = require("./utils/logo");
+console.log(logo_1.LOGO);
+// Prevent duplicate launch: exit immediately if bot is already running
+(0, lockfile_1.acquireLock)();
+(0, bot_1.startBot)().catch(logger_1.logger.error);

package/dist/middleware/auth.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAuth = void 0;
+const withAuth = (userId, allowedUserIds, next) => {
+    if (allowedUserIds.includes(userId)) {
+        next();
+    }
+    return;
+};
+exports.withAuth = withAuth;