paseo-acp-agy 1.2.3 → 1.2.4

package/dist/asar.d.ts

@@ -4,6 +4,11 @@ export interface AsarNode {
     offset?: string;
     executable?: boolean;
     unpacked?: boolean;
+    link?: string;
+}
+export interface ExtractResult {
+    unpackedPaths: string[];
+    originalHeader: AsarNode;
 }
 /**
  * Reads and parses the ASAR archive header and returns the root node and base offset for data.
@@ -20,9 +25,13 @@ export declare function listPackage(archivePath: string): string[];
  * Pure TypeScript, zero-dependency ASAR archive extractor.
  * Compatible with all Node.js versions (Node 18, 20, 22, 24+) across Windows, macOS, and Linux.
  */
-export declare function extractAll(archivePath: string, destDir: string): void;
+export declare function extractAll(archivePath: string, destDir: string): ExtractResult;
+export interface CreatePackageOptions {
+    unpackedPaths?: string[];
+    originalHeader?: AsarNode;
+}
 /**
  * Pure TypeScript, zero-dependency ASAR archive builder.
  * Compatible with all Node.js versions (Node 18, 20, 22, 24+) across Windows, macOS, and Linux.
  */
-export declare function createPackage(srcDir: string, destFile: string): Promise<void>;
+export declare function createPackage(srcDir: string, destFile: string, options?: CreatePackageOptions): Promise<void>;

package/dist/asar.js

