antigravity-autopilot 1.4.3 → 1.4.5

package/{AutoAccept.ps1 → AutoPilot.ps1}

@@ -1,6 +1,6 @@
 # Antigravity Auto-Accept - Floating Panel
 # A small always-on-top window for toggling auto-accept
-# Run with: powershell -WindowStyle Hidden -File AutoAccept.ps1
+# Run with: powershell -WindowStyle Hidden -File AutoPilot.ps1
 
 Add-Type -AssemblyName System.Windows.Forms
 Add-Type -AssemblyName System.Drawing

package/README.md

@@ -95,7 +95,7 @@ Built-in protection against destructive commands. **54+ preset patterns** coveri
 Add your own patterns via Settings:
 
 ```json
-"antigravityAutoAccept.dangerousCommandBlocking.customPatterns": [
+"antigravityAutoPilot.dangerousCommandBlocking.customPatterns": [
   "^my-dangerous-script",
   "DROP TABLE"
 ]

package/extension.js

@@ -112,7 +112,7 @@ function getActiveBuiltinPatterns() {
  * @returns {{ matched: boolean, label: string, pattern: string }}
  */
 function checkDangerousCommand(cmd) {
-  const cfg = vscode.workspace.getConfiguration('antigravityAutoAccept');
+  const cfg = vscode.workspace.getConfiguration('antigravityAutoPilot');
   const enabled = cfg.get('dangerousCommandBlocking.enabled', true);
   if (!enabled) return { matched: false, label: '', pattern: '' };
 
@@ -149,7 +149,7 @@ function checkDangerousCommand(cmd) {
  * @param {string} label - Human-readable reason
  */
 function handleDangerousCommand(cmd, label) {
-  const cfg = vscode.workspace.getConfiguration('antigravityAutoAccept');
+  const cfg = vscode.workspace.getConfiguration('antigravityAutoPilot');
   const action = cfg.get('dangerousCommandBlocking.action', 'block');
   const msg = `🛡️ Dangerous command detected: "${label}" — \`${cmd.trim().substring(0, 80)}\``;
 
