lazy-gravity 0.6.2 → 0.7.1

package/dist/services/chatSessionService.js

@@ -30,6 +30,56 @@ const GET_CHAT_TITLE_SCRIPT = `(() => {
     const hasActiveChat = title.length > 0 && title !== 'Agent';
     return { title: title || '(Untitled)', hasActiveChat };
 })()`;
+const GET_SESSION_VIEW_STATE_SCRIPT = `(() => {
+    const panel = document.querySelector('.antigravity-agent-side-panel');
+    if (!panel) {
+        return {
+            panelFound: false,
+            title: '',
+            hasActiveChat: false,
+            hasLoadingIndicator: false,
+            hasRenderableContent: false,
+            renderablePreview: [],
+        };
+    }
+    const header = panel.querySelector('div[class*="border-b"]');
+    const titleEl = header?.querySelector('div[class*="text-ellipsis"]');
+    const title = titleEl ? (titleEl.textContent || '').trim() : '';
+    const hasActiveChat = title.length > 0 && title !== 'Agent';
+
+    const bodyCandidates = Array.from(panel.querySelectorAll(
+        '[data-message-author-role], [data-message-role], .rendered-markdown, .prose'
+    ));
+    const renderablePreview = bodyCandidates.filter((el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const text = (el.textContent || '').trim();
+        if (el.offsetParent === null || text.length === 0) return false;
+        if (/^\\/\\*\\s*Copied from /i.test(text)) return false;
+        return true;
+    }).slice(0, 5).map((el) => ({
+        tag: el.tagName,
+        className: el.className || '',
+        text: ((el.textContent || '').trim()).slice(0, 160),
+    }));
+    const hasRenderableContent = renderablePreview.length > 0;
+
+    const hasLoadingIndicator = Boolean(
+        panel.querySelector(
+            '[role="progressbar"], ' +
+            'svg[class*="animate-spin"], div[class*="animate-spin"], ' +
+            'svg[class*="spinner"], div[class*="spinner"], div[class*="loading"]'
+        )
+    );
+
+    return {
+        panelFound: true,
+        title: title || '(Untitled)',
+        hasActiveChat,
+        hasLoadingIndicator,
+        hasRenderableContent,
+        renderablePreview,
+    };
+})()`;
 /**
  * Script to find the Past Conversations button and return its coordinates.
  * We use coordinates so that the actual click is done via CDP Input.dispatchMouseEvent,
@@ -432,6 +482,10 @@ class ChatSessionService {
     static ACTIVATE_SESSION_MAX_WAIT_MS = 30000;
     static ACTIVATE_SESSION_RETRY_INTERVAL_MS = 800;
     static LIST_SESSIONS_TARGET = 20;
+    static HYDRATE_RETRY_DELAY_MS = 700;
+    static REOPEN_RETRY_ATTEMPTS = 4;
+    static REOPEN_NEW_CHAT_DELAY_MS = 400;
+    static REOPEN_HISTORY_DELAY_MS = 1000;
     /**
      * List recent sessions by opening the Past Conversations panel.
      *
@@ -556,6 +610,25 @@ class ChatSessionService {
             type: 'mouseReleased', x, y, button: 'left', clickCount: 1,
         });
     }
+    async dispatchNewConversationShortcut(cdpService) {
+        const modifiers = process.platform === 'darwin' ? 8 : 10;
+        await cdpService.call('Input.dispatchKeyEvent', {
+            type: 'keyDown',
+            key: 'L',
+            code: 'KeyL',
+            modifiers,
+            windowsVirtualKeyCode: 76,
+            nativeVirtualKeyCode: 76,
+        });
+        await cdpService.call('Input.dispatchKeyEvent', {
+            type: 'keyUp',
+            key: 'L',
+            code: 'KeyL',
+            modifiers,
+            windowsVirtualKeyCode: 76,
+            nativeVirtualKeyCode: 76,
+        });
+    }
     /**
      * Start a new chat session in the Antigravity UI.
      *
@@ -597,27 +670,23 @@ class ChatSessionService {
             if (!btnState.enabled) {
                 return { ok: true };
             }
-            // cursor: pointer -> click via CDP Input API coordinates
-            await cdpService.call('Input.dispatchMouseEvent', {
-                type: 'mouseMoved', x: btnState.x, y: btnState.y,
-            });
-            await cdpService.call('Input.dispatchMouseEvent', {
-                type: 'mousePressed', x: btnState.x, y: btnState.y,
-                button: 'left', clickCount: 1,
-            });
-            await cdpService.call('Input.dispatchMouseEvent', {
-                type: 'mouseReleased', x: btnState.x, y: btnState.y,
-                button: 'left', clickCount: 1,
-            });
-            // Wait for UI to update after click
+            // Prefer the keyboard shortcut because some Antigravity builds bind hover tips to the button target.
+            await this.dispatchNewConversationShortcut(cdpService);
+            // Wait for UI to update after shortcut
             await new Promise(r => setTimeout(r, 1500));
             // Check if button changed to not-allowed (evidence that a new chat was opened)
             const afterState = await this.getNewChatButtonState(cdpService, contexts);
             if (afterState.found && !afterState.enabled) {
                 return { ok: true };
             }
-            // Button still enabled -> click may not have worked
-            return { ok: false, error: 'Clicked new chat button but state did not change' };
+            // Fallback for older builds where the shortcut is not wired.
+            await this.cdpMouseClick(cdpService, btnState.x, btnState.y);
+            await new Promise(r => setTimeout(r, 1500));
+            const afterFallback = await this.getNewChatButtonState(cdpService, contexts);
+            if (afterFallback.found && !afterFallback.enabled) {
+                return { ok: true };
+            }
+            return { ok: false, error: 'New conversation shortcut and button click did not change state' };
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -655,6 +724,104 @@ class ChatSessionService {
             return { title: '(Failed to retrieve)', hasActiveChat: false };
         }
     }
+    async getCurrentSessionViewState(cdpService) {
+        try {
+            const contexts = cdpService.getContexts();
+            for (const ctx of contexts) {
+                try {
+                    const result = await cdpService.call('Runtime.evaluate', {
+                        expression: GET_SESSION_VIEW_STATE_SCRIPT,
+                        returnByValue: true,
+                        contextId: ctx.id,
+                    });
+                    const value = result?.result?.value;
+                    const hasPanel = value?.panelFound === true;
+                    const looksUseful = Boolean(hasPanel ||
+                        value?.hasLoadingIndicator ||
+                        value?.hasRenderableContent ||
+                        (typeof value?.title === 'string' && value.title.trim().length > 0));
+                    if (value && looksUseful) {
+                        return {
+                            title: value.title,
+                            hasActiveChat: value.hasActiveChat ?? false,
+                            panelFound: value.panelFound ?? false,
+                            hasLoadingIndicator: value.hasLoadingIndicator ?? false,
+                            hasRenderableContent: value.hasRenderableContent ?? false,
+                            renderablePreview: Array.isArray(value.renderablePreview) ? value.renderablePreview : [],
+                        };
+                    }
+                }
+                catch (_) { /* try next context */ }
+            }
+        }
+        catch (_) { /* fall through */ }
+        return {
+            title: '(Failed to retrieve)',
+            hasActiveChat: false,
+            panelFound: false,
+            hasLoadingIndicator: false,
+            hasRenderableContent: false,
+            renderablePreview: [],
+        };
+    }
+    async refreshSessionViewIfStuck(cdpService, title) {
+        const state = await this.getCurrentSessionViewState(cdpService);
+        if (state.title.trim() !== title.trim()) {
+            return { ok: false, error: `Current title mismatch before refresh (expected="${title}", actual="${state.title}")` };
+        }
+        if (!state.hasLoadingIndicator && state.hasRenderableContent) {
+            return { ok: true };
+        }
+        const bounce = await this.recoverSessionViewWithNewConversationBounce(cdpService, title);
+        if (bounce.ok) {
+            return bounce;
+        }
+        return {
+            ok: false,
+            error: `Session "${title}" still appears stuck after new-conversation recovery ` +
+                `(${bounce.error || 'unknown'})`,
+        };
+    }
+    async recoverSessionViewWithNewConversationBounce(cdpService, title, options) {
+        const state = await this.getCurrentSessionViewState(cdpService);
+        if (state.title.trim() === title.trim() && !state.hasLoadingIndicator && state.hasRenderableContent) {
+            return { ok: true };
+        }
+        const maxAttempts = options?.maxAttempts ?? ChatSessionService.REOPEN_RETRY_ATTEMPTS;
+        const newChatDelayMs = options?.newChatDelayMs ?? ChatSessionService.REOPEN_NEW_CHAT_DELAY_MS;
+        const reopenDelayMs = options?.reopenDelayMs ?? ChatSessionService.REOPEN_HISTORY_DELAY_MS;
+        let lastError = `Session "${title}" still appears stuck before recovery`;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            const newChat = await this.startNewChat(cdpService);
+            if (!newChat.ok) {
+                lastError =
+                    `Attempt ${attempt}/${maxAttempts}: failed to open a fresh new conversation before reopening "${title}": ` +
+                        `${newChat.error || 'unknown'}`;
+                continue;
+            }
+            await new Promise((resolve) => setTimeout(resolve, newChatDelayMs));
+            const reopened = await this.activateSessionByTitle(cdpService, title, {
+                maxWaitMs: 8000,
+                retryIntervalMs: 300,
+                allowVisibilityWarmupMs: 1000,
+            });
+            if (!reopened.ok) {
+                lastError =
+                    `Attempt ${attempt}/${maxAttempts}: failed to reopen "${title}" after new conversation: ` +
+                        `${reopened.error || 'unknown'}`;
+                continue;
+            }
+            await new Promise((resolve) => setTimeout(resolve, reopenDelayMs));
+            const after = await this.getCurrentSessionViewState(cdpService);
+            if (after.title.trim() === title.trim() && (!after.hasLoadingIndicator || after.hasRenderableContent)) {
+                return { ok: true };
+            }
+            lastError =
+                `Attempt ${attempt}/${maxAttempts}: session "${title}" still appears stuck after reopening ` +
+                    `(loading=${after.hasLoadingIndicator}, content=${after.hasRenderableContent}, actual="${after.title}")`;
+        }
+        return { ok: false, error: lastError };
+    }
     /**
      * Activate an existing chat by title.
      * Returns ok:false if the target chat cannot be located or verified.
@@ -669,12 +836,14 @@ class ChatSessionService {
         }
         const maxWaitMs = options?.maxWaitMs ?? ChatSessionService.ACTIVATE_SESSION_MAX_WAIT_MS;
         const retryIntervalMs = options?.retryIntervalMs ?? ChatSessionService.ACTIVATE_SESSION_RETRY_INTERVAL_MS;
+        const allowVisibilityWarmupMs = options?.allowVisibilityWarmupMs ?? 0;
         let usedPastConversations = false;
         let directResult = { ok: false, error: 'not attempted' };
         let pastResult = null;
         let clicked = false;
-        const startedAt = Date.now();
+        let startedAt = Date.now();
         let attempts = 0;
+        let warmupConsumed = false;
         while (Date.now() - startedAt <= maxWaitMs) {
             attempts += 1;
             directResult = await this.tryActivateByDirectSidePanel(cdpService, title);
@@ -704,8 +873,21 @@ class ChatSessionService {
         await new Promise((resolve) => setTimeout(resolve, 500));
         const after = await this.getCurrentSessionInfo(cdpService);
         if (after.title.trim() === title.trim()) {
+            if (usedPastConversations) {
+                await this.closePanelWithEscape(cdpService);
+            }
             return { ok: true };
         }
+        if (!warmupConsumed && allowVisibilityWarmupMs > 0 && after.title.trim() === 'Agent') {
+            warmupConsumed = true;
+            startedAt = Date.now();
+            await new Promise((resolve) => setTimeout(resolve, allowVisibilityWarmupMs));
+            return this.activateSessionByTitle(cdpService, title, {
+                maxWaitMs,
+                retryIntervalMs,
+                allowVisibilityWarmupMs: 0,
+            });
+        }
         // If direct side-panel activation hit the wrong row, try the explicit Past Conversations flow.
         if (!usedPastConversations) {
             const viaPast = await this.tryActivateByPastConversations(cdpService, title);
@@ -713,6 +895,7 @@ class ChatSessionService {
                 await new Promise((resolve) => setTimeout(resolve, 500));
                 const afterPast = await this.getCurrentSessionInfo(cdpService);
                 if (afterPast.title.trim() === title.trim()) {
+                    await this.closePanelWithEscape(cdpService);
                     return { ok: true };
                 }
                 return {

package/dist/services/userMessageDetector.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserMessageDetector = void 0;
+const events_1 = require("events");
 const node_crypto_1 = require("node:crypto");
 const logger_1 = require("../utils/logger");
 /**
@@ -74,10 +75,9 @@ function computeEchoHash(text) {
  * Detects user messages posted directly in the Antigravity UI (e.g., from a PC).
  * Follows the ApprovalDetector polling pattern.
  */
