fix: preserve file permissions during unpack operation (#43)

- Parse ZIP central directory to extract Unix file permissions
- Restore executable permissions using chmodSync after unpacking files
- Skip permission restoration on Windows (Unix-only feature)
- Add comprehensive test to verify executable and regular file permissions are preserved
- Fix test setup to use npm instead of yarn for consistent build process

Fixes issue where executable files lose their execute permissions after being packed and unpacked, which is critical for extensions containing binary executables or shell scripts.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-authored-by: Claude <noreply@anthropic.com>

src/cli/unpack.ts

@@ -1,5 +1,5 @@
 import { unzipSync } from "fflate";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join, resolve } from "path";
 
 import { extractSignatureBlock } from "../node/sign.js";
@@ -34,6 +34,51 @@ export async function unpackExtension({
     const fileContent = readFileSync(resolvedDxtPath);
     const { originalContent } = extractSignatureBlock(fileContent);
 
+    // Parse file attributes from ZIP central directory
+    const fileAttributes = new Map<string, number>();
+    const isUnix = process.platform !== "win32";
+
+    if (isUnix) {
+      // Parse ZIP central directory to extract file attributes
+      const zipBuffer = originalContent;
+      
+      // Find end of central directory record
+      let eocdOffset = -1;
+      for (let i = zipBuffer.length - 22; i >= 0; i--) {
+        if (zipBuffer.readUInt32LE(i) === 0x06054b50) {
+          eocdOffset = i;
+          break;
+        }
+      }
+
+      if (eocdOffset !== -1) {
+        const centralDirOffset = zipBuffer.readUInt32LE(eocdOffset + 16);
+        const centralDirEntries = zipBuffer.readUInt16LE(eocdOffset + 8);
+        
+        let offset = centralDirOffset;
+        
+        for (let i = 0; i < centralDirEntries; i++) {
+          if (zipBuffer.readUInt32LE(offset) === 0x02014b50) {
+            const externalAttrs = zipBuffer.readUInt32LE(offset + 38);
+            const filenameLength = zipBuffer.readUInt16LE(offset + 28);
+            const filename = zipBuffer.toString('utf8', offset + 46, offset + 46 + filenameLength);
+            
+            // Extract Unix permissions from external attributes (upper 16 bits)
+            const mode = (externalAttrs >> 16) & 0o777;
+            if (mode > 0) {
+              fileAttributes.set(filename, mode);
+            }
+            
+            const extraFieldLength = zipBuffer.readUInt16LE(offset + 30);
+            const commentLength = zipBuffer.readUInt16LE(offset + 32);
+            offset += 46 + filenameLength + extraFieldLength + commentLength;
+          } else {
+            break;
+          }
+        }
+      }
+    }
+
     const decompressed = unzipSync(originalContent);
 
     for (const relativePath in decompressed) {
@@ -45,6 +90,18 @@ export async function unpackExtension({
           mkdirSync(dir, { recursive: true });
         }
         writeFileSync(fullPath, data);
+
+        // Restore Unix file permissions if available
+        if (isUnix && fileAttributes.has(relativePath)) {
+          try {
+            const mode = fileAttributes.get(relativePath);
+            if (mode !== undefined) {
+              chmodSync(fullPath, mode);
+            }
+          } catch (error) {
+            // Silently ignore permission errors
+          }
+        }
       }
     }