antigravity-autopilot 1.4.3 → 1.4.4

package/extension.js

@@ -343,6 +343,24 @@ class AntigravityPanelProvider {
         vscode.window.showInformationMessage(
           next ? '🛡️ Command Blocking enabled' : '⚠️ Command Blocking disabled',
         );
+      } else if (msg.command === 'toggleBrowserPermission') {
+        const cfg = vscode.workspace.getConfiguration('antigravityAutoAccept');
+        const current = cfg.get('autoAcceptBrowserPermission', true);
+        const next = !current;
+        await cfg.update('autoAcceptBrowserPermission', next, vscode.ConfigurationTarget.Global);
+        this.sendBrowserPermissionEnabled(next);
+        vscode.window.showInformationMessage(
+          next ? '🌐 Auto-accept browser permission enabled' : '🌐 Auto-accept browser permission disabled',
+        );
+      } else if (msg.command === 'toggleFilePermission') {
+        const cfg = vscode.workspace.getConfiguration('antigravityAutoAccept');
+        const current = cfg.get('autoAcceptFilePermission', true);
+        const next = !current;
+        await cfg.update('autoAcceptFilePermission', next, vscode.ConfigurationTarget.Global);
+        this.sendFilePermissionEnabled(next);
+        vscode.window.showInformationMessage(
+          next ? '📁 Auto-accept file permission enabled' : '📁 Auto-accept file permission disabled',
+        );
       } else if (msg.command === 'removePattern') {
         // Remove a built-in pattern by ID
         const removed = getRemovedPatternIds();
@@ -364,6 +382,12 @@ class AntigravityPanelProvider {
     this.sendBlockingEnabled(
       vscode.workspace.getConfiguration('antigravityAutoAccept').get('dangerousCommandBlocking.enabled', true),
     );
+    this.sendBrowserPermissionEnabled(
+      vscode.workspace.getConfiguration('antigravityAutoAccept').get('autoAcceptBrowserPermission', true),
+    );
+    this.sendFilePermissionEnabled(
+      vscode.workspace.getConfiguration('antigravityAutoAccept').get('autoAcceptFilePermission', true),
+    );
     this.sendPatterns();
   }
 
@@ -395,6 +419,18 @@ class AntigravityPanelProvider {
     this._view.webview.postMessage({ command: 'setBlockingEnabled', enabled });
   }
 
+  /** @param {boolean} enabled */
+  sendBrowserPermissionEnabled(enabled) {
+    if (!this._view) return;
+    this._view.webview.postMessage({ command: 'setBrowserPermissionEnabled', enabled });
+  }
+
+  /** @param {boolean} enabled */
+  sendFilePermissionEnabled(enabled) {
+    if (!this._view) return;
+    this._view.webview.postMessage({ command: 'setFilePermissionEnabled', enabled });
+  }
+
   /** Send current pattern list to the webview */
   sendPatterns() {
     if (!this._view) return;
@@ -633,6 +669,30 @@ class AntigravityPanelProvider {
   </label>
 </div>
 
+<!-- Browser Permission toggle -->
+<div class="toggle-row" id="browserPermToggleRow">
+  <div>
+    <div class="toggle-label">🌐 Browser Permission</div>
+    <div class="toggle-sub" id="browserPermToggleSub">Active — auto-accepting browser actions</div>
+  </div>
+  <label class="switch" title="Toggle auto-accept browser permission">
+    <input type="checkbox" id="browserPermToggleCheck" checked onchange="send('toggleBrowserPermission')">
+    <span class="slider"></span>
+  </label>
+</div>
+
+<!-- File Permission toggle -->
+<div class="toggle-row" id="filePermToggleRow">
+  <div>
+    <div class="toggle-label">📁 File Permission</div>
+    <div class="toggle-sub" id="filePermToggleSub">Active — auto-allowing file access</div>
+  </div>
+  <label class="switch" title="Toggle auto-accept file permission">
+    <input type="checkbox" id="filePermToggleCheck" checked onchange="send('toggleFilePermission')">
+    <span class="slider"></span>
+  </label>
+</div>
+
 <!-- Dangerous Command Blocking section -->
 <div class="section" id="blockSection">
   <div class="section-header" id="blockHeader">
@@ -660,6 +720,7 @@ class AntigravityPanelProvider {
 
   function send(cmd, extra) {
     if (cmd !== 'openSettings' && cmd !== 'toggleEnabled' && cmd !== 'toggleCommandBlocking'
+        && cmd !== 'toggleBrowserPermission' && cmd !== 'toggleFilePermission'
         && cmd !== 'refresh' && cmd !== 'removePattern' && cmd !== 'resetPatterns') {
       document.getElementById('btnApply').disabled = true;
       document.getElementById('btnRevert').disabled = true;
@@ -751,6 +812,22 @@ class AntigravityPanelProvider {
       if (section) section.style.opacity = data.enabled ? '1' : '0.4';
     }
 
+    if (data.command === 'setBrowserPermissionEnabled') {
+      const chk = document.getElementById('browserPermToggleCheck');
+      chk.checked = data.enabled;
+      document.getElementById('browserPermToggleSub').textContent = data.enabled
+        ? 'Active — auto-accepting browser actions'
+        : 'Disabled — browser actions require confirmation';
+    }
+
+    if (data.command === 'setFilePermissionEnabled') {
+      const chk = document.getElementById('filePermToggleCheck');
+      chk.checked = data.enabled;
+      document.getElementById('filePermToggleSub').textContent = data.enabled
+        ? 'Active — auto-allowing file access'
+        : 'Disabled — file access requires confirmation';
+    }
+
     if (data.command === 'patterns') {
       renderPatterns(data.patterns, data.totalBuiltin);
     }

package/package.json

@@ -2,7 +2,7 @@
   "name": "antigravity-autopilot",
   "displayName": "Antigravity AutoPilot",
   "description": "Enables autopilot mode for Antigravity: automatically executes all tool calls and terminal commands without manual confirmation. Patches the runtime JS bundle to inject auto-accept logic whenever the 'Always Proceed' policy is active — regex-based and version-agnostic.",
-  "version": "1.4.3",
+  "version": "1.4.4",
   "license": "MIT",
   "publisher": "nguyen-hoang",
   "bin": {
@@ -109,6 +109,16 @@
           },
           "default": [],
           "description": "Additional regex patterns (JavaScript syntax) to treat as dangerous commands. Example: [\"^dd if=.*of=/dev/sd\", \"^shred\"]"
+        },
+        "antigravityAutoAccept.autoAcceptBrowserPermission": {
+          "type": "boolean",
+          "default": true,
+          "description": "Automatically accept browser action permissions (e.g. 'Agent needs permission to act on chromewebdata'). Requires patch to be applied."
+        },
+        "antigravityAutoAccept.autoAcceptFilePermission": {
+          "type": "boolean",
+          "default": true,
+          "description": "Automatically allow file access permissions with conversation scope. Requires patch to be applied."
         }
       }
     }

package/patcher.js

@@ -189,13 +189,170 @@ function analyzeFile(content, label) {
     };
 }
 
+// ─── Browser Action Permission (auto-confirm) ───────────────────────────────
+
+/**
+ * Finds the JPc browser-action confirmation component and builds auto-confirm patch.
+ * Pattern: COMP=({sourceTrajectoryStepInfo:VAR,...,url:VAR})=>{...CONFIRM_FN=Mt(()=>{SEND(Ui(MSG,{...,interaction:{case:"browserAction",value:Ui(TYPE,{confirm:!0})}}))},...)...}
+ */
+function analyzeBrowserAction(content, label) {
+    const log = (msg) => process.send({ type: 'log', msg: `[AutoAccept] [${label}] [browser] ${msg}` });
+
+    // 1. Find the browserAction confirm:!0 callback pattern
+    //    VAR=Mt(()=>{SEND(Ui(MSG,{trajectoryId:VAR,stepIndex:VAR,interaction:{case:"browserAction",value:Ui(TYPE,{confirm:!0})}}))},DEPS)
+    const confirmRe = /(\w+)=Mt\(\(\)=>\{(\w+)\(Ui\((\w+),\{trajectoryId:(\w+),stepIndex:(\w+),interaction:\{case:"browserAction",value:Ui\((\w+),\{confirm:!0\}\)\}\}\)\)\},\[([\w,]*)\]\)/;
+    const confirmMatch = content.match(confirmRe);
+
+    if (!confirmMatch) {
+        log('❌ Could not find browserAction confirm pattern');
+        const idx = content.indexOf('browserAction');
+        if (idx >= 0) {
+            log(`  Context: ...${content.slice(Math.max(0, idx - 80), idx + 120)}...`);
+        }
+        return null;
+    }
+
+    const [fullMatch, confirmVar] = confirmMatch;
+    const matchIndex = content.indexOf(fullMatch);
+    log(`✓ Found browserAction confirm at offset ${matchIndex}`);
+    log(`  confirmVar=${confirmVar}`);
+
+    // 2. Find useEffect alias (reuse from nearby code)
+    const nearbyCode = content.substring(Math.max(0, matchIndex - 5000), matchIndex + 5000);
+    const effectCandidates = {};
+    const effectRe = /\b(\w{2,3})\(\(\)=>\{[^}]{3,80}\},\[/g;
+    let m;
+    while ((m = effectRe.exec(nearbyCode)) !== null) {
+        const alias = m[1];
+        if (alias !== 'Mt' && alias !== 'Vi' && alias !== 'var' && alias !== 'new') {
+            effectCandidates[alias] = (effectCandidates[alias] || 0) + 1;
+        }
+    }
+    const cleanupRe = /\b(\w{2,3})\(\(\)=>\{[^}]*return\s*\(\)=>/g;
+    while ((m = cleanupRe.exec(content)) !== null) {
+        const alias = m[1];
+        if (alias !== 'Mt' && alias !== 'Vi') {
+            effectCandidates[alias] = (effectCandidates[alias] || 0) + 5;
+        }
+    }
+    let useEffectAlias = null;
+    let maxCount = 0;
+    for (const [alias, count] of Object.entries(effectCandidates)) {
+        if (count > maxCount) {
+            maxCount = count;
+            useEffectAlias = alias;
+        }
+    }
+    if (!useEffectAlias) {
+        log('❌ Could not determine useEffect alias');
+        return null;
+    }
+    log(`  useEffect=${useEffectAlias} (confidence: ${maxCount} hits)`);
+
+    // 3. Build patch — auto-call confirmVar() on mount
+    const patchCode = `_abp=${useEffectAlias}(()=>{${confirmVar}()},[${confirmVar}]),`;
+
+    return {
+        target: fullMatch,
+        replacement: patchCode + fullMatch,
+        patchMarker: `_abp=${useEffectAlias}(()=>{${confirmVar}()}`,
+        label
+    };
+}
+
+// ─── File Access Permission (auto-allow with conversation scope) ─────────────
+
+/**
+ * Finds the rBe file-permission component and builds auto-allow patch.
+ * Pattern: COMP=({sourceTrajectoryStepInfo:VAR,req:VAR,status:VAR})=>{...SEND_FN...filePermission...scope...}
+ */
+function analyzeFilePermission(content, label) {
+    const log = (msg) => process.send({ type: 'log', msg: `[AutoAccept] [${label}] [file] ${msg}` });
+
+    // 1. Find the filePermission sender pattern
+    //    VAR=(ALLOW_VAR,SCOPE_VAR)=>{SEND(Ui(MSG,{trajectoryId:VAR,stepIndex:VAR,interaction:{case:"filePermission",value:Ui(TYPE,{allow:ALLOW_VAR,scope:SCOPE_VAR,absolutePathUri:REQ.absolutePathUri})}}))};
+    const senderRe = /(\w+)=\((\w+),(\w+)\)=>\{(\w+)\(Ui\((\w+),\{trajectoryId:(\w+),stepIndex:(\w+),interaction:\{case:"filePermission",value:Ui\((\w+),\{allow:\2,scope:\3,absolutePathUri:(\w+)\.absolutePathUri\}\)\}\}\)\)\}/;
+    const senderMatch = content.match(senderRe);
+
+    if (!senderMatch) {
+        log('❌ Could not find filePermission sender pattern');
+        const idx = content.indexOf('filePermission');
+        if (idx >= 0) {
+            log(`  Context: ...${content.slice(Math.max(0, idx - 80), idx + 120)}...`);
+        }
+        return null;
+    }
+
+    const [fullMatch, senderVar, , , , , , , , reqVar] = senderMatch;
+    const matchIndex = content.indexOf(fullMatch);
+    log(`✓ Found filePermission sender at offset ${matchIndex}`);
+    log(`  senderVar=${senderVar}, reqVar=${reqVar}`);
+
+    // 2. Find the scope enum (kot) — look for kot.CONVERSATION or similar near filePermission
+    //    Pattern: o(!0,ENUM.CONVERSATION) in the Allow This Conversation button
+    const scopeRe = new RegExp(`${senderVar.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\(!0,(\w+)\.CONVERSATION\)`);
+    const scopeMatch = content.substring(matchIndex, matchIndex + 2000).match(scopeRe);
+
+    if (!scopeMatch) {
+        log('❌ Could not find scope enum (CONVERSATION)');
+        return null;
+    }
+    const scopeEnum = scopeMatch[1];
+    log(`  scopeEnum=${scopeEnum}`);
+
+    // 3. Find useEffect alias
+    const nearbyCode = content.substring(Math.max(0, matchIndex - 5000), matchIndex + 5000);
+    const effectCandidates = {};
+    const effectRe = /\b(\w{2,3})\(\(\)=>\{[^}]{3,80}\},\[/g;
+    let m2;
+    while ((m2 = effectRe.exec(nearbyCode)) !== null) {
+        const alias = m2[1];
+        if (alias !== 'Mt' && alias !== 'Vi' && alias !== 'var' && alias !== 'new') {
+            effectCandidates[alias] = (effectCandidates[alias] || 0) + 1;
+        }
+    }
+    const cleanupRe = /\b(\w{2,3})\(\(\)=>\{[^}]*return\s*\(\)=>/g;
+    while ((m2 = cleanupRe.exec(content)) !== null) {
+        const alias = m2[1];
+        if (alias !== 'Mt' && alias !== 'Vi') {
+            effectCandidates[alias] = (effectCandidates[alias] || 0) + 5;
+        }
+    }
+    let useEffectAlias = null;
+    let maxCount = 0;
+    for (const [alias, count] of Object.entries(effectCandidates)) {
+        if (count > maxCount) {
+            maxCount = count;
+            useEffectAlias = alias;
+        }
+    }
+    if (!useEffectAlias) {
+        log('❌ Could not determine useEffect alias');
+        return null;
+    }
+    log(`  useEffect=${useEffectAlias} (confidence: ${maxCount} hits)`);
+
+    // 4. Build patch — auto-call senderVar(!0, scopeEnum.CONVERSATION) on mount
+    const patchCode = `_afp=${useEffectAlias}(()=>{${senderVar}(!0,${scopeEnum}.CONVERSATION)},[${senderVar}]),`;
+
+    return {
+        target: fullMatch,
+        replacement: patchCode + fullMatch,
+        patchMarker: `_afp=${useEffectAlias}(()=>{${senderVar}(!0,${scopeEnum}.CONVERSATION)`,
+        label
+    };
+}
+
 // ─── File Operations ─────────────────────────────────────────────────────────
 
 function isFilePatched(filePath) {
     if (!fs.existsSync(filePath)) return false;
     try {
         const content = fs.readFileSync(filePath, 'utf8');
-        return content.includes('_aep=') && /_aep=\w+\(\(\)=>\{[^}]+EAGER/.test(content);
+        const hasTerminal = content.includes('_aep=') && /_aep=\w+\(\(\)=>\{[^}]+EAGER/.test(content);
+        const hasBrowser = content.includes('_abp=') && /_abp=\w+\(\(\)=>\{\w+\(\)\}/.test(content);
+        const hasFile = content.includes('_afp=') && /_afp=\w+\(\(\)=>\{\w+\(!0,/.test(content);
+        return hasTerminal || hasBrowser || hasFile;
     } catch {
         return false;
     }
@@ -215,33 +372,77 @@ function patchFile(filePath, label) {
         return false;
     }
 
-    if (isFilePatched(filePath)) {
-        process.send({ type: 'log', msg: `[AutoAccept] ⏭️  [${label}] Already patched` });
-        return true;
-    }
-
-    const analysis = analyzeFile(content, label);
-    if (!analysis) return false;
-
-    // Verify target uniqueness
-    const count = content.split(analysis.target).length - 1;
-    if (count !== 1) {
-        process.send({ type: 'log', msg: `[AutoAccept] ❌ [${label}] Target found ${count}x (expected 1)` });
-        return false;
-    }
-
-    // Backup original
+    // Backup original (before any patching)
     const bakPath = filePath + '.bak';
     if (!fs.existsSync(bakPath)) {
         fs.copyFileSync(filePath, bakPath);
         process.send({ type: 'log', msg: `[AutoAccept] 📦 [${label}] Backup created` });
     }
 
-    const patched = content.replace(analysis.target, analysis.replacement);
-    fs.writeFileSync(filePath, patched, 'utf8');
+    let patched = content;
+    let anyPatched = false;
+
+    // ── Terminal auto-execute patch ──
+    if (!content.includes('_aep=')) {
+        const analysis = analyzeFile(content, label);
+        if (analysis) {
+            const count = patched.split(analysis.target).length - 1;
+            if (count === 1) {
+                patched = patched.replace(analysis.target, analysis.replacement);
+                anyPatched = true;
+                process.send({ type: 'log', msg: `[AutoAccept] ✅ [${label}] Terminal auto-execute patched` });
+            } else {
+                process.send({ type: 'log', msg: `[AutoAccept] ⚠️ [${label}] Terminal target found ${count}x (expected 1)` });
+            }
+        }
+    } else {
+        process.send({ type: 'log', msg: `[AutoAccept] ⏭️  [${label}] Terminal already patched` });
+    }
+
+    // ── Browser action auto-confirm patch ──
+    if (!patched.includes('_abp=')) {
+        const browserAnalysis = analyzeBrowserAction(patched, label);
+        if (browserAnalysis) {
+            const count = patched.split(browserAnalysis.target).length - 1;
+            if (count === 1) {
+                patched = patched.replace(browserAnalysis.target, browserAnalysis.replacement);
+                anyPatched = true;
+                process.send({ type: 'log', msg: `[AutoAccept] ✅ [${label}] Browser action auto-confirm patched` });
+            } else {
+                process.send({ type: 'log', msg: `[AutoAccept] ⚠️ [${label}] Browser target found ${count}x (expected 1)` });
+            }
+        }
+    } else {
+        process.send({ type: 'log', msg: `[AutoAccept] ⏭️  [${label}] Browser action already patched` });
+    }
 
-    const sizeDiff = fs.statSync(filePath).size - fs.statSync(bakPath).size;
-    process.send({ type: 'log', msg: `[AutoAccept] ✅ [${label}] Patched (+${sizeDiff} bytes)` });
+    // ── File permission auto-allow patch ──
+    if (!patched.includes('_afp=')) {
+        const fileAnalysis = analyzeFilePermission(patched, label);
+        if (fileAnalysis) {
+            const count = patched.split(fileAnalysis.target).length - 1;
+            if (count === 1) {
+                patched = patched.replace(fileAnalysis.target, fileAnalysis.replacement);
+                anyPatched = true;
+                process.send({ type: 'log', msg: `[AutoAccept] ✅ [${label}] File permission auto-allow patched` });
+            } else {
+                process.send({ type: 'log', msg: `[AutoAccept] ⚠️ [${label}] File target found ${count}x (expected 1)` });
+            }
+        }
+    } else {
+        process.send({ type: 'log', msg: `[AutoAccept] ⏭️  [${label}] File permission already patched` });
+    }
+
+    if (anyPatched) {
+        fs.writeFileSync(filePath, patched, 'utf8');
+        const sizeDiff = fs.statSync(filePath).size - fs.statSync(bakPath).size;
+        process.send({ type: 'log', msg: `[AutoAccept] ✅ [${label}] All patches applied (+${sizeDiff} bytes)` });
+    } else if (!content.includes('_aep=') && !content.includes('_abp=') && !content.includes('_afp=')) {
+        process.send({ type: 'log', msg: `[AutoAccept] ❌ [${label}] No patches could be applied` });
+        return false;
+    } else {
+        process.send({ type: 'log', msg: `[AutoAccept] ⏭️  [${label}] All patches already applied` });
+    }
     return true;
 }
 
@@ -266,11 +467,23 @@ process.on('message', (msg) => {
             process.exit(0);
             return;
         }
-        const files = getTargetFiles(basePath).map(f => ({
-            label: f.label,
-            patched: isFilePatched(f.filePath),
-            exists: fs.existsSync(f.filePath),
-        }));
+        const files = getTargetFiles(basePath).map(f => {
+            let patchDetails = { terminal: false, browser: false, file: false };
+            if (fs.existsSync(f.filePath)) {
+                try {
+                    const fc = fs.readFileSync(f.filePath, 'utf8');
+                    patchDetails.terminal = fc.includes('_aep=') && /_aep=\w+\(\(\)=>\{[^}]+EAGER/.test(fc);
+                    patchDetails.browser = fc.includes('_abp=') && /_abp=\w+\(\(\)=>\{\w+\(\)\}/.test(fc);
+                    patchDetails.file = fc.includes('_afp=') && /_afp=\w+\(\(\)=>\{\w+\(!0,/.test(fc);
+                } catch { }
+            }
+            return {
+                label: f.label,
+                patched: patchDetails.terminal || patchDetails.browser || patchDetails.file,
+                patchDetails,
+                exists: fs.existsSync(f.filePath),
+            };
+        });
         process.send({ type: 'status', basePath, files });
         process.exit(0);