paseo-acp-agy 1.1.7 → 1.1.9

package/dist/acp-server.js

@@ -204,8 +204,37 @@ export class ACPServer {
                 }
                 case ACP_METHODS.SESSION_LOAD:
                 case ACP_METHODS.SESSION_LOAD_ALIAS: {
-                    if (!isNotification) {
-                        this.sendError(id, -32601, "session/load is not supported because agy-acp does not replay prior history; use session/resume");
+                    const sessionId = String(params.sessionId || "");
+                    const cwd = typeof params.cwd === "string" ? params.cwd : undefined;
+                    if (!sessionId) {
+                        if (!isNotification)
+                            this.sendError(id, -32602, "sessionId is required");
+                        break;
+                    }
+                    let session = this.sessionManager.getSession(sessionId);
+                    let created = false;
+                    try {
+                        if (!session) {
+                            session = this.sessionManager.createSession({
+                                id: sessionId,
+                                cwd,
+                                binaryPath: this.binaryPath,
+                            });
+                            created = true;
+                        }
+                        if (!created && session.process.currentConversationId) {
+                            await session.ensureReadyForResume();
+                        }
+                        if (!isNotification) {
+                            this.sendSuccess(id, await this.sessionState(session));
+                            this.publishCommands(session.id);
+                            this.publishUsageUpdate(session);
+                        }
+                    }
+                    catch (err) {
+                        if (!isNotification) {
+                            this.sendError(id, -32603, `Failed to load session ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+                        }
                     }
                     break;
                 }

package/dist/antigravity-process.d.ts

@@ -1,7 +1,10 @@
 import { EventEmitter } from "node:events";
 import { AgyInitEvent, AgyStepUpdateEvent, AgyResultEvent } from "./protocol.js";
 import { PermissionSettings } from "./permissions.js";
-export declare function resolveDefaultAgyBinary(): string;
+export declare const BINARY_RESOLVE_TTL_MS: number;
+export declare function clearBinaryResolutionCache(): void;
+export declare function isWindowsBatchScript(filePath: string): boolean;
+export declare function resolveDefaultAgyBinary(force?: boolean): string;
 export interface AntigravityProcessOptions {
     binaryPath?: string;
     cwd?: string;

package/dist/antigravity-process.js

@@ -6,41 +6,120 @@ import path from "node:path";
 import { logger } from "./logger.js";
 import { getEffectiveEffortForModel, } from "./protocol.js";
 import { buildAgyArgs, resolvePermissionSettings } from "./permissions.js";
-export function resolveDefaultAgyBinary() {
-    if (process.env.AGY_BIN_PATH)
-        return process.env.AGY_BIN_PATH;
-    const home = os.homedir();
-    if (home) {
-        if (process.platform === "win32") {
-            const candidates = [
-                path.join(home, ".local", "bin", "agy.exe"),
-                path.join(home, "AppData", "Local", "Programs", "antigravity", "agy.exe"),
-                path.join(home, ".local", "bin", "agy.cmd"),
-                path.join(home, ".local", "bin", "agy.bat"),
-            ];
-            for (const cand of candidates) {
-                if (fs.existsSync(cand))
-                    return cand;
+let cachedBinaryPath = null;
+let lastBinaryResolveTime = 0;
+export const BINARY_RESOLVE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours TTL
+export function clearBinaryResolutionCache() {
+    cachedBinaryPath = null;
+    lastBinaryResolveTime = 0;
+}
+export function isWindowsBatchScript(filePath) {
+    return /\.(cmd|bat)$/i.test(filePath);
+}
+export function resolveDefaultAgyBinary(force = false) {
+    const now = Date.now();
+    if (!force &&
+        cachedBinaryPath &&
+        now - lastBinaryResolveTime < BINARY_RESOLVE_TTL_MS &&
+        (cachedBinaryPath === "agy" || fs.existsSync(cachedBinaryPath))) {
+        return cachedBinaryPath;
+    }
+    let resolved = "agy";
+    if (process.env.AGY_BIN_PATH) {
+        resolved = process.env.AGY_BIN_PATH;
+    }
+    else {
+        const home = os.homedir();
+        if (home) {
+            if (process.platform === "win32") {
+                const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+                const localAppData = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local");
+                const programFiles = process.env.ProgramFiles || "C:\\Program Files";
+                const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
+                const exeCandidates = [
+                    path.join(localAppData, "Programs", "Antigravity", "bin", "agy.exe"),
+                    path.join(localAppData, "Programs", "antigravity", "agy.exe"),
+                    path.join(localAppData, "Programs", "Antigravity", "agy.exe"),
+                    path.join(programFiles, "Antigravity", "bin", "agy.exe"),
+                    path.join(programFilesX86, "Antigravity", "bin", "agy.exe"),
+                    path.join(localAppData, "Microsoft", "WindowsApps", "agy.exe"),
+                    path.join(home, ".local", "bin", "agy.exe"),
+                    path.join(appData, "npm", "agy.exe"),
+                    path.join(localAppData, "npm", "agy.exe"),
+                ];
+                for (const cand of exeCandidates) {
+                    if (fs.existsSync(cand)) {
+                        resolved = cand;
+                        break;
+                    }
+                }
+                if (resolved === "agy") {
+                    for (const target of ["agy", "agy.exe"]) {
+                        try {
+                            const out = execFileSync("where.exe", [target], {
+                                encoding: "utf-8",
+                                timeout: 2000,
+                                windowsHide: true,
+                            }).trim();
+                            const lines = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+                            for (const line of lines) {
+                                if (/\.exe$/i.test(line) && fs.existsSync(line)) {
+                                    resolved = line;
+                                    break;
+                                }
+                            }
+                            if (resolved !== "agy")
+                                break;
+                        }
+                        catch { }
+                    }
+                }
+                if (resolved === "agy") {
+                    const batchCandidates = [
+                        path.join(appData, "npm", "agy.cmd"),
+                        path.join(localAppData, "npm", "agy.cmd"),
+                        path.join(home, ".local", "bin", "agy.cmd"),
+                        path.join(appData, "npm", "agy.bat"),
+                    ];
+                    for (const cand of batchCandidates) {
+                        if (fs.existsSync(cand)) {
+                            resolved = cand;
+                            break;
+                        }
+                    }
+                    if (resolved === "agy") {
+                        for (const target of ["agy", "agy.cmd", "agy.bat"]) {
+                            try {
+                                const out = execFileSync("where.exe", [target], {
+                                    encoding: "utf-8",
+                                    timeout: 2000,
+                                    windowsHide: true,
+                                }).trim();
+                                const lines = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+                                for (const line of lines) {
+                                    if (isWindowsBatchScript(line) && fs.existsSync(line)) {
+                                        resolved = line;
+                                        break;
+                                    }
+                                }
+                                if (resolved !== "agy")
+                                    break;
+                            }
+                            catch { }
+                        }
+                    }
+                }
             }
-            try {
-                const out = execFileSync("where.exe", ["agy"], {
-                    encoding: "utf-8",
-                    timeout: 2000,
-                    windowsHide: true,
-                }).trim();
-                const first = out.split(/\r?\n/)[0]?.trim();
-                if (first && fs.existsSync(first))
-                    return first;
+            else {
+                const localPath = path.join(home, ".local", "bin", "agy");
+                if (fs.existsSync(localPath))
+                    resolved = localPath;
             }
-            catch { }
-        }
-        else {
-            const localPath = path.join(home, ".local", "bin", "agy");
-            if (fs.existsSync(localPath))
-                return localPath;
         }
     }
-    return "agy";
+    cachedBinaryPath = resolved;
+    lastBinaryResolveTime = now;
+    return resolved;
 }
 export class AntigravityProcess extends EventEmitter {
     child = null;
@@ -269,12 +348,13 @@ export class AntigravityProcess extends EventEmitter {
             effectiveEffort,
         });
         const isWin = process.platform === "win32";
+        const isBatch = isWin && isWindowsBatchScript(this.binaryPath);
         const child = spawn(this.binaryPath, args, {
             cwd: this.cwd,
             env: this.env,
             stdio: ["pipe", "pipe", "pipe"],
             detached: !isWin,
-            shell: isWin,
+            shell: isBatch,
             windowsHide: true,
         });
         this.child = child;

package/dist/index.js

@@ -1,8 +1,12 @@
 #!/usr/bin/env node
+import fs from "node:fs";
+import { execFileSync } from "node:child_process";
 import { ACPServer } from "./acp-server.js";
 import { logger } from "./logger.js";
 import { formatDiagnosticVersion, resolveBuildMetadata } from "./version.js";
-import { ensurePaseoIntegration } from "./paseo-patcher.js";
+import { ensurePaseoIntegration, findPaseoServerInstallations, findPaseoAsarPaths, isPaseoServerPatched, isPaseoAsarPatched, isPaseoRunning, } from "./paseo-patcher.js";
+import { resolveDefaultAgyBinary, isWindowsBatchScript } from "./antigravity-process.js";
+import { parseAgyQuotaOutput } from "./protocol.js";
 const args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
     if (args.includes("--json")) {
@@ -21,13 +25,16 @@ Usage:
   agy-acp [options]
   npx -y paseo-acp-agy [options]
   npx -y paseo-acp-agy setup
+  npx -y paseo-acp-agy doctor
 
 Commands:
   setup, patch   Configure and integrate Antigravity telemetry with Paseo
+  doctor         Diagnose Antigravity binary, quota provider, and Paseo status
 
 Options:
   --acp          Start ACP server over stdio (default)
   --setup        Integrate Antigravity with local Paseo server installation
+  --doctor       Run environment, binary, and telemetry diagnostics
   -v, --version  Show version
   --json         Show version in JSON format (with --version)
   -h, --help     Show help
@@ -39,30 +46,190 @@ Environment Variables:
   AGY_ACP_DANGEROUSLY_SKIP_PERMISSIONS Set to 'true' to auto-approve tool permissions
   AGY_BIN_PATH                      Path to agy binary (default: agy in PATH or ~/.local/bin/agy)
   PASEO_SERVER_PATH                 Path to local @getpaseo/server directory
+  PASEO_ASAR_PATH                   Path to local Paseo app.asar package
 `);
     process.exit(0);
 }
+if (args.includes("doctor") || args.includes("--doctor")) {
+    process.stdout.write("=== Paseo & Antigravity Doctor ===\n");
+    process.stdout.write(`Operating System: ${process.platform} (${process.arch})\n`);
+    process.stdout.write(`Node.js Version: ${process.version}\n`);
+    process.stdout.write(`Paseo ACP Adapter: ${formatDiagnosticVersion()}\n\n`);
+    process.stdout.write("1. Antigravity Binary Resolution:\n");
+    const binPath = resolveDefaultAgyBinary(true);
+    const exists = fs.existsSync(binPath);
+    const isWin = process.platform === "win32";
+    let execType = "Executable";
+    if (isWin) {
+        if (/\.exe$/i.test(binPath))
+            execType = "Native Windows Executable (.exe)";
+        else if (/\.cmd$/i.test(binPath))
+            execType = "Windows Command Script (.cmd)";
+        else if (/\.bat$/i.test(binPath))
+            execType = "Windows Batch Script (.bat)";
+        else
+            execType = "CLI command in PATH";
+    }
+    else {
+        execType = "POSIX binary";
+    }
+    if (exists) {
+        process.stdout.write(`  [OK] Binary found: ${binPath} (${execType})\n`);
+    }
+    else if (binPath === "agy") {
+        process.stdout.write(`  [?] Binary fallback: 'agy' via system PATH (${execType})\n`);
+    }
+    else {
+        process.stdout.write(`  [FAIL] Binary not found at: ${binPath}\n`);
+    }
+    process.stdout.write("\n2. CLI Telemetry & Runtime Probes:\n");
+    const isBatch = isWin && isWindowsBatchScript(binPath);
+    let modelsSuccess = false;
+    let modelsCount = 0;
+    const t0 = Date.now();
+    try {
+        const modelsOut = execFileSync(binPath, ["models"], {
+            encoding: "utf-8",
+            timeout: 15000,
+            windowsHide: true,
+            shell: isBatch,
+        });
+        const latency = Date.now() - t0;
+        const modelLines = modelsOut
+            .trim()
+            .split(/\r?\n/)
+            .map((l) => l.trim())
+            .filter((l) => Boolean(l) && !l.toLowerCase().startsWith("models:"));
+        modelsCount = modelLines.length;
+        modelsSuccess = true;
+        process.stdout.write(`  [OK] 'agy models' probe succeeded in ${latency}ms (${modelsCount} models detected)\n`);
+    }
+    catch (err) {
+        const latency = Date.now() - t0;
+        process.stdout.write(`  [WARN] 'agy models' probe failed in ${latency}ms: ${err?.message || String(err)}\n`);
+    }
+    let quotaSuccess = false;
+    let quotaCount = 0;
+    const t1 = Date.now();
+    try {
+        const usageOut = execFileSync(binPath, ["--print-timeout", "24h", "--print", "/usage"], {
+            encoding: "utf-8",
+            timeout: 15000,
+            windowsHide: true,
+            shell: isBatch,
+        });
+        const latency = Date.now() - t1;
+        const normalized = usageOut.replace(/\r\n/g, "\n");
+        const windows = parseAgyQuotaOutput(normalized);
+        quotaCount = windows.length;
+        quotaSuccess = true;
+        process.stdout.write(`  [OK] 'agy --print /usage' probe succeeded in ${latency}ms (${quotaCount} quota limit item(s) parsed)\n`);
+    }
+    catch (err) {
+        const latency = Date.now() - t1;
+        process.stdout.write(`  [WARN] 'agy --print /usage' probe failed in ${latency}ms: ${err?.message || String(err)}\n`);
+    }
+    process.stdout.write("\n3. Paseo Installation Targets:\n");
+    const serverPaths = findPaseoServerInstallations();
+    const asarPaths = findPaseoAsarPaths();
+    const totalFound = serverPaths.length + asarPaths.length;
+    if (totalFound === 0) {
+        process.stdout.write("  [!] No Paseo server or desktop installations discovered in standard paths.\n");
+    }
+    else {
+        for (const sPath of serverPaths) {
+            const patched = isPaseoServerPatched(sPath);
+            process.stdout.write(`  - [Server] ${sPath} -> ${patched ? "[PATCHED]" : "[UNPATCHED]"}\n`);
+        }
+        for (const aPath of asarPaths) {
+            const patched = await isPaseoAsarPatched(aPath);
+            process.stdout.write(`  - [ASAR]   ${aPath} -> ${patched ? "[PATCHED]" : "[UNPATCHED]"}\n`);
+        }
+    }
+    process.stdout.write("\n4. Paseo Process Status:\n");
+    const paseoRunning = isPaseoRunning();
+    if (paseoRunning) {
+        process.stdout.write("  [!] Paseo process is currently running.\n");
+        process.stdout.write("      Note: If you run setup/patch, please close Paseo completely (check system tray and Task Manager) to avoid EBUSY file locking.\n");
+    }
+    else {
+        process.stdout.write("  [OK] Paseo is not currently running (safe to patch/update).\n");
+    }
+    process.stdout.write("\n=== Doctor Recommendations ===\n");
+    let unpatchedCount = 0;
+    for (const sPath of serverPaths) {
+        if (!isPaseoServerPatched(sPath))
+            unpatchedCount++;
+    }
+    for (const aPath of asarPaths) {
+        if (!(await isPaseoAsarPatched(aPath)))
+            unpatchedCount++;
+    }
+    let hasIssue = false;
+    if (!exists && binPath !== "agy") {
+        hasIssue = true;
+        process.stdout.write("  - Antigravity CLI ('agy') executable was not found.\n");
+        process.stdout.write("    Action: Install Antigravity CLI or set AGY_BIN_PATH environment variable.\n");
+    }
+    if (totalFound === 0) {
+        hasIssue = true;
+        process.stdout.write("  - No Paseo installations found.\n");
+        process.stdout.write("    Action: Set PASEO_SERVER_PATH or PASEO_ASAR_PATH to your Paseo install directory if located elsewhere.\n");
+    }
+    else if (unpatchedCount > 0) {
+        hasIssue = true;
+        if (paseoRunning) {
+            process.stdout.write(`  - Found ${unpatchedCount} unpatched Paseo target(s), but Paseo is currently running.\n`);
+            process.stdout.write("    Action: Close Paseo.exe completely, then run:\n");
+            process.stdout.write("      npx -y paseo-acp-agy setup\n");
+        }
+        else {
+            process.stdout.write(`  - Found ${unpatchedCount} unpatched Paseo target(s).\n`);
+            process.stdout.write("    Action: Run setup to patch Paseo for Antigravity telemetry:\n");
+            process.stdout.write("      npx -y paseo-acp-agy setup\n");
+        }
+    }
+    if (!modelsSuccess || !quotaSuccess) {
+        if (exists || binPath === "agy") {
+            hasIssue = true;
+            process.stdout.write("  - Antigravity CLI telemetry probes experienced errors.\n");
+            process.stdout.write("    Action: Ensure you are logged in to Antigravity CLI (try running 'agy auth' or 'agy /status').\n");
+        }
+    }
+    if (!hasIssue) {
+        process.stdout.write("  [ALL OK] Everything is properly configured! Antigravity quota and telemetry are ready to use in Paseo.\n");
+    }
+    process.exit(0);
+}
 if (args.includes("setup") ||
     args.includes("patch") ||
     args.includes("--setup") ||
     args.includes("--patch")) {
+    if (isPaseoRunning()) {
+        process.stdout.write("Notice: Paseo appears to be running. If setup fails with EBUSY, please close Paseo completely (from system tray / task manager) and re-run setup.\n\n");
+    }
     process.stdout.write("Checking Paseo installation and configuring Antigravity telemetry...\n");
     try {
-        const res = ensurePaseoIntegration({ verbose: true });
+        const res = await ensurePaseoIntegration({ verbose: true });
         if (!res.found) {
-            process.stdout.write("Notice: No active @getpaseo/server installation found in standard paths.\n" +
-                "If Paseo is installed in a custom directory, set PASEO_SERVER_PATH and run setup again.\n");
+            process.stdout.write("Notice: No active @getpaseo/server installation or app.asar found in standard paths.\n" +
+                "If Paseo is installed in a custom directory, set PASEO_SERVER_PATH or PASEO_ASAR_PATH and run setup again.\n");
         }
         else {
-            process.stdout.write(`Found ${res.serverPaths.length} Paseo server installation(s).\n`);
-            if (res.patchedPaths.length > 0) {
-                process.stdout.write(`Successfully integrated with: \n${res.patchedPaths.map((p) => `  - ${p}`).join("\n")}\n\n` +
+            const totalFound = res.serverPaths.length + (res.asarPaths?.length || 0);
+            process.stdout.write(`Found ${totalFound} Paseo installation target(s) (${res.serverPaths.length} server dir(s), ${res.asarPaths?.length || 0} asar package(s)).\n`);
+            const allPatched = [...res.patchedPaths, ...(res.patchedAsarPaths || [])];
+            if (allPatched.length > 0) {
+                process.stdout.write(`Successfully integrated with: \n${allPatched.map((p) => `  - ${p}`).join("\n")}\n\n` +
                     `Antigravity quota provider and context-window telemetry are now enabled!\n` +
                     `Please restart Paseo (or run 'paseo daemon restart') to apply changes.\n`);
             }
             else {
                 process.stdout.write("Paseo is already up-to-date and configured for Antigravity telemetry.\n");
             }
+            if (res.errors.length > 0) {
+                process.stderr.write(`Notice: Some paths could not be modified (may require admin/close Paseo):\n${res.errors.map(e => `  - ${e}`).join("\n")}\n`);
+            }
         }
     }
     catch (err) {
@@ -71,10 +238,7 @@ if (args.includes("setup") ||
     process.exit(0);
 }
 // Auto-run integration in background when starting ACP server
-try {
-    ensurePaseoIntegration();
-}
-catch { }
+void ensurePaseoIntegration().catch(() => { });
 const server = new ACPServer();
 const cleanup = async () => {
     try {

package/dist/paseo-patcher.d.ts

@@ -2,6 +2,8 @@ export interface PatchResult {
     found: boolean;
     serverPaths: string[];
     patchedPaths: string[];
+    asarPaths?: string[];
+    patchedAsarPaths?: string[];
     errors: string[];
 }
 /**
@@ -26,9 +28,37 @@ export declare function patchPaseoServer(serverDir: string): {
     error?: string;
 };
 /**
- * Discovers and patches all accessible Paseo installations.
+ * Searches the host machine for Paseo Desktop app.asar archives across
+ * Windows, macOS, and Linux.
+ */
+export declare function findPaseoAsarPaths(): string[];
+/**
+ * Extracts, patches, and repacks a Paseo app.asar archive to integrate Antigravity
+ * quota fetchers and token telemetry.
+ */
+export declare function patchPaseoAsar(asarPath: string): Promise<{
+    success: boolean;
+    changes: string[];
+    error?: string;
+}>;
+/**
+ * Discovers and patches all accessible Paseo installations (both directory and app.asar).
  */
 export declare function ensurePaseoIntegration(options?: {
     verbose?: boolean;
     targetPaths?: string[];
-}): PatchResult;
+    targetAsarPaths?: string[];
+}): Promise<PatchResult>;
+/**
+ * Checks whether a @getpaseo/server installation directory is already patched
+ * for Antigravity quota and telemetry support.
+ */
+export declare function isPaseoServerPatched(serverDir: string): boolean;
+/**
+ * Checks whether a Paseo app.asar archive is already patched with Antigravity telemetry.
+ */
+export declare function isPaseoAsarPatched(asarPath: string): Promise<boolean>;
+/**
+ * Detects if Paseo Desktop is currently running on the host.
+ */
+export declare function isPaseoRunning(): boolean;

package/dist/paseo-patcher.js

@@ -92,6 +92,8 @@ export function findPaseoServerInstallations() {
                     path.join(path.dirname(paseoDir), "node_modules", "@getpaseo", "server"),
                     path.join(paseoDir, "resources", "app.asar.unpacked", "node_modules", "@getpaseo", "server"),
                     path.join(paseoDir, "resources", "app", "node_modules", "@getpaseo", "server"),
+                    path.join(path.dirname(paseoDir), "resources", "app.asar.unpacked", "node_modules", "@getpaseo", "server"),
+                    path.join(path.dirname(paseoDir), "resources", "app", "node_modules", "@getpaseo", "server"),
                 ];
                 for (const c of checks) {
                     if (fs.existsSync(c))
@@ -179,31 +181,100 @@ import { toneFromUsedPct, windowFromUsedPct, unavailableUsage } from "../usage.j
 
 const execFileAsync = promisify(execFile);
 
+let cachedAgyBin = null;
+let cachedAgyBinTime = 0;
+const BIN_CACHE_TTL_MS = 86400000; // 24 hours
+
 function resolveAgyBinary() {
     if (process.env.AGY_BIN_PATH) return process.env.AGY_BIN_PATH;
+    const now = Date.now();
+    if (cachedAgyBin && (now - cachedAgyBinTime < BIN_CACHE_TTL_MS)) {
+        return cachedAgyBin;
+    }
+
+    let resolved = "agy";
     const home = os.homedir();
     if (home) {
         if (process.platform === "win32") {
-            const candidates = [
+            const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+            const localAppData = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local");
+            const programFiles = process.env.ProgramFiles || "C:\\\\Program Files";
+            const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\\\Program Files (x86)";
+
+            // Prioritize .exe candidates over .cmd / .bat
+            const exeCandidates = [
+                path.join(localAppData, "Programs", "Antigravity", "bin", "agy.exe"),
+                path.join(localAppData, "Programs", "antigravity", "agy.exe"),
+                path.join(localAppData, "Programs", "Antigravity", "agy.exe"),
+                path.join(programFiles, "Antigravity", "bin", "agy.exe"),
+                path.join(programFilesX86, "Antigravity", "bin", "agy.exe"),
+                path.join(localAppData, "Microsoft", "WindowsApps", "agy.exe"),
                 path.join(home, ".local", "bin", "agy.exe"),
-                path.join(home, "AppData", "Local", "Programs", "antigravity", "agy.exe"),
-                path.join(home, ".local", "bin", "agy.cmd"),
-                path.join(home, ".local", "bin", "agy.bat"),
+                path.join(appData, "npm", "agy.exe"),
+                path.join(localAppData, "npm", "agy.exe"),
             ];
-            for (const cand of candidates) {
-                if (fs.existsSync(cand)) return cand;
+            for (const cand of exeCandidates) {
+                if (fs.existsSync(cand)) {
+                    resolved = cand;
+                    break;
+                }
+            }
+
+            // Check where.exe agy and select first .exe
+            if (resolved === "agy") {
+                for (const target of ["agy", "agy.exe"]) {
+                    try {
+                        const out = execFileSync("where.exe", [target], { encoding: "utf-8", timeout: 2000, windowsHide: true }).trim();
+                        const lines = out.split(/\\r?\\n/).map(l => l.trim()).filter(Boolean);
+                        const firstExe = lines.find(l => /\\.exe$/i.test(l) && fs.existsSync(l));
+                        if (firstExe) {
+                            resolved = firstExe;
+                            break;
+                        }
+                    } catch {}
+                }
+            }
+
+            // Fallback to batch scripts (.cmd / .bat) if no .exe found
+            if (resolved === "agy") {
+                const batchCandidates = [
+                    path.join(appData, "npm", "agy.cmd"),
+                    path.join(localAppData, "npm", "agy.cmd"),
+                    path.join(home, ".local", "bin", "agy.cmd"),
+                    path.join(appData, "npm", "agy.bat"),
+                    path.join(localAppData, "npm", "agy.bat"),
+                    path.join(home, ".local", "bin", "agy.bat"),
+                ];
+                for (const cand of batchCandidates) {
+                    if (fs.existsSync(cand)) {
+                        resolved = cand;
+                        break;
+                    }
+                }
+            }
+
+            if (resolved === "agy") {
+                for (const target of ["agy", "agy.cmd", "agy.bat"]) {
+                    try {
+                        const out = execFileSync("where.exe", [target], { encoding: "utf-8", timeout: 2000, windowsHide: true }).trim();
+                        const lines = out.split(/\\r?\\n/).map(l => l.trim()).filter(Boolean);
+                        const firstAny = lines.find(l => /\\.(cmd|bat)$/i.test(l) && fs.existsSync(l));
+                        if (firstAny) {
+                            resolved = firstAny;
+                            break;
+                        }
+                    } catch {}
+                }
             }
-            try {
-                const out = execFileSync("where.exe", ["agy"], { encoding: "utf-8", timeout: 2000, windowsHide: true }).trim();
-                const first = out.split(/\\r?\\n/)[0]?.trim();
-                if (first && fs.existsSync(first)) return first;
-            } catch {}
         } else {
             const localPath = path.join(home, ".local", "bin", "agy");
-            if (fs.existsSync(localPath)) return localPath;
+            if (fs.existsSync(localPath)) resolved = localPath;
         }
     }
-    return "agy";
+
+    cachedAgyBin = resolved;
+    cachedAgyBinTime = now;
+    return resolved;
 }
 
 export class AntigravityQuotaProvider {
@@ -217,20 +288,22 @@ export class AntigravityQuotaProvider {
     async fetchUsage() {
         try {
             const isWin = process.platform === "win32";
-            let bin = this.binaryPath;
-            if (isWin && bin.includes(" ") && !bin.startsWith('"')) {
-                bin = \`"\${bin}"\`;
-            }
+            const bin = resolveAgyBinary();
+            this.binaryPath = bin;
+            const isBatch = isWin && /\\.(cmd|bat)$/i.test(bin);
             const [usageRes, creditsRes] = await Promise.allSettled([
-                execFileAsync(bin, ["--print", "/usage"], { timeout: 8000, env: process.env, shell: isWin, windowsHide: true }),
-                execFileAsync(bin, ["--print", "/credits"], { timeout: 8000, env: process.env, shell: isWin, windowsHide: true }),
+                execFileAsync(bin, ["--print-timeout", "24h", "--print", "/usage"], { timeout: 15000, env: process.env, shell: isBatch, windowsHide: true }),
+                execFileAsync(bin, ["--print-timeout", "24h", "--print", "/credits"], { timeout: 15000, env: process.env, shell: isBatch, windowsHide: true }),
             ]);
 
-            const usageOut = usageRes.status === "fulfilled" ? usageRes.value.stdout || usageRes.value.stderr : "";
-            const creditsOut = creditsRes.status === "fulfilled" ? creditsRes.value.stdout || creditsRes.value.stderr : "";
+            const rawUsageOut = usageRes.status === "fulfilled" ? usageRes.value.stdout || usageRes.value.stderr : "";
+            const rawCreditsOut = creditsRes.status === "fulfilled" ? creditsRes.value.stdout || creditsRes.value.stderr : "";
+
+            const usageOut = (rawUsageOut || "").replace(/\\r\\n/g, "\\n");
+            const creditsOut = (rawCreditsOut || "").replace(/\\r\\n/g, "\\n");
 
             const rawWindows = [];
-            for (const line of usageOut.split(/[\\r\\n]+/)) {
+            for (const line of usageOut.split("\\n")) {
                 const trimmed = line.trim();
                 if (!trimmed || trimmed.toLowerCase().startsWith("quota:")) continue;
 
@@ -348,7 +421,7 @@ export function patchPaseoServer(serverDir) {
                         if (found)
                             return found;
                     }
-                    else if (e.isFile() && e.name === "manifest.js" && dir.includes("quota-fetcher")) {
+                    else if (e.isFile() && e.name === "manifest.js" && dir.replace(/\\/g, "/").includes("quota-fetcher")) {
                         return full;
                     }
                 }
@@ -375,9 +448,9 @@ export function patchPaseoServer(serverDir) {
             }
             if (!manifestCode.includes('providerId: "antigravity"')) {
                 const entryToAdd = `    {\n        providerId: "antigravity",\n        create: (options) => new AntigravityQuotaProvider({\n            logger: options.logger,\n            fetch: options.fetch,\n        }),\n    },\n`;
-                const marker = "export const PROVIDER_USAGE_FETCHERS = [";
-                if (manifestCode.includes(marker)) {
-                    manifestCode = manifestCode.replace(marker, `${marker}\n${entryToAdd}`);
+                const fetcherArrayRegex = /export\s+const\s+PROVIDER_USAGE_FETCHERS\s*=\s*\[/;
+                if (fetcherArrayRegex.test(manifestCode)) {
+                    manifestCode = manifestCode.replace(fetcherArrayRegex, (match) => `${match}\n${entryToAdd}`);
                     manifestModified = true;
                 }
             }
@@ -434,11 +507,44 @@ export function patchPaseoServer(serverDir) {
                     acpCode = acpCode.replace(oldMapRegex, newMap);
                     acpModified = true;
                 }
+                else {
+                    const mapMatch = acpCode.match(/export\s+function\s+mapACPUsage\s*\([^)]*\)\s*\{/);
+                    if (mapMatch && mapMatch.index !== undefined) {
+                        const mapStart = mapMatch.index;
+                        const openBrace = acpCode.indexOf("{", mapStart);
+                        let depth = 1;
+                        let i = openBrace + 1;
+                        while (i < acpCode.length && depth > 0) {
+                            if (acpCode[i] === "{")
+                                depth++;
+                            else if (acpCode[i] === "}")
+                                depth--;
+                            i++;
+                        }
+                        if (depth === 0) {
+                            acpCode = acpCode.slice(0, mapStart) + newMap + acpCode.slice(i);
+                            acpModified = true;
+                        }
+                    }
+                }
             }
             // Patch handleUsageUpdate
-            if (acpCode.includes("handleUsageUpdate(update) {") && (!acpCode.includes("this.deliverTranslatedEvents") || acpCode.includes("this.notifySubscribers"))) {
-                const handlerRegex = /handleUsageUpdate\s*\(\s*update\s*\)\s*\{[\s\S]*?(?:void\s+update;|this\.notifySubscribers)[\s\S]*?\n\s*\}/m;
-                const newHandler = `handleUsageUpdate(update) {
+            if (acpCode.includes("handleUsageUpdate") && (!acpCode.includes("this.deliverTranslatedEvents") || acpCode.includes("this.notifySubscribers"))) {
+                const startIdx = acpCode.search(/\bhandleUsageUpdate\s*\(/);
+                if (startIdx !== -1) {
+                    const openBrace = acpCode.indexOf("{", startIdx);
+                    if (openBrace !== -1) {
+                        let depth = 1;
+                        let i = openBrace + 1;
+                        while (i < acpCode.length && depth > 0) {
+                            if (acpCode[i] === "{")
+                                depth++;
+                            else if (acpCode[i] === "}")
+                                depth--;
+                            i++;
+                        }
+                        if (depth === 0) {
+                            const newHandler = `handleUsageUpdate(update) {
         if (!update) return;
         const usage = mapACPUsage(update);
         if (usage) {
@@ -456,9 +562,10 @@ export function patchPaseoServer(serverDir) {
             }
         }
     }`;
-                if (handlerRegex.test(acpCode)) {
-                    acpCode = acpCode.replace(handlerRegex, newHandler);
-                    acpModified = true;
+                            acpCode = acpCode.slice(0, startIdx) + newHandler + acpCode.slice(i);
+                            acpModified = true;
+                        }
+                    }
                 }
             }
             if (acpModified) {
@@ -475,11 +582,197 @@ export function patchPaseoServer(serverDir) {
     }
 }
 /**
- * Discovers and patches all accessible Paseo installations.
+ * Searches the host machine for Paseo Desktop app.asar archives across
+ * Windows, macOS, and Linux.
+ */
+export function findPaseoAsarPaths() {
+    const candidates = new Set();
+    const home = os.homedir();
+    if (process.env.PASEO_ASAR_PATH && fs.existsSync(process.env.PASEO_ASAR_PATH)) {
+        candidates.add(path.resolve(process.env.PASEO_ASAR_PATH));
+    }
+    if (process.platform === "win32") {
+        const localAppData = process.env.LOCALAPPDATA || (home ? path.join(home, "AppData", "Local") : "");
+        const appData = process.env.APPDATA || (home ? path.join(home, "AppData", "Roaming") : "");
+        const programFiles = process.env.ProgramFiles || "C:\\Program Files";
+        const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
+        const winAsarLocations = [
+            path.join(localAppData, "Programs", "Paseo", "resources", "app.asar"),
+            path.join(localAppData, "Programs", "paseo", "resources", "app.asar"),
+            path.join(localAppData, "Paseo", "resources", "app.asar"),
+            path.join(programFiles, "Paseo", "resources", "app.asar"),
+            path.join(programFiles, "paseo", "resources", "app.asar"),
+            path.join(programFilesX86, "Paseo", "resources", "app.asar"),
+            path.join(programFilesX86, "paseo", "resources", "app.asar"),
+            path.join(appData, "Paseo", "resources", "app.asar"),
+        ];
+        for (const loc of winAsarLocations) {
+            if (loc && fs.existsSync(loc))
+                candidates.add(path.resolve(loc));
+        }
+        try {
+            const whereOut = execFileSync("where.exe", ["paseo"], {
+                encoding: "utf-8",
+                timeout: 2000,
+                windowsHide: true,
+            }).trim();
+            for (const line of whereOut.split(/\r?\n/).map((l) => l.trim()).filter(Boolean)) {
+                const asarCandidate1 = path.join(path.dirname(line), "resources", "app.asar");
+                const asarCandidate2 = path.resolve(path.dirname(line), "..", "resources", "app.asar");
+                const asarCandidate3 = path.resolve(line, "..", "..", "resources", "app.asar");
+                for (const cand of [asarCandidate1, asarCandidate2, asarCandidate3]) {
+                    if (fs.existsSync(cand))
+                        candidates.add(path.resolve(cand));
+                }
+            }
+        }
+        catch { }
+    }
+    else if (process.platform === "darwin") {
+        const macLocations = [
+            "/Applications/Paseo.app/Contents/Resources/app.asar",
+            path.join(home, "Applications", "Paseo.app", "Contents", "Resources", "app.asar"),
+        ];
+        for (const loc of macLocations) {
+            if (fs.existsSync(loc))
+                candidates.add(path.resolve(loc));
+        }
+    }
+    else {
+        const linuxLocations = [
+            "/opt/Paseo/resources/app.asar",
+            "/usr/lib/paseo/resources/app.asar",
+            path.join(home, ".local", "share", "paseo", "resources", "app.asar"),
+        ];
+        for (const loc of linuxLocations) {
+            if (fs.existsSync(loc))
+                candidates.add(path.resolve(loc));
+        }
+    }
+    return Array.from(candidates);
+}
+/**
+ * Extracts, patches, and repacks a Paseo app.asar archive to integrate Antigravity
+ * quota fetchers and token telemetry.
+ */
+export async function patchPaseoAsar(asarPath) {
+    const changes = [];
+    let tempDir = null;
+    let tempAsar = null;
+    try {
+        if (!fs.existsSync(asarPath)) {
+            return { success: false, changes: [], error: `Asar archive not found: ${asarPath}` };
+        }
+        // Dynamic import of @electron/asar
+        const asarModule = await import("@electron/asar");
+        const asar = asarModule.default || asarModule;
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "paseo-asar-extract-"));
+        asar.extractAll(asarPath, tempDir);
+        // Look for server directory in extracted files
+        const serverCandidates = [
+            path.join(tempDir, "node_modules", "@getpaseo", "server"),
+            path.join(tempDir, "dist", "node_modules", "@getpaseo", "server"),
+        ];
+        let serverDir = serverCandidates.find((c) => fs.existsSync(c));
+        if (!serverDir) {
+            // Search recursively within 3 levels
+            const searchDirs = [tempDir];
+            while (searchDirs.length > 0 && !serverDir) {
+                const current = searchDirs.shift();
+                try {
+                    const entries = fs.readdirSync(current, { withFileTypes: true });
+                    for (const ent of entries) {
+                        if (ent.isDirectory()) {
+                            const full = path.join(current, ent.name);
+                            const normalizedFull = full.replace(/\\/g, "/");
+                            if (ent.name === "server" && normalizedFull.includes("@getpaseo/server")) {
+                                serverDir = full;
+                                break;
+                            }
+                            if (full.split(path.sep).length - tempDir.split(path.sep).length < 4) {
+                                searchDirs.push(full);
+                            }
+                        }
+                    }
+                }
+                catch { }
+            }
+        }
+        if (!serverDir) {
+            return { success: false, changes: [], error: `Could not locate @getpaseo/server inside ${asarPath}` };
+        }
+        const patchResult = patchPaseoServer(serverDir);
+        if (!patchResult.success) {
+            return { success: false, changes: [], error: patchResult.error };
+        }
+        if (patchResult.changes.length === 0) {
+            // Already patched!
+            return { success: true, changes: [] };
+        }
+        changes.push(...patchResult.changes);
+        // Create backup if not already present
+        const backupPath = `${asarPath}.bak`;
+        if (!fs.existsSync(backupPath)) {
+            try {
+                fs.copyFileSync(asarPath, backupPath);
+                changes.push(`Backed up original asar to ${backupPath}`);
+            }
+            catch (backupErr) {
+                logger.warn(`Could not create asar backup at ${backupPath}`, { error: String(backupErr) });
+            }
+        }
+        tempAsar = path.join(os.tmpdir(), `app-${Date.now()}.asar`);
+        await asar.createPackage(tempDir, tempAsar);
+        // Replace original archive with locked file handling for Windows
+        try {
+            fs.copyFileSync(tempAsar, asarPath);
+            changes.push(`Repacked updated asar archive at ${asarPath}`);
+        }
+        catch (copyErr) {
+            if (copyErr && (copyErr.code === "EBUSY" || copyErr.code === "EPERM" || copyErr.code === "EACCES")) {
+                const oldPath = `${asarPath}.old-${Date.now()}`;
+                try {
+                    fs.renameSync(asarPath, oldPath);
+                    fs.copyFileSync(tempAsar, asarPath);
+                    changes.push(`Repacked updated asar archive at ${asarPath} (safe replaced locked file, moved previous to ${oldPath})`);
+                }
+                catch (renameErr) {
+                    throw new Error(`Cannot update ${asarPath}: file is locked by a running Paseo process (${copyErr.code}). Please close Paseo completely (Paseo.exe in system tray / Task Manager) and retry.`);
+                }
+            }
+            else {
+                throw copyErr;
+            }
+        }
+        return { success: true, changes };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { success: false, changes, error: msg };
+    }
+    finally {
+        if (tempDir) {
+            try {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            }
+            catch { }
+        }
+        if (tempAsar) {
+            try {
+                fs.unlinkSync(tempAsar);
+            }
+            catch { }
+        }
+    }
+}
+/**
+ * Discovers and patches all accessible Paseo installations (both directory and app.asar).
  */
-export function ensurePaseoIntegration(options) {
+export async function ensurePaseoIntegration(options) {
     const serverPaths = options?.targetPaths || findPaseoServerInstallations();
+    const asarPaths = options?.targetAsarPaths || findPaseoAsarPaths();
     const patchedPaths = [];
+    const patchedAsarPaths = [];
     const errors = [];
     for (const sPath of serverPaths) {
         const res = patchPaseoServer(sPath);
@@ -495,10 +788,124 @@ export function ensurePaseoIntegration(options) {
             errors.push(`${sPath}: ${res.error}`);
         }
     }
+    for (const aPath of asarPaths) {
+        const res = await patchPaseoAsar(aPath);
+        if (res.success) {
+            if (res.changes.length > 0) {
+                patchedAsarPaths.push(aPath);
+                if (options?.verbose) {
+                    logger.info(`Integrated with Paseo desktop asar at ${aPath}`, { changes: res.changes });
+                }
+            }
+        }
+        else if (res.error) {
+            errors.push(`${aPath}: ${res.error}`);
+        }
+    }
     return {
-        found: serverPaths.length > 0,
+        found: serverPaths.length > 0 || asarPaths.length > 0,
         serverPaths,
         patchedPaths,
+        asarPaths,
+        patchedAsarPaths,
         errors,
     };
 }
+/**
+ * Checks whether a @getpaseo/server installation directory is already patched
+ * for Antigravity quota and telemetry support.
+ */
+export function isPaseoServerPatched(serverDir) {
+    try {
+        if (!fs.existsSync(serverDir))
+            return false;
+        const antigravityJsCandidates = [
+            path.join(serverDir, "dist", "server", "services", "quota-fetcher", "providers", "antigravity.js"),
+            path.join(serverDir, "dist", "services", "quota-fetcher", "providers", "antigravity.js"),
+        ];
+        let hasProvider = antigravityJsCandidates.some((p) => fs.existsSync(p));
+        if (!hasProvider && fs.existsSync(path.join(serverDir, "dist"))) {
+            const checkRecursive = (dir, depth = 0) => {
+                if (depth > 5)
+                    return false;
+                try {
+                    const entries = fs.readdirSync(dir, { withFileTypes: true });
+                    for (const e of entries) {
+                        if (e.isDirectory() && e.name !== "node_modules") {
+                            if (checkRecursive(path.join(dir, e.name), depth + 1))
+                                return true;
+                        }
+                        else if (e.isFile() && e.name === "antigravity.js" && dir.replace(/\\/g, "/").includes("quota-fetcher")) {
+                            return true;
+                        }
+                    }
+                }
+                catch { }
+                return false;
+            };
+            hasProvider = checkRecursive(path.join(serverDir, "dist"));
+        }
+        if (hasProvider)
+            return true;
+        const manifestCandidates = [
+            path.join(serverDir, "dist", "server", "services", "quota-fetcher", "manifest.js"),
+            path.join(serverDir, "dist", "services", "quota-fetcher", "manifest.js"),
+        ];
+        for (const cand of manifestCandidates) {
+            if (fs.existsSync(cand)) {
+                const content = fs.readFileSync(cand, "utf-8");
+                if (content.includes('providerId: "antigravity"'))
+                    return true;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Checks whether a Paseo app.asar archive is already patched with Antigravity telemetry.
+ */
+export async function isPaseoAsarPatched(asarPath) {
+    try {
+        if (!fs.existsSync(asarPath))
+            return false;
+        const asarModule = await import("@electron/asar");
+        const asar = asarModule.default || asarModule;
+        const files = asar.listPackage(asarPath);
+        return files.some((f) => f.includes("antigravity.js"));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Detects if Paseo Desktop is currently running on the host.
+ */
+export function isPaseoRunning() {
+    try {
+        if (process.platform === "win32") {
+            const out = execFileSync("tasklist.exe", ["/FI", "IMAGENAME eq Paseo*", "/NH"], {
+                encoding: "utf-8",
+                timeout: 3000,
+                windowsHide: true,
+            });
+            return /paseo/i.test(out) && !out.includes("INFO:") && !out.includes("No tasks");
+        }
+        else {
+            const out = execFileSync("pgrep", ["-i", "-x", "paseo"], {
+                encoding: "utf-8",
+                timeout: 2000,
+            });
+            const pids = out
+                .split(/\r?\n/)
+                .map((s) => parseInt(s.trim(), 10))
+                .filter((p) => !isNaN(p) && p !== process.pid);
+            return pids.length > 0;
+        }
+    }
+    catch {
+        return false;
+    }
+}

package/dist/protocol.d.ts

@@ -173,7 +173,12 @@ export interface ProviderUsage {
     }>;
     error: string | null;
 }
-export declare function formatExecBinaryPath(binaryPath: string): string;
+export declare function formatExecBinaryPath(binaryPath: string, shell?: boolean): string;
+export interface ResolvedCommandExecution {
+    cmd: string;
+    shell: boolean;
+}
+export declare function resolveCommandExecution(binaryPath: string): ResolvedCommandExecution;
 export declare function fetchAntigravityUsage(binaryPath?: string, force?: boolean): Promise<ProviderUsage>;
 export declare const ALL_THINKING_LEVELS: Record<string, {
     name: string;

package/dist/protocol.js

@@ -3,6 +3,7 @@ import { promisify } from "node:util";
 import { fileURLToPath } from "node:url";
 import { logger } from "./logger.js";
 import { saveBase64Image } from "./attachments.js";
+import { isWindowsBatchScript } from "./antigravity-process.js";
 const execFileAsync = promisify(execFile);
 // ACP wire methods use snake_case. The aliases retain the public method names
 // accepted by the adapter before the hardening work so existing clients do not
@@ -278,12 +279,19 @@ function cacheProviderUsage(binaryPath, result, now) {
     lastProviderUsageFetch = now;
     return result;
 }
-export function formatExecBinaryPath(binaryPath) {
-    if (process.platform === "win32" && binaryPath.includes(" ") && !binaryPath.startsWith('"')) {
+export function formatExecBinaryPath(binaryPath, shell) {
+    const isWin = process.platform === "win32";
+    const needsShell = shell ?? (isWin && isWindowsBatchScript(binaryPath));
+    if (needsShell && isWin && binaryPath.includes(" ") && !binaryPath.startsWith('"')) {
         return `"${binaryPath}"`;
     }
     return binaryPath;
 }
+export function resolveCommandExecution(binaryPath) {
+    const isBatch = process.platform === "win32" && isWindowsBatchScript(binaryPath);
+    const cmd = isBatch && binaryPath.includes(" ") && !binaryPath.startsWith('"') ? `"${binaryPath}"` : binaryPath;
+    return { cmd, shell: isBatch };
+}
 export async function fetchAntigravityUsage(binaryPath = "agy", force = false) {
     const now = Date.now();
     if (!force &&
@@ -292,21 +300,22 @@ export async function fetchAntigravityUsage(binaryPath = "agy", force = false) {
         now - lastProviderUsageFetch < PROVIDER_USAGE_CACHE_TTL_MS) {
         return cachedProviderUsage;
     }
-    const cmd = formatExecBinaryPath(binaryPath);
+    const isBatch = process.platform === "win32" && isWindowsBatchScript(binaryPath);
+    const cmd = isBatch && binaryPath.includes(" ") && !binaryPath.startsWith('"') ? `"${binaryPath}"` : binaryPath;
     try {
         const [usageResult, creditsResult] = await Promise.allSettled([
             execFileAsync(cmd, ["--print", "/usage"], {
                 timeout: 8_000,
                 maxBuffer: 1024 * 1024,
                 env: process.env,
-                shell: process.platform === "win32",
+                shell: isBatch,
                 windowsHide: true,
             }),
             execFileAsync(cmd, ["--print", "/credits"], {
                 timeout: 8_000,
                 maxBuffer: 1024 * 1024,
                 env: process.env,
-                shell: process.platform === "win32",
+                shell: isBatch,
                 windowsHide: true,
             }),
         ]);
@@ -429,13 +438,14 @@ export async function fetchAvailableModels(binaryPath = "agy", force = false) {
         return inFlightModelFetch;
     }
     inFlightModelFetch = (async () => {
-        const cmd = formatExecBinaryPath(binaryPath);
+        const isBatch = process.platform === "win32" && isWindowsBatchScript(binaryPath);
+        const cmd = isBatch && binaryPath.includes(" ") && !binaryPath.startsWith('"') ? `"${binaryPath}"` : binaryPath;
         try {
             const { stdout } = await execFileAsync(cmd, ["models"], {
                 timeout: 10_000,
                 env: process.env,
                 maxBuffer: 4 * 1024 * 1024,
-                shell: process.platform === "win32",
+                shell: isBatch,
                 windowsHide: true,
             });
             const parsed = parseAgyModelsOutput(stdout);

package/dist/slash-commands.js

@@ -5,7 +5,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { logger } from "./logger.js";
 import { sessionStore } from "./session-store.js";
-import { formatExecBinaryPath } from "./protocol.js";
+import { isWindowsBatchScript } from "./antigravity-process.js";
 const execFileAsync = promisify(execFile);
 const AGY_COMMAND_TIMEOUT_MS = 30_000;
 const AGY_COMMAND_MAX_BUFFER = 4 * 1024 * 1024;
@@ -337,13 +337,14 @@ export function formatUsageOutput(rawText) {
     return out;
 }
 async function runAgySlash(binaryPath, cwd, slashCommand) {
-    const cmd = formatExecBinaryPath(binaryPath);
-    const { stdout, stderr } = await execFileAsync(cmd, ["--print", slashCommand], {
+    const isBatch = process.platform === "win32" && isWindowsBatchScript(binaryPath);
+    const cmd = isBatch && binaryPath.includes(" ") && !binaryPath.startsWith('"') ? `"${binaryPath}"` : binaryPath;
+    const { stdout, stderr } = await execFileAsync(cmd, ["--print-timeout", "24h", "--print", slashCommand], {
         cwd,
         env: process.env,
         timeout: AGY_COMMAND_TIMEOUT_MS,
         maxBuffer: AGY_COMMAND_MAX_BUFFER,
-        shell: process.platform === "win32",
+        shell: isBatch,
         windowsHide: true,
     });
     return stdout.trim() || stderr.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo-acp-agy",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "ACP (Agent Client Protocol) provider for Google Antigravity in Paseo and Zed",
   "type": "module",
   "main": "dist/index.js",
@@ -45,7 +45,8 @@
   },
   "homepage": "https://github.com/tucomel/paseo-acp-agy#readme",
   "dependencies": {
-    "@agentclientprotocol/sdk": "^0.17.1"
+    "@agentclientprotocol/sdk": "^0.17.1",
+    "@electron/asar": "^4.3.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",