antigravity-autopilot 1.0.0

package/AutoAccept.ps1

@@ -0,0 +1,305 @@
+# Antigravity Auto-Accept - Floating Panel
+# A small always-on-top window for toggling auto-accept
+# Run with: powershell -WindowStyle Hidden -File AutoAccept.ps1
+
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+public class WinAPI {
+    [DllImport("user32.dll")]
+    public static extern IntPtr GetForegroundWindow();
+    [DllImport("user32.dll", SetLastError=true)]
+    public static extern int GetWindowThreadProcessId(IntPtr hWnd, out int processId);
+    [DllImport("user32.dll")]
+    public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);
+}
+"@
+
+# ---- State ----
+$script:IsEnabled = $false
+$script:Count = 0
+$script:Timer = $null
+$HWND_TOPMOST = [IntPtr](-1)
+$SWP_NOSIZE = 0x0001
+$SWP_NOMOVE = 0x0002
+
+# ---- Fonts & Colors ----
+$fontMain = New-Object System.Drawing.Font("Segoe UI", 9)
+$fontBig = New-Object System.Drawing.Font("Segoe UI", 11, [System.Drawing.FontStyle]::Bold)
+$fontMono = New-Object System.Drawing.Font("Consolas", 8)
+$colorBg = [System.Drawing.Color]::FromArgb(30, 30, 30)
+$colorPanel = [System.Drawing.Color]::FromArgb(40, 40, 40)
+$colorOn = [System.Drawing.Color]::FromArgb(0, 200, 100)
+$colorOff = [System.Drawing.Color]::FromArgb(100, 100, 100)
+$colorText = [System.Drawing.Color]::White
+$colorDim = [System.Drawing.Color]::FromArgb(160, 160, 160)
+$colorAccent = [System.Drawing.Color]::FromArgb(90, 180, 255)
+
+# ---- Main Form ----
+$form = New-Object System.Windows.Forms.Form
+$form.Text = "AG Auto-Accept"
+$form.Size = New-Object System.Drawing.Size(280, 320)
+$form.StartPosition = "Manual"
+$form.Location = New-Object System.Drawing.Point(
+    ([System.Windows.Forms.Screen]::PrimaryScreen.WorkingArea.Right - 290),
+    ([System.Windows.Forms.Screen]::PrimaryScreen.WorkingArea.Bottom - 330)
+)
+$form.FormBorderStyle = "FixedSingle"
+$form.MaximizeBox = $false
+$form.MinimizeBox = $true
+$form.BackColor = $colorBg
+$form.ForeColor = $colorText
+$form.Font = $fontMain
+$form.TopMost = $true
+$form.ShowInTaskbar = $true
+
+# ---- Title bar area ----
+$lblTitle = New-Object System.Windows.Forms.Label
+$lblTitle.Text = "⚡ Antigravity Auto-Accept"
+$lblTitle.Font = $fontBig
+$lblTitle.ForeColor = $colorAccent
+$lblTitle.Location = New-Object System.Drawing.Point(12, 12)
+$lblTitle.Size = New-Object System.Drawing.Size(256, 24)
+$form.Controls.Add($lblTitle)
+
+$lblSub = New-Object System.Windows.Forms.Label
+$lblSub.Text = "Tự động accept Antigravity commands"
+$lblSub.Font = $fontMono
+$lblSub.ForeColor = $colorDim
+$lblSub.Location = New-Object System.Drawing.Point(12, 36)
+$lblSub.Size = New-Object System.Drawing.Size(256, 16)
+$form.Controls.Add($lblSub)
+
+# ---- Separator ----
+$sep = New-Object System.Windows.Forms.Label
+$sep.Location = New-Object System.Drawing.Point(12, 57)
+$sep.Size = New-Object System.Drawing.Size(254, 1)
+$sep.BackColor = [System.Drawing.Color]::FromArgb(60, 60, 60)
+$form.Controls.Add($sep)
+
+# ---- Status indicator (big circle + text) ----
+$pnlStatus = New-Object System.Windows.Forms.Panel
+$pnlStatus.Location = New-Object System.Drawing.Point(12, 68)
+$pnlStatus.Size = New-Object System.Drawing.Size(254, 80)
+$pnlStatus.BackColor = $colorPanel
+$form.Controls.Add($pnlStatus)
+
+$picDot = New-Object System.Windows.Forms.PictureBox
+$picDot.Location = New-Object System.Drawing.Point(16, 20)
+$picDot.Size = New-Object System.Drawing.Size(40, 40)
+$picDot.BackColor = [System.Drawing.Color]::Transparent
+$pnlStatus.Controls.Add($picDot)
+
+function Draw-Dot([bool]$on) {
+    $bmp = New-Object System.Drawing.Bitmap(40, 40)
+    $g = [System.Drawing.Graphics]::FromImage($bmp)
+    $g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
+    $g.Clear([System.Drawing.Color]::Transparent)
+    if ($on) {
+        $g.FillEllipse([System.Drawing.Brushes]::LimeGreen, 4, 4, 32, 32)
+        # lightning bolt
+        $pen = New-Object System.Drawing.Pen([System.Drawing.Color]::White, 2.5)
+        $pts = @(
+            [System.Drawing.Point]::new(24, 8),
+            [System.Drawing.Point]::new(16, 22),
+            [System.Drawing.Point]::new(22, 22),
+            [System.Drawing.Point]::new(14, 32)
+        )
+        $g.DrawLines($pen, $pts)
+        $pen.Dispose()
+    }
+    else {
+        $g.FillEllipse([System.Drawing.Brushes]::DimGray, 4, 4, 32, 32)
+        $pen = New-Object System.Drawing.Pen([System.Drawing.Color]::Gray, 2)
+        $g.DrawLine($pen, 12, 12, 28, 28)
+        $g.DrawLine($pen, 28, 12, 12, 28)
+        $pen.Dispose()
+    }
+    $g.Dispose()
+    $picDot.Image = $bmp
+}
+Draw-Dot $false
+
+$lblStatus = New-Object System.Windows.Forms.Label
+$lblStatus.Text = "OFF"
+$lblStatus.Font = New-Object System.Drawing.Font("Segoe UI", 20, [System.Drawing.FontStyle]::Bold)
+$lblStatus.ForeColor = $colorOff
+$lblStatus.Location = New-Object System.Drawing.Point(66, 14)
+$lblStatus.Size = New-Object System.Drawing.Size(100, 36)
+$pnlStatus.Controls.Add($lblStatus)
+
+$lblStatusSub = New-Object System.Windows.Forms.Label
+$lblStatusSub.Text = "Click button to enable"
+$lblStatusSub.Font = $fontMono
+$lblStatusSub.ForeColor = $colorDim
+$lblStatusSub.Location = New-Object System.Drawing.Point(66, 50)
+$lblStatusSub.Size = New-Object System.Drawing.Size(180, 20)
+$pnlStatus.Controls.Add($lblStatusSub)
+
+# ---- Stats ----
+$pnlStats = New-Object System.Windows.Forms.Panel
+$pnlStats.Location = New-Object System.Drawing.Point(12, 158)
+$pnlStats.Size = New-Object System.Drawing.Size(254, 50)
+$pnlStats.BackColor = $colorPanel
+$form.Controls.Add($pnlStats)
+
+$lblCountLabel = New-Object System.Windows.Forms.Label
+$lblCountLabel.Text = "Accepted"
+$lblCountLabel.Font = $fontMono
+$lblCountLabel.ForeColor = $colorDim
+$lblCountLabel.Location = New-Object System.Drawing.Point(12, 8)
+$lblCountLabel.Size = New-Object System.Drawing.Size(80, 16)
+$pnlStats.Controls.Add($lblCountLabel)
+
+$lblCount = New-Object System.Windows.Forms.Label
+$lblCount.Text = "0"
+$lblCount.Font = New-Object System.Drawing.Font("Segoe UI", 14, [System.Drawing.FontStyle]::Bold)
+$lblCount.ForeColor = $colorAccent
+$lblCount.Location = New-Object System.Drawing.Point(100, 4)
+$lblCount.Size = New-Object System.Drawing.Size(80, 30)
+$pnlStats.Controls.Add($lblCount)
+
+$lblUnit = New-Object System.Windows.Forms.Label
+$lblUnit.Text = "commands"
+$lblUnit.Font = $fontMono
+$lblUnit.ForeColor = $colorDim
+$lblUnit.Location = New-Object System.Drawing.Point(180, 10)
+$lblUnit.Size = New-Object System.Drawing.Size(70, 16)
+$pnlStats.Controls.Add($lblUnit)
+
+# ---- Toggle Button ----
+$btnToggle = New-Object System.Windows.Forms.Button
+$btnToggle.Text = "▶  ENABLE AUTO-ACCEPT"
+$btnToggle.Font = New-Object System.Drawing.Font("Segoe UI", 10, [System.Drawing.FontStyle]::Bold)
+$btnToggle.Size = New-Object System.Drawing.Size(254, 44)
+$btnToggle.Location = New-Object System.Drawing.Point(12, 220)
+$btnToggle.FlatStyle = [System.Windows.Forms.FlatStyle]::Flat
+$btnToggle.FlatAppearance.BorderSize = 0
+$btnToggle.BackColor = [System.Drawing.Color]::FromArgb(0, 150, 80)
+$btnToggle.ForeColor = $colorText
+$btnToggle.Cursor = [System.Windows.Forms.Cursors]::Hand
+$form.Controls.Add($btnToggle)
+
+# ---- Interval label ----
+$lblInterval = New-Object System.Windows.Forms.Label
+$lblInterval.Text = "Interval: 800ms  |  Only when VS Code focused"
+$lblInterval.Font = $fontMono
+$lblInterval.ForeColor = $colorDim
+$lblInterval.Location = New-Object System.Drawing.Point(12, 274)
+$lblInterval.Size = New-Object System.Drawing.Size(254, 16)
+$lblInterval.TextAlign = [System.Drawing.ContentAlignment]::MiddleCenter
+$form.Controls.Add($lblInterval)
+
+# ---- System tray icon ----
+$tray = New-Object System.Windows.Forms.NotifyIcon
+$tray.Text = "Antigravity Auto-Accept: OFF"
+$tray.Visible = $true
+
+$trayBmp = New-Object System.Drawing.Bitmap(16, 16)
+$tg = [System.Drawing.Graphics]::FromImage($trayBmp)
+$tg.Clear([System.Drawing.Color]::Transparent)
+$tg.FillEllipse([System.Drawing.Brushes]::CornflowerBlue, 1, 1, 14, 14)
+$tg.Dispose()
+$tray.Icon = [System.Drawing.Icon]::FromHandle($trayBmp.GetHicon())
+
+$trayMenu = New-Object System.Windows.Forms.ContextMenuStrip
+$trayShow = New-Object System.Windows.Forms.ToolStripMenuItem "Show Panel"
+$trayToggle = New-Object System.Windows.Forms.ToolStripMenuItem "Enable Auto-Accept"
+$traySep = New-Object System.Windows.Forms.ToolStripSeparator
+$trayExit = New-Object System.Windows.Forms.ToolStripMenuItem "Exit"
+$trayMenu.Items.AddRange(@($trayShow, $trayToggle, $traySep, $trayExit))
+$tray.ContextMenuStrip = $trayMenu
+
+# ---- Core: Send Alt+A ----
+function Send-AltA {
+    $fgWnd = [WinAPI]::GetForegroundWindow()
+    $fgPid = 0
+    [WinAPI]::GetWindowThreadProcessId($fgWnd, [ref]$fgPid) | Out-Null
+    $fgProc = Get-Process -Id $fgPid -ErrorAction SilentlyContinue
+    if ($fgProc -and $fgProc.ProcessName -match 'Code') {
+        [System.Windows.Forms.SendKeys]::SendWait("%a")
+        $script:Count++
+        $lblCount.Text = "$($script:Count)"
+        $tray.Text = "AG Auto-Accept: ON ($($script:Count) accepted)"
+    }
+}
+
+# ---- Toggle logic ----
+function Toggle {
+    $script:IsEnabled = -not $script:IsEnabled
+
+    if ($script:IsEnabled) {
+        $script:Count = 0
+        $lblCount.Text = "0"
+
+        # Start timer
+        $script:Timer = New-Object System.Windows.Forms.Timer
+        $script:Timer.Interval = 800
+        $script:Timer.Add_Tick({ Send-AltA })
+        $script:Timer.Start()
+
+        # Update UI
+        $lblStatus.Text = "ON"
+        $lblStatus.ForeColor = $colorOn
+        $lblStatusSub.Text = "Sending Alt+A every 800ms..."
+        $btnToggle.Text = "⏸  DISABLE AUTO-ACCEPT"
+        $btnToggle.BackColor = [System.Drawing.Color]::FromArgb(180, 50, 50)
+        $pnlStatus.BackColor = [System.Drawing.Color]::FromArgb(20, 60, 30)
+        $trayToggle.Text = "Disable Auto-Accept"
+        $tray.Text = "AG Auto-Accept: ON"
+        Draw-Dot $true
+
+        $tray.ShowBalloonTip(2000, "Auto-Accept ON", "Tự động accept Antigravity commands", [System.Windows.Forms.ToolTipIcon]::Info)
+    }
+    else {
+        if ($script:Timer) {
+            $script:Timer.Stop()
+            $script:Timer.Dispose()
+            $script:Timer = $null
+        }
+
+        # Update UI
+        $lblStatus.Text = "OFF"
+        $lblStatus.ForeColor = $colorOff
+        $lblStatusSub.Text = "Click button to enable"
+        $btnToggle.Text = "▶  ENABLE AUTO-ACCEPT"
+        $btnToggle.BackColor = [System.Drawing.Color]::FromArgb(0, 150, 80)
+        $pnlStatus.BackColor = $colorPanel
+        $trayToggle.Text = "Enable Auto-Accept"
+        $tray.Text = "AG Auto-Accept: OFF"
+        Draw-Dot $false
+    }
+}
+
+# ---- Event handlers ----
+$btnToggle.Add_Click({ Toggle })
+$trayToggle.Add_Click({ Toggle })
+$trayShow.Add_Click({ $form.Show(); $form.BringToFront() })
+$tray.Add_DoubleClick({ $form.Show(); $form.BringToFront() })
+$trayExit.Add_Click({
+        if ($script:Timer) { $script:Timer.Stop(); $script:Timer.Dispose() }
+        $tray.Visible = $false
+        $tray.Dispose()
+        $form.Close()
+    })
+$form.Add_FormClosing({
+        param($s, $e)
+        # Minimize to tray instead of closing
+        if ($e.CloseReason -eq [System.Windows.Forms.CloseReason]::UserClosing) {
+            $e.Cancel = $true
+            $form.Hide()
+            $tray.ShowBalloonTip(1500, "Still running!", "Double-click tray icon to reopen.", [System.Windows.Forms.ToolTipIcon]::Info)
+        }
+    })
+
+# Keep always on top
+$form.Add_Shown({
+        [WinAPI]::SetWindowPos($form.Handle, $HWND_TOPMOST, 0, 0, 0, 0, ($SWP_NOSIZE -bor $SWP_NOMOVE)) | Out-Null
+    })
+
+# ---- Launch ----
+$tray.ShowBalloonTip(2500, "Antigravity Auto-Accept", "✅ Running! Click toggle button to enable.", [System.Windows.Forms.ToolTipIcon]::Info)
+[System.Windows.Forms.Application]::Run($form)

