@mcpher/gas-fakes 2.3.2 → 2.3.3

package/package.json

@@ -10,7 +10,7 @@
     "@modelcontextprotocol/sdk": "^1.28.0",
     "@sindresorhus/is": "^7.2.0",
     "acorn": "^8.16.0",
-    "archiver": "^7.0.1",
+    "adm-zip": "^0.5.16",
     "commander": "^14.0.3",
     "dotenv": "^17.3.1",
     "fast-xml-parser": "^5.5.9",
@@ -24,12 +24,8 @@
     "mime": "^4.1.0",
     "prompts": "^2.4.2",
     "sleep-synchronously": "^2.0.0",
-    "unzipper": "^0.12.3",
     "zod": "^4.3.6"
   },
-  "overrides": {
-    "minimatch": "^10.0.3"
-  },
   "type": "module",
   "scripts": {
     "pub": "npm publish --access public",
@@ -39,7 +35,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "2.3.2",
+  "version": "2.3.3",
   "license": "MIT",
   "main": "main.js",
   "description": "An implementation of the Google Workspace Apps Script runtime: Run native App Script Code on Node and Cloud Run",

package/src/support/sxzip.js

@@ -5,19 +5,9 @@
  * note
  * - arguments and returns must be serializable ie. primitives or plain objects
  */
-import archiver from 'archiver';
-import unzipper from 'unzipper';
+import AdmZip from 'adm-zip';
 import { syncWarn, syncError } from './workersync/synclogger.js';
 
-const streamToBuffer = (stream) => {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    stream.on('data', chunk => chunks.push(chunk));
-    stream.on('error', err => reject(err));
-    stream.on('end', () => resolve(Buffer.concat(chunks)));
-  });
-};
-
 /**
  * create a zipped version of multiple files
  * @param {object} p params
@@ -25,23 +15,14 @@ const streamToBuffer = (stream) => {
  * @return  {byte[]} the zipped content
  */
 export const sxZipper = async (_Auth, { blobsContent }) => {
- 
-  const archive = archiver.create('zip', {});
-
   try {
-    // It's important to handle warnings, as they don't necessarily reject the promise.
-    archive.on('warning', (err) => syncWarn(`Archiver warning: ${err}`));
-
-    // Start collecting the buffer in parallel. This promise resolves when the stream ends.
-    const bufferPromise = streamToBuffer(archive);
+    const zip = new AdmZip();
 
     blobsContent.forEach((f) => {
-      archive.append(Buffer.from(f.bytes), { name: f.name });
+      zip.addFile(f.name, Buffer.from(f.bytes));
     });
 
-    // Wait for BOTH the stream to end (which gives us the buffer) AND
-    // for finalization to be complete. This is the most robust way.
-    const [buffer] = await Promise.all([bufferPromise, archive.finalize()]);
+    const buffer = zip.toBuffer();
     return Array.from(buffer);
   } catch (err) {
     syncError('sxZipper failed', err);
@@ -56,23 +37,24 @@ export const sxZipper = async (_Auth, { blobsContent }) => {
  * @return  {SerializedBlob[]} the unzipped content
  */
 export const sxUnzipper = async (_Auth, { blobContent }) => {
-
-  const buffer = Buffer.from(blobContent.bytes)
-  const unzipped = await unzipper.Open.buffer(buffer)
-
-  // By wrapping the Promise.all in a try/catch, we ensure that if any
-  // single file stream fails, the entire operation rejects cleanly.
   try {
-    const result = await Promise.all(
-      unzipped.files.map(async (file) => {
-        const buffer = await streamToBuffer(file.stream());
-        return { bytes: Array.from(buffer), name: file.path };
-      })
-    );
+    const buffer = Buffer.from(blobContent.bytes);
+    const zip = new AdmZip(buffer);
+    const zipEntries = zip.getEntries();
+    
+    // Ignore directory entries (they end with a slash)
+    const result = zipEntries
+      .filter(zipEntry => !zipEntry.isDirectory)
+      .map(zipEntry => {
+        return { 
+          bytes: Array.from(zipEntry.getData()), 
+          name: zipEntry.entryName 
+        };
+      });
 
     return result;
   } catch (err) {
     syncError('An error occurred while unzipping a file stream inside the archive.', err);
-    throw err; // Re-throw to be caught by the main worker error handler
+    throw err;
   }
 }