lazy-gravity 0.0.2 → 0.0.3

package/dist/middleware/sanitize.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSafePath = void 0;
+const path_1 = __importDefault(require("path"));
+const resolveSafePath = (inputPath, baseDir) => {
+    const resolvedPath = path_1.default.resolve(baseDir, inputPath);
+    const normalizedBaseDir = path_1.default.resolve(baseDir);
+    const relative = path_1.default.relative(normalizedBaseDir, resolvedPath);
+    if (relative && (relative.startsWith('..' + path_1.default.sep) || relative === '..')) {
+        throw new Error('Path traversal detected');
+    }
+    if (path_1.default.isAbsolute(relative)) {
+        throw new Error('Path traversal detected');
+    }
+    return resolvedPath;
+};
+exports.resolveSafePath = resolveSafePath;

package/dist/services/antigravityLauncher.js

@@ -0,0 +1,89 @@
+"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.ensureAntigravityRunning = ensureAntigravityRunning;
+const logger_1 = require("../utils/logger");
+const cdpPorts_1 = require("../utils/cdpPorts");
+const http = __importStar(require("http"));
+/**
+ * Check if CDP responds on the specified port.
+ */
+function checkPort(port) {
+    return new Promise((resolve) => {
+        const req = http.get(`http://127.0.0.1:${port}/json/list`, (res) => {
+            let data = '';
+            res.on('data', (chunk) => (data += chunk));
+            res.on('end', () => {
+                try {
+                    const parsed = JSON.parse(data);
+                    resolve(Array.isArray(parsed));
+                }
+                catch {
+                    resolve(false);
+                }
+            });
+        });
+        req.on('error', () => resolve(false));
+        req.setTimeout(2000, () => {
+            req.destroy();
+            resolve(false);
+        });
+    });
+}
+/**
+ * Check if Antigravity is running with CDP ports.
+ * If not running, output a warning log (no auto-start or restart).
+ *
+ * Called during Bot initialization.
+ */
+async function ensureAntigravityRunning() {
+    logger_1.logger.info('[AntigravityLauncher] Checking CDP ports...');
+    for (const port of cdpPorts_1.CDP_PORTS) {
+        if (await checkPort(port)) {
+            logger_1.logger.info(`[AntigravityLauncher] OK — Port ${port} responding`);
+            return;
+        }
+    }
+    logger_1.logger.warn('');
+    logger_1.logger.warn('='.repeat(70));
+    logger_1.logger.warn('  Antigravity CDP ports are not responding');
+    logger_1.logger.warn('');
+    logger_1.logger.warn('  Please run AntigravityDebug.command before starting the Bot');
+    logger_1.logger.warn('');
+    logger_1.logger.warn('  Or manually:');
+    logger_1.logger.warn('    open -a Antigravity --args --remote-debugging-port=9222');
+    logger_1.logger.warn('='.repeat(70));
+    logger_1.logger.warn('');
+}

package/dist/services/approvalDetector.js