package/README.md

@@ -0,0 +1,38 @@
+# Antigravity Auto-Accept
+
+Auto-accept Antigravity tool call prompts with a **one-click toggle** in the VS Code status bar.
+
+## Features
+
+- ⚡ **Status bar toggle** — Click to enable/disable auto-accept
+- 🎯 **Smart targeting** — Only sends keystrokes when VS Code is focused
+- ⌨️ **Keyboard shortcut** — `Ctrl+Shift+F12` to toggle
+- 📊 **Accept counter** — Shows how many commands were auto-accepted
+- ⚙️ **Configurable** — Adjust interval, auto-start on boot
+
+## Installation
+
+```powershell
+# Run from this directory
+.\install.ps1
+```
+
+Then reload VS Code (`Ctrl+Shift+P` → "Developer: Reload Window").
+
+## Usage
+
+1. Look for **`$(circle-slash) Auto-Accept: OFF`** in the status bar (bottom right)
+2. Click it or press `Ctrl+Shift+F12` to toggle ON
+3. When ON (⚡ yellow background), all Antigravity commands will be auto-accepted
+4. Click again to turn OFF
+
+## Settings
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `antigravityAutoAccept.intervalMs` | `800` | Interval between accept attempts (ms) |
+| `antigravityAutoAccept.enabledOnStartup` | `false` | Auto-enable on VS Code start |
+
+## How It Works
+
+Sends `Alt+A` (the Antigravity accept shortcut) via PowerShell `SendKeys` at a configurable interval, but **only** when VS Code is the foreground window.

