lazy-gravity 0.1.0 → 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/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/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/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 };
+}

package/dist/utils/antigravityPaths.js

@@ -0,0 +1,94 @@
+"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.getAntigravityCliPath = getAntigravityCliPath;
+exports.getAntigravityFallback = getAntigravityFallback;
+exports.getAntigravityCdpHint = getAntigravityCdpHint;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const APP_NAME = 'Antigravity';
+/**
+ * Get the Antigravity CLI binary path for the current platform.
+ *
+ * - macOS: /Applications/Antigravity.app/Contents/Resources/app/bin/antigravity
+ * - Windows: %LOCALAPPDATA%\Programs\Antigravity\Antigravity.exe
+ * - Linux: antigravity (assumed in PATH)
+ */
+function getAntigravityCliPath() {
+    switch (process.platform) {
+        case 'darwin':
+            return '/Applications/Antigravity.app/Contents/Resources/app/bin/antigravity';
+        case 'win32': {
+            const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+            return path.join(localAppData, 'Programs', APP_NAME, `${APP_NAME}.exe`);
+        }
+        default:
+            return APP_NAME.toLowerCase();
+    }
+}
+/**
+ * Get fallback launch command and args for opening a workspace.
+ *
+ * - macOS: open -a Antigravity <path>
+ * - Windows: use full exe path with shell (handles spaces in paths)
+ * - Linux: antigravity <path>
+ */
+function getAntigravityFallback(workspacePath) {
+    switch (process.platform) {
+        case 'darwin':
+            return { command: 'open', args: ['-a', APP_NAME, workspacePath] };
+        case 'win32': {
+            const exePath = getAntigravityCliPath();
+            return { command: exePath, args: [workspacePath], options: { shell: true } };
+        }
+        default:
+            return { command: APP_NAME.toLowerCase(), args: [workspacePath] };
+    }
+}
+/**
+ * Get a platform-appropriate hint for starting Antigravity with CDP.
+ *
+ * Used in user-facing messages (Discord embeds, CLI doctor, logs).
+ */
+function getAntigravityCdpHint(port = 9222) {
+    switch (process.platform) {
+        case 'darwin':
+            return `open -a ${APP_NAME} --args --remote-debugging-port=${port}`;
+        case 'win32':
+            return `${APP_NAME}.exe --remote-debugging-port=${port}`;
+        default:
+            return `${APP_NAME.toLowerCase()} --remote-debugging-port=${port}`;
+    }
+}

package/dist/utils/configLoader.js

@@ -92,6 +92,7 @@ function mergeConfig(persisted) {
     const workspaceBaseDir = expandTilde(rawDir);
     const guildId = process.env.GUILD_ID ?? persisted.guildId ?? undefined;
     const autoApproveFileEdits = resolveBoolean(process.env.AUTO_APPROVE_FILE_EDITS, persisted.autoApproveFileEdits, false);
+    const logLevel = resolveLogLevel(process.env.LOG_LEVEL, persisted.logLevel);
     const extractionMode = resolveExtractionMode(process.env.EXTRACTION_MODE, persisted.extractionMode);
     return {
         discordToken: token,
@@ -100,6 +101,7 @@ function mergeConfig(persisted) {
         allowedUserIds,
         workspaceBaseDir,
         autoApproveFileEdits,
+        logLevel,
         extractionMode,
     };
 }
@@ -116,6 +118,14 @@ function resolveAllowedUserIds(persisted) {
     }
     return [];
 }
+const VALID_LOG_LEVELS = ['debug', 'info', 'warn', 'error', 'none'];
+function resolveLogLevel(envValue, persistedValue) {
+    const raw = envValue?.toLowerCase() ?? persistedValue;
+    if (raw && VALID_LOG_LEVELS.includes(raw)) {
+        return raw;
+    }
+    return 'info';
+}
 function resolveExtractionMode(envValue, persistedValue) {
     const raw = envValue ?? persistedValue;
     if (raw === 'legacy')

package/dist/utils/discordButtonUtils.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 message component rows.
+ * Shared utility used by interaction handlers and detector callbacks.
+ */
+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((button) => button !== null);
+        if (disabledButtons.length === 0)
+            return null;
+        nextRow.addComponents(...disabledButtons);
+        return nextRow;
+    })
+        .filter((row) => row !== null);
+}

package/dist/utils/logBuffer.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logBuffer = exports.LogBuffer = void 0;
+const MAX_ENTRIES = 200;
+// Strip ANSI escape codes for clean buffer storage
+const ANSI_REGEX = /\x1b\[[0-9;]*m/g;
+function stripAnsi(text) {
+    return text.replace(ANSI_REGEX, '');
+}
+class LogBuffer {
+    buffer = [];
+    head = 0;
+    count = 0;
+    append(level, message) {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            message: stripAnsi(message),
+        };
+        if (this.count < MAX_ENTRIES) {
+            this.buffer.push(entry);
+            this.count++;
+        }
+        else {
+            this.buffer[this.head] = entry;
+        }
+        this.head = (this.head + 1) % MAX_ENTRIES;
+    }
+    getRecent(count, levelFilter) {
+        const all = [];
+        for (let i = 0; i < this.count; i++) {
+            const idx = (this.head - this.count + i + MAX_ENTRIES * 2) % MAX_ENTRIES;
+            all.push(this.buffer[idx]);
+        }
+        const filtered = levelFilter
+            ? all.filter((e) => e.level === levelFilter)
+            : all;
+        return filtered.slice(-count);
+    }
+    clear() {
+        this.buffer.length = 0;
+        this.head = 0;
+        this.count = 0;
+    }
+}
+exports.LogBuffer = LogBuffer;
+exports.logBuffer = new LogBuffer();