antigravity-autopilot 1.4.4 → 1.4.6

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/cli.js

@@ -1,12 +1,15 @@
 #!/usr/bin/env node
 
 /**
- * Antigravity AutoPilot — CLI v1.3.0
+ * Antigravity AutoPilot — CLI v1.4.0
  * ====================================
- *   npx antigravity-autopilot           Apply patch
- *   npx antigravity-autopilot --check   Check status
- *   npx antigravity-autopilot --revert  Restore originals
- *   npx antigravity-autopilot --help    Show help
+ *   npx antigravity-autopilot                Apply all patches
+ *   npx antigravity-autopilot --only terminal  Patch terminal only
+ *   npx antigravity-autopilot --only browser   Patch browser only
+ *   npx antigravity-autopilot --only file      Patch file only
+ *   npx antigravity-autopilot --check        Check status
+ *   npx antigravity-autopilot --revert       Restore originals
+ *   npx antigravity-autopilot --help         Show help
  */
 
 'use strict';
@@ -71,7 +74,8 @@ function printBanner() {
 
 function printHelp() {
     const cmds = [
-        ['(no args)', 'Apply the AutoPilot patch'],
+        ['(no args)', 'Apply all patches (terminal, browser, file)'],
+        ['--only TYPE', 'Patch only: terminal | browser | file'],
         ['--check', 'Check current patch status'],
         ['--revert', 'Restore original files'],
         ['--help', 'Show this help screen'],
@@ -82,9 +86,15 @@ function printHelp() {
     console.log(c.bold + c.white + '  OPTIONS' + c.reset);
     console.log(c.gray + '  ─────────────────────────────────────────────' + c.reset);
     for (const [flag, desc] of cmds) {
-        console.log('  ' + c.yellow + c.bold + flag.padEnd(12) + c.reset + '  ' + c.white + desc + c.reset);
+        console.log('  ' + c.yellow + c.bold + flag.padEnd(14) + c.reset + '  ' + c.white + desc + c.reset);
     }
     console.log('');
+    console.log(c.bold + c.white + '  PATCH TYPES' + c.reset);
+    console.log(c.gray + '  ─────────────────────────────────────────────' + c.reset);
+    console.log('  ' + c.cyan + 'terminal' + c.reset + '      Auto-execute terminal commands');
+    console.log('  ' + c.cyan + 'browser' + c.reset + '       Auto-confirm browser actions');
+    console.log('  ' + c.cyan + 'file' + c.reset + '          Auto-allow file permissions');
+    console.log('');
     console.log(c.bold + c.white + '  WORKFLOW' + c.reset);
     console.log(c.gray + '  ─────────────────────────────────────────────' + c.reset);
     console.log('  ' + c.green + '1.' + c.reset + ' Run ' + c.cyan + 'npx antigravity-autopilot' + c.reset + '  →  patch applied');
@@ -185,12 +195,12 @@ function getVersion(basePath) {
     } catch { return 'unknown'; }
 }
 
-// ─── Core Patch Logic ─────────────────────────────────────────────────────────
+// ─── Analyze: Terminal Auto-Execute ───────────────────────────────────────────
 
-function analyzeFile(content, label) {
+function analyzeTerminal(content) {
     const onChangeRe = /(\w+)=(\w+)\((\w+)=>\{\w+\?\.setTerminalAutoExecutionPolicy\?\.\(\3\),\3===(\w+)\.EAGER\&\&(\w+)\(!0\)\},\[[\w,]*\]\)/;
     const onChangeMatch = content.match(onChangeRe);
-    if (!onChangeMatch) { return null; }
+    if (!onChangeMatch) return null;
 
     const [fullMatch, , callbackAlias, , enumAlias, confirmFn] = onChangeMatch;
     const matchIndex = content.indexOf(fullMatch);
@@ -235,50 +245,183 @@ function analyzeFile(content, label) {
     };
 }
 
-// ─── File Operations ──────────────────────────────────────────────────────────
+// ─── Analyze: Browser Action Auto-Confirm ─────────────────────────────────────
+
+function analyzeBrowser(content) {
+    // Find the browserAction confirm:!0 callback pattern
+    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) return null;
+
+    const [fullMatch, confirmVar] = confirmMatch;
+    const matchIndex = content.indexOf(fullMatch);
+
+    // 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 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, maxCount = 0;
+    for (const [alias, count] of Object.entries(effectCandidates)) {
+        if (count > maxCount) { maxCount = count; useEffectAlias = alias; }
+    }
+    if (!useEffectAlias) return null;
 
-function isPatched(filePath) {
-    if (!fs.existsSync(filePath)) return false;
-    const c = fs.readFileSync(filePath, 'utf8');
-    return c.includes('_aep=') && /_aep=\w+\(()=>\{[^}]+EAGER/.test(c);
+    const patchCode = `_abp=${useEffectAlias}(()=>{${confirmVar}()},[${confirmVar}]),`;
+    return {
+        target: fullMatch,
+        replacement: patchCode + fullMatch,
+        patchMarker: `_abp=${useEffectAlias}(()=>{${confirmVar}()}`,
+    };
 }
 
+// ─── Analyze: File Permission Auto-Allow ──────────────────────────────────────
+
+function analyzeFile_(content) {
+    // Find the filePermission sender pattern
+    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) return null;
+
+    const [fullMatch, senderVar, , , , , , , , reqVar] = senderMatch;
+    const matchIndex = content.indexOf(fullMatch);
+
+    // Find scope enum — look for senderVar(!0, ENUM.CONVERSATION)
+    const scopeRe = new RegExp(`${senderVar.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\(!0,(\\w+)\\.CONVERSATION\\)`);
+    const scopeMatch = content.substring(matchIndex, matchIndex + 2000).match(scopeRe);
+    if (!scopeMatch) return null;
+    const scopeEnum = scopeMatch[1];
+
+    // 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, maxCount = 0;
+    for (const [alias, count] of Object.entries(effectCandidates)) {
+        if (count > maxCount) { maxCount = count; useEffectAlias = alias; }
+    }
+    if (!useEffectAlias) return null;
+
+    const patchCode = `_afp=${useEffectAlias}(()=>{${senderVar}(!0,${scopeEnum}.CONVERSATION)},[${senderVar}]),`;
+    return {
+        target: fullMatch,
+        replacement: patchCode + fullMatch,
+        patchMarker: `_afp=${useEffectAlias}(()=>{${senderVar}(!0,${scopeEnum}.CONVERSATION)`,
+    };
+}
+
+// ─── Patch Status Detection ───────────────────────────────────────────────────
+
+const PATCH_TYPES = ['terminal', 'browser', 'file'];
+const PATCH_LABELS = { terminal: 'Terminal auto-execute', browser: 'Browser auto-confirm', file: 'File auto-allow' };
+const PATCH_MARKERS = {
+    terminal: { includes: '_aep=', re: /_aep=\w+\(\(\)=>\{[^}]+EAGER/ },
+    browser: { includes: '_abp=', re: /_abp=\w+\(\(\)=>\{\w+\(\)\}/ },
+    file: { includes: '_afp=', re: /_afp=\w+\(\(\)=>\{\w+\(!0,/ },
+};
+const ANALYZERS = {
+    terminal: analyzeTerminal,
+    browser: analyzeBrowser,
+    file: analyzeFile_,
+};
+
+function getPatchStatus(content) {
+    const status = {};
+    for (const type of PATCH_TYPES) {
+        const m = PATCH_MARKERS[type];
+        status[type] = content.includes(m.includes) && m.re.test(content);
+    }
+    return status;
+}
+
+// ─── Display Helpers ──────────────────────────────────────────────────────────
+
 function row(icon, color, label, msg) {
     console.log('  ' + color + icon + c.reset + '  ' + c.bold + label.padEnd(14) + c.reset + c.gray + msg + c.reset);
 }
 
-function patchFile(filePath, label) {
+function patchRow(icon, color, fileLabel, patchType, msg) {
+    const combined = `[${fileLabel}]`;
+    console.log('  ' + color + icon + c.reset + '  ' + c.bold + combined.padEnd(16) + c.reset + c.cyan + patchType.padEnd(10) + c.reset + c.gray + msg + c.reset);
+}
+
+// ─── File Operations ──────────────────────────────────────────────────────────
+
+function patchFile(filePath, label, onlyTypes) {
     if (!fs.existsSync(filePath)) {
         row('⊘', c.gray, `[${label}]`, 'File not found — skipping');
         return true;
     }
+
     const content = fs.readFileSync(filePath, 'utf8');
-    if (isPatched(filePath)) {
-        row('✔', c.green, `[${label}]`, 'Already patched');
-        return true;
-    }
-    const analysis = analyzeFile(content, label);
-    if (!analysis) {
-        row('✖', c.red, `[${label}]`, 'Pattern not found — may be incompatible version');
-        return false;
-    }
+    const status = getPatchStatus(content);
+    const typesToPatch = onlyTypes || PATCH_TYPES;
 
-    const count = content.split(analysis.target).length - 1;
-    if (count !== 1) {
-        row('✖', c.red, `[${label}]`, `Target found ${count}× (expected 1)`);
-        return false;
+    let patched = content;
+    let anyNewPatch = false;
+    let anyFailure = false;
+
+    for (const type of typesToPatch) {
+        if (status[type]) {
+            patchRow('✔', c.green, label, type, 'Already patched — skipped');
+            continue;
+        }
+        const analysis = ANALYZERS[type](patched);
+        if (!analysis) {
+            patchRow('⊘', c.yellow, label, type, 'Pattern not found — may be incompatible');
+            // Not a hard failure — the pattern might not exist in this file
+            continue;
+        }
+        const count = patched.split(analysis.target).length - 1;
+        if (count !== 1) {
+            patchRow('✖', c.red, label, type, `Target found ${count}× (expected 1)`);
+            anyFailure = true;
+            continue;
+        }
+        patched = patched.replace(analysis.target, analysis.replacement);
+        anyNewPatch = true;
+        patchRow('✔', c.green, label, type, 'Patched successfully');
     }
 
-    const bak = filePath + '.bak';
-    if (!fs.existsSync(bak)) {
-        fs.copyFileSync(filePath, bak);
-        row('◈', c.blue, `[${label}]`, 'Backup created (.bak)');
+    if (anyNewPatch) {
+        // Backup original (before any patching)
+        const bak = filePath + '.bak';
+        if (!fs.existsSync(bak)) {
+            fs.copyFileSync(filePath, filePath + '.bak');
+        }
+        fs.writeFileSync(filePath, patched, 'utf8');
+        const diff = fs.statSync(filePath).size - fs.statSync(filePath + '.bak').size;
+        row('◈', c.blue, `[${label}]`, `Written (+${diff} bytes)`);
     }
 
-    fs.writeFileSync(filePath, content.replace(analysis.target, analysis.replacement), 'utf8');
-    const diff = fs.statSync(filePath).size - fs.statSync(bak).size;
-    row('✔', c.green, `[${label}]`, `Patched successfully (+${diff} bytes)`);
-    return true;
+    return !anyFailure;
 }
 
 function revertFile(filePath, label) {
@@ -293,22 +436,28 @@ function revertFile(filePath, label) {
 
 function checkFile(filePath, label) {
     if (!fs.existsSync(filePath)) {
-        row('✖', c.red, `[${label}]`, 'File not found');
+        row('⊘', c.gray, `[${label}]`, 'File not found');
         return false;
     }
     const content = fs.readFileSync(filePath, 'utf8');
-    const patched = isPatched(filePath);
+    const status = getPatchStatus(content);
     const hasBak = fs.existsSync(filePath + '.bak');
-    const analysis = !patched ? analyzeFile(content, label) : null;
-
-    if (patched) {
-        row('✔', c.green, `[${label}]`, 'PATCHED' + (hasBak ? ' · backup exists' : ''));
-    } else if (analysis) {
-        row('○', c.yellow, `[${label}]`, 'NOT PATCHED · patchable, ready to apply');
-    } else {
-        row('⚠', c.yellow, `[${label}]`, 'NOT PATCHED · may be incompatible');
+    let allPatched = true;
+
+    for (const type of PATCH_TYPES) {
+        if (status[type]) {
+            patchRow('✔', c.green, label, type, 'PATCHED' + (hasBak ? ' · backup exists' : ''));
+        } else {
+            const analysis = ANALYZERS[type](content);
+            if (analysis) {
+                patchRow('○', c.yellow, label, type, 'NOT PATCHED · patchable');
+            } else {
+                patchRow('⊘', c.gray, label, type, 'NOT PATCHED · pattern not found');
+            }
+            allPatched = false;
+        }
     }
-    return patched;
+    return allPatched;
 }
 
 // ─── Main ─────────────────────────────────────────────────────────────────────
@@ -320,6 +469,18 @@ function main() {
             : args.includes('--help') ? 'help'
                 : 'apply';
 
+    // Parse --only flag
+    let onlyTypes = null;
+    const onlyIdx = args.indexOf('--only');
+    if (onlyIdx !== -1 && args[onlyIdx + 1]) {
+        const requested = args[onlyIdx + 1].toLowerCase();
+        if (!PATCH_TYPES.includes(requested)) {
+            console.error(`Unknown patch type: ${requested}. Valid types: ${PATCH_TYPES.join(', ')}`);
+            process.exit(1);
+        }
+        onlyTypes = [requested];
+    }
+
     printBanner();
 
     if (action === 'help') { printHelp(); return; }
@@ -346,7 +507,12 @@ function main() {
             console.log('');
             files.forEach(f => checkFile(f.filePath, f.label));
             console.log('');
-            const allPatched = files.every(f => isPatched(f.filePath));
+            const allPatched = files.every(f => {
+                if (!fs.existsSync(f.filePath)) return true;
+                const content = fs.readFileSync(f.filePath, 'utf8');
+                const s = getPatchStatus(content);
+                return s.terminal && s.browser && s.file;
+            });
             if (allPatched) {
                 console.log('  ' + c.green + c.bold + '✔  AutoPilot is ACTIVE on this machine.' + c.reset);
                 console.log('  ' + c.gray + 'Restart Antigravity for changes to take effect.' + c.reset);
@@ -369,9 +535,10 @@ function main() {
 
         case 'apply':
         default: {
-            section('Applying AutoPilot Patch', '⚡');
+            const typeLabel = onlyTypes ? onlyTypes.join(', ') : 'all';
+            section(`Applying AutoPilot Patch (${typeLabel})`, '⚡');
             console.log('');
-            const ok = files.every(f => patchFile(f.filePath, f.label));
+            const ok = files.every(f => patchFile(f.filePath, f.label, onlyTypes));
             console.log('');
             if (ok) {
                 console.log('  +' + repeat('-', W - 2) + '+');
@@ -379,10 +546,11 @@ function main() {
                 console.log('  |' + pad(c.white + '     Restart Antigravity to activate AutoPilot.' + c.reset, W - 2) + '|');
                 console.log('  |' + repeat(' ', W - 2) + '|');
                 console.log('  |' + pad(c.gray + '  TIP Run with --revert to undo at any time.' + c.reset, W - 2) + '|');
+                console.log('  |' + pad(c.gray + '  TIP Run with --check to see patch status.' + c.reset, W - 2) + '|');
                 console.log('  |' + pad(c.gray + '  NOTE Re-run this command after Antigravity updates.' + c.reset, W - 2) + '|');
                 console.log('  +' + repeat('-', W - 2) + '+');
             } else {
-                console.log('  ' + c.red + c.bold + '✖  Some files could not be patched.' + c.reset);
+                console.log('  ' + c.red + c.bold + '✖  Some patches could not be applied.' + c.reset);
                 console.log('  ' + c.gray + 'Check output above for details.' + c.reset);
                 process.exit(1);
             }

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);
@@ -344,19 +344,19 @@ class AntigravityPanelProvider {
           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 cfg = vscode.workspace.getConfiguration('antigravityAutoPilot');
+        const current = cfg.get('browserPermission', true);
         const next = !current;
-        await cfg.update('autoAcceptBrowserPermission', next, vscode.ConfigurationTarget.Global);
+        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('antigravityAutoAccept');
-        const current = cfg.get('autoAcceptFilePermission', true);
+        const cfg = vscode.workspace.getConfiguration('antigravityAutoPilot');
+        const current = cfg.get('filePermission', true);
         const next = !current;
-        await cfg.update('autoAcceptFilePermission', next, vscode.ConfigurationTarget.Global);
+        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',
@@ -380,13 +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('antigravityAutoAccept').get('autoAcceptBrowserPermission', true),
+      vscode.workspace.getConfiguration('antigravityAutoPilot').get('browserPermission', true),
     );
     this.sendFilePermissionEnabled(
-      vscode.workspace.getConfiguration('antigravityAutoAccept').get('autoAcceptFilePermission', true),
+      vscode.workspace.getConfiguration('antigravityAutoPilot').get('filePermission', true),
     );
     this.sendPatterns();
   }
@@ -894,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();
@@ -909,7 +909,7 @@ function activate(context) {
   panelProvider = new AntigravityPanelProvider(context);
   context.subscriptions.push(
     vscode.window.registerWebviewViewProvider(
-      'antigravityAutoAccept.panel',
+      'antigravityAutoPilot.panel',
       panelProvider,
       { webviewOptions: { retainContextWhenHidden: true } },
     ),
@@ -932,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);
       }
@@ -942,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!');
@@ -975,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,9 +2,9 @@
   "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.4",
+  "version": "1.4.6",
   "license": "MIT",
-  "publisher": "nguyen-hoang",
+  "publisher": "nguyenhx2",
   "bin": {
     "antigravity-autopilot": "./cli.js"
   },
@@ -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,7 +102,7 @@
           "default": "block",
           "description": "Action to take when a dangerous command is detected."
         },
-        "antigravityAutoAccept.dangerousCommandBlocking.customPatterns": {
+        "antigravityAutoPilot.dangerousCommandBlocking.customPatterns": {
           "type": "array",
           "items": {
             "type": "string"
@@ -110,12 +110,12 @@
           "default": [],
           "description": "Additional regex patterns (JavaScript syntax) to treat as dangerous commands. Example: [\"^dd if=.*of=/dev/sd\", \"^shred\"]"
         },
-        "antigravityAutoAccept.autoAcceptBrowserPermission": {
+        "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."
         },
-        "antigravityAutoAccept.autoAcceptFilePermission": {
+        "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)},[...])
@@ -196,7 +196,7 @@ function analyzeFile(content, label) {
  * 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}` });
+    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)
@@ -267,7 +267,7 @@ function analyzeBrowserAction(content, label) {
  * 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}` });
+    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})}}))};
@@ -360,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
     }
 
@@ -368,7 +368,7 @@ 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;
     }
 
@@ -376,7 +376,7 @@ function patchFile(filePath, label) {
     const bakPath = filePath + '.bak';
     if (!fs.existsSync(bakPath)) {
         fs.copyFileSync(filePath, bakPath);
-        process.send({ type: 'log', msg: `[AutoAccept] 📦 [${label}] Backup created` });
+        process.send({ type: 'log', msg: `[AutoPilot] 📦 [${label}] Backup created` });
     }
 
     let patched = content;
@@ -390,13 +390,13 @@ function patchFile(filePath, label) {
             if (count === 1) {
                 patched = patched.replace(analysis.target, analysis.replacement);
                 anyPatched = true;
-                process.send({ type: 'log', msg: `[AutoAccept] ✅ [${label}] Terminal auto-execute patched` });
+                process.send({ type: 'log', msg: `[AutoPilot] ✅ [${label}] Terminal auto-execute patched` });
             } else {
-                process.send({ type: 'log', msg: `[AutoAccept] ⚠️ [${label}] Terminal target found ${count}x (expected 1)` });
+                process.send({ type: 'log', msg: `[AutoPilot] ⚠️ [${label}] Terminal target found ${count}x (expected 1)` });
             }
         }
     } else {
-        process.send({ type: 'log', msg: `[AutoAccept] ⏭️  [${label}] Terminal already patched` });
+        process.send({ type: 'log', msg: `[AutoPilot] ⏭️  [${label}] Terminal already patched` });
     }
 
     // ── Browser action auto-confirm patch ──
@@ -407,13 +407,13 @@ function patchFile(filePath, label) {
             if (count === 1) {
                 patched = patched.replace(browserAnalysis.target, browserAnalysis.replacement);
                 anyPatched = true;
-                process.send({ type: 'log', msg: `[AutoAccept] ✅ [${label}] Browser action auto-confirm patched` });
+                process.send({ type: 'log', msg: `[AutoPilot] ✅ [${label}] Browser action auto-confirm patched` });
             } else {
-                process.send({ type: 'log', msg: `[AutoAccept] ⚠️ [${label}] Browser target found ${count}x (expected 1)` });
+                process.send({ type: 'log', msg: `[AutoPilot] ⚠️ [${label}] Browser target found ${count}x (expected 1)` });
             }
         }
     } else {
-        process.send({ type: 'log', msg: `[AutoAccept] ⏭️  [${label}] Browser action already patched` });
+        process.send({ type: 'log', msg: `[AutoPilot] ⏭️  [${label}] Browser action already patched` });
     }
 
     // ── File permission auto-allow patch ──
@@ -424,24 +424,24 @@ function patchFile(filePath, label) {
             if (count === 1) {
                 patched = patched.replace(fileAnalysis.target, fileAnalysis.replacement);
                 anyPatched = true;
-                process.send({ type: 'log', msg: `[AutoAccept] ✅ [${label}] File permission auto-allow patched` });
+                process.send({ type: 'log', msg: `[AutoPilot] ✅ [${label}] File permission auto-allow patched` });
             } else {
-                process.send({ type: 'log', msg: `[AutoAccept] ⚠️ [${label}] File target found ${count}x (expected 1)` });
+                process.send({ type: 'log', msg: `[AutoPilot] ⚠️ [${label}] File target found ${count}x (expected 1)` });
             }
         }
     } else {
-        process.send({ type: 'log', msg: `[AutoAccept] ⏭️  [${label}] File permission already patched` });
+        process.send({ type: 'log', msg: `[AutoPilot] ⏭️  [${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)` });
+        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: `[AutoAccept] ❌ [${label}] No patches could be applied` });
+        process.send({ type: 'log', msg: `[AutoPilot] ❌ [${label}] No patches could be applied` });
         return false;
     } else {
-        process.send({ type: 'log', msg: `[AutoAccept] ⏭️  [${label}] All patches already applied` });
+        process.send({ type: 'log', msg: `[AutoPilot] ⏭️  [${label}] All patches already applied` });
     }
     return true;
 }
@@ -449,11 +449,11 @@ function patchFile(filePath, label) {
 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 ──────────────────────────────────────────────────────────
@@ -501,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);