package/extension.js

@@ -0,0 +1,453 @@
+// @ts-check
+'use strict';
+
+const vscode = require('vscode');
+const path = require('path');
+const { fork } = require('child_process');
+
+const PATCHER = path.join(__dirname, 'patcher.js');
+
+// ─── State ───────────────────────────────────────────────────────────────────
+/** @type {vscode.StatusBarItem} */
+let statusBarItem;
+/** @type {boolean} */
+let isPatchApplied = false;
+/** @type {AntigravityPanelProvider | null} */
+let panelProvider = null;
+/** @type {{ basePath: string|null, files: any[], patched: boolean } | null} */
+let _cachedStatus = null;
+
+// ─── Child Process Bridge ─────────────────────────────────────────────────────
+
+/**
+ * Runs patcher.js in a child process.
+ * All heavy file I/O lives in patcher.js — never blocks the extension host.
+ * @param {'status'|'apply'|'revert'} command
+ * @returns {Promise<any>}
+ */
+function runPatcher(command) {
+  return new Promise((resolve, reject) => {
+    const child = fork(PATCHER, [], { silent: true });
+    const channel = vscode.window.createOutputChannel('AutoAccept');
+
+    child.on('message', (msg) => {
+      if (!msg || typeof msg !== 'object') return;
+      const m = /** @type {{type:string,msg?:string}} */(msg);
+      if (m.type === 'log') {
+        console.log(m.msg);
+        channel.appendLine(m.msg || '');
+      } else {
+        resolve(msg); // status or result message
+      }
+    });
+
+    child.on('error', (err) => {
+      channel.appendLine(`[AutoAccept] fork error: ${err.message}`);
+      reject(err);
+    });
+
+    child.on('exit', (code) => {
+      if (code !== 0) {
+        resolve({
+          type: 'result',
+          success: false,
+          message: `Process exited with code ${code}. Check Output > AutoAccept for details.`,
+        });
+      }
+    });
+
+    child.send({ command });
+  });
+}
+
+// ─── Patch Manager (async, non-blocking) ─────────────────────────────────────
+
+/**
+ * Gets patch status via child process.
+ * @returns {Promise<{basePath:string|null, patched:boolean, files:Array<{label:string,patched:boolean,exists:boolean}>}>}
+ */
+async function getPatchStatus() {
+  try {
+    const res = /** @type {any} */(await runPatcher('status'));
+    const files = res.files || [];
+    _cachedStatus = { basePath: res.basePath || null, files, patched: files.some((/** @type {any} */f) => f.patched) };
+    return _cachedStatus;
+  } catch {
+    return { basePath: null, patched: false, files: [] };
+  }
+}
+
+/**
+ * Applies the patch via child process.
+ * @returns {Promise<{success:boolean, message:string}>}
+ */
+async function applyPatch() {
+  try {
+    const res = /** @type {any} */(await runPatcher('apply'));
+    const success = res.success === true;
+    isPatchApplied = success;
+    await refreshStatus();
+    return { success, message: res.message || '' };
+  } catch (e) {
+    return { success: false, message: `❌ Error: ${e}` };
+  }
+}
+
+/**
+ * Reverts the patch via child process.
+ * @returns {Promise<{success:boolean, message:string}>}
+ */
+async function revertPatch() {
+  try {
+    const res = /** @type {any} */(await runPatcher('revert'));
+    isPatchApplied = false;
+    await refreshStatus();
+    return { success: res.success === true, message: res.message || '' };
+  } catch (e) {
+    return { success: false, message: `❌ Error: ${e}` };
+  }
+}
+
+/** Refreshes status and updates all UI elements. */
+async function refreshStatus() {
+  const status = await getPatchStatus();
+  isPatchApplied = status.patched;
+  updateStatusBarFromCache();
+  if (panelProvider) panelProvider.sendStatus(status);
+}
+
+// ─── Sidebar WebView ──────────────────────────────────────────────────────
+
+class AntigravityPanelProvider {
+  /** @param {vscode.ExtensionContext} context */
+  constructor(context) {
+    this._context = context;
+    /** @type {vscode.WebviewView | null} */
+    this._view = null;
+  }
+
+  /** @param {vscode.WebviewView} webviewView */
+  resolveWebviewView(webviewView) {
+    this._view = webviewView;
+    webviewView.webview.options = { enableScripts: true };
+    webviewView.webview.html = this._getHtml();
+
+    webviewView.webview.onDidReceiveMessage(async (msg) => {
+      if (msg.command === 'apply') {
+        this._postLoading('⏳ Patching...');
+        const result = await applyPatch();
+        vscode.window.showInformationMessage(result.message);
+      } else if (msg.command === 'revert') {
+        this._postLoading('⏳ Reverting...');
+        const result = await revertPatch();
+        vscode.window.showInformationMessage(result.message);
+      } else if (msg.command === 'refresh') {
+        this._postLoading('⏳ Checking...');
+        await refreshStatus();
+      }
+    });
+
+    // Initial load
+    refreshStatus();
+  }
+
+  /** @param {string} text */
+  _postLoading(text) {
+    if (this._view) this._view.webview.postMessage({ command: 'loading', text });
+  }
+
+  /** @param {{basePath:string|null,patched:boolean,files:any[]}} status */
+  sendStatus(status) {
+    if (!this._view) return;
+    this._view.webview.postMessage({
+      command: 'update',
+      patched: status.patched,
+      basePath: status.basePath,
+      files: status.files,
+    });
+  }
+
+  /** @deprecated use sendStatus */
+  updateState() { refreshStatus(); }
+
+  _getHtml() {
+    return /* html */`<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<style>
+  *{box-sizing:border-box;margin:0;padding:0}
+  body{
+    font-family:'Segoe UI',sans-serif;
+    background:var(--vscode-sideBar-background);
+    color:var(--vscode-foreground);
+    padding:16px;user-select:none;
+  }
+  .header{
+    display:flex;align-items:center;gap:8px;
+    margin-bottom:16px;padding-bottom:12px;
+    border-bottom:1px solid var(--vscode-panel-border);
+  }
+  .header-icon{font-size:20px}
+  .header-title{font-size:13px;font-weight:600;letter-spacing:.3px}
+  .header-sub{font-size:11px;color:var(--vscode-descriptionForeground);margin-top:2px}
+
+  .status-card{
+    border-radius:8px;padding:16px;margin-bottom:12px;
+    background:var(--vscode-editor-background);
+    border:1px solid var(--vscode-panel-border);
+    transition:border-color .3s,background .3s;
+  }
+  .status-card.patched{border-color:#4ec94e;background:rgba(78,201,78,.07)}
+  .status-card.not-found{border-color:#e06c75;background:rgba(224,108,117,.07)}
+  .status-row{display:flex;align-items:center;gap:12px}
+  .dot{
+    width:36px;height:36px;border-radius:50%;
+    display:flex;align-items:center;justify-content:center;
+    font-size:18px;flex-shrink:0;background:#3c3c3c;
+    transition:background .3s;
+  }
+  .dot.patched{background:#4ec94e}
+  .dot.not-found{background:#e06c75}
+  .status-label{font-size:18px;font-weight:700;line-height:1}
+  .status-label.patched{color:#4ec94e}
+  .status-label.pending{color:#e5c07b}
+  .status-label.not-found{color:#e06c75}
+  .status-label.loading{color:var(--vscode-descriptionForeground)}
+  .status-desc{font-size:11px;color:var(--vscode-descriptionForeground);margin-top:4px}
+
+  .path-box{
+    font-size:10px;color:var(--vscode-descriptionForeground);
+    background:var(--vscode-editor-background);
+    border:1px solid var(--vscode-panel-border);
+    border-radius:4px;padding:6px 8px;margin-bottom:10px;
+    word-break:break-all;
+  }
+
+  .files-list{margin-bottom:12px}
+  .file-item{
+    display:flex;align-items:center;gap:6px;
+    font-size:11px;padding:4px 0;
+  }
+  .file-dot{width:8px;height:8px;border-radius:50%;flex-shrink:0}
+  .file-dot.patched{background:#4ec94e}
+  .file-dot.pending{background:#e5c07b}
+
+  .btn{
+    width:100%;padding:10px;border:none;border-radius:6px;
+    font-size:12px;font-weight:700;letter-spacing:.5px;
+    cursor:pointer;transition:background .2s,transform .1s;
+    font-family:inherit;margin-bottom:6px;
+  }
+  .btn:active{transform:scale(.98)}
+  .btn:disabled{opacity:.5;cursor:not-allowed}
+  .btn-apply{background:#0e7a4c;color:#fff}
+  .btn-apply:hover:not(:disabled){background:#0f9058}
+  .btn-revert{background:#5a1a1a;color:#fff}
+  .btn-revert:hover:not(:disabled){background:#7a2020}
+  .btn-refresh{background:var(--vscode-button-secondaryBackground);color:var(--vscode-button-secondaryForeground)}
+
+  .note{
+    margin-top:10px;font-size:10px;
+    color:var(--vscode-descriptionForeground);
+    text-align:center;line-height:1.5;
+  }
+</style>
+</head>
+<body>
+<div class="header">
+  <span class="header-icon">⚡</span>
+  <div>
+    <div class="header-title">Antigravity Auto-Accept</div>
+    <div class="header-sub">Patches "Always Proceed" to auto-run</div>
+  </div>
+</div>
+
+<div class="status-card" id="card">
+  <div class="status-row">
+    <div class="dot" id="dot">⊘</div>
+    <div>
+      <div class="status-label loading" id="lbl">Loading...</div>
+      <div class="status-desc" id="desc">Detecting Antigravity...</div>
+    </div>
+  </div>
+</div>
+
+<div class="path-box" id="pathBox" style="display:none"></div>
+
+<div class="files-list" id="filesList"></div>
+
+<button class="btn btn-apply" id="btnApply" onclick="send('apply')" style="display:none">⚡ APPLY PATCH</button>
+<button class="btn btn-revert" id="btnRevert" onclick="send('revert')" style="display:none">↩ REVERT PATCH</button>
+<button class="btn btn-refresh" onclick="send('refresh')">🔄 Refresh Status</button>
+
+<div class="note" id="noteBox"></div>
+
+<script>
+  const vscode = acquireVsCodeApi();
+  function send(cmd) {
+    document.getElementById('btnApply').disabled = true;
+    document.getElementById('btnRevert').disabled = true;
+    document.getElementById('btnRefresh') && (document.getElementById('btnRefresh').disabled = true);
+    vscode.postMessage({ command: cmd });
+  }
+  send('refresh');
+
+  window.addEventListener('message', e => {
+    const { command, patched, basePath, files, text } = e.data;
+
+    if (command === 'loading') {
+      document.getElementById('lbl').className = 'status-label loading';
+      document.getElementById('lbl').textContent = text || '⏳ Working...';
+      document.getElementById('desc').textContent = 'Please wait...';
+      return;
+    }
+
+    if (command !== 'update') return;
+
+    // Re-enable buttons
+    document.getElementById('btnApply').disabled = false;
+    document.getElementById('btnRevert').disabled = false;
+
+    const notFound = !basePath;
+
+    document.getElementById('card').className = 'status-card' + (notFound ? ' not-found' : patched ? ' patched' : '');
+    document.getElementById('dot').className  = 'dot' + (notFound ? ' not-found' : patched ? ' patched' : '');
+    document.getElementById('dot').textContent = notFound ? '✕' : patched ? '✓' : '○';
+
+    const lbl = document.getElementById('lbl');
+    lbl.className = 'status-label ' + (notFound ? 'not-found' : patched ? 'patched' : 'pending');
+    lbl.textContent = notFound ? 'NOT FOUND' : patched ? 'PATCHED' : 'NOT PATCHED';
+
+    document.getElementById('desc').textContent = notFound
+      ? 'Antigravity not installed'
+      : patched
+        ? 'useEffect added — restart Antigravity!'
+        : 'Patch not applied yet';
+
+    const pathBox = document.getElementById('pathBox');
+    if (basePath) {
+      pathBox.textContent = '📍 ' + basePath;
+      pathBox.style.display = '';
+    } else {
+      pathBox.style.display = 'none';
+    }
+
+    const filesList = document.getElementById('filesList');
+    filesList.innerHTML = '';
+    if (files && files.length) {
+      for (const f of files) {
+        const d = document.createElement('div');
+        d.className = 'file-item';
+        d.innerHTML = '<div class="file-dot ' + (f.patched ? 'patched' : 'pending') + '"></div>'
+          + '<span>' + f.label + ': ' + (f.patched ? '✅ patched' : '⬜ not patched') + '</span>';
+        filesList.appendChild(d);
+      }
+    }
+
+    document.getElementById('btnApply').style.display = (notFound || patched) ? 'none' : '';
+    document.getElementById('btnRevert').style.display = patched ? '' : 'none';
+
+    document.getElementById('noteBox').textContent = notFound
+      ? '⚠️ Install Antigravity first'
+      : patched
+        ? '💡 Re-run after Antigravity updates'
+        : '💡 Apply patch once, then restart Antigravity';
+  });
+</script>
+</body>
+</html>`;
+  }
+}
+
+// ─── Status Bar ──────────────────────────────────────────────────────────
+
+function updateStatusBarFromCache() {
+  const status = _cachedStatus;
+  if (!status || !status.basePath) {
+    statusBarItem.text = `$(warning) AG Patch: Not Found`;
+    statusBarItem.tooltip = 'Antigravity not detected';
+    statusBarItem.backgroundColor = undefined;
+  } else if (status.patched) {
+    statusBarItem.text = `$(check) AG Patch: Active`;
+    statusBarItem.tooltip = 'Auto-Accept patch is applied — click to manage';
+    statusBarItem.backgroundColor = new vscode.ThemeColor('statusBarItem.warningBackground');
+  } else {
+    statusBarItem.text = `$(zap) AG Patch: OFF`;
+    statusBarItem.tooltip = 'Auto-Accept patch not applied — click to open panel';
+    statusBarItem.backgroundColor = undefined;
+  }
+}
+
+/** @deprecated kept for backward compat */
+function updateStatusBar() { updateStatusBarFromCache(); }
+
+// ─── Activate / Deactivate ──────────────────────────────────────────────
+
+/** @param {vscode.ExtensionContext} context */
+function activate(context) {
+  // Status bar — shows spinner until first async check completes
+  statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
+  statusBarItem.command = 'antigravityAutoAccept.openPanel';
+  statusBarItem.text = `$(sync~spin) AG Patch`;
+  statusBarItem.tooltip = 'Checking patch status...';
+  statusBarItem.show();
+
+  // Sidebar
+  panelProvider = new AntigravityPanelProvider(context);
+  context.subscriptions.push(
+    vscode.window.registerWebviewViewProvider(
+      'antigravityAutoAccept.panel',
+      panelProvider,
+      { webviewOptions: { retainContextWhenHidden: true } },
+    ),
+  );
+
+  // Commands
+  context.subscriptions.push(
+    vscode.commands.registerCommand('antigravityAutoAccept.applyPatch', async () => {
+      const result = await applyPatch();
+      vscode.window.showInformationMessage(result.message);
+    }),
+    vscode.commands.registerCommand('antigravityAutoAccept.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('antigravityAutoAccept.checkStatus', async () => {
+      const status = await getPatchStatus();
+      if (!status.basePath) {
+        vscode.window.showWarningMessage('Antigravity not found!');
+      } else {
+        vscode.window.showInformationMessage(
+          `Patch status: ${status.patched ? '✅ Applied' : '⬜ Not applied'} | ${status.basePath}`,
+        );
+      }
+    }),
+  );
+
+  context.subscriptions.push(statusBarItem);
+
+  // Async startup — never blocks extension host!
+  (async () => {
+    const status = await getPatchStatus();
+    isPatchApplied = status.patched;
+    updateStatusBarFromCache();
+    if (panelProvider) panelProvider.sendStatus(status);
+
+    const cfg = vscode.workspace.getConfiguration('antigravityAutoAccept');
+    if (cfg.get('applyOnStartup') && !status.patched && status.basePath) {
+      const result = await applyPatch();
+      if (result.success) {
+        console.log('[AutoAccept] Auto-patch applied on startup');
+      }
+    }
+  })();
+}
+
+function deactivate() { /* nothing to clean up */ }
+
+module.exports = { activate, deactivate };

