neozipkit 0.1.1

package/src/server/platform/server/ZipKitServer.ts

@@ -0,0 +1,459 @@
+/**
+ * ZipKitServer
+ * Copyright (c) 2025 NeoWare, Inc. All rights reserved.
+ * 
+ * Server-side implementation of ZipKit that passes through all functions
+ * directly to the parent ZipKit class. This class provides a consistent interface
+ * for server environments and ensures all ZipKit functionality is available.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+import { exit } from 'process';
+
+import ZipKit,{ CompressOptions, ZipEntry, TIMESTAMP_METADATA, TIMESTAMP_SUBMITTED, CMP_METHOD } from '../../../shared/ZipKit';
+import { createTimestamp, deserializeOts, TimestampResult } from '../servercomponents/ZipKitOTS';
+import * as Headers from '../../../shared/constants/Headers';
+import { crc32 } from '../../../shared/components/Util';
+import OTS from '../../../shared/components/CertificateOTS';
+import Errors from '../../../shared/constants/Errors';
+
+// Re-export everything from ZipKit
+export * from '../../../shared/ZipKit';
+export { Headers };
+
+/**
+ * This implementation is optimized for server environments and handles all
+ * ZIP operations including compression, extraction, encryption, and file management.
+ */
+export default class ZipKitServer extends ZipKit {
+  /**
+   * Creates a new ZipKitServer instance
+   * 
+   * Initializes the parent ZipKit class and logs environment support information
+   * for diagnostic purposes.
+   */
+  constructor() {
+    super();      // Call the parent constructor
+
+    // console.log('ZipKit.support.isNode: ', ZipKit.support.isNode);
+    // console.log('ZipKit.support.buffer: ', ZipKit.support.buffer);
+    // console.log('ZipKit.support.blob: ', ZipKit.support.blob);
+    // console.log('ZipKit.support.streams: ', ZipKit.support.streams);
+    // console.log('ZipKit.support.fileReader: ', ZipKit.support.fileReader);
+  }
+    
+  /**
+   * Loads a ZIP file from the filesystem for updating/creating operations
+   * 
+   * Attempts to read an existing ZIP file, but creates a new empty archive if
+   * the file doesn't exist. This method is used when adding or updating entries
+   * in an archive, handling both new and existing ZIP files gracefully.
+   * 
+   * @param zipFile - Path to the ZIP file to load or create
+   */
+  loadZipFile(zipFile: string): void {
+    let inBuffer: Buffer | null = null;
+    let fdIn: number | null = null;
+
+    try {
+      if (fs.existsSync(zipFile)) {
+        fdIn = fs.openSync(zipFile, 'r');
+        const stats = fs.fstatSync(fdIn);
+        inBuffer = Buffer.alloc(stats.size);
+        fs.readSync(fdIn, inBuffer, 0, stats.size, 0);
+      } else {
+        // File doesn't exist, use an empty buffer
+        inBuffer = Buffer.alloc(0);
+      }
+    } catch (error) {
+      console.log('Warning: Could not open existing file. Creating new archive.');
+      inBuffer = Buffer.alloc(0);
+    } finally {
+      if (fdIn !== null) {
+        fs.closeSync(fdIn);
+      }
+    }
+
+    // Initialize empty buffer if null
+    const buffer = inBuffer || Buffer.alloc(0);
+    super.loadZip(buffer);
+  }
+
+  /**
+   * Loads a ZIP file from the filesystem for extraction and listing operations
+   * 
+   * Reads an existing ZIP file and throws an error if the file doesn't exist.
+   * Use this method when working with existing archives that need to be extracted.
+   * 
+   * @param zipFile - Path to the ZIP file to load
+   * @throws Error if the file doesn't exist or can't be read
+   */
+  loadUnzipFile(zipFile: string): void {
+    try {
+      // Check if the file exists before trying to read it
+      if (!fs.existsSync(zipFile)) {
+        console.error(`Error: Zip file "${zipFile}" does not exist`);
+        exit(1);
+      }
+      
+      const inBuffer = fs.readFileSync(zipFile);
+      super.loadZip(inBuffer);
+    } catch (error) {
+      console.error(`Error: Failed to read zip file "${zipFile}"`);
+      exit(1);
+    }
+  }
+
+  /**
+   * Adds a single file to the ZIP archive
+   * @param filename - Path to the file to be added
+   * @param comment - Optional comment for the file entry
+   * 
+   * Handles:
+   * - Creating/updating ZipEntry objects
+   * - Setting file attributes and timestamps
+   * - Respecting freshen (-f) and update (-u) flags
+   * - Setting compression method
+   */
+  addFile(filename: string, freshen: boolean = false, update: boolean = false): void {
+    let entry = super.getZipEntry(filename);
+    if (!entry) {
+      // Check for Freshen option
+      if (freshen) return;
+      entry = super.createZipEntry(filename);
+    } else if (!update) {
+      // Mark this entry as not being updated
+      entry.isUpdated = false;
+      return;
+    }
+    entry.platform = process.platform;
+
+    // Correctly retrieve file stats
+    let attr = fs.statSync(filename); // Synchronously get the stats of the file
+
+    entry.uncompressedSize = attr.size;
+
+    // Set the DOS file time/date based on the Date stamp of the file.
+    const utcDate = new Date(attr.mtime.getTime());
+    entry.timeDateDOS = entry.setDateTime(utcDate);
+    entry.universalTime = Math.floor(attr.mtime.getTime() / 1000); // Store Unix timestamp
+
+    // Set Unix UID/GID if on Unix-like system
+    if (process.platform !== 'win32') {
+      entry.uid = attr.uid;
+      entry.gid = attr.gid;
+    }
+
+    // Use attr.mode for file permissions
+    entry.isDirectory = attr.isDirectory();
+    let _fattr = (attr.mode & 0xfff) | (entry.isDirectory ? 0x4000 : 0x8000);
+    entry.extFileAttr = ((_fattr << 16) | (entry.isDirectory ? 0x10 : 0)) >>> 0;
+
+    // Set Compression method
+    // if (options.store) {
+    //   entry.cmpMethod = CMP_METHOD.STORED;
+    // } else if (options.Z) {
+    // entry.cmpMethod = Headers.CMP_METHOD.DEFLATED;
+    // } else {
+    //   entry.cmpMethod = CMP_METHOD.ZSTD;
+    // }
+  }
+  
+  /**
+   * Processes files to be added to the ZIP archive
+   * Creates ZipEntry objects for each file and initiates the compression process
+   */
+  addFiles(files: string[], freshen: boolean = false, update: boolean = false) {
+    let filesAdded = 0;
+    for (var i=0; files[i] != undefined; i++) {
+      const filename = String(files[i]);
+      // console.log('filename: ', filename);
+
+      // Skip arguments that look like options (start with hyphen but aren't files)
+      if (filename.startsWith('-') && !fs.existsSync(filename)) {
+        console.warn(`Warning: Skipping '${filename}' which appears to be an option, not a file.`);
+        continue;
+      }
+      
+      this.addFile(filename, freshen, update);
+      filesAdded++;
+    }
+  
+    return filesAdded;
+  }
+
+  /**
+   * Creates a ZIP file with optional OpenTimestamps (OTS) metadata
+   * 
+   * This method creates a ZIP file with optional OpenTimestamps (OTS) metadata,
+   * which includes a timestamp of the ZIP file's contents on the Bitcoin blockchain.
+   * 
+   * @param zipFile - The path to the ZIP file to create
+   * @param compressOptions - The compression options for the ZIP file
+   * @returns void - The method triggers a download of the ZIP file
+   */
+  async createZip(zipFile: string, compressOptions: CompressOptions) {
+  
+    // Ensure the directory structure for the output file exists
+    const outputDir = path.dirname(zipFile);
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+  
+    // Generate a unique temporary file name in the output directory
+    const _tempZipFile = path.join(outputDir, `neozip-${uuidv4()}.zip`);
+  
+    // Open or create the .zip file for writing
+    const fd = fs.openSync(_tempZipFile, 'w');
+  
+    let offset = await super.createZipFileData(compressOptions, {
+      onReadEntryData: (entry: ZipEntry) => {
+        // console.log(`Reading file: ${entry.filename}`);
+        try {
+          return fs.readFileSync(entry.filename);
+        } catch (error) {
+          throw new Error(`Failed to read file: ${entry.filename}`);
+        }
+        // return fs.readFileSync(entry.filename);
+      },
+      onOutputBuffer: (buffer: Buffer) => {
+        fs.writeSync(fd, buffer);
+      },
+      onEntryDone: (entry: ZipEntry, status: string) => {
+        console.log(`${status} ${entry.filename} to ${zipFile}`);
+      } 
+    });
+    
+    // Write the metadata entry to the .zip fi
+    await super.finishZipFileData(
+      offset, 
+      function onOutputBuffer(buffer: Buffer) {
+        fs.writeSync(fd, buffer);
+      },
+      undefined
+    );
+  
+    // Close the .zip file
+    fs.closeSync(fd);
+    
+    // Delete the existing .zip file if it exists
+    if (fs.existsSync(zipFile)) {
+      fs.unlinkSync(zipFile);
+    }
+  
+    // Replace the existing .zip file with the temporary file
+    fs.renameSync(_tempZipFile, zipFile);
+  }
+
+  /**
+   * Creates a ZIP file with OpenTimestamps (OTS) metadata
+   * 
+   * This method creates a ZIP file with OpenTimestamps (OTS) metadata, which
+   * includes a timestamp of the ZIP file's contents on the Bitcoin blockchain.
+   * 
+   * @param zipFile - The path to the ZIP file to create
+   * @param compressOptions - The compression options for the ZIP file
+   * @returns void - The method triggers a download of the ZIP file
+   */
+  async createZipOTS(zipFile: string, compressOptions: CompressOptions) {
+  
+    // Ensure the directory structure for the output file exists
+    const outputDir = path.dirname(zipFile);
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+  
+    // Generate a unique temporary file name in the output directory
+    const _tempZipFile = path.join(outputDir, `neozip-${uuidv4()}.zip`);
+  
+    // Open or create the .zip file for writing
+    const fd = fs.openSync(_tempZipFile, 'w');
+  
+    let offset = await super.createZipFileData(compressOptions, {
+      onReadEntryData: (entry: ZipEntry) => {
+        // console.log(`Reading file: ${entry.filename}`);
+        try {
+          return fs.readFileSync(entry.filename);
+        } catch (error) {
+          throw new Error(`Failed to read file: ${entry.filename}`);
+        }
+        // return fs.readFileSync(entry.filename);
+      },
+      onOutputBuffer: (buffer: Buffer) => {
+        fs.writeSync(fd, buffer);
+      },
+      onEntryDone: (entry: ZipEntry, status: string) => {
+        console.log(`${status} ${entry.filename} to ${zipFile}`);
+      } 
+    });
+  
+    // Timestamp the zip file to the Bitcoin blockchain
+    let _metadataEntry = null;
+  
+    console.log('Timestamping to Bitcoin blockchain...');
+    const _merkleRoot = super.getMerkleRoot();
+    console.log('Merkle Root: ' + _merkleRoot);
+    const _ots = await createTimestamp(_merkleRoot);
+    _metadataEntry = super.createTimestampMetadataEntry(_ots);
+  
+    // Write the metadata entry to the .zip fi
+    await super.finishZipFileData(
+      offset, 
+      function onOutputBuffer(buffer: Buffer) {
+        fs.writeSync(fd, buffer);
+      },
+      _metadataEntry || undefined
+    );
+  
+    // Close the .zip file
+    fs.closeSync(fd);
+    
+    // Delete the existing .zip file if it exists
+    if (fs.existsSync(zipFile)) {
+      fs.unlinkSync(zipFile);
+    }
+  
+    // Replace the existing .zip file with the temporary file
+    fs.renameSync(_tempZipFile, zipFile);
+  }
+
+  /**
+   * Removes specified files from the ZIP archive
+   * Deletes matching ZipEntry objects and rebuilds the archive if any files were removed
+   */
+  deleteFiles(delFiles: string[]): number {
+
+    super.getDirectory();
+    let filesDel = 0;
+    delFiles.forEach(fname => {
+      const deleted = super.deleteFile(fname);
+      if (deleted) {
+        console.log('   deleting: ' + fname + "\n");
+        ++filesDel;
+      } else {
+        console.log('   warning: name not found: ' + fname + "\n"); 
+      }
+    })
+
+    return filesDel;
+  }
+
+  /**
+   * Upgrades a timestamp in an existing ZIP file
+   * 
+   * This method takes an existing ZIP file and upgrades its timestamp by:
+   * 1. Loading the original ZIP file
+   * 2. Removing any existing timestamp metadata entries
+   * 3. Adding a new timestamp metadata entry with the upgraded OTS proof
+   * 4. Creating a new ZIP file with the updated timestamp
+   * 
+   * @param zipFile - The original ZIP file to upgrade
+   * @param upgradedOts - The upgraded OpenTimestamps proof as an ArrayBuffer
+   * @returns void - The method triggers a download of the upgraded ZIP file
+   */
+  async upgradeOTS(fileName: string, upgradedOts: Buffer) {
+
+    // Generate a unique temporary file name in the output directory
+    let tempName = fileName.replace('.zip', '.upgrade.zip');
+
+    // Open or create the .zip file for writing
+    const fd = fs.openSync(tempName, 'w');
+    try {
+      const zipEntries = this.getDirectory();
+
+      let offset = 0;
+      // Copy the entries from the original file to the output file
+      for (const entry of zipEntries) {
+        if (entry.filename === TIMESTAMP_METADATA || entry.filename === TIMESTAMP_SUBMITTED) {
+          this.deleteFile(entry.filename);
+        } else {
+          // Copy the entry data to the output file
+          console.log('Copying entry: ', entry.filename);
+          const inData = this.copyEntry(entry);
+          entry.localHdrOffset = offset
+          offset += inData.length;
+          fs.writeSync(fd, inData);
+        }        
+      }
+
+      // Add the new timestamp metadata file
+      let tsEntry = this.createZipEntry(TIMESTAMP_METADATA);
+      tsEntry.timeDateDOS = tsEntry.setDateTime(new Date());
+      tsEntry.compressedSize = upgradedOts.byteLength;
+      tsEntry.uncompressedSize = upgradedOts.byteLength;
+      tsEntry.cmpMethod = CMP_METHOD.STORED;
+      tsEntry.crc = crc32(upgradedOts);
+      tsEntry.fileBuffer = upgradedOts;
+      console.log('tsEntry: ', tsEntry);
+
+      const localHdr = tsEntry.createLocalHdr();
+      // Save local header offset for entry and calculate next offset
+      tsEntry.localHdrOffset = offset;        
+      offset += localHdr.length + tsEntry.compressedSize;
+      fs.writeSync(fd, localHdr);
+      fs.writeSync(fd, upgradedOts);
+
+      // Output ZipEntries as Central End Directory
+      const centralDirOffset = offset;
+      for (const entry of zipEntries) {
+        const centralDirEntry = entry.centralDirEntry();
+        offset += centralDirEntry.length;
+        fs.writeSync(fd, centralDirEntry);
+      }
+      const centralDirSize = offset - centralDirOffset;
+
+      let ceBuf = this.centralEndHdr(centralDirSize, centralDirOffset);
+      fs.writeSync(fd, ceBuf);
+
+      // Close the .zip file
+      fs.closeSync(fd);
+
+      // Delete the existing .zip file if it exists
+      if (fs.existsSync(fileName)) {
+        fs.unlinkSync(fileName);
+      }
+
+      // Replace the existing .zip file with the temporary file
+      fs.renameSync(tempName, fileName);  
+    }
+    catch (err) {
+      console.error('Error-upgradeOTS: ', err);
+    }
+  }
+
+  async createCertificateOTS(fileName: string, zipEntries: ZipEntry[], timestampResult: TimestampResult): Promise<string> {
+    if (!timestampResult || !timestampResult.merkleRoot || !fileName)
+      return Errors.CERTIFICATE_OTS_BAD;
+
+    let rsp = await deserializeOts(timestampResult);
+    if (!rsp) return Errors.CERTIFICATE_OTS_FAILED;
+    const result = JSON.parse(rsp);
+
+    const cert = OTS(
+      result.attestStr,
+      fileName,
+      timestampResult.merkleRoot,
+      result.needsUpdateMsg,
+      result.attestationValues,
+      zipEntries,
+      false,
+    );
+    if (!cert) return Errors.CERTIFICATE_OTS_FAILED;
+
+    // Generate certificate file name
+    const certFileName = fileName + '.certificate.html';
+    
+    try {
+      // Write the certificate HTML to a file
+      fs.writeFileSync(certFileName, cert, { encoding: 'utf8' });
+      return `Certificate created as ${certFileName}`;
+    } catch (error) {
+      console.error(`Failed to write certificate file: ${error}`);
+      return Errors.CERTIFICATE_OTS_FAILED;
+    }
+  }
+}
+
+