@@ -0,0 +1,384 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApprovalDetector = void 0;
+const logger_1 = require("../utils/logger");
+/**
+ * Approval button detection script for the Antigravity UI
+ *
+ * Detects allow/deny button pairs and extracts descriptions with fallbacks.
+ */
+const DETECT_APPROVAL_SCRIPT = `(() => {
+    const ALLOW_ONCE_PATTERNS = ['allow once', 'allow one time', '今回のみ許可', '1回のみ許可', '一度許可'];
+    const ALWAYS_ALLOW_PATTERNS = [
+        'allow this conversation',
+        'allow this chat',
+        'always allow',
+        '常に許可',
+        'この会話を許可',
+    ];
+    const ALLOW_PATTERNS = ['allow', 'permit', '許可', '承認', '確認'];
+    const DENY_PATTERNS = ['deny', '拒否', 'decline'];
+
+    const normalize = (text) => (text || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+
+    const allButtons = Array.from(document.querySelectorAll('button'))
+        .filter(btn => btn.offsetParent !== null);
+
+    let approveBtn = allButtons.find(btn => {
+        const t = normalize(btn.textContent || '');
+        return ALLOW_ONCE_PATTERNS.some(p => t.includes(p));
+    }) || null;
+
+    if (!approveBtn) {
+        approveBtn = allButtons.find(btn => {
+            const t = normalize(btn.textContent || '');
+            const isAlways = ALWAYS_ALLOW_PATTERNS.some(p => t.includes(p));
+            return !isAlways && ALLOW_PATTERNS.some(p => t.includes(p));
+        }) || null;
+    }
+
+    if (!approveBtn) return null;
+
+    const container = approveBtn.closest('[role="dialog"], .modal, .dialog, .approval-container, .permission-dialog')
+        || approveBtn.parentElement?.parentElement
+        || approveBtn.parentElement
+        || document.body;
+
+    const containerButtons = Array.from(container.querySelectorAll('button'))
+        .filter(btn => btn.offsetParent !== null);
+
+    const denyBtn = containerButtons.find(btn => {
+        const t = normalize(btn.textContent || '');
+        return DENY_PATTERNS.some(p => t.includes(p));
+    }) || null;
+
+    if (!denyBtn) return null;
+
+    const alwaysAllowBtn = containerButtons.find(btn => {
+        const t = normalize(btn.textContent || '');
+        return ALWAYS_ALLOW_PATTERNS.some(p => t.includes(p));
+    }) || null;
+
+    const approveText = (approveBtn.textContent || '').trim();
+    const alwaysAllowText = alwaysAllowBtn ? (alwaysAllowBtn.textContent || '').trim() : '';
+    const denyText = (denyBtn.textContent || '').trim();
+
+    // Description extraction (multiple fallbacks)
+    let description = '';
+
+    // 1. p or .description inside dialog/modal
+    const dialog = container;
+    if (dialog) {
+        const descEl = dialog.querySelector('p, .description, [data-testid="description"]');
+        if (descEl) {
+            description = (descEl.textContent || '').trim();
+        }
+    }
+
+    // 2. Parent element text (excluding button text)
+    if (!description) {
+        const parent = approveBtn.parentElement?.parentElement || approveBtn.parentElement;
+        if (parent) {
+            const clone = parent.cloneNode(true);
+            const buttons = clone.querySelectorAll('button');
+            buttons.forEach(b => b.remove());
+            const parentText = (clone.textContent || '').trim();
+            if (parentText.length > 5 && parentText.length < 500) {
+                description = parentText;
+            }
+        }
+    }
+
+    // 3. aria-label fallback
+    if (!description) {
+        const ariaLabel = approveBtn.getAttribute('aria-label') || '';
+        if (ariaLabel) description = ariaLabel;
+    }
+
+    return { approveText, alwaysAllowText, denyText, description };
+})()`;
+/**
+ * Press the toggle on the right side of Allow Once to expand the Always Allow dropdown.
+ */
+const EXPAND_ALWAYS_ALLOW_MENU_SCRIPT = `(() => {
+    const ALLOW_ONCE_PATTERNS = ['allow once', 'allow one time', '今回のみ許可', '1回のみ許可', '一度許可'];
+    const ALWAYS_ALLOW_PATTERNS = [
+        'allow this conversation',
+        'allow this chat',
+        'always allow',
+        '常に許可',
+        'この会話を許可',
+    ];
+
+    const normalize = (text) => (text || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+    const visibleButtons = Array.from(document.querySelectorAll('button'))
+        .filter(btn => btn.offsetParent !== null);
+
+    const directAlways = visibleButtons.find(btn => {
+        const t = normalize(btn.textContent || '');
+        return ALWAYS_ALLOW_PATTERNS.some(p => t.includes(p));
+    });
+    if (directAlways) return { ok: true, reason: 'already-visible' };
+
+    const allowOnceBtn = visibleButtons.find(btn => {
+        const t = normalize(btn.textContent || '');
+        return ALLOW_ONCE_PATTERNS.some(p => t.includes(p));
+    });
+    if (!allowOnceBtn) return { ok: false, error: 'allow-once button not found' };
+
+    const container = allowOnceBtn.closest('[role="dialog"], .modal, .dialog, .approval-container, .permission-dialog')
+        || allowOnceBtn.parentElement?.parentElement
+        || allowOnceBtn.parentElement
+        || document.body;
+
+    const containerButtons = Array.from(container.querySelectorAll('button'))
+        .filter(btn => btn.offsetParent !== null);
+
+    const toggleBtn = containerButtons.find(btn => {
+        if (btn === allowOnceBtn) return false;
+        const text = normalize(btn.textContent || '');
+        const aria = normalize(btn.getAttribute('aria-label') || '');
+        const hasPopup = btn.getAttribute('aria-haspopup');
+        if (hasPopup === 'menu' || hasPopup === 'listbox') return true;
+        if (text === '') return true;
+        return /menu|more|expand|options|dropdown|chevron|arrow/.test(aria);
+    });
+
+    if (toggleBtn) {
+        toggleBtn.click();
+        return { ok: true, reason: 'toggle-button' };
+    }
+
+    const rect = allowOnceBtn.getBoundingClientRect();
+    if (!rect || rect.width <= 0 || rect.height <= 0) {
+        return { ok: false, error: 'allow-once button rect unavailable' };
+    }
+
+    const clickX = rect.right - Math.max(4, Math.min(12, rect.width * 0.15));
+    const clickY = rect.top + rect.height / 2;
+
+    const events = ['pointerdown', 'mousedown', 'mouseup', 'click'];
+    for (const type of events) {
+        allowOnceBtn.dispatchEvent(new MouseEvent(type, {
+            bubbles: true,
+            cancelable: true,
+            view: window,
+            clientX: clickX,
+            clientY: clickY,
+        }));
+    }
+    return { ok: true, reason: 'allow-once-right-edge' };
+})()`;
+/**
+ * Generate a CDP script that clicks a button
+ *
+ * @param buttonText Text of the button to click
+ */
+function buildClickScript(buttonText) {
+    const safeText = JSON.stringify(buttonText);
+    return `(() => {
+        const normalize = (text) => (text || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+        const text = ${safeText};
+        const wanted = normalize(text);
+        const allButtons = Array.from(document.querySelectorAll('button'));
+        const target = allButtons.find(btn => {
+            if (!btn.offsetParent) return false;
+            const buttonText = normalize(btn.textContent || '');
+            const ariaLabel = normalize(btn.getAttribute('aria-label') || '');
+            return buttonText === wanted ||
+                ariaLabel === wanted ||
+                buttonText.includes(wanted) ||
+                ariaLabel.includes(wanted);
+        });
+        if (!target) return { ok: false, error: 'Button not found: ' + text };
+        target.click();
+        return { ok: true };
+    })()`;
+}
+/**
+ * Class that detects approval buttons in the Antigravity UI via polling.
+ *
+ * Notifies detected button info through the onApprovalRequired callback,
+ * and performs the actual click operations via approveButton() / denyButton() methods.
+ */
+class ApprovalDetector {
+    cdpService;
+    pollIntervalMs;
+    onApprovalRequired;
+    pollTimer = null;
+    isRunning = false;
+    /** Key of the last detected button info (for duplicate notification prevention) */
+    lastDetectedKey = null;
+    /** Full ApprovalInfo from the last detection (used for clicking) */
+    lastDetectedInfo = null;
+    constructor(options) {
+        this.cdpService = options.cdpService;
+        this.pollIntervalMs = options.pollIntervalMs ?? 1500;
+        this.onApprovalRequired = options.onApprovalRequired;
+    }
+    /**
+     * Start monitoring.
+     */
+    start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this.lastDetectedKey = null;
+        this.lastDetectedInfo = null;
+        this.schedulePoll();
+    }
+    /**
+     * Stop monitoring.
+     */
+    async stop() {
+        this.isRunning = false;
+        if (this.pollTimer) {
+            clearTimeout(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    /**
+     * Return the last detected approval button info.
+     * Returns null if nothing has been detected.
+     */
+    getLastDetectedInfo() {
+        return this.lastDetectedInfo;
+    }
+    /** 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 approval button info from DOM (with contextId)
+     *   2. Notify via callback only on new detection (prevent duplicates)
+     *   3. Reset lastDetectedKey / lastDetectedInfo when buttons disappear
+     */
+    async poll() {
+        try {
+            const contextId = this.cdpService.getPrimaryContextId();
+            const callParams = {
+                expression: DETECT_APPROVAL_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;
+            if (info) {
+                // Duplicate prevention: use approveText + description combination as key
+                const key = `${info.approveText}::${info.description}`;
+                if (key !== this.lastDetectedKey) {
+                    this.lastDetectedKey = key;
+                    this.lastDetectedInfo = info;
+                    this.onApprovalRequired(info);
+                }
+            }
+            else {
+                // Reset when buttons disappear (prepare for next approval detection)
+                this.lastDetectedKey = null;
+                this.lastDetectedInfo = null;
+            }
+        }
+        catch (error) {
+            // Ignore CDP errors and continue monitoring
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes('WebSocket is not connected')) {
+                return;
+            }
+            logger_1.logger.error('[ApprovalDetector] Error during polling:', error);
+        }
+    }
+    /**
+     * Click the approve button with the specified text via CDP.
+     * @param buttonText Text of the button to click (default: detected approveText or "Allow")
+     * @returns true if click succeeded
+     */
+    async approveButton(buttonText) {
+        const text = buttonText ?? this.lastDetectedInfo?.approveText ?? 'Allow';
+        return this.clickButton(text);
+    }
+    /**
+     * Select "Allow This Conversation / Always Allow".
+     * If the button is not directly visible, expand the Allow Once dropdown and select it.
+     */
+    async alwaysAllowButton() {
+        const directCandidates = [
+            this.lastDetectedInfo?.alwaysAllowText,
+            'Allow This Conversation',
+            'Allow This Chat',
+            'この会話を許可',
+            'Always Allow',
+            '常に許可',
+        ].filter((value) => typeof value === 'string' && value.trim().length > 0);
+        for (const candidate of directCandidates) {
+            if (await this.clickButton(candidate))
+                return true;
+        }
+        const expanded = await this.runEvaluateScript(EXPAND_ALWAYS_ALLOW_MENU_SCRIPT);
+        if (expanded?.ok !== true) {
+            return false;
+        }
+        for (let i = 0; i < 5; i++) {
+            for (const candidate of directCandidates) {
+                if (await this.clickButton(candidate))
+                    return true;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 120));
+        }
+        return false;
+    }
+    /**
+     * Click the deny button with the specified text via CDP.
+     * @param buttonText Text of the button to click (default: detected denyText or "Deny")
+     * @returns true if click succeeded
+     */
+    async denyButton(buttonText) {
+        const text = buttonText ?? this.lastDetectedInfo?.denyText ?? 'Deny';
+        return this.clickButton(text);
+    }
+    /**
+     * Internal click handler (shared implementation for approveButton / denyButton).
+     * Specifies contextId to click in the correct execution context.
+     */
+    async clickButton(buttonText) {
+        try {
+            const result = await this.runEvaluateScript(buildClickScript(buttonText));
+            return result?.ok === true;
+        }
+        catch (error) {
+            logger_1.logger.error('[ApprovalDetector] Error while clicking button:', error);
+            return false;
+        }
+    }
+    /**
+     * Execute Runtime.evaluate with contextId and return result.value.
+     */
+    async runEvaluateScript(expression) {
+        const contextId = this.cdpService.getPrimaryContextId();
+        const callParams = {
+            expression,
+            returnByValue: true,
+            awaitPromise: false,
+        };
+        if (contextId !== null) {
+            callParams.contextId = contextId;
+        }
+        const result = await this.cdpService.call('Runtime.evaluate', callParams);
+        return result?.result?.value;
+    }
+    /** Returns whether monitoring is currently active */
+    isActive() {
+        return this.isRunning;
+    }
+}
+exports.ApprovalDetector = ApprovalDetector;

package/dist/services/autoAcceptService.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoAcceptService = void 0;
+const i18n_1 = require("../utils/i18n");
+class AutoAcceptService {
+    enabled;
+    constructor(initialEnabled = false) {
+        this.enabled = initialEnabled;
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    handle(rawAction) {
+        const action = this.normalizeAction(rawAction);
+        if (!action) {
+            return {
+                success: false,
+                enabled: this.enabled,
+                changed: false,
+                message: (0, i18n_1.t)('⚠️ Invalid argument. Usage: `/autoaccept [on/off/status]`'),
+            };
+        }
+        if (action === 'status') {
+            return {
+                success: true,
+                enabled: this.enabled,
+                changed: false,
+                message: (0, i18n_1.t)(`⚙️ Auto-accept mode: **${this.enabled ? 'ON' : 'OFF'}**`),
+            };
+        }
+        if (action === 'on') {
+            if (this.enabled) {
+                return {
+                    success: true,
+                    enabled: true,
+                    changed: false,
+                    message: (0, i18n_1.t)('ℹ️ Auto-accept mode is already **ON**.'),
+                };
+            }
+            this.enabled = true;
+            return {
+                success: true,
+                enabled: true,
+                changed: true,
+                message: (0, i18n_1.t)('✅ Auto-accept mode turned **ON**. Future dialogs will be auto-allowed.'),
+            };
+        }
+        if (!this.enabled) {
+            return {
+                success: true,
+                enabled: false,
+                changed: false,
+                message: (0, i18n_1.t)('ℹ️ Auto-accept mode is already **OFF**.'),
+            };
+        }
+        this.enabled = false;
+        return {
+            success: true,
+            enabled: false,
+            changed: true,
+            message: (0, i18n_1.t)('✅ Auto-accept mode turned **OFF**. Returned to manual approval.'),
+        };
+    }
+    normalizeAction(rawAction) {
+        if (!rawAction || rawAction.trim().length === 0)
+            return 'status';
+        const normalized = rawAction.trim().toLowerCase();
+        if (['on', 'enable', 'enabled', 'true', '1'].includes(normalized)) {
+            return 'on';
+        }
+        if (['off', 'disable', 'disabled', 'false', '0'].includes(normalized)) {
+            return 'off';
+        }
+        if (['status', 'state', 'show'].includes(normalized)) {
+            return 'status';
+        }
+        return null;
+    }
+}
+exports.AutoAcceptService = AutoAcceptService;