package/icon-sidebar.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"/>
+</svg>

package/install.ps1

@@ -0,0 +1,48 @@
+# Antigravity Auto-Accept - Installation Script
+# Creates a symlink in VS Code extensions directory for development
+
+$ExtensionName = "antigravity-auto-accept"
+$SourceDir = $PSScriptRoot
+$VSCodeExtDir = Join-Path $env:USERPROFILE ".vscode\extensions\$ExtensionName"
+
+Write-Host ""
+Write-Host "========================================" -ForegroundColor Cyan
+Write-Host "  Antigravity Auto-Accept Installer" -ForegroundColor Cyan
+Write-Host "========================================" -ForegroundColor Cyan
+Write-Host ""
+
+# Check if already installed
+if (Test-Path $VSCodeExtDir) {
+    Write-Host "[!] Extension already installed at: $VSCodeExtDir" -ForegroundColor Yellow
+    $confirm = Read-Host "Remove and reinstall? (y/n)"
+    if ($confirm -ne 'y') {
+        Write-Host "Cancelled." -ForegroundColor Red
+        exit 1
+    }
+    # Remove existing (handle both symlink and directory)
+    if ((Get-Item $VSCodeExtDir).Attributes -band [IO.FileAttributes]::ReparsePoint) {
+        (Get-Item $VSCodeExtDir).Delete()
+    } else {
+        Remove-Item $VSCodeExtDir -Recurse -Force
+    }
+    Write-Host "[OK] Removed existing installation" -ForegroundColor Green
+}
+
+# Create symlink (requires admin or developer mode)
+try {
+    New-Item -ItemType SymbolicLink -Path $VSCodeExtDir -Target $SourceDir -ErrorAction Stop | Out-Null
+    Write-Host "[OK] Created symlink:" -ForegroundColor Green
+    Write-Host "     $VSCodeExtDir -> $SourceDir" -ForegroundColor DarkGray
+} catch {
+    Write-Host "[!] Symlink failed (may need admin or Developer Mode)." -ForegroundColor Yellow
+    Write-Host "    Falling back to file copy..." -ForegroundColor Yellow
+    
+    New-Item -ItemType Directory -Path $VSCodeExtDir -Force | Out-Null
+    Copy-Item -Path "$SourceDir\*" -Destination $VSCodeExtDir -Recurse -Force
+    Write-Host "[OK] Copied files to: $VSCodeExtDir" -ForegroundColor Green
+}
+
+Write-Host ""
+Write-Host "[NEXT] Reload VS Code:" -ForegroundColor Cyan
+Write-Host "       Ctrl+Shift+P -> 'Developer: Reload Window'" -ForegroundColor White
+Write-Host ""

