paseo-acp-agy 1.1.7 → 1.1.8

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

@@ -12,11 +12,24 @@ export function resolveDefaultAgyBinary() {
     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 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"),
+                path.join(appData, "npm", "agy.cmd"),
+                path.join(appData, "npm", "agy.exe"),
+                path.join(appData, "npm", "agy.bat"),
+                path.join(localAppData, "npm", "agy.cmd"),
+                path.join(localAppData, "npm", "agy.exe"),
+                path.join(localAppData, "Programs", "antigravity", "agy.exe"),
+                path.join(localAppData, "Programs", "Antigravity", "bin", "agy.exe"),
+                path.join(localAppData, "Microsoft", "WindowsApps", "agy.exe"),
+                path.join(programFiles, "Antigravity", "bin", "agy.exe"),
+                path.join(programFilesX86, "Antigravity", "bin", "agy.exe"),
             ];
             for (const cand of candidates) {
                 if (fs.existsSync(cand))

package/dist/index.js

@@ -48,21 +48,26 @@ if (args.includes("setup") ||
     args.includes("--patch")) {
     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 +76,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,24 @@ 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>;

package/dist/paseo-patcher.js

@@ -184,11 +184,25 @@ function resolveAgyBinary() {
     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 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"),
+                path.join(appData, "npm", "agy.cmd"),
+                path.join(appData, "npm", "agy.exe"),
+                path.join(appData, "npm", "agy.bat"),
+                path.join(localAppData, "npm", "agy.cmd"),
+                path.join(localAppData, "npm", "agy.exe"),
+                path.join(localAppData, "Programs", "antigravity", "agy.exe"),
+                path.join(localAppData, "Programs", "Antigravity", "bin", "agy.exe"),
+                path.join(localAppData, "Microsoft", "WindowsApps", "agy.exe"),
+                path.join(programFiles, "Antigravity", "bin", "agy.exe"),
+                path.join(programFilesX86, "Antigravity", "bin", "agy.exe"),
             ];
             for (const cand of candidates) {
                 if (fs.existsSync(cand)) return cand;
@@ -222,8 +236,8 @@ export class AntigravityQuotaProvider {
                 bin = \`"\${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: isWin, windowsHide: true }),
+                execFileAsync(bin, ["--print-timeout", "24h", "--print", "/credits"], { timeout: 15000, env: process.env, shell: isWin, windowsHide: true }),
             ]);
 
             const usageOut = usageRes.status === "fulfilled" ? usageRes.value.stdout || usageRes.value.stderr : "";
@@ -475,11 +489,166 @@ 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, "Paseo", "resources", "app.asar"),
+            path.join(programFiles, "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 asarCandidate = path.join(path.dirname(line), "resources", "app.asar");
+                if (fs.existsSync(asarCandidate))
+                    candidates.add(path.resolve(asarCandidate));
+            }
+        }
+        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 function ensurePaseoIntegration(options) {
+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);
+                            if (ent.name === "server" && full.includes(path.join("@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)) {
+            fs.copyFileSync(asarPath, backupPath);
+            changes.push(`Backed up original asar to ${backupPath}`);
+        }
+        tempAsar = path.join(os.tmpdir(), `app-${Date.now()}.asar`);
+        await asar.createPackage(tempDir, tempAsar);
+        // Replace original archive
+        fs.copyFileSync(tempAsar, asarPath);
+        changes.push(`Repacked updated asar archive at ${asarPath}`);
+        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 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 +664,26 @@ 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,
     };
 }

package/dist/slash-commands.js

@@ -338,7 +338,7 @@ export function formatUsageOutput(rawText) {
 }
 async function runAgySlash(binaryPath, cwd, slashCommand) {
     const cmd = formatExecBinaryPath(binaryPath);
-    const { stdout, stderr } = await execFileAsync(cmd, ["--print", slashCommand], {
+    const { stdout, stderr } = await execFileAsync(cmd, ["--print-timeout", "24h", "--print", slashCommand], {
         cwd,
         env: process.env,
         timeout: AGY_COMMAND_TIMEOUT_MS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo-acp-agy",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "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",