antigravity-rtl-patcher 1.0.0 → 2.0.0

package/README.md

@@ -1,77 +1,115 @@
 # 🌌 Antigravity RTL Patcher
 
 <div align="center">
-  <img src="https://img.shields.io/npm/v/antigravity-rtl-patcher?color=cyan&label=Version&style=for-the-badge" alt="Version">
-  <img src="https://img.shields.io/npm/dt/antigravity-rtl-patcher?color=magenta&style=for-the-badge" alt="Downloads">
-  <img src="https://img.shields.io/badge/License-MIT-green.svg?style=for-the-badge" alt="License">
-</div>
 
-<br>
+![Version](https://img.shields.io/npm/v/antigravity-rtl-patcher?color=%2300bcd4&style=for-the-badge&label=VERSION)
+![Downloads](https://img.shields.io/npm/dt/antigravity-rtl-patcher?color=%23e040fb&style=for-the-badge)
+![License](https://img.shields.io/badge/LICENSE-MIT-brightgreen?style=for-the-badge)
+![Node](https://img.shields.io/badge/NODE-%3E%3D16-339933?style=for-the-badge&logo=node.js&logoColor=white)
+
+**Intelligent RTL & Persian Typography Engine for Antigravity IDE**
+
+*One command. Full right-to-left support. Zero config.*
 
-<div align="center">
-  <h3>An elegant, intelligent, and seamless RTL & Typography patcher for Antigravity IDE.</h3>
-  <p>Bring native support for Persian, Arabic, and Hebrew to your favorite AI IDE.</p>
 </div>
 
 ---
 
-## ⚡ What is this?
-Antigravity IDE (like many modern AI editors) is built on Electron. Out of the box, it lacks proper Right-to-Left (RTL) support. When AI generates Persian or Arabic text, the alignment breaks, fonts look terrible, and mixed English/RTL sentences become unreadable.
+## 🧬 How It Works
 
-This tool is a **CLI Patcher**. It deeply hooks into the core of Antigravity IDE (`app.asar`), injects a smart JavaScript `MutationObserver` engine, and automatically formats text direction dynamically.
+Antigravity IDE is built on Electron. This CLI tool directly patches the IDE's core workbench files to inject a smart **MutationObserver** engine that:
 
-## 🚀 Features
-- **🧠 Smart Direction:** Detects RTL languages using Regex and applies alignment only where necessary.
-- **🎨 Beautiful Typography:** Automatically injects the modern **Vazirmatn** font for perfect legibility.
-- **🧩 Mixed Text Support:** Uses `unicode-bidi: plaintext` to ensure English code blocks inside Persian text don't break.
-- **🛡️ Safe & Reversible:** Automatically creates a backup. You can restore the IDE to its original state with a single command.
-- **⚙️ OS Agnostic:** Works on Windows, macOS, and Linux out of the box.
+1. 🔍 **Watches** the DOM for new chat messages and AI responses in real-time
+2. 🧠 **Detects** Persian/Arabic/Hebrew text using Unicode analysis with ratio-based scoring
+3. 🎨 **Applies** `direction: rtl` and `unicode-bidi: plaintext` only where needed
+4. ✍️ **Injects** the beautiful **Vazirmatn** font for perfect Persian/Arabic readability
+5. 🔒 **Isolates** English code blocks inside RTL text so they don't break
 
 ---
 
-## 📦 Installation & Usage
-
-You don't even need to download the repository. Just run it directly via `npx`!
-
-### 1. Patch the IDE
-To inject RTL support, run the following command in your terminal:
+## ⚡ Quick Start
 
 ```bash
-# macOS & Linux (Requires sudo to modify application files)
+# Linux / macOS
+npx antigravity-rtl-patcher patch
+
+# If installed in system directory (e.g., /opt/)
 sudo npx antigravity-rtl-patcher patch
+```
 
-# Windows (Run PowerShell as Administrator)
+```bash
+# Windows (Run terminal as Administrator if needed)
 npx antigravity-rtl-patcher patch
 ```
 
-### 2. Restore (Unpatch)
-If you want to remove the patch or an update breaks something, you can easily restore from the backup:
+That's it. Restart Antigravity IDE and enjoy native RTL support. ✨
+
+---
+
+## 📖 Commands
+
+| Command | Description |
+|---------|-------------|
+| `agy-rtl patch` | Inject RTL support into Antigravity IDE |
+| `agy-rtl restore` | Remove patch and restore original files |
+| `agy-rtl status` | Check if IDE is currently patched |
+| `agy-rtl patch --path /custom/path` | Patch a custom installation directory |
+
+---
+
+## 🔄 After IDE Updates
+
+When Antigravity IDE updates, the patch may be overwritten. Simply run the patch command again:
 
 ```bash
-# macOS & Linux
-sudo npx antigravity-rtl-patcher restore
+npx antigravity-rtl-patcher patch
+```
 
-# Windows
-npx antigravity-rtl-patcher restore
+---
+
+## 🏗️ Architecture
+
+```
+antigravity-rtl-patcher/
+├── bin/
+│   └── cli.js              # CLI entry point (commander-based)
+├── src/
+│   ├── patcher.js           # Core logic: backup, inject, repack
+│   ├── paths.js             # OS-aware installation path detection
+│   └── utils.js             # Permission checks & helpers
+├── payload/
+│   ├── rtl-engine.js        # MutationObserver RTL detection engine
+│   └── styles.css           # Vazirmatn font + RTL typography fixes
+├── package.json
+└── README.md
 ```
 
-*(Note: Whenever Antigravity IDE updates, the patch will be overwritten. Just run the `patch` command again!)*
+### Supported Installation Types
+
+| Type | Description | Method |
+|------|-------------|--------|
+| **Unpacked** | IDE with `resources/app/` directory | Direct file modification |
+| **ASAR** | App bundled as `app.asar` | Extract → Patch → Repack |
 
 ---
 
-## 🛠️ Architecture
+## 🔐 Permissions
+
+- **User directory installs** (e.g., `~/Downloads/`): No special permissions needed
+- **System directory installs** (e.g., `/opt/`): Requires `sudo` on Linux/macOS
 
-This project is divided into two main parts:
-1. **The Patcher (`src/patcher.js`)**: A Node.js CLI that locates the `app.asar` file, extracts it to a temporary directory, injects our payload into the main `index.html`, and repacks it.
-2. **The Payload (`payload/`)**: A combination of smart CSS and Vanilla JavaScript that runs inside the Electron UI. It uses a `MutationObserver` to watch for new chat messages dynamically generated by the AI and styles them on the fly.
+---
 
 ## 🤝 Contributing
+
 Contributions, issues, and feature requests are welcome!
-Feel free to check [issues page](https://github.com/VaFa1726/antigravity-rtl-patcher/issues).
+
+1. Fork the repo
+2. Create your feature branch (`git checkout -b feature/amazing`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing`)
+5. Open a Pull Request
 
 ## 📄 License
-This project is [MIT](https://choosealicense.com/licenses/mit/) licensed.
 
----
-<div align="center">
-</div>
+[MIT](https://choosealicense.com/licenses/mit/)

package/bin/cli.js

@@ -2,20 +2,28 @@
 
 const { program } = require('commander');
 const chalk = require('chalk');
-const { patch, restore } = require('../src/patcher');
+const { patch, restore, status } = require('../src/patcher');
+
+const BANNER = `
+${chalk.cyan('╔══════════════════════════════════════════════╗')}
+${chalk.cyan('║')}  ${chalk.bold.white('🌌 Antigravity RTL Patcher')}  ${chalk.gray('v2.0.0')}        ${chalk.cyan('║')}
+${chalk.cyan('║')}  ${chalk.gray('Intelligent RTL support for Antigravity IDE')} ${chalk.cyan('║')}
+${chalk.cyan('╚══════════════════════════════════════════════╝')}
+`;
 
 program
   .name('agy-rtl')
   .description('RTL & Typography patcher for Antigravity IDE')
-  .version('1.0.0');
+  .version('2.0.0');
 
 program
   .command('patch')
   .description('Inject RTL support into Antigravity IDE')
-  .action(async () => {
+  .option('-p, --path <path>', 'Custom path to Antigravity IDE installation')
+  .action(async (options) => {
+    console.log(BANNER);
     try {
-      console.log(chalk.cyan.bold('\n🚀 Starting Antigravity RTL Patcher...'));
-      await patch();
+      await patch(options.path);
     } catch (err) {
       console.error(chalk.red('\n❌ Patch failed:'), err.message);
       process.exit(1);
@@ -25,14 +33,29 @@ program
 program
   .command('restore')
   .description('Restore Antigravity IDE to its original state')
-  .action(async () => {
+  .option('-p, --path <path>', 'Custom path to Antigravity IDE installation')
+  .action(async (options) => {
+    console.log(BANNER);
     try {
-      console.log(chalk.yellow.bold('\n🔄 Restoring Antigravity...'));
-      await restore();
+      await restore(options.path);
     } catch (err) {
       console.error(chalk.red('\n❌ Restore failed:'), err.message);
       process.exit(1);
     }
   });
 
+program
+  .command('status')
+  .description('Check if Antigravity IDE is currently patched')
+  .option('-p, --path <path>', 'Custom path to Antigravity IDE installation')
+  .action(async (options) => {
+    console.log(BANNER);
+    try {
+      await status(options.path);
+    } catch (err) {
+      console.error(chalk.red('\n❌ Status check failed:'), err.message);
+      process.exit(1);
+    }
+  });
+
 program.parse(process.argv);

package/package.json

@@ -1,32 +1,50 @@
 {
   "name": "antigravity-rtl-patcher",
-  "version": "1.0.0",
-  "description": "An elegant RTL and typography patcher for Antigravity IDE based on Electron",
+  "version": "2.0.0",
+  "description": "🌌 Intelligent RTL & Persian/Arabic typography patcher for Antigravity IDE",
   "main": "src/patcher.js",
   "bin": {
+    "antigravity-rtl-patcher": "./bin/cli.js",
     "agy-rtl": "./bin/cli.js"
   },
   "scripts": {
-    "start": "node ./bin/cli.js"
+    "start": "node ./bin/cli.js",
+    "patch": "node ./bin/cli.js patch",
+    "restore": "node ./bin/cli.js restore"
   },
   "keywords": [
     "antigravity",
     "rtl",
     "farsi",
+    "persian",
     "arabic",
     "hebrew",
     "patcher",
     "electron",
-    "asar"
+    "asar",
+    "ide",
+    "vscode",
+    "right-to-left",
+    "bidirectional"
   ],
   "author": "VaFa1726",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VaFa1726/antigravity-rtl-patcher.git"
+  },
+  "bugs": {
+    "url": "https://github.com/VaFa1726/antigravity-rtl-patcher/issues"
+  },
+  "homepage": "https://github.com/VaFa1726/antigravity-rtl-patcher#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  },
   "dependencies": {
     "@electron/asar": "^3.2.14",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "fs-extra": "^11.2.0",
-    "ora": "^5.4.1",
-    "sudo-prompt": "^9.2.1"
+    "ora": "^5.4.1"
   }
 }

package/payload/rtl-engine.js

@@ -1,73 +1,156 @@
-(function() {
-  console.log('🚀 AGY RTL Engine Initialized');
+/**
+ * AGY RTL Engine v2.0.0
+ * Intelligent RTL detection & styling for Antigravity IDE
+ * 
+ * This script runs inside the Electron renderer process.
+ * It uses MutationObserver to watch for DOM changes and
+ * automatically applies RTL direction to Persian/Arabic/Hebrew text.
+ * 
+ * CSP Compatible: No use of innerHTML, eval, or inline event handlers.
+ */
+(function () {
+  'use strict';
 
-  // Regex to detect RTL characters (Arabic, Persian, Hebrew)
-  const rtlRegex = /[\u0591-\u07FF\uFB1D-\uFDFD\uFE70-\uFEFC]/;
+  // Unicode ranges for RTL scripts
+  const RTL_REGEX = /[\u0591-\u07FF\u200F\u202B\u202E\uFB1D-\uFDFD\uFE70-\uFEFC]/;
 
+  // Minimum ratio of RTL characters to consider text as RTL
+  const RTL_CHAR_REGEX = /[\u0591-\u07FF\uFB1D-\uFDFD\uFE70-\uFEFC]/g;
+  const MIN_RTL_RATIO = 0.3;
+
+  // Attribute to mark processed elements
+  const PROCESSED_ATTR = 'data-agy-rtl';
+
+  // Selectors to target (chat messages, markdown output, editor tooltips)
+  const TARGET_SELECTORS = [
+    // Chat and AI response areas
+    '.chat-response-content p',
+    '.chat-response-content li',
+    '.chat-response-content h1',
+    '.chat-response-content h2',
+    '.chat-response-content h3',
+    '.chat-response-content h4',
+    '.chat-response-content blockquote',
+    // Markdown preview
+    '.markdown-body p',
+    '.markdown-body li',
+    '.markdown-body h1',
+    '.markdown-body h2',
+    '.markdown-body h3',
+    '.markdown-body blockquote',
+    // Generic rendered text
+    '.rendered-markdown p',
+    '.rendered-markdown li',
+    '.rendered-markdown h1',
+    '.rendered-markdown h2',
+    '.rendered-markdown h3',
+    '.rendered-markdown blockquote',
+    // Monaco editor hover & tooltips
+    '.monaco-hover-content p',
+    '.suggest-details p',
+    // Notifications
+    '.notification-toast-container p',
+    // Generic paragraphs and spans in webview
+    'p', 'li', 'h1', 'h2', 'h3', 'h4', 'blockquote',
+  ].join(', ');
+
+  /**
+   * Determine if a text string is primarily RTL.
+   */
   function isRTL(text) {
-    // Basic heuristic: check if any RTL char exists
-    return rtlRegex.test(text);
+    if (!text || text.trim().length === 0) return false;
+
+    // Quick check: does it contain any RTL character at all?
+    if (!RTL_REGEX.test(text)) return false;
+
+    // Count RTL characters vs total alphabetic characters
+    const rtlMatches = text.match(RTL_CHAR_REGEX);
+    if (!rtlMatches) return false;
+
+    const alphaChars = text.replace(/[\s\d\W]/g, '').length;
+    if (alphaChars === 0) return false;
+
+    return (rtlMatches.length / alphaChars) >= MIN_RTL_RATIO;
   }
 
+  /**
+   * Apply RTL styling to an element.
+   */
   function applyRTL(element) {
-    // Only process text nodes or direct containers
-    const textContent = element.textContent || element.innerText || '';
-    
-    if (isRTL(textContent)) {
-      element.setAttribute('data-agy-rtl', 'true');
+    if (element.getAttribute(PROCESSED_ATTR)) return;
+
+    const text = element.textContent || '';
+    if (isRTL(text)) {
+      element.setAttribute(PROCESSED_ATTR, 'true');
       element.style.direction = 'rtl';
       element.style.textAlign = 'start';
-      
-      // Crucial for mixed English/Farsi content (like code snippets in Farsi text)
-      element.style.unicodeBidi = 'plaintext'; 
-      
-      // Mark as processed
-      element.classList.add('agy-rtl-processed');
+      element.style.unicodeBidi = 'plaintext';
     }
   }
 
-  // Observe DOM mutations for dynamically added chat messages
-  const observer = new MutationObserver((mutations) => {
-    mutations.forEach((mutation) => {
-      if (mutation.addedNodes.length) {
-        mutation.addedNodes.forEach((node) => {
+  /**
+   * Scan a subtree for elements that need RTL.
+   */
+  function scanElement(root) {
+    if (!root || root.nodeType !== Node.ELEMENT_NODE) return;
+
+    // Check if the root itself matches
+    try {
+      if (root.matches && root.matches(TARGET_SELECTORS)) {
+        applyRTL(root);
+      }
+    } catch (e) {
+      // Ignore selector errors
+    }
+
+    // Scan children
+    try {
+      const elements = root.querySelectorAll(TARGET_SELECTORS);
+      elements.forEach(function (el) {
+        applyRTL(el);
+      });
+    } catch (e) {
+      // Ignore errors
+    }
+  }
+
+  /**
+   * Initialize the MutationObserver.
+   */
+  function initObserver() {
+    var observer = new MutationObserver(function (mutations) {
+      mutations.forEach(function (mutation) {
+        // Handle added nodes
+        mutation.addedNodes.forEach(function (node) {
           if (node.nodeType === Node.ELEMENT_NODE) {
-            // Apply logic to the node itself if it has text
-            if (node.textContent && node.textContent.trim().length > 0) {
-              // We should probably target specific chat bubble selectors here if we knew them.
-              // For a generic approach, we look for paragraphs or divs with raw text.
-              const elementsToScan = node.querySelectorAll('p, span, div.message-content, div.chat-bubble, li, h1, h2, h3');
-              elementsToScan.forEach(el => {
-                if (!el.classList.contains('agy-rtl-processed')) {
-                  applyRTL(el);
-                }
-              });
-              
-              // Also check the root node added
-              if (!node.classList.contains('agy-rtl-processed')) {
-                 applyRTL(node);
-              }
-            }
+            scanElement(node);
           }
         });
-      }
+
+        // Handle text content changes
+        if (mutation.type === 'characterData' && mutation.target.parentElement) {
+          applyRTL(mutation.target.parentElement);
+        }
+      });
     });
-  });
 
-  // Start observing
-  window.addEventListener('load', () => {
-    observer.observe(document.body, { 
-      childList: true, 
+    observer.observe(document.body, {
+      childList: true,
       subtree: true,
-      characterData: true
+      characterData: true,
     });
-    
-    // Initial scan
-    document.querySelectorAll('p, span, div, li, h1, h2, h3').forEach(el => {
-      if (el.textContent && el.textContent.trim().length > 0 && !el.children.length) {
-         applyRTL(el);
-      }
-    });
-  });
 
+    // Initial full-page scan
+    scanElement(document.body);
+  }
+
+  // Start when DOM is ready
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', initObserver);
+  } else {
+    // DOM already loaded, wait a moment for dynamic content
+    setTimeout(initObserver, 500);
+  }
+
+  console.log('%c🌌 AGY RTL Engine v2.0.0 loaded', 'color: cyan; font-weight: bold;');
 })();

package/payload/styles.css

@@ -1,20 +1,37 @@
-/* Import a modern Persian font from Google Fonts (Vazirmatn) */
+/*
+ * AGY RTL Styles v2.0.0
+ * Typography & RTL fixes for Antigravity IDE
+ */
+
+/* Vazirmatn — Modern Persian/Arabic font from Google Fonts */
 @import url('https://fonts.googleapis.com/css2?family=Vazirmatn:wght@300;400;500;700&display=swap');
 
-/* Apply font to patched elements */
+/* RTL text styling */
 [data-agy-rtl="true"] {
-  font-family: 'Vazirmatn', system-ui, -apple-system, sans-serif !important;
-  line-height: 1.8 !important;
-  letter-spacing: normal !important;
+  font-family: 'Vazirmatn', system-ui, -apple-system, 'Segoe UI', sans-serif !important;
+  line-height: 1.85 !important;
+  word-spacing: 0.02em;
 }
 
-/* Fix code blocks inside RTL text */
-[data-agy-rtl="true"] code, 
-[data-agy-rtl="true"] pre {
+/* Preserve LTR for code blocks inside RTL text */
+[data-agy-rtl="true"] code,
+[data-agy-rtl="true"] pre,
+[data-agy-rtl="true"] .monaco-tokenized-source {
   direction: ltr !important;
   text-align: left !important;
   unicode-bidi: isolate !important;
-  font-family: monospace !important;
+  font-family: 'Cascadia Code', 'Fira Code', 'JetBrains Mono', 'Consolas', monospace !important;
   display: inline-block;
-  margin: 0 4px;
+}
+
+/* Inline code in RTL paragraphs */
+[data-agy-rtl="true"] code {
+  margin: 0 3px;
+  padding: 1px 5px;
+  border-radius: 3px;
+}
+
+/* Fix list markers in RTL */
+[data-agy-rtl="true"] li {
+  list-style-position: inside;
 }

package/src/patcher.js

@@ -4,57 +4,103 @@ const path = require('path');
 const os = require('os');
 const ora = require('ora');
 const chalk = require('chalk');
-const { getAsarPath } = require('./paths');
+const { findInstallations } = require('./paths');
 const { checkPermissions, delay } = require('./utils');
 
-async function patch() {
-  checkPermissions();
-  
-  const spinner = ora('Locating Antigravity IDE...').start();
-  let asarPath;
-  
-  try {
-    asarPath = getAsarPath();
-    spinner.succeed(`Found Antigravity at: ${chalk.gray(asarPath)}`);
-  } catch (err) {
-    spinner.fail(err.message);
-    throw err;
+const PATCH_MARKER = 'agy-rtl-engine';
+const BACKUP_SUFFIX = '.agy-rtl-backup';
+const ENGINE_FILENAME = 'agy-rtl-engine.js';
+const STYLES_FILENAME = 'agy-rtl-styles.css';
+
+/**
+ * Patch an unpacked Antigravity IDE installation.
+ * Copies payload files and modifies workbench.html.
+ */
+async function patchUnpacked(installation, spinner) {
+  const { workbenchDir, workbenchHtml } = installation;
+
+  // 1. Backup
+  const backupPath = workbenchHtml + BACKUP_SUFFIX;
+  if (!fs.existsSync(backupPath)) {
+    await fs.copy(workbenchHtml, backupPath);
+    spinner.succeed('Backup created: ' + chalk.gray(path.basename(backupPath)));
+  } else {
+    spinner.info('Backup already exists, skipping.');
   }
 
-  const backupPath = `${asarPath}.backup`;
-  const tmpDir = path.join(os.tmpdir(), 'agy-patch-tmp');
-  
+  // 2. Check if already patched
+  spinner.start('Checking patch status...');
+  const htmlContent = await fs.readFile(workbenchHtml, 'utf-8');
+  if (htmlContent.includes(PATCH_MARKER)) {
+    spinner.info('IDE is already patched. Use "restore" first to re-patch.');
+    return;
+  }
+
+  // 3. Copy payload files to workbench directory
+  spinner.start('Copying RTL engine & styles...');
+  const payloadDir = path.join(__dirname, '..', 'payload');
+
+  await fs.copy(
+    path.join(payloadDir, 'rtl-engine.js'),
+    path.join(workbenchDir, ENGINE_FILENAME)
+  );
+  await fs.copy(
+    path.join(payloadDir, 'styles.css'),
+    path.join(workbenchDir, STYLES_FILENAME)
+  );
+  spinner.succeed('Payload files copied.');
+
+  // 4. Inject references into workbench.html
+  spinner.start('Injecting RTL support into workbench...');
+  let modified = htmlContent;
+
+  // Add stylesheet link in <head> before </head>
+  const styleTag = `\n\t<!-- AGY-RTL-PATCH -->\n\t<link rel="stylesheet" href="./${STYLES_FILENAME}">\n\t<!-- /AGY-RTL-PATCH -->`;
+  modified = modified.replace('</head>', `${styleTag}\n</head>`);
+
+  // Add script before </html>
+  const scriptTag = `\n<!-- AGY-RTL-PATCH -->\n<script src="./${ENGINE_FILENAME}" id="${PATCH_MARKER}"></script>\n<!-- /AGY-RTL-PATCH -->`;
+  modified = modified.replace('</html>', `${scriptTag}\n</html>`);
+
+  await fs.writeFile(workbenchHtml, modified, 'utf-8');
+  spinner.succeed('RTL support injected into workbench.');
+}
+
+/**
+ * Patch an ASAR-packed Antigravity installation.
+ * Extracts the asar, patches files, and repacks.
+ */
+async function patchAsar(installation, spinner) {
+  const { asarPath } = installation;
+  const backupPath = asarPath + BACKUP_SUFFIX;
+  const tmpDir = path.join(os.tmpdir(), 'agy-rtl-patch-' + Date.now());
+
   try {
     // 1. Backup
-    spinner.start('Creating backup...');
     if (!fs.existsSync(backupPath)) {
+      spinner.start('Creating backup...');
       await fs.copy(asarPath, backupPath);
-      spinner.succeed('Backup created successfully.');
+      spinner.succeed('Backup created.');
     } else {
       spinner.info('Backup already exists, skipping.');
     }
 
     // 2. Extract
-    spinner.start('Extracting core files...');
-    if (fs.existsSync(tmpDir)) {
-      await fs.remove(tmpDir);
-    }
+    spinner.start('Extracting app.asar...');
     await fs.ensureDir(tmpDir);
     asar.extractAll(asarPath, tmpDir);
-    spinner.succeed('Core files extracted.');
+    spinner.succeed('Extracted successfully.');
 
-    // 3. Inject Payload
-    spinner.start('Injecting RTL engine & typography...');
-    
-    // Find the main HTML file - usually index.html in the root or a dist folder
-    const possibleHtmlPaths = [
+    // 3. Find workbench.html inside extracted asar
+    const possiblePaths = [
+      path.join(tmpDir, 'out', 'vs', 'code', 'electron-browser', 'workbench', 'workbench.html'),
       path.join(tmpDir, 'index.html'),
+      path.join(tmpDir, 'dist', 'index.html'),
       path.join(tmpDir, 'out', 'index.html'),
-      path.join(tmpDir, 'dist', 'index.html')
     ];
-    
+
     let targetHtml = null;
-    for (const p of possibleHtmlPaths) {
+    for (const p of possiblePaths) {
       if (fs.existsSync(p)) {
         targetHtml = p;
         break;
@@ -62,90 +108,197 @@ async function patch() {
     }
 
     if (!targetHtml) {
-      throw new Error('Could not find the main HTML file to inject.');
+      spinner.warn('No patchable HTML found in this package. Skipping.');
+      await fs.remove(tmpDir);
+      return;
     }
 
-    let htmlContent = await fs.readFile(targetHtml, 'utf-8');
-    
-    // Read payload files
-    const engineCode = await fs.readFile(path.join(__dirname, '..', 'payload', 'rtl-engine.js'), 'utf-8');
-    const stylesCode = await fs.readFile(path.join(__dirname, '..', 'payload', 'styles.css'), 'utf-8');
-
     // Check if already patched
-    if (htmlContent.includes('agy-rtl-engine')) {
-      spinner.info('IDE is already patched.');
+    const htmlContent = await fs.readFile(targetHtml, 'utf-8');
+    if (htmlContent.includes(PATCH_MARKER)) {
+      spinner.info('ASAR is already patched.');
       await fs.remove(tmpDir);
       return;
     }
 
-    const injection = `
-      <!-- AGY RTL PATCH -->
-      <style id="agy-rtl-styles">${stylesCode}</style>
-      <script id="agy-rtl-engine">${engineCode}</script>
-      <!-- END AGY RTL PATCH -->
-    `;
+    // 4. Copy payload files
+    spinner.start('Injecting RTL engine...');
+    const payloadDir = path.join(__dirname, '..', 'payload');
+    const targetDir = path.dirname(targetHtml);
+
+    await fs.copy(path.join(payloadDir, 'rtl-engine.js'), path.join(targetDir, ENGINE_FILENAME));
+    await fs.copy(path.join(payloadDir, 'styles.css'), path.join(targetDir, STYLES_FILENAME));
+
+    // 5. Modify HTML
+    let modified = htmlContent;
+    const styleTag = `\n\t<!-- AGY-RTL-PATCH -->\n\t<link rel="stylesheet" href="./${STYLES_FILENAME}">\n\t<!-- /AGY-RTL-PATCH -->`;
+    const scriptTag = `\n<!-- AGY-RTL-PATCH -->\n<script src="./${ENGINE_FILENAME}" id="${PATCH_MARKER}"></script>\n<!-- /AGY-RTL-PATCH -->`;
 
-    // Inject just before </body>
-    if (htmlContent.includes('</body>')) {
-      htmlContent = htmlContent.replace('</body>', `${injection}\n</body>`);
+    if (modified.includes('</head>')) {
+      modified = modified.replace('</head>', `${styleTag}\n</head>`);
+    }
+    if (modified.includes('</html>')) {
+      modified = modified.replace('</html>', `${scriptTag}\n</html>`);
+    } else if (modified.includes('</body>')) {
+      modified = modified.replace('</body>', `${scriptTag}\n</body>`);
     } else {
-      // Fallback
-      htmlContent += injection;
+      modified += scriptTag;
     }
 
-    await fs.writeFile(targetHtml, htmlContent);
-    spinner.succeed('Payload injected into UI.');
+    await fs.writeFile(targetHtml, modified, 'utf-8');
+    spinner.succeed('RTL engine injected.');
 
-    // 4. Repack
-    spinner.start('Repacking core files...');
-    await delay(500); // Give file system a moment
+    // 6. Repack
+    spinner.start('Repacking app.asar...');
+    await delay(300);
     await asar.createPackage(tmpDir, asarPath);
-    spinner.succeed('Core repacked successfully.');
-
-    // 5. Cleanup
-    spinner.start('Cleaning up...');
-    await fs.remove(tmpDir);
-    spinner.succeed('Cleanup complete.');
+    spinner.succeed('Repacked successfully.');
 
-    console.log(chalk.green.bold('\n✨ Antigravity IDE successfully patched with RTL support!'));
-    console.log(chalk.cyan('Please restart Antigravity for the changes to take effect.\n'));
-
-  } catch (err) {
-    spinner.fail('An error occurred during patching.');
+  } finally {
+    // Cleanup temp dir
     if (fs.existsSync(tmpDir)) {
       await fs.remove(tmpDir);
     }
-    throw err;
   }
 }
 
-async function restore() {
-  checkPermissions();
-  const spinner = ora('Locating Antigravity IDE...').start();
-  
-  let asarPath;
-  try {
-    asarPath = getAsarPath();
-    spinner.succeed(`Found Antigravity at: ${chalk.gray(asarPath)}`);
-  } catch (err) {
-    spinner.fail(err.message);
-    throw err;
+/**
+ * Main patch function.
+ */
+async function patch(customPath) {
+  const spinner = ora('Searching for Antigravity IDE...').start();
+
+  const installations = findInstallations(customPath);
+
+  if (installations.length === 0) {
+    spinner.fail('Antigravity IDE installation not found.');
+    console.error(chalk.yellow('\nTry specifying the path manually:'));
+    console.error(chalk.cyan('  agy-rtl patch --path /path/to/Antigravity-IDE\n'));
+    throw new Error('Installation not found.');
+  }
+
+  spinner.succeed(`Found ${installations.length} installation(s).`);
+
+  for (const inst of installations) {
+    console.log(chalk.cyan(`\n📂 Patching: ${chalk.white(inst.basePath)}`));
+    console.log(chalk.gray(`   Type: ${inst.type === 'unpacked' ? 'Unpacked App' : 'ASAR Package'}`));
+
+    checkPermissions(inst.basePath);
+
+    if (inst.type === 'unpacked') {
+      await patchUnpacked(inst, ora());
+    } else {
+      await patchAsar(inst, ora());
+    }
+  }
+
+  console.log(chalk.green.bold('\n✨ Antigravity IDE successfully patched with RTL support!'));
+  console.log(chalk.cyan('   Please restart Antigravity IDE for changes to take effect.\n'));
+}
+
+/**
+ * Restore an unpacked installation from backup.
+ */
+async function restoreUnpacked(installation, spinner) {
+  const { workbenchDir, workbenchHtml } = installation;
+  const backupPath = workbenchHtml + BACKUP_SUFFIX;
+
+  if (fs.existsSync(backupPath)) {
+    spinner.start('Restoring workbench.html from backup...');
+    await fs.copy(backupPath, workbenchHtml);
+    await fs.remove(backupPath);
+    spinner.succeed('Workbench restored.');
+  } else {
+    spinner.warn('No backup found for workbench.html.');
   }
 
-  const backupPath = `${asarPath}.backup`;
-  
-  spinner.start('Restoring from backup...');
+  // Remove injected payload files
+  const engineFile = path.join(workbenchDir, ENGINE_FILENAME);
+  const stylesFile = path.join(workbenchDir, STYLES_FILENAME);
+
+  if (fs.existsSync(engineFile)) await fs.remove(engineFile);
+  if (fs.existsSync(stylesFile)) await fs.remove(stylesFile);
+  spinner.succeed('Payload files removed.');
+}
+
+/**
+ * Restore an ASAR installation from backup.
+ */
+async function restoreAsar(installation, spinner) {
+  const { asarPath } = installation;
+  const backupPath = asarPath + BACKUP_SUFFIX;
+
   if (fs.existsSync(backupPath)) {
+    spinner.start('Restoring app.asar from backup...');
     await fs.copy(backupPath, asarPath);
     await fs.remove(backupPath);
-    spinner.succeed('Restored successfully.');
-    console.log(chalk.green.bold('\n✨ Antigravity IDE restored to original state!'));
+    spinner.succeed('ASAR restored.');
   } else {
-    spinner.fail('No backup found. The IDE might not be patched or backup was removed.');
+    spinner.warn('No backup found for app.asar.');
+  }
+}
+
+/**
+ * Main restore function.
+ */
+async function restore(customPath) {
+  const spinner = ora('Searching for Antigravity IDE...').start();
+  const installations = findInstallations(customPath);
+
+  if (installations.length === 0) {
+    spinner.fail('Antigravity IDE installation not found.');
+    throw new Error('Installation not found.');
+  }
+
+  spinner.succeed(`Found ${installations.length} installation(s).`);
+
+  for (const inst of installations) {
+    console.log(chalk.yellow(`\n🔄 Restoring: ${chalk.white(inst.basePath)}`));
+
+    checkPermissions(inst.basePath);
+
+    if (inst.type === 'unpacked') {
+      await restoreUnpacked(inst, ora());
+    } else {
+      await restoreAsar(inst, ora());
+    }
+  }
+
+  console.log(chalk.green.bold('\n✨ Antigravity IDE restored to original state!'));
+  console.log(chalk.cyan('   Please restart Antigravity IDE for changes to take effect.\n'));
+}
+
+/**
+ * Check patch status.
+ */
+async function status(customPath) {
+  const spinner = ora('Searching for Antigravity IDE...').start();
+  const installations = findInstallations(customPath);
+
+  if (installations.length === 0) {
+    spinner.fail('Antigravity IDE installation not found.');
+    return;
+  }
+
+  spinner.succeed(`Found ${installations.length} installation(s).`);
+
+  for (const inst of installations) {
+    let isPatched = false;
+
+    if (inst.type === 'unpacked') {
+      const html = await fs.readFile(inst.workbenchHtml, 'utf-8');
+      isPatched = html.includes(PATCH_MARKER);
+    }
+
+    const statusIcon = isPatched ? chalk.green('● PATCHED') : chalk.red('○ NOT PATCHED');
+    console.log(`\n  ${statusIcon}  ${chalk.white(inst.basePath)}`);
+    console.log(chalk.gray(`            Type: ${inst.type === 'unpacked' ? 'Unpacked App' : 'ASAR Package'}`));
   }
+  console.log('');
 }
 
 module.exports = {
   patch,
-  restore
+  restore,
+  status,
 };

package/src/paths.js

@@ -2,36 +2,116 @@ const fs = require('fs-extra');
 const path = require('path');
 const os = require('os');
 
-function getAsarPath() {
+/**
+ * Known installation paths for Antigravity IDE across all platforms.
+ * Both the IDE (unpacked) and the standalone app (asar) are supported.
+ */
+function getSearchPaths() {
+  const home = os.homedir();
   const platform = os.platform();
-  
-  // Possible paths where the IDE might be installed
-  const paths = {
-    win32: [
-      path.join(process.env.LOCALAPPDATA || '', 'Programs', 'antigravity', 'resources', 'app.asar'),
-      path.join(process.env.PROGRAMFILES || '', 'antigravity', 'resources', 'app.asar')
+
+  const common = [
+    // Downloads (common for manual installs)
+    path.join(home, 'Downloads', 'Antigravity-IDE'),
+    path.join(home, 'Downloads', 'Antigravity-x64'),
+    path.join(home, 'Downloads', 'Antigravity'),
+    // Desktop
+    path.join(home, 'Desktop', 'Antigravity-IDE'),
+    path.join(home, 'Desktop', 'Antigravity-x64'),
+  ];
+
+  const platformPaths = {
+    linux: [
+      ...common,
+      '/opt/antigravity-ide',
+      '/opt/Antigravity-IDE',
+      '/opt/antigravity',
+      '/usr/lib/antigravity-ide',
+      '/usr/share/antigravity-ide',
+      path.join(home, '.local', 'share', 'antigravity-ide'),
+      path.join(home, '.local', 'lib', 'antigravity-ide'),
     ],
     darwin: [
-      '/Applications/Antigravity.app/Contents/Resources/app.asar',
-      path.join(os.homedir(), 'Applications', 'Antigravity.app', 'Contents', 'Resources', 'app.asar')
+      '/Applications/Antigravity IDE.app/Contents',
+      path.join(home, 'Applications', 'Antigravity IDE.app', 'Contents'),
+      '/Applications/Antigravity.app/Contents',
+      ...common,
+    ],
+    win32: [
+      path.join(process.env.LOCALAPPDATA || '', 'Programs', 'antigravity-ide'),
+      path.join(process.env.LOCALAPPDATA || '', 'Programs', 'Antigravity IDE'),
+      path.join(process.env.PROGRAMFILES || '', 'Antigravity IDE'),
+      path.join(process.env.LOCALAPPDATA || '', 'Programs', 'antigravity'),
+      ...common,
     ],
-    linux: [
-      '/opt/antigravity/resources/app.asar',
-      '/usr/local/lib/antigravity/resources/app.asar'
-    ]
   };
 
-  const possiblePaths = paths[platform] || [];
+  return platformPaths[platform] || common;
+}
+
+/**
+ * Detect the type of Antigravity installation.
+ * Returns: { type: 'unpacked' | 'asar', basePath, workbenchDir, workbenchHtml }
+ */
+function detectInstallation(basePath) {
+  // Type 1: Unpacked app directory (IDE version)
+  const unpackedApp = path.join(basePath, 'resources', 'app');
+  const workbenchUnpacked = path.join(
+    unpackedApp,
+    'out', 'vs', 'code', 'electron-browser', 'workbench', 'workbench.html'
+  );
+
+  if (fs.existsSync(workbenchUnpacked)) {
+    return {
+      type: 'unpacked',
+      basePath,
+      appDir: unpackedApp,
+      workbenchDir: path.dirname(workbenchUnpacked),
+      workbenchHtml: workbenchUnpacked,
+    };
+  }
+
+  // Type 2: ASAR packed app
+  const asarPath = path.join(basePath, 'resources', 'app.asar');
+  if (fs.existsSync(asarPath)) {
+    return {
+      type: 'asar',
+      basePath,
+      asarPath,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Find all Antigravity IDE installations on the system.
+ */
+function findInstallations(customPath) {
+  const results = [];
+
+  if (customPath) {
+    const info = detectInstallation(customPath);
+    if (info) {
+      results.push(info);
+    }
+    return results;
+  }
 
-  for (const p of possiblePaths) {
-    if (fs.existsSync(p)) {
-      return p;
+  const searchPaths = getSearchPaths();
+  for (const sp of searchPaths) {
+    if (fs.existsSync(sp)) {
+      const info = detectInstallation(sp);
+      if (info) {
+        results.push(info);
+      }
     }
   }
 
-  throw new Error('Antigravity installation not found. Please ensure it is installed in the default location.');
+  return results;
 }
 
 module.exports = {
-  getAsarPath
+  findInstallations,
+  detectInstallation,
 };

package/src/utils.js

@@ -1,26 +1,35 @@
 const chalk = require('chalk');
 
-function checkPermissions() {
+/**
+ * Check if the current process has sufficient permissions
+ * to modify system-level application files.
+ */
+function checkPermissions(targetPath) {
   const isWindows = process.platform === 'win32';
-  
+
   if (!isWindows) {
-    // Check if running as root
     const isRoot = process.getuid && process.getuid() === 0;
-    if (!isRoot) {
+    // Check if the target is in a user-writable directory
+    const isUserDir = targetPath && targetPath.startsWith(require('os').homedir());
+
+    if (!isRoot && !isUserDir) {
       console.error(chalk.red.bold('\n⚠️  Permission Denied!'));
       console.error(chalk.white('Modifying system applications requires administrator privileges.'));
-      console.error(chalk.white(`Please run the command with ${chalk.yellow('sudo')}:\n`));
-      console.error(chalk.cyan('  sudo npx agy-rtl patch\n'));
+      console.error(chalk.white(`Please run with ${chalk.yellow('sudo')}:\n`));
+      console.error(chalk.cyan('  sudo npx antigravity-rtl-patcher patch\n'));
       process.exit(1);
     }
   }
 }
 
+/**
+ * Simple async delay helper.
+ */
 function delay(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 module.exports = {
   checkPermissions,
-  delay
+  delay,
 };