-class UserMessageDetector {
+class UserMessageDetector extends events_1.EventEmitter {
     cdpService;
     pollIntervalMs;
-    onUserMessage;
     pollTimer = null;
     isRunning = false;
     /** Hash of the last detected message (for duplicate prevention) */
@@ -90,9 +90,9 @@ class UserMessageDetector {
     /** True during the first poll — seeds existing DOM state without firing callback */
     isPriming = false;
     constructor(options) {
+        super();
         this.cdpService = options.cdpService;
         this.pollIntervalMs = options.pollIntervalMs ?? 2000;
-        this.onUserMessage = options.onUserMessage;
     }
     /**
      * Register a message hash as an echo (sent by LazyGravity).
@@ -207,7 +207,7 @@ class UserMessageDetector {
                 this.lastDetectedHash = hash;
                 this.addToSeenHashes(hash);
                 logger_1.logger.debug(`[UserMessageDetector] New message detected: "${preview}..."`);
-                this.onUserMessage(info);
+                this.emit('message', info);
             }
         }
         catch (error) {

package/dist/ui/accountUi.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACCOUNT_SELECT_ID = void 0;
+exports.buildAccountPayload = buildAccountPayload;
+exports.sendAccountUI = sendAccountUI;
+const discord_js_1 = require("discord.js");
+const richContentBuilder_1 = require("../platform/richContentBuilder");
+exports.ACCOUNT_SELECT_ID = 'account_select';
+function buildAccountPayload(currentAccount, accountNames) {
+    const names = accountNames.length > 0 ? accountNames : ['default'];
+    const rc = (0, richContentBuilder_1.withTimestamp)((0, richContentBuilder_1.withFooter)((0, richContentBuilder_1.withDescription)((0, richContentBuilder_1.withColor)((0, richContentBuilder_1.withTitle)((0, richContentBuilder_1.createRichContent)(), 'Account Management'), 0x57F287), `**Current Account:** ${currentAccount}\n\n` +
+        `**Available Accounts (${names.length})**\n` +
+        names.map((name) => {
+            const icon = name === currentAccount ? '[x]' : '[ ]';
+            return `${icon} **${name}**`;
+        }).join('\n')), 'Select an account from the dropdown below'));
+    return {
+        richContent: rc,
+        components: [
+            {
+                components: [
+                    {
+                        type: 'selectMenu',
+                        customId: exports.ACCOUNT_SELECT_ID,
+                        placeholder: 'Select an account...',
+                        options: names.map((name) => ({
+                            label: name,
+                            value: name,
+                            isDefault: name === currentAccount,
+                        })),
+                    },
+                ],
+            },
+        ],
+    };
+}
+async function sendAccountUI(target, currentAccount, accountNames) {
+    const names = accountNames.length > 0 ? accountNames : ['default'];
+    const embed = new discord_js_1.EmbedBuilder()
+        .setTitle('Account Management')
+        .setColor(0x57F287)
+        .setDescription(`**Current Account:** ${currentAccount}\n\n` +
+        `**Available Accounts (${names.length})**\n` +
+        names.map((name) => {
+            const icon = name === currentAccount ? '[x]' : '[ ]';
+            return `${icon} **${name}**`;
+        }).join('\n'))
+        .setFooter({ text: 'Select an account from the dropdown below' })
+        .setTimestamp();
+    const selectMenu = new discord_js_1.StringSelectMenuBuilder()
+        .setCustomId(exports.ACCOUNT_SELECT_ID)
+        .setPlaceholder('Select an account...')
+        .addOptions(names.map((name) => ({
+        label: name,
+        value: name,
+        default: name === currentAccount,
+    })));
+    const row = new discord_js_1.ActionRowBuilder().addComponents(selectMenu);
+    await target.editReply({ content: '', embeds: [embed], components: [row] });
+}

package/dist/utils/accountUtils.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveValidAccountName = resolveValidAccountName;
+exports.listAccountNames = listAccountNames;
+exports.inferParentScopeChannelId = inferParentScopeChannelId;
+exports.resolveScopedAccountName = resolveScopedAccountName;
+function resolveValidAccountName(requested, accounts) {
+    const safeAccounts = accounts && accounts.length > 0 ? accounts : [{ name: 'default', cdpPort: 9222 }];
+    if (!requested)
+        return safeAccounts[0].name;
+    return safeAccounts.some((account) => account.name === requested) ? requested : safeAccounts[0].name;
+}
+function listAccountNames(accounts) {
+    const safeAccounts = accounts && accounts.length > 0 ? accounts : [{ name: 'default', cdpPort: 9222 }];
+    return safeAccounts.map((account) => account.name);
+}
+function inferParentScopeChannelId(channelId, explicitParentChannelId) {
+    if (explicitParentChannelId && explicitParentChannelId.trim().length > 0) {
+        return explicitParentChannelId.trim();
+    }
+    const underscoreIndex = channelId.indexOf('_');
+    if (underscoreIndex > 0) {
+        return channelId.slice(0, underscoreIndex);
+    }
+    return null;
+}
+function resolveScopedAccountName(options) {
+    const parentChannelId = inferParentScopeChannelId(options.channelId, options.parentChannelId);
+    return resolveValidAccountName(options.sessionAccountName
+        ?? options.selectedAccountByChannel?.get(options.channelId)
+        ?? options.channelPrefRepo?.getAccountName(options.channelId)
+        ?? (parentChannelId ? options.selectedAccountByChannel?.get(parentChannelId) : null)
+        ?? (parentChannelId ? options.channelPrefRepo?.getAccountName(parentChannelId) : null)
+        ?? options.accountPrefRepo?.getAccountName(options.userId)
+        ?? 'default', options.accounts);
+}

package/dist/utils/cdpPorts.js

@@ -1,5 +1,100 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CDP_PORTS = void 0;
+exports.CDP_PORTS = exports.DEFAULT_CDP_PORTS = void 0;
+exports.normalizeAntigravityAccounts = normalizeAntigravityAccounts;
+exports.parseAntigravityAccounts = parseAntigravityAccounts;
+exports.serializeAntigravityAccounts = serializeAntigravityAccounts;
+exports.getConfiguredCdpPorts = getConfiguredCdpPorts;
+exports.getAccountPortMap = getAccountPortMap;
+/** Default CDP port list scanned for Antigravity connections. */
+exports.DEFAULT_CDP_PORTS = [9222, 9223, 9333, 9444, 9555, 9666];
+function parsePort(raw) {
+    const port = Number(raw);
+    if (!Number.isInteger(port))
+        return null;
+    if (port < 1 || port > 65535)
+        return null;
+    return port;
+}
+function normalizeAntigravityAccounts(accounts) {
+    if (!accounts || accounts.length === 0) {
+        return [{ name: 'default', cdpPort: exports.DEFAULT_CDP_PORTS[0] }];
+    }
+    const seenNames = new Set();
+    const normalized = [];
+    for (const account of accounts) {
+        const name = String(account.name || '').trim();
+        const cdpPort = parsePort(String(account.cdpPort));
+        if (!name || cdpPort === null || seenNames.has(name))
+            continue;
+        seenNames.add(name);
+        const userDataDir = typeof account.userDataDir === 'string'
+            ? account.userDataDir.trim()
+            : '';
+        normalized.push({
+            name,
+            cdpPort,
+            ...(userDataDir ? { userDataDir } : {}),
+        });
+    }
+    return normalized.length > 0
+        ? normalized
+        : [{ name: 'default', cdpPort: exports.DEFAULT_CDP_PORTS[0] }];
+}
+function parseAntigravityAccounts(rawValue) {
+    if (!rawValue || rawValue.trim().length === 0) {
+        return [{ name: 'default', cdpPort: exports.DEFAULT_CDP_PORTS[0] }];
+    }
+    const parsed = rawValue
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0)
+        .map((entry) => {
+        const colonIndex = entry.indexOf(':');
+        if (colonIndex <= 0)
+            return null;
+        const name = entry.slice(0, colonIndex).trim();
+        const rest = entry.slice(colonIndex + 1).trim();
+        const atIndex = rest.indexOf('@');
+        const portRaw = atIndex >= 0 ? rest.slice(0, atIndex).trim() : rest;
+        const userDataDirRaw = atIndex >= 0 ? rest.slice(atIndex + 1).trim() : '';
+        const cdpPort = parsePort(portRaw);
+        if (!name || cdpPort === null)
+            return null;
+        return {
+            name,
+            cdpPort,
+            ...(userDataDirRaw ? { userDataDir: userDataDirRaw } : {}),
+        };
+    })
+        .filter((account) => account !== null);
+    return normalizeAntigravityAccounts(parsed);
+}
+function serializeAntigravityAccounts(accounts) {
+    return normalizeAntigravityAccounts(accounts)
+        .map((account) => {
+        const userDataDir = typeof account.userDataDir === 'string'
+            ? account.userDataDir.trim()
+            : '';
+        return userDataDir
+            ? `${account.name}:${account.cdpPort}@${userDataDir}`
+            : `${account.name}:${account.cdpPort}`;
+    })
+        .join(',');
+}
+function getConfiguredCdpPorts(rawValue) {
+    if (!rawValue || rawValue.trim().length === 0) {
+        return [...exports.DEFAULT_CDP_PORTS];
+    }
+    const accounts = parseAntigravityAccounts(rawValue);
+    const uniquePorts = new Set();
+    for (const account of accounts) {
+        uniquePorts.add(account.cdpPort);
+    }
+    return uniquePorts.size > 0 ? [...uniquePorts] : [...exports.DEFAULT_CDP_PORTS];
+}
+function getAccountPortMap(rawValue) {
+    return Object.fromEntries(parseAntigravityAccounts(rawValue).map((account) => [account.name, account.cdpPort]));
+}
 /** CDP port list scanned for Antigravity connections */
-exports.CDP_PORTS = [9222, 9223, 9333, 9444, 9555, 9666];
+exports.CDP_PORTS = exports.DEFAULT_CDP_PORTS;

package/dist/utils/configLoader.js

@@ -38,6 +38,7 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const dotenv = __importStar(require("dotenv"));
+const cdpPorts_1 = require("./cdpPorts");
 // Load .env at module init time (same as the original config.ts behavior).
 // dotenv will NOT override already-set env vars by default.
 dotenv.config();
@@ -103,6 +104,7 @@ function mergeConfig(persisted) {
     const logLevel = resolveLogLevel(process.env.LOG_LEVEL, persisted.logLevel);
     const extractionMode = resolveExtractionMode(process.env.EXTRACTION_MODE, persisted.extractionMode);
     const responseTimeoutMs = resolvePositiveInt(process.env.RESPONSE_TIMEOUT_MS, persisted.responseTimeoutMs, 900000);
+    const antigravityAccounts = resolveAntigravityAccounts(process.env.ANTIGRAVITY_ACCOUNTS, persisted.antigravityAccounts);
     // Telegram credentials — only required when Telegram is an active platform
     const telegramToken = process.env.TELEGRAM_BOT_TOKEN ?? persisted.telegramToken ?? undefined;
     const telegramAllowedUserIds = resolveTelegramAllowedUserIds(persisted);
@@ -119,6 +121,7 @@ function mergeConfig(persisted) {
         logLevel,
         extractionMode,
         responseTimeoutMs,
+        antigravityAccounts,
         telegramToken,
         telegramAllowedUserIds,
         platforms,
@@ -164,6 +167,17 @@ function resolveTelegramAllowedUserIds(persisted) {
     }
     return undefined;
 }
+function resolveAntigravityAccounts(envValue, persistedValue) {
+    if (envValue && envValue.trim().length > 0) {
+        return (0, cdpPorts_1.parseAntigravityAccounts)(envValue);
+    }
+    if (typeof persistedValue === 'string' && persistedValue.trim().length > 0) {
+        return (0, cdpPorts_1.parseAntigravityAccounts)(persistedValue);
+    }
+    return Array.isArray(persistedValue)
+        ? (0, cdpPorts_1.normalizeAntigravityAccounts)(persistedValue)
+        : (0, cdpPorts_1.normalizeAntigravityAccounts)(undefined);
+}
 const VALID_PLATFORMS = ['discord', 'telegram'];
 function resolvePlatforms(envValue, persistedValue) {
     if (envValue) {

package/dist/utils/lockfile.js

@@ -6,8 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.acquireLock = acquireLock;
 const logger_1 = require("./logger");
 const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
-const LOCK_FILE = path_1.default.resolve(process.cwd(), '.bot.lock');
+const LOCK_DIR = process.env.XDG_RUNTIME_DIR || path_1.default.join(os_1.default.tmpdir(), `lazygravity-${process.getuid ? process.getuid() : 'user'}`);
+const LOCK_FILE = path_1.default.join(LOCK_DIR, '.bot.lock');
 /**
  * Check if a process with the given PID is running
  */
@@ -20,64 +22,54 @@ function isProcessRunning(pid) {
         return false;
     }
 }
-/**
- * Stop an existing process and wait for it to exit
- */
-function killExistingProcess(pid) {
-    logger_1.logger.warn(`🔄 Stopping existing Bot process (PID: ${pid})...`);
-    try {
-        process.kill(pid, 'SIGTERM');
-    }
-    catch {
-        // Ignore if already terminated
-        return;
-    }
-    // Wait up to 5 seconds for process to exit
-    const deadline = Date.now() + 5000;
-    while (Date.now() < deadline) {
-        if (!isProcessRunning(pid)) {
-            logger_1.logger.info(`✅ Existing process (PID: ${pid}) stopped`);
-            return;
-        }
-        // Wait 50ms (busy wait)
-        const waitUntil = Date.now() + 50;
-        while (Date.now() < waitUntil) { /* spin */ }
-    }
-    // Timeout: force kill with SIGKILL
-    logger_1.logger.warn(`⚠️  Process did not exit with SIGTERM, force killing (SIGKILL)`);
-    try {
-        process.kill(pid, 'SIGKILL');
-    }
-    catch {
-        // ignore
-    }
-}
 /**
  * Acquire a lockfile to prevent duplicate bot instances.
- * If another process is already running, stop it before starting.
  *
  * @returns A function to release the lock
  */
 function acquireLock() {
+    fs_1.default.mkdirSync(LOCK_DIR, { recursive: true, mode: 0o700 });
+    const dirStat = fs_1.default.lstatSync(LOCK_DIR);
+    if (!dirStat.isDirectory()) {
+        throw new Error(`Lock path is not a directory: ${LOCK_DIR}`);
+    }
+    if (typeof process.getuid === 'function' && dirStat.uid !== process.getuid()) {
+        throw new Error(`Lock directory is not owned by current user: ${LOCK_DIR}`);
+    }
+    if ((dirStat.mode & 0o077) !== 0) {
+        throw new Error(`Lock directory has overly permissive permissions: ${LOCK_DIR}`);
+    }
     // Check existing lock file
     if (fs_1.default.existsSync(LOCK_FILE)) {
         const content = fs_1.default.readFileSync(LOCK_FILE, 'utf-8').trim();
         const existingPid = parseInt(content, 10);
         if (!isNaN(existingPid) && existingPid !== process.pid && isProcessRunning(existingPid)) {
-            // Stop existing process and restart
-            killExistingProcess(existingPid);
+            throw new Error(`Another Bot process is already running (PID: ${existingPid})`);
         }
         else if (!isNaN(existingPid) && !isProcessRunning(existingPid)) {
             logger_1.logger.warn(`⚠️  Stale lock file detected (PID: ${existingPid} has exited). Cleaning up.`);
+            try {
+                fs_1.default.unlinkSync(LOCK_FILE);
+            }
+            catch { /* ignore */ }
         }
-        // Remove stale lock file
+    }
+    // Create new lock file atomically
+    try {
+        const fd = fs_1.default.openSync(LOCK_FILE, 'wx', 0o600);
         try {
-            fs_1.default.unlinkSync(LOCK_FILE);
+            fs_1.default.writeFileSync(fd, String(process.pid), { encoding: 'utf-8' });
+        }
+        finally {
+            fs_1.default.closeSync(fd);
+        }
+    }
+    catch (err) {
+        if (err?.code === 'EEXIST') {
+            throw new Error('Another Bot process is already running');
         }
-        catch { /* ignore */ }
+        throw err;
     }
-    // Create new lock file
-    fs_1.default.writeFileSync(LOCK_FILE, String(process.pid), 'utf-8');
     logger_1.logger.info(`🔒 Lock acquired (PID: ${process.pid})`);
     // Cleanup function
     const releaseLock = () => {