lazy-gravity 0.0.4 → 0.2.0

package/dist/services/updateCheckService.js

@@ -0,0 +1,147 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COOLDOWN_MS = exports.UPDATE_CHECK_FILE = void 0;
+exports.shouldCheckForUpdates = shouldCheckForUpdates;
+exports.fetchLatestVersion = fetchLatestVersion;
+exports.checkForUpdates = checkForUpdates;
+const https = __importStar(require("https"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const CONFIG_DIR = '.lazy-gravity';
+exports.UPDATE_CHECK_FILE = 'update-check.json';
+exports.COOLDOWN_MS = 24 * 60 * 60 * 1000; // 24 hours
+const REGISTRY_URL = 'https://registry.npmjs.org/lazy-gravity/latest';
+const REQUEST_TIMEOUT_MS = 5000;
+function getCachePath() {
+    return path.join(os.homedir(), CONFIG_DIR, exports.UPDATE_CHECK_FILE);
+}
+/**
+ * Determine whether enough time has elapsed since the last update check.
+ * Returns true if we should query the registry.
+ */
+function shouldCheckForUpdates() {
+    const cachePath = getCachePath();
+    try {
+        if (!fs.existsSync(cachePath))
+            return true;
+        const raw = fs.readFileSync(cachePath, 'utf-8');
+        const cache = JSON.parse(raw);
+        return Date.now() - cache.lastCheck >= exports.COOLDOWN_MS;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Query the npm registry for the latest published version.
+ */
+function fetchLatestVersion() {
+    return new Promise((resolve, reject) => {
+        const req = https.get(REGISTRY_URL, (res) => {
+            if (res.statusCode !== 200) {
+                reject(new Error(`HTTP ${res.statusCode}`));
+                return;
+            }
+            let body = '';
+            res.on('data', (chunk) => {
+                body += chunk;
+            });
+            res.on('end', () => {
+                try {
+                    const data = JSON.parse(body);
+                    resolve(data.version);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('Request timed out'));
+        });
+    });
+}
+function writeCache() {
+    const cachePath = getCachePath();
+    const dir = path.dirname(cachePath);
+    try {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const cache = { lastCheck: Date.now() };
+        fs.writeFileSync(cachePath, JSON.stringify(cache), 'utf-8');
+    }
+    catch {
+        // Silently ignore cache write failures
+    }
+}
+/**
+ * Compare two semver strings. Returns:
+ *  -1 if a < b, 0 if a === b, 1 if a > b
+ */
+function compareSemver(a, b) {
+    const partsA = a.split('.').map(Number);
+    const partsB = b.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        const diff = (partsA[i] ?? 0) - (partsB[i] ?? 0);
+        if (diff < 0)
+            return -1;
+        if (diff > 0)
+            return 1;
+    }
+    return 0;
+}
+/**
+ * Non-blocking update check. Call at startup (fire-and-forget).
+ * Respects a 24-hour cooldown via a local cache file.
+ */
+async function checkForUpdates(currentVersion) {
+    if (!shouldCheckForUpdates())
+        return;
+    try {
+        const latest = await fetchLatestVersion();
+        writeCache();
+        if (compareSemver(currentVersion, latest) < 0) {
+            console.info(`\n  Update available: ${currentVersion} \u2192 ${latest} \u2014 run \x1b[36mnpm i -g lazy-gravity\x1b[0m\n`);
+        }
+    }
+    catch {
+        // Silently ignore — update check should never block startup
+    }
+}

package/dist/services/userMessageDetector.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserMessageDetector = void 0;
+const node_crypto_1 = require("node:crypto");
+const logger_1 = require("../utils/logger");
+/**
+ * Script to detect the latest user message in the Antigravity chat.
+ *
+ * Antigravity user message DOM structure:
+ *   <div class="bg-gray-500/15 p-2 rounded-lg w-full text-sm select-text">
+ *     <div class="flex flex-row items-end gap-2">
+ *       <div class="flex-1 flex flex-col gap-2">
+ *         <div>
+ *           <div class="whitespace-pre-wrap text-sm" style="word-break: break-word;">
+ *             {user message text}
+ *           </div>
+ *         </div>
+ *       </div>
+ *       <div> <!-- undo button --> </div>
+ *     </div>
+ *   </div>
+ */
+const DETECT_USER_MESSAGE_SCRIPT = `(() => {
+    const panel = document.querySelector('.antigravity-agent-side-panel');
+    const scope = panel || document;
+
+    // Strategy A (primary): Query .whitespace-pre-wrap elements directly inside
+    // user bubble containers. This avoids the parent-container problem where
+    // querySelectorAll matches a wrapper that contains multiple bubbles.
+    const textEls = scope.querySelectorAll(
+        '[class*="bg-gray-500/15"][class*="select-text"] .whitespace-pre-wrap'
+    );
+
+    if (textEls.length > 0) {
+        const lastTextEl = textEls[textEls.length - 1];
+        const text = (lastTextEl.textContent || '').trim();
+        if (text.length > 0) return { text };
+    }
+
+    // Strategy B (fallback): Find individual bubble containers, filtering out
+    // any element that itself contains nested bubble elements (i.e., a parent wrapper).
+    const userBubbles = Array.from(scope.querySelectorAll(
+        '[class*="bg-gray-500/15"][class*="rounded-lg"][class*="select-text"]'
+    )).filter(el => !el.querySelector('[class*="bg-gray-500/15"][class*="select-text"]'));
+
+    if (userBubbles.length === 0) return null;
+
+    const lastBubble = userBubbles[userBubbles.length - 1];
+    const textEl = lastBubble.querySelector('.whitespace-pre-wrap')
+        || lastBubble.querySelector('[style*="word-break"]');
+
+    const text = textEl
+        ? (textEl.textContent || '').trim()
+        : (lastBubble.textContent || '').trim();
+
+    if (!text || text.length < 1) return null;
+
+    return { text };
+})()`;
+/**
+ * Normalize text for echo hash comparison.
+ * Trims, collapses whitespace, and takes first 200 chars.
+ */
+function normalizeForHash(text) {
+    return text.trim().replace(/\s+/g, ' ').slice(0, 200);
+}
+/**
+ * Compute a short hash for echo prevention.
+ */
+function computeEchoHash(text) {
+    return (0, node_crypto_1.createHash)('sha256').update(normalizeForHash(text)).digest('hex').slice(0, 16);
+}
+/**
+ * Detects user messages posted directly in the Antigravity UI (e.g., from a PC).
+ * Follows the ApprovalDetector polling pattern.
+ */
+class UserMessageDetector {
+    cdpService;
+    pollIntervalMs;
+    onUserMessage;
+    pollTimer = null;
+    isRunning = false;
+    /** Hash of the last detected message (for duplicate prevention) */
+    lastDetectedHash = null;
+    /** Set of echo hashes — messages sent by LazyGravity that should be ignored */
+    echoHashes = new Set();
+    /** Set of all previously detected message hashes (defense-in-depth dedup) */
+    seenHashes = new Set();
+    static MAX_SEEN_HASHES = 50;
+    /** True during the first poll — seeds existing DOM state without firing callback */
+    isPriming = false;
+    constructor(options) {
+        this.cdpService = options.cdpService;
+        this.pollIntervalMs = options.pollIntervalMs ?? 2000;
+        this.onUserMessage = options.onUserMessage;
+    }
+    /**
+     * Register a message hash as an echo (sent by LazyGravity).
+     * When this message is detected in the DOM, it will be skipped.
+     */
+    addEchoHash(text) {
+        const hash = computeEchoHash(text);
+        this.echoHashes.add(hash);
+        // Auto-cleanup: remove after 60s to prevent memory leak
+        setTimeout(() => {
+            this.echoHashes.delete(hash);
+        }, 60000);
+    }
+    /** Start monitoring. The first poll seeds the current DOM state without firing the callback. */
+    start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this.lastDetectedHash = null;
+        this.seenHashes.clear();
+        this.isPriming = true;
+        // echoHashes are intentionally NOT cleared — they have their own 60s TTL
+        // and keeping them prevents false echo pickup during rapid stop/start cycles.
+        this.schedulePoll();
+    }
+    /** Stop monitoring. */
+    stop() {
+        this.isRunning = false;
+        if (this.pollTimer) {
+            clearTimeout(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    /** Returns whether monitoring is currently active. */
+    isActive() {
+        return this.isRunning;
+    }
+    /** Add a hash to the seenHashes set, evicting the oldest entry if at capacity. */
+    addToSeenHashes(hash) {
+        if (this.seenHashes.size >= UserMessageDetector.MAX_SEEN_HASHES) {
+            // Evict the oldest entry (first inserted)
+            const oldest = this.seenHashes.values().next().value;
+            if (oldest !== undefined) {
+                this.seenHashes.delete(oldest);
+            }
+        }
+        this.seenHashes.add(hash);
+    }
+    /** Schedule the next poll. */
+    schedulePoll() {
+        if (!this.isRunning)
+            return;
+        this.pollTimer = setTimeout(async () => {
+            await this.poll();
+            if (this.isRunning) {
+                this.schedulePoll();
+            }
+        }, this.pollIntervalMs);
+    }
+    /**
+     * Single poll iteration:
+     *   1. Get latest user message from DOM
+     *   2. Check for duplicates and echoes
+     *   3. Notify via callback on new detection
+     */
+    async poll() {
+        try {
+            const contextId = this.cdpService.getPrimaryContextId();
+            const callParams = {
+                expression: DETECT_USER_MESSAGE_SCRIPT,
+                returnByValue: true,
+                awaitPromise: false,
+            };
+            if (contextId !== null) {
+                callParams.contextId = contextId;
+            }
+            const result = await this.cdpService.call('Runtime.evaluate', callParams);
+            const info = result?.result?.value ?? null;
+            // Clear priming flag even if DOM is empty (e.g., new/empty chat)
+            if (this.isPriming && (!info || !info.text)) {
+                this.isPriming = false;
+                logger_1.logger.debug('[UserMessageDetector] Primed with empty DOM');
+                return;
+            }
+            if (info && info.text) {
+                const hash = computeEchoHash(info.text);
+                const preview = info.text.slice(0, 40);
+                // First poll: seed the current DOM state without firing callback
+                if (this.isPriming) {
+                    this.isPriming = false;
+                    this.lastDetectedHash = hash;
+                    this.addToSeenHashes(hash);
+                    logger_1.logger.debug(`[UserMessageDetector] Primed with existing message: "${preview}..."`);
+                    return;
+                }
+                // Skip if same as last detected message
+                if (hash === this.lastDetectedHash)
+                    return;
+                // Skip if already seen (defense-in-depth dedup)
+                if (this.seenHashes.has(hash)) {
+                    logger_1.logger.debug(`[UserMessageDetector] seenHash hit, skipping: "${preview}..."`);
+                    this.lastDetectedHash = hash;
+                    return;
+                }
+                // Skip if this is an echo (sent by LazyGravity)
+                if (this.echoHashes.has(hash)) {
+                    logger_1.logger.debug(`[UserMessageDetector] Echo hash match, skipping: "${preview}..."`);
+                    this.lastDetectedHash = hash;
+                    this.addToSeenHashes(hash);
+                    return;
+                }
+                this.lastDetectedHash = hash;
+                this.addToSeenHashes(hash);
+                logger_1.logger.debug(`[UserMessageDetector] New message detected: "${preview}..."`);
+                this.onUserMessage(info);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes('WebSocket is not connected'))
+                return;
+            logger_1.logger.error('[UserMessageDetector] Error during polling:', error);
+        }
+    }
+}
+exports.UserMessageDetector = UserMessageDetector;

package/dist/ui/buttonUtils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disableAllButtons = disableAllButtons;
+const discord_js_1 = require("discord.js");
+/**
+ * Disable all buttons in the given message component rows.
+ * Returns new ActionRows with every button set to disabled.
+ */
+function disableAllButtons(components) {
+    return 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((btn) => btn !== null);
+        if (disabledButtons.length === 0)
+            return null;
+        nextRow.addComponents(...disabledButtons);
+        return nextRow;
+    })
+        .filter((row) => row !== null);
+}

package/dist/ui/modeUi.js

@@ -6,7 +6,17 @@ const modeService_1 = require("../services/modeService");
 /**
  * Build and send the interactive UI for the /mode command (dropdown style)
  */
-async function sendModeUI(target, modeService) {
+async function sendModeUI(target, modeService, deps) {
+    // If CDP is available, query the live mode and sync modeService
+    if (deps?.getCurrentCdp) {
+        const cdp = deps.getCurrentCdp();
+        if (cdp) {
+            const liveMode = await cdp.getCurrentMode();
+            if (liveMode) {
+                modeService.setMode(liveMode);
+            }
+        }
+    }
     const currentMode = modeService.getCurrentMode();
     const embed = new discord_js_1.EmbedBuilder()
         .setTitle('Mode Management')

package/dist/ui/modelsUi.js

@@ -1,23 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildModelsUI = buildModelsUI;
 exports.sendModelsUI = sendModelsUI;
 const discord_js_1 = require("discord.js");
 /**
- * Build and send the interactive UI for the /models command
+ * Build the embed + button components for the models UI.
+ * Returns null when CDP is unavailable or no models are found.
  */
-async function sendModelsUI(target, deps) {
-    const cdp = deps.getCurrentCdp();
-    if (!cdp) {
-        await target.editReply({ content: 'Not connected to CDP.' });
-        return;
-    }
+async function buildModelsUI(cdp, fetchQuota) {
     const models = await cdp.getUiModels();
     const currentModel = await cdp.getCurrentModel();
-    const quotaData = await deps.fetchQuota();
-    if (models.length === 0) {
-        await target.editReply({ content: 'Failed to retrieve model list from Antigravity.' });
-        return;
-    }
+    const quotaData = await fetchQuota();
+    if (models.length === 0)
+        return null;
     function formatQuota(mName, current) {
         if (!mName)
             return `${current ? '[x]' : '[ ]'} Unknown`;
@@ -93,5 +88,21 @@ async function sendModelsUI(target, deps) {
             rows.push(refreshRow);
         }
     }
-    await target.editReply({ content: '', embeds: [embed], components: rows });
+    return { embeds: [embed], components: rows };
+}
+/**
+ * Build and send the interactive UI for the /models command
+ */
+async function sendModelsUI(target, deps) {
+    const cdp = deps.getCurrentCdp();
+    if (!cdp) {
+        await target.editReply({ content: 'Not connected to CDP.' });
+        return;
+    }
+    const payload = await buildModelsUI(cdp, deps.fetchQuota);
+    if (!payload) {
+        await target.editReply({ content: 'Failed to retrieve model list from Antigravity.' });
+        return;
+    }
+    await target.editReply({ content: '', ...payload });
 }

package/dist/ui/outputUi.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTPUT_BTN_PLAIN = exports.OUTPUT_BTN_EMBED = void 0;
+exports.sendOutputUI = sendOutputUI;
+const discord_js_1 = require("discord.js");
+exports.OUTPUT_BTN_EMBED = 'output_btn_embed';
+exports.OUTPUT_BTN_PLAIN = 'output_btn_plain';
+async function sendOutputUI(target, currentFormat) {
+    const isEmbed = currentFormat === 'embed';
+    const embed = new discord_js_1.EmbedBuilder()
+        .setTitle('Output Format')
+        .setColor(isEmbed ? 0x5865F2 : 0x2ECC71)
+        .setDescription(`**Current Format:** ${isEmbed ? '📋 Embed' : '📝 Plain Text'}\n\n` +
+        'Embed: Rich formatting with colored borders (default).\n' +
+        'Plain Text: Simple text output, easy to copy on mobile.')
+        .setFooter({ text: 'Use buttons below to change format' })
+        .setTimestamp();
+    const row = new discord_js_1.ActionRowBuilder().addComponents(new discord_js_1.ButtonBuilder()
+        .setCustomId(exports.OUTPUT_BTN_EMBED)
+        .setLabel('Embed')
+        .setStyle(isEmbed ? discord_js_1.ButtonStyle.Primary : discord_js_1.ButtonStyle.Secondary), new discord_js_1.ButtonBuilder()
+        .setCustomId(exports.OUTPUT_BTN_PLAIN)
+        .setLabel('Plain Text')
+        .setStyle(!isEmbed ? discord_js_1.ButtonStyle.Success : discord_js_1.ButtonStyle.Secondary));
+    await target.editReply({
+        content: '',
+        embeds: [embed],
+        components: [row],
+    });
+}

package/dist/ui/projectListUi.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ITEMS_PER_PAGE = exports.PROJECT_PAGE_PREFIX = exports.WORKSPACE_SELECT_ID = exports.PROJECT_SELECT_ID = void 0;
+exports.parseProjectPageId = parseProjectPageId;
+exports.isProjectSelectId = isProjectSelectId;
+exports.buildProjectListUI = buildProjectListUI;
+const discord_js_1 = require("discord.js");
+const i18n_1 = require("../utils/i18n");
+/** Select menu custom ID (legacy, page 0) */
+exports.PROJECT_SELECT_ID = 'project_select';
+/** Backward compatibility: also accept old ID */
+exports.WORKSPACE_SELECT_ID = 'workspace_select';
+/** Button customId prefix for page navigation. Format: project_page:<page> */
+exports.PROJECT_PAGE_PREFIX = 'project_page';
+/** Maximum items per page (Discord select menu limit) */
+exports.ITEMS_PER_PAGE = 25;
+/**
+ * Parse page number from a page-button customId.
+ * Returns NaN if the customId does not match the expected format.
+ */
+function parseProjectPageId(customId) {
+    if (!customId.startsWith(`${exports.PROJECT_PAGE_PREFIX}:`))
+        return NaN;
+    return parseInt(customId.slice(exports.PROJECT_PAGE_PREFIX.length + 1), 10);
+}
+/**
+ * Check if a customId belongs to a project select menu.
+ * Matches legacy IDs (`project_select`, `workspace_select`) and
+ * paginated IDs (`project_select:<page>`).
+ */
+function isProjectSelectId(customId) {
+    return (customId === exports.PROJECT_SELECT_ID ||
+        customId === exports.WORKSPACE_SELECT_ID ||
+        customId.startsWith(`${exports.PROJECT_SELECT_ID}:`));
+}
+/**
+ * Build the project list UI with select menu and optional Prev/Next buttons.
+ *
+ * @param workspaces - Full list of workspace names
+ * @param page - Zero-based page index (clamped to valid range)
+ * @returns Object with embeds and components arrays ready for Discord reply
+ */
+function buildProjectListUI(workspaces, page = 0) {
+    const totalPages = Math.max(1, Math.ceil(workspaces.length / exports.ITEMS_PER_PAGE));
+    const safePage = Math.max(0, Math.min(page, totalPages - 1));
+    const embed = new discord_js_1.EmbedBuilder()
+        .setTitle('\u{1F4C1} Projects')
+        .setColor(0x5865F2)
+        .setDescription((0, i18n_1.t)('Select a project to auto-create a category and session channel'))
+        .setTimestamp();
+    if (workspaces.length === 0) {
+        return { embeds: [embed], components: [] };
+    }
+    const start = safePage * exports.ITEMS_PER_PAGE;
+    const end = Math.min(start + exports.ITEMS_PER_PAGE, workspaces.length);
+    const pageItems = workspaces.slice(start, end);
+    if (totalPages > 1) {
+        embed.setFooter({
+            text: `Page ${safePage + 1} / ${totalPages} (${workspaces.length} projects total)`,
+        });
+    }
+    const components = [];
+    const options = pageItems.map((ws) => ({ label: ws, value: ws }));
+    const selectMenu = new discord_js_1.StringSelectMenuBuilder()
+        .setCustomId(`${exports.PROJECT_SELECT_ID}:${safePage}`)
+        .setPlaceholder((0, i18n_1.t)('Select a project...'))
+        .addOptions(options);
+    components.push(new discord_js_1.ActionRowBuilder().addComponents(selectMenu));
+    if (totalPages > 1) {
+        const prevBtn = new discord_js_1.ButtonBuilder()
+            .setCustomId(`${exports.PROJECT_PAGE_PREFIX}:${Math.max(0, safePage - 1)}`)
+            .setLabel('\u25C0 Prev')
+            .setStyle(discord_js_1.ButtonStyle.Secondary)
+            .setDisabled(safePage === 0);
+        const nextBtn = new discord_js_1.ButtonBuilder()
+            .setCustomId(`${exports.PROJECT_PAGE_PREFIX}:${safePage + 1}`)
+            .setLabel('Next \u25B6')
+            .setStyle(discord_js_1.ButtonStyle.Secondary)
+            .setDisabled(safePage >= totalPages - 1);
+        components.push(new discord_js_1.ActionRowBuilder().addComponents(prevBtn, nextBtn));
+    }
+    return { embeds: [embed], components };
+}

package/dist/ui/sessionPickerUi.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_SELECT_ID = void 0;
+exports.isSessionSelectId = isSessionSelectId;
+exports.buildSessionPickerUI = buildSessionPickerUI;
+const discord_js_1 = require("discord.js");
+const i18n_1 = require("../utils/i18n");
+/** Select menu custom ID for session picker */
+exports.SESSION_SELECT_ID = 'session_select';
+/** Maximum items per select menu (Discord limit) */
+const MAX_SELECT_OPTIONS = 25;
+/**
+ * Check if a customId belongs to the session select menu.
+ */
+function isSessionSelectId(customId) {
+    return customId === exports.SESSION_SELECT_ID;
+}
+/**
+ * Build the session picker UI with a select menu.
+ *
+ * @param sessions - List of sessions from the side panel
+ * @returns Object with embeds and components arrays ready for Discord reply
+ */
+function buildSessionPickerUI(sessions) {
+    const embed = new discord_js_1.EmbedBuilder()
+        .setTitle((0, i18n_1.t)('🔗 Join Session'))
+        .setColor(0x5865F2)
+        .setTimestamp();
+    if (sessions.length === 0) {
+        embed.setDescription((0, i18n_1.t)('No sessions found in the Antigravity side panel.'));
+        return { embeds: [embed], components: [] };
+    }
+    embed.setDescription((0, i18n_1.t)(`Select a session to join (${sessions.length} found)`));
+    const pageItems = sessions.slice(0, MAX_SELECT_OPTIONS);
+    const options = pageItems.map((session) => ({
+        label: session.title.slice(0, 100),
+        value: session.title.slice(0, 100),
+        description: session.isActive ? (0, i18n_1.t)('Current') : undefined,
+    }));
+    const selectMenu = new discord_js_1.StringSelectMenuBuilder()
+        .setCustomId(exports.SESSION_SELECT_ID)
+        .setPlaceholder((0, i18n_1.t)('Select a session...'))
+        .addOptions(options);
+    const components = [
+        new discord_js_1.ActionRowBuilder().addComponents(selectMenu),
+    ];
+    return { embeds: [embed], components };
+}