@@ -326,16 +326,16 @@ class AntigravityPanelProvider {
       } else if (msg.command === 'toggleEnabled') {
         autoPilotEnabled = !autoPilotEnabled;
         updateStatusBarFromCache();
-        const cfg = vscode.workspace.getConfiguration('antigravityAutoAccept');
+        const cfg = vscode.workspace.getConfiguration('antigravityAutoPilot');
         await cfg.update('enabledOnStartup', autoPilotEnabled, vscode.ConfigurationTarget.Global);
         if (panelProvider) panelProvider.sendEnabled(autoPilotEnabled);
         vscode.window.showInformationMessage(
           autoPilotEnabled ? '⚡ AutoPilot resumed' : '⏸ AutoPilot suspended',
         );
       } else if (msg.command === 'openSettings') {
-        vscode.commands.executeCommand('workbench.action.openSettings', 'antigravityAutoAccept');
+        vscode.commands.executeCommand('workbench.action.openSettings', 'antigravityAutoPilot');
       } else if (msg.command === 'toggleCommandBlocking') {
-        const cfg = vscode.workspace.getConfiguration('antigravityAutoAccept');
+        const cfg = vscode.workspace.getConfiguration('antigravityAutoPilot');
         const current = cfg.get('dangerousCommandBlocking.enabled', true);
         const next = !current;
         await cfg.update('dangerousCommandBlocking.enabled', next, vscode.ConfigurationTarget.Global);
@@ -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('antigravityAutoPilot');
+        const current = cfg.get('browserPermission', true);
+        const next = !current;
+        await cfg.update('browserPermission', 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('antigravityAutoPilot');
+        const current = cfg.get('filePermission', true);
+        const next = !current;
+        await cfg.update('filePermission', 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();
@@ -362,7 +380,13 @@ class AntigravityPanelProvider {
     refreshStatus();
     this.sendEnabled(autoPilotEnabled);
     this.sendBlockingEnabled(
-      vscode.workspace.getConfiguration('antigravityAutoAccept').get('dangerousCommandBlocking.enabled', true),
+      vscode.workspace.getConfiguration('antigravityAutoPilot').get('dangerousCommandBlocking.enabled', true),
+    );
+    this.sendBrowserPermissionEnabled(
+      vscode.workspace.getConfiguration('antigravityAutoPilot').get('browserPermission', true),
+    );
+    this.sendFilePermissionEnabled(
+      vscode.workspace.getConfiguration('antigravityAutoPilot').get('filePermission', 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);
     }
@@ -817,12 +894,12 @@ function activate(context) {
   context.subscriptions.push(outputChannel);
 
   // Read enabledOnStartup setting
-  const cfg = vscode.workspace.getConfiguration('antigravityAutoAccept');
+  const cfg = vscode.workspace.getConfiguration('antigravityAutoPilot');
   autoPilotEnabled = cfg.get('enabledOnStartup', true);
 
   // Status bar
   statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
-  statusBarItem.command = 'antigravityAutoAccept.openPanel';
+  statusBarItem.command = 'antigravityAutoPilot.openPanel';
   statusBarItem.text = `$(sync~spin) AG Patch`;
   statusBarItem.tooltip = 'Checking patch status...';
   statusBarItem.show();
@@ -832,7 +909,7 @@ function activate(context) {
   panelProvider = new AntigravityPanelProvider(context);
   context.subscriptions.push(
     vscode.window.registerWebviewViewProvider(
-      'antigravityAutoAccept.panel',
+      'antigravityAutoPilot.panel',
       panelProvider,
       { webviewOptions: { retainContextWhenHidden: true } },
     ),
@@ -855,8 +932,8 @@ function activate(context) {
   // Config change listener
   context.subscriptions.push(
     vscode.workspace.onDidChangeConfiguration((e) => {
-      if (e.affectsConfiguration('antigravityAutoAccept.enabledOnStartup')) {
-        autoPilotEnabled = vscode.workspace.getConfiguration('antigravityAutoAccept').get('enabledOnStartup', true);
+      if (e.affectsConfiguration('antigravityAutoPilot.enabledOnStartup')) {
+        autoPilotEnabled = vscode.workspace.getConfiguration('antigravityAutoPilot').get('enabledOnStartup', true);
         updateStatusBarFromCache();
         if (panelProvider) panelProvider.sendEnabled(autoPilotEnabled);
       }
@@ -865,18 +942,18 @@ function activate(context) {
 
   // Commands
   context.subscriptions.push(
-    vscode.commands.registerCommand('antigravityAutoAccept.applyPatch', async () => {
+    vscode.commands.registerCommand('antigravityAutoPilot.applyPatch', async () => {
       const result = await applyPatch();
       vscode.window.showInformationMessage(result.message);
     }),
-    vscode.commands.registerCommand('antigravityAutoAccept.revertPatch', async () => {
+    vscode.commands.registerCommand('antigravityAutoPilot.revertPatch', async () => {
       const result = await revertPatch();
       vscode.window.showInformationMessage(result.message);
     }),
-    vscode.commands.registerCommand('antigravityAutoAccept.openPanel', () => {
-      vscode.commands.executeCommand('antigravityAutoAccept.panel.focus');
+    vscode.commands.registerCommand('antigravityAutoPilot.openPanel', () => {
+      vscode.commands.executeCommand('antigravityAutoPilot.panel.focus');
     }),
-    vscode.commands.registerCommand('antigravityAutoAccept.checkStatus', async () => {
+    vscode.commands.registerCommand('antigravityAutoPilot.checkStatus', async () => {
       const status = await getPatchStatus();
       if (!status.basePath) {
         vscode.window.showWarningMessage('Antigravity not found!');
@@ -898,7 +975,7 @@ function activate(context) {
       panelProvider.sendEnabled(autoPilotEnabled);
     }
 
-    const startCfg = vscode.workspace.getConfiguration('antigravityAutoAccept');
+    const startCfg = vscode.workspace.getConfiguration('antigravityAutoPilot');
     if (startCfg.get('applyOnStartup') && !status.patched && status.basePath) {
       const result = await applyPatch();
       if (result.success) {

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.5",
   "license": "MIT",
   "publisher": "nguyen-hoang",
   "bin": {
@@ -37,57 +37,57 @@
       "antigravity-autopilot": [
         {
           "type": "webview",
-          "id": "antigravityAutoAccept.panel",
+          "id": "antigravityAutoPilot.panel",
           "name": "AutoPilot"
         }
       ]
     },
     "commands": [
       {
-        "command": "antigravityAutoAccept.applyPatch",
+        "command": "antigravityAutoPilot.applyPatch",
         "title": "Antigravity: Apply AutoPilot Patch",
         "icon": "$(zap)"
       },
       {
-        "command": "antigravityAutoAccept.revertPatch",
+        "command": "antigravityAutoPilot.revertPatch",
         "title": "Antigravity: Revert AutoPilot Patch",
         "icon": "$(discard)"
       },
       {
-        "command": "antigravityAutoAccept.checkStatus",
+        "command": "antigravityAutoPilot.checkStatus",
         "title": "Antigravity: Check Patch Status",
         "icon": "$(info)"
       },
       {
-        "command": "antigravityAutoAccept.openPanel",
+        "command": "antigravityAutoPilot.openPanel",
         "title": "Antigravity: Open AutoPilot Panel"
       }
     ],
     "keybindings": [
       {
-        "command": "antigravityAutoAccept.applyPatch",
+        "command": "antigravityAutoPilot.applyPatch",
         "key": "ctrl+shift+f12"
       }
     ],
     "configuration": {
       "title": "Antigravity AutoPilot",
       "properties": {
-        "antigravityAutoAccept.applyOnStartup": {
+        "antigravityAutoPilot.applyOnStartup": {
           "type": "boolean",
           "default": false,
           "description": "Automatically apply the AutoPilot patch when VS Code starts. Safe to enable — patch is idempotent."
         },
-        "antigravityAutoAccept.enabledOnStartup": {
+        "antigravityAutoPilot.enabledOnStartup": {
           "type": "boolean",
           "default": true,
           "description": "Keep AutoPilot enabled (active) when VS Code starts. When disabled, AutoPilot will be suspended until manually turned on from the sidebar."
         },
-        "antigravityAutoAccept.dangerousCommandBlocking.enabled": {
+        "antigravityAutoPilot.dangerousCommandBlocking.enabled": {
           "type": "boolean",
           "default": true,
           "description": "Block dangerous terminal commands (e.g. rm -rf /, format C:) before they execute. Fully customizable via the blocklist setting."
         },
-        "antigravityAutoAccept.dangerousCommandBlocking.action": {
+        "antigravityAutoPilot.dangerousCommandBlocking.action": {
           "type": "string",
           "enum": [
             "block",
@@ -102,13 +102,23 @@
           "default": "block",
           "description": "Action to take when a dangerous command is detected."
         },
-        "antigravityAutoAccept.dangerousCommandBlocking.customPatterns": {
+        "antigravityAutoPilot.dangerousCommandBlocking.customPatterns": {
           "type": "array",
           "items": {
             "type": "string"
           },
           "default": [],
           "description": "Additional regex patterns (JavaScript syntax) to treat as dangerous commands. Example: [\"^dd if=.*of=/dev/sd\", \"^shred\"]"
+        },
+        "antigravityAutoPilot.browserPermission": {
+          "type": "boolean",
+          "default": true,
+          "description": "Automatically accept browser action permissions (e.g. 'Agent needs permission to act on chromewebdata'). Requires patch to be applied."
+        },
+        "antigravityAutoPilot.filePermission": {
+          "type": "boolean",
+          "default": true,
+          "description": "Automatically allow file access permissions with conversation scope. Requires patch to be applied."
         }
       }
     }

package/patcher.js

@@ -95,7 +95,7 @@ function getTargetFiles(basePath) {
  * Port of: https://github.com/Kanezal/better-antigravity/blob/main/fixes/auto-run-fix/patch.js
  */
 function analyzeFile(content, label) {
-    const log = (msg) => process.send({ type: 'log', msg: `[AutoAccept] [${label}] ${msg}` });
+    const log = (msg) => process.send({ type: 'log', msg: `[AutoPilot] [${label}] ${msg}` });
 
     // 1. Find the onChange handler: contains setTerminalAutoExecutionPolicy AND .EAGER
     //    Pattern: VARNAME=CALLBACK(ARG=>{...setTerminalAutoExecutionPolicy...,ARG===ENUM.EAGER&&CONFIRM(!0)},[...])
@@ -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: `[AutoPilot] [${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: `[AutoPilot] [${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;
     }
@@ -203,7 +360,7 @@ function isFilePatched(filePath) {
 
 function patchFile(filePath, label) {
     if (!fs.existsSync(filePath)) {
-        process.send({ type: 'log', msg: `[AutoAccept] ⏭️  [${label}] File not found, skipping` });
+        process.send({ type: 'log', msg: `[AutoPilot] ⏭️  [${label}] File not found, skipping` });
         return true; // optional file missing is not a failure
     }
 
@@ -211,48 +368,92 @@ function patchFile(filePath, label) {
     try {
         content = fs.readFileSync(filePath, 'utf8');
     } catch (e) {
-        process.send({ type: 'log', msg: `[AutoAccept] ❌ [${label}] Read error: ${e.message}` });
+        process.send({ type: 'log', msg: `[AutoPilot] ❌ [${label}] Read error: ${e.message}` });
         return false;
     }
 
-    if (isFilePatched(filePath)) {
-        process.send({ type: 'log', msg: `[AutoAccept] ⏭️  [${label}] Already patched` });
-        return true;
+    // Backup original (before any patching)
+    const bakPath = filePath + '.bak';
+    if (!fs.existsSync(bakPath)) {
+        fs.copyFileSync(filePath, bakPath);
+        process.send({ type: 'log', msg: `[AutoPilot] 📦 [${label}] Backup created` });
     }
 
-    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;
+    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: `[AutoPilot] ✅ [${label}] Terminal auto-execute patched` });
+            } else {
+                process.send({ type: 'log', msg: `[AutoPilot] ⚠️ [${label}] Terminal target found ${count}x (expected 1)` });
+            }
+        }
+    } else {
+        process.send({ type: 'log', msg: `[AutoPilot] ⏭️  [${label}] Terminal already patched` });
     }
 
-    // Backup original
-    const bakPath = filePath + '.bak';
-    if (!fs.existsSync(bakPath)) {
-        fs.copyFileSync(filePath, bakPath);
-        process.send({ type: 'log', msg: `[AutoAccept] 📦 [${label}] Backup created` });
+    // ── 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: `[AutoPilot] ✅ [${label}] Browser action auto-confirm patched` });
+            } else {
+                process.send({ type: 'log', msg: `[AutoPilot] ⚠️ [${label}] Browser target found ${count}x (expected 1)` });
+            }
+        }
+    } else {
+        process.send({ type: 'log', msg: `[AutoPilot] ⏭️  [${label}] Browser action already patched` });
     }
 
-    const patched = content.replace(analysis.target, analysis.replacement);
-    fs.writeFileSync(filePath, patched, 'utf8');
+    // ── 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: `[AutoPilot] ✅ [${label}] File permission auto-allow patched` });
+            } else {
+                process.send({ type: 'log', msg: `[AutoPilot] ⚠️ [${label}] File target found ${count}x (expected 1)` });
+            }
+        }
+    } else {
+        process.send({ type: 'log', msg: `[AutoPilot] ⏭️  [${label}] File permission already patched` });
+    }
 
-    const sizeDiff = fs.statSync(filePath).size - fs.statSync(bakPath).size;
-    process.send({ type: 'log', msg: `[AutoAccept] ✅ [${label}] Patched (+${sizeDiff} bytes)` });
+    if (anyPatched) {
+        fs.writeFileSync(filePath, patched, 'utf8');
+        const sizeDiff = fs.statSync(filePath).size - fs.statSync(bakPath).size;
+        process.send({ type: 'log', msg: `[AutoPilot] ✅ [${label}] All patches applied (+${sizeDiff} bytes)` });
+    } else if (!content.includes('_aep=') && !content.includes('_abp=') && !content.includes('_afp=')) {
+        process.send({ type: 'log', msg: `[AutoPilot] ❌ [${label}] No patches could be applied` });
+        return false;
+    } else {
+        process.send({ type: 'log', msg: `[AutoPilot] ⏭️  [${label}] All patches already applied` });
+    }
     return true;
 }
 
 function revertFile(filePath, label) {
     const bak = filePath + '.bak';
     if (!fs.existsSync(bak)) {
-        process.send({ type: 'log', msg: `[AutoAccept] ⏭️  [${label}] No backup, skipping` });
+        process.send({ type: 'log', msg: `[AutoPilot] ⏭️  [${label}] No backup, skipping` });
         return;
     }
     fs.copyFileSync(bak, filePath);
-    process.send({ type: 'log', msg: `[AutoAccept] ✅ [${label}] Reverted` });
+    process.send({ type: 'log', msg: `[AutoPilot] ✅ [${label}] Reverted` });
 }
 
 // ─── Message Handler ──────────────────────────────────────────────────────────
@@ -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);
 
@@ -288,7 +501,7 @@ process.on('message', (msg) => {
             success,
             message: success
                 ? '✅ Patch thành công! Restart Antigravity để áp dụng.'
-                : '⚠️ Một số file không patch được. Xem Output > AutoAccept để biết chi tiết.',
+                : '⚠️ Một số file không patch được. Xem Output > AutoPilot để biết chi tiết.',
         });
         process.exit(success ? 0 : 1);