package/package.json

@@ -0,0 +1,71 @@
+{
+  "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.0.0",
+  "publisher": "nguyen-hoang",
+  "engines": {
+    "vscode": "^1.85.0"
+  },
+  "categories": ["Other"],
+  "activationEvents": ["onStartupFinished"],
+  "main": "./extension.js",
+  "icon": "icon.png",
+  "contributes": {
+    "viewsContainers": {
+      "activitybar": [
+        {
+          "id": "antigravity-auto-accept",
+          "title": "Antigravity Auto-Accept",
+          "icon": "icon-sidebar.svg"
+        }
+      ]
+    },
+    "views": {
+      "antigravity-auto-accept": [
+        {
+          "type": "webview",
+          "id": "antigravityAutoAccept.panel",
+          "name": "Auto-Accept Patcher"
+        }
+      ]
+    },
+    "commands": [
+      {
+        "command": "antigravityAutoAccept.applyPatch",
+        "title": "Antigravity: Apply Auto-Accept Patch",
+        "icon": "$(zap)"
+      },
+      {
+        "command": "antigravityAutoAccept.revertPatch",
+        "title": "Antigravity: Revert Auto-Accept Patch",
+        "icon": "$(discard)"
+      },
+      {
+        "command": "antigravityAutoAccept.checkStatus",
+        "title": "Antigravity: Check Patch Status",
+        "icon": "$(info)"
+      },
+      {
+        "command": "antigravityAutoAccept.openPanel",
+        "title": "Antigravity: Open Patcher Panel"
+      }
+    ],
+    "keybindings": [
+      {
+        "command": "antigravityAutoAccept.applyPatch",
+        "key": "ctrl+shift+f12"
+      }
+    ],
+    "configuration": {
+      "title": "Antigravity Auto-Accept",
+      "properties": {
+        "antigravityAutoAccept.applyOnStartup": {
+          "type": "boolean",
+          "default": false,
+          "description": "Automatically apply the patch when this extension activates (on startup). Safe to enable — patch is idempotent."
+        }
+      }
+    }
+  }
+}

package/patcher.js

@@ -0,0 +1,265 @@
+// patcher.js — runs in child_process.fork(), handles all heavy file I/O
+// Ported directly from https://github.com/Kanezal/better-antigravity/blob/main/fixes/auto-run-fix/patch.js
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// ─── Installation Detection ──────────────────────────────────────────────────
+
+function findAntigravityPath() {
+    const candidates = [];
+    if (process.platform === 'win32') {
+        candidates.push(
+            path.join(process.env.LOCALAPPDATA || '', 'Programs', 'Antigravity'),
+            path.join(process.env.PROGRAMFILES || '', 'Antigravity'),
+            path.join(process.env['PROGRAMFILES(X86)'] || '', 'Antigravity'),
+        );
+    } else if (process.platform === 'darwin') {
+        candidates.push(
+            '/Applications/Antigravity.app/Contents/Resources',
+            path.join(os.homedir(), 'Applications', 'Antigravity.app', 'Contents', 'Resources'),
+        );
+    } else {
+        candidates.push(
+            '/usr/share/antigravity',
+            '/opt/antigravity',
+            path.join(os.homedir(), '.local', 'share', 'antigravity'),
+        );
+    }
+    for (const c of candidates) {
+        const f = path.join(c, 'resources', 'app', 'out', 'vs', 'workbench', 'workbench.desktop.main.js');
+        if (fs.existsSync(f)) return c;
+    }
+    return null;
+}
+
+function getTargetFiles(basePath) {
+    return [
+        {
+            filePath: path.join(basePath, 'resources', 'app', 'out', 'vs', 'workbench', 'workbench.desktop.main.js'),
+            label: 'workbench',
+        },
+        {
+            filePath: path.join(basePath, 'resources', 'app', 'out', 'jetskiAgent', 'main.js'),
+            label: 'jetskiAgent',
+        },
+    ];
+}
+
+// ─── Smart Pattern Matching (ported from better-antigravity) ─────────────────
+
+/**
+ * Finds the onChange handler and extracts variable names, regardless of minification.
+ * 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}` });
+
+    // 1. Find the onChange handler: contains setTerminalAutoExecutionPolicy AND .EAGER
+    //    Pattern: VARNAME=CALLBACK(ARG=>{...setTerminalAutoExecutionPolicy...,ARG===ENUM.EAGER&&CONFIRM(!0)},[...])
+    //    Exact regex from https://github.com/Kanezal/better-antigravity/blob/main/fixes/auto-run-fix/patch.js
+    const onChangeRe = /(\w+)=(\w+)\((\w+)=>\{\w+\?\.setTerminalAutoExecutionPolicy\?\.\(\3\),\3===(\w+)\.EAGER&&(\w+)\(!0\)\},\[[\w,]*\]\)/;
+    const onChangeMatch = content.match(onChangeRe);
+
+    if (!onChangeMatch) {
+        log('❌ Could not find onChange handler pattern');
+        const idx = content.indexOf('setTerminalAutoExecutionPolicy');
+        if (idx >= 0) {
+            log(`  Context: ...${content.slice(Math.max(0, idx - 80), idx + 120)}...`);
+        }
+        return null;
+    }
+
+    const [fullMatch, assignVar, callbackAlias, argName, enumAlias, confirmFn] = onChangeMatch;
+    const matchIndex = content.indexOf(fullMatch);
+
+    log(`✓ Found onChange at offset ${matchIndex}`);
+    log(`  callback=${callbackAlias}, enum=${enumAlias}, confirm=${confirmFn}`);
+
+    // 2. Find policy variable: VARNAME=HANDLER?.terminalAutoExecutionPolicy??ENUM.OFF
+    //    NOTE: must use ?\. (optional chaining) — this was the bug in previous version
+    const policyRe = new RegExp(`(\\w+)=\\w+\\?\\.terminalAutoExecutionPolicy\\?\\?${enumAlias}\\.OFF`);
+    const policyMatch = content.substring(Math.max(0, matchIndex - 2000), matchIndex).match(policyRe);
+
+    if (!policyMatch) {
+        log('❌ Could not find policy variable');
+        return null;
+    }
+    const policyVar = policyMatch[1];
+    log(`  policyVar=${policyVar}`);
+
+    // 3. Find secureMode variable: VARNAME=HANDLER?.secureModeEnabled??!1
+    const secureRe = /(\w+)=\w+\?\.secureModeEnabled\?\?!1/;
+    const secureMatch = content.substring(Math.max(0, matchIndex - 2000), matchIndex).match(secureRe);
+
+    if (!secureMatch) {
+        log('❌ Could not find secureMode variable');
+        return null;
+    }
+    const secureVar = secureMatch[1];
+    log(`  secureVar=${secureVar}`);
+
+    // 4. Find useEffect alias: look for ALIAS(()=>{...},[...]) calls nearby (not useCallback/useMemo)
+    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 !== callbackAlias && alias !== 'var' && alias !== 'new') {
+            effectCandidates[alias] = (effectCandidates[alias] || 0) + 1;
+        }
+    }
+
+    // Also check broader file for common useEffect patterns (with cleanup return)
+    const cleanupRe = /\b(\w{2,3})\(\(\)=>\{[^}]*return\s*\(\)=>/g;
+    while ((m = cleanupRe.exec(content)) !== null) {
+        const alias = m[1];
+        if (alias !== callbackAlias) {
+            effectCandidates[alias] = (effectCandidates[alias] || 0) + 5; // higher weight
+        }
+    }
+
+    // Pick the most common candidate
+    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)`);
+
+    // 5. Build patch — exact same logic as original
+    const patchCode = `_aep=${useEffectAlias}(()=>{${policyVar}===${enumAlias}.EAGER&&!${secureVar}&&${confirmFn}(!0)},[]),`;
+
+    return {
+        target: fullMatch,
+        replacement: patchCode + fullMatch,
+        patchMarker: `_aep=${useEffectAlias}(()=>{${policyVar}===${enumAlias}.EAGER`,
+        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);
+    } catch {
+        return false;
+    }
+}
+
+function patchFile(filePath, label) {
+    if (!fs.existsSync(filePath)) {
+        process.send({ type: 'log', msg: `[AutoAccept] ⏭️  [${label}] File not found, skipping` });
+        return true; // optional file missing is not a failure
+    }
+
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf8');
+    } catch (e) {
+        process.send({ type: 'log', msg: `[AutoAccept] ❌ [${label}] Read error: ${e.message}` });
+        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
+    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');
+
+    const sizeDiff = fs.statSync(filePath).size - fs.statSync(bakPath).size;
+    process.send({ type: 'log', msg: `[AutoAccept] ✅ [${label}] Patched (+${sizeDiff} bytes)` });
+    return true;
+}
+
+function revertFile(filePath, label) {
+    const bak = filePath + '.bak';
+    if (!fs.existsSync(bak)) {
+        process.send({ type: 'log', msg: `[AutoAccept] ⏭️  [${label}] No backup, skipping` });
+        return;
+    }
+    fs.copyFileSync(bak, filePath);
+    process.send({ type: 'log', msg: `[AutoAccept] ✅ [${label}] Reverted` });
+}
+
+// ─── Message Handler ──────────────────────────────────────────────────────────
+
+process.on('message', (msg) => {
+    const basePath = findAntigravityPath();
+
+    if (msg.command === 'status') {
+        if (!basePath) {
+            process.send({ type: 'status', basePath: null, files: [] });
+            process.exit(0);
+            return;
+        }
+        const files = getTargetFiles(basePath).map(f => ({
+            label: f.label,
+            patched: isFilePatched(f.filePath),
+            exists: fs.existsSync(f.filePath),
+        }));
+        process.send({ type: 'status', basePath, files });
+        process.exit(0);
+
+    } else if (msg.command === 'apply') {
+        if (!basePath) {
+            process.send({ type: 'result', success: false, message: '❌ Antigravity không tìm thấy! Hãy đảm bảo đã cài đặt.' });
+            process.exit(1);
+            return;
+        }
+        const targets = getTargetFiles(basePath);
+        const results = targets.map(f => patchFile(f.filePath, f.label));
+        const success = results.every(Boolean);
+        process.send({
+            type: 'result',
+            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.',
+        });
+        process.exit(success ? 0 : 1);
+
+    } else if (msg.command === 'revert') {
+        if (!basePath) {
+            process.send({ type: 'result', success: false, message: '❌ Antigravity không tìm thấy!' });
+            process.exit(1);
+            return;
+        }
+        getTargetFiles(basePath).forEach(f => revertFile(f.filePath, f.label));
+        process.send({ type: 'result', success: true, message: '✅ Đã hoàn tác! Restart Antigravity để áp dụng.' });
+        process.exit(0);
+    }
+});