@@ -61,6 +61,7 @@ export function listPackage(archivePath) {
 export function extractAll(archivePath, destDir) {
     const { header, dataBaseOffset } = readArchiveHeader(archivePath);
     const fd = fs.openSync(archivePath, "r");
+    const unpackedPaths = [];
     try {
         function extractNode(node, currentPath, relParts = []) {
             if (node.files) {
@@ -69,6 +70,20 @@ export function extractAll(archivePath, destDir) {
                     extractNode(child, path.join(currentPath, name), [...relParts, name]);
                 }
             }
+            else if (node.link) {
+                fs.mkdirSync(path.dirname(currentPath), { recursive: true });
+                try {
+                    fs.unlinkSync(currentPath);
+                }
+                catch { }
+                fs.symlinkSync(node.link, currentPath);
+            }
+            else if (node.unpacked) {
+                // Unpacked files belong in archive.unpacked and must NOT be copied into destDir,
+                // so that re-packing does not duplicate external binaries into the asar payload.
+                const relPath = relParts.join("/");
+                unpackedPaths.push(relPath);
+            }
             else if (node.size !== undefined && node.offset !== undefined) {
                 const fileOffset = dataBaseOffset + parseInt(node.offset, 10);
                 const fileBuf = Buffer.alloc(node.size);
@@ -80,15 +95,9 @@ export function extractAll(archivePath, destDir) {
                     mode: node.executable ? 0o755 : 0o644,
                 });
             }
-            else if (node.unpacked) {
-                const unpackedSrc = path.join(archivePath + ".unpacked", ...relParts);
-                if (fs.existsSync(unpackedSrc)) {
-                    fs.mkdirSync(path.dirname(currentPath), { recursive: true });
-                    fs.copyFileSync(unpackedSrc, currentPath);
-                }
-            }
         }
         extractNode(header, destDir);
+        return { unpackedPaths, originalHeader: header };
     }
     finally {
         fs.closeSync(fd);
@@ -98,7 +107,7 @@ export function extractAll(archivePath, destDir) {
  * Pure TypeScript, zero-dependency ASAR archive builder.
  * Compatible with all Node.js versions (Node 18, 20, 22, 24+) across Windows, macOS, and Linux.
  */
-export async function createPackage(srcDir, destFile) {
+export async function createPackage(srcDir, destFile, options) {
     const files = [];
     function walk(dir, rel = "") {
         const entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -106,16 +115,25 @@ export async function createPackage(srcDir, destFile) {
         for (const e of entries) {
             const entryRel = rel ? `${rel}/${e.name}` : e.name;
             const full = path.join(dir, e.name);
-            if (e.isDirectory()) {
+            const lstat = fs.lstatSync(full);
+            if (lstat.isSymbolicLink()) {
+                files.push({
+                    relPath: entryRel,
+                    fullPath: full,
+                    size: 0,
+                    isLink: true,
+                    linkTarget: fs.readlinkSync(full),
+                });
+            }
+            else if (lstat.isDirectory()) {
                 walk(full, entryRel);
             }
-            else if (e.isFile()) {
-                const stat = fs.statSync(full);
-                const executable = Boolean(stat.mode & 0o111);
+            else if (lstat.isFile()) {
+                const executable = Boolean(lstat.mode & 0o111);
                 files.push({
                     relPath: entryRel,
                     fullPath: full,
-                    size: stat.size,
+                    size: lstat.size,
                     executable: executable || undefined,
                 });
             }
@@ -134,12 +152,39 @@ export async function createPackage(srcDir, destFile) {
             curr = curr[parts[i]].files;
         }
         const leaf = parts[parts.length - 1];
-        curr[leaf] = {
-            size: f.size,
-            offset: String(currentOffset),
-            executable: f.executable,
-        };
-        currentOffset += f.size;
+        if (f.isLink) {
+            curr[leaf] = { link: f.linkTarget };
+        }
+        else {
+            curr[leaf] = {
+                size: f.size,
+                offset: String(currentOffset),
+                executable: f.executable,
+            };
+            currentOffset += f.size;
+        }
+    }
+    // Restore unpacked file references from original archive if provided
+    if (options?.unpackedPaths && options?.originalHeader) {
+        for (const relPath of options.unpackedPaths) {
+            const parts = relPath.split("/");
+            let origNode = options.originalHeader;
+            for (const p of parts) {
+                origNode = origNode?.files?.[p];
+            }
+            let curr = header.files;
+            for (let i = 0; i < parts.length - 1; i++) {
+                if (!curr[parts[i]]) {
+                    curr[parts[i]] = { files: {} };
+                }
+                curr = curr[parts[i]].files;
+            }
+            const leaf = parts[parts.length - 1];
+            curr[leaf] = {
+                size: origNode?.size ?? 0,
+                unpacked: true,
+            };
+        }
     }
     const jsonBuf = Buffer.from(JSON.stringify(header), "utf8");
     const alignedJsonLen = (jsonBuf.length + 3) & ~3;
@@ -159,7 +204,7 @@ export async function createPackage(srcDir, destFile) {
         fs.writeSync(fd, sizePickle);
         fs.writeSync(fd, headerPickle);
         for (const f of files) {
-            if (f.size > 0) {
+            if (!f.isLink && f.size > 0) {
                 const content = fs.readFileSync(f.fullPath);
                 fs.writeSync(fd, content);
             }

package/dist/paseo-patcher.js

@@ -798,7 +798,7 @@ export async function patchPaseoAsar(asarPath) {
             return { success: false, changes: [], error: `Asar archive not found: ${asarPath}` };
         }
         tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "paseo-asar-extract-"));
-        extractAll(asarPath, tempDir);
+        const { unpackedPaths, originalHeader } = extractAll(asarPath, tempDir);
         // Look for server directory in extracted files
         const serverCandidates = [
             path.join(tempDir, "node_modules", "@getpaseo", "server"),
@@ -841,8 +841,27 @@ export async function patchPaseoAsar(asarPath) {
             return { success: true, changes: [] };
         }
         changes.push(...patchResult.changes);
-        // Create backup if not already present
-        const backupPath = `${asarPath}.bak`;
+        // Create backup if not already present.
+        // On macOS, never write backup inside .app bundle (e.g. app.asar.bak) because it breaks code signing seals.
+        let backupPath;
+        if (process.platform === "darwin" && asarPath.includes(".app")) {
+            const backupDir = path.join(os.homedir(), ".paseo", "backups");
+            if (!fs.existsSync(backupDir)) {
+                fs.mkdirSync(backupDir, { recursive: true });
+            }
+            backupPath = path.join(backupDir, "app.asar.bak");
+            // Clean up any orphan backup inside the .app bundle from previous runs
+            const orphanBak = `${asarPath}.bak`;
+            if (fs.existsSync(orphanBak)) {
+                try {
+                    fs.unlinkSync(orphanBak);
+                }
+                catch { }
+            }
+        }
+        else {
+            backupPath = `${asarPath}.bak`;
+        }
         if (!fs.existsSync(backupPath)) {
             try {
                 fs.copyFileSync(asarPath, backupPath);
@@ -853,7 +872,7 @@ export async function patchPaseoAsar(asarPath) {
             }
         }
         tempAsar = path.join(os.tmpdir(), `app-${Date.now()}.asar`);
-        await createPackage(tempDir, tempAsar);
+        await createPackage(tempDir, tempAsar, { unpackedPaths, originalHeader });
         // Replace original archive with locked file handling for Windows
         try {
             fs.copyFileSync(tempAsar, asarPath);
@@ -875,6 +894,21 @@ export async function patchPaseoAsar(asarPath) {
                 throw copyErr;
             }
         }
+        // On macOS, re-sign application bundle if inside an .app directory to satisfy Gatekeeper
+        if (process.platform === "darwin" && asarPath.includes(".app")) {
+            const appIndex = asarPath.indexOf(".app");
+            const appBundlePath = asarPath.slice(0, appIndex + 4);
+            try {
+                execFileSync("codesign", ["--force", "--deep", "--sign", "-", appBundlePath], {
+                    stdio: "ignore",
+                    timeout: 15000,
+                });
+                changes.push(`Re-signed macOS bundle at ${appBundlePath}`);
+            }
+            catch (signErr) {
+                logger.warn(`Could not re-sign ${appBundlePath}`, { error: String(signErr) });
+            }
+        }
         return { success: true, changes };
     }
     catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo-acp-agy",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "description": "ACP (Agent Client Protocol) provider for Google Antigravity in Paseo and Zed",
   "type": "module",
   "main": "dist/index.js",