neozipkit 0.1.1

package/dist/server/platform/server/ZipKitServer.js

@@ -0,0 +1,437 @@
+"use strict";
+/**
+ * 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Headers = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const uuid_1 = require("uuid");
+const process_1 = require("process");
+const ZipKit_1 = __importStar(require("../../../shared/ZipKit"));
+const ZipKitOTS_1 = require("../servercomponents/ZipKitOTS");
+const Headers = __importStar(require("../../../shared/constants/Headers"));
+exports.Headers = Headers;
+const Util_1 = require("../../../shared/components/Util");
+const CertificateOTS_1 = __importDefault(require("../../../shared/components/CertificateOTS"));
+const Errors_1 = __importDefault(require("../../../shared/constants/Errors"));
+// Re-export everything from ZipKit
+__exportStar(require("../../../shared/ZipKit"), exports);
+/**
+ * This implementation is optimized for server environments and handles all
+ * ZIP operations including compression, extraction, encryption, and file management.
+ */
+class ZipKitServer extends ZipKit_1.default {
+    /**
+     * 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) {
+        let inBuffer = null;
+        let fdIn = 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) {
+        try {
+            // Check if the file exists before trying to read it
+            if (!fs.existsSync(zipFile)) {
+                console.error(`Error: Zip file "${zipFile}" does not exist`);
+                (0, process_1.exit)(1);
+            }
+            const inBuffer = fs.readFileSync(zipFile);
+            super.loadZip(inBuffer);
+        }
+        catch (error) {
+            console.error(`Error: Failed to read zip file "${zipFile}"`);
+            (0, process_1.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, freshen = false, update = false) {
+        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, freshen = false, update = 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, 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-${(0, uuid_1.v4)()}.zip`);
+        // Open or create the .zip file for writing
+        const fd = fs.openSync(_tempZipFile, 'w');
+        let offset = await super.createZipFileData(compressOptions, {
+            onReadEntryData: (entry) => {
+                // 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) => {
+                fs.writeSync(fd, buffer);
+            },
+            onEntryDone: (entry, status) => {
+                console.log(`${status} ${entry.filename} to ${zipFile}`);
+            }
+        });
+        // Write the metadata entry to the .zip fi
+        await super.finishZipFileData(offset, function onOutputBuffer(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, 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-${(0, uuid_1.v4)()}.zip`);
+        // Open or create the .zip file for writing
+        const fd = fs.openSync(_tempZipFile, 'w');
+        let offset = await super.createZipFileData(compressOptions, {
+            onReadEntryData: (entry) => {
+                // 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) => {
+                fs.writeSync(fd, buffer);
+            },
+            onEntryDone: (entry, status) => {
+                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 (0, ZipKitOTS_1.createTimestamp)(_merkleRoot);
+        _metadataEntry = super.createTimestampMetadataEntry(_ots);
+        // Write the metadata entry to the .zip fi
+        await super.finishZipFileData(offset, function onOutputBuffer(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) {
+        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, upgradedOts) {
+        // 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 === ZipKit_1.TIMESTAMP_METADATA || entry.filename === ZipKit_1.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(ZipKit_1.TIMESTAMP_METADATA);
+            tsEntry.timeDateDOS = tsEntry.setDateTime(new Date());
+            tsEntry.compressedSize = upgradedOts.byteLength;
+            tsEntry.uncompressedSize = upgradedOts.byteLength;
+            tsEntry.cmpMethod = ZipKit_1.CMP_METHOD.STORED;
+            tsEntry.crc = (0, Util_1.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, zipEntries, timestampResult) {
+        if (!timestampResult || !timestampResult.merkleRoot || !fileName)
+            return Errors_1.default.CERTIFICATE_OTS_BAD;
+        let rsp = await (0, ZipKitOTS_1.deserializeOts)(timestampResult);
+        if (!rsp)
+            return Errors_1.default.CERTIFICATE_OTS_FAILED;
+        const result = JSON.parse(rsp);
+        const cert = (0, CertificateOTS_1.default)(result.attestStr, fileName, timestampResult.merkleRoot, result.needsUpdateMsg, result.attestationValues, zipEntries, false);
+        if (!cert)
+            return Errors_1.default.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_1.default.CERTIFICATE_OTS_FAILED;
+        }
+    }
+}
+exports.default = ZipKitServer;

package/dist/server/platform/servercomponents/ZipKitOTS.d.ts

@@ -0,0 +1,91 @@
+declare global {
+    var _bitcore: any;
+}
+/**
+ * ZipKitOTS - OpenTimestamps utilities for NeoZip
+ *
+ * This module provides functions for creating and verifying OpenTimestamps
+ * proofs for ZIP archives and their contents. It includes utilities for timestamp
+ * creation, verification, and serialization/deserialization.
+ */
+/**
+ * Interface for timestamp verification results
+ * Contains all necessary information about a verified timestamp
+ */
+export interface TimestampResult {
+    merkleRoot: string | null;
+    ots: ArrayBuffer | null;
+    verified: boolean;
+    results: any | null;
+    error: string | null;
+    attestations: any | null;
+    upgradedOts: ArrayBuffer | null;
+}
+export interface TimestampInfo {
+    message: string;
+    results: string[];
+    attestDate: Date | null;
+    attestHeight: number | null;
+    submittedUri: string | null;
+    otsUpgraded: boolean;
+}
+/**
+ * Verifies a timestamp proof against a file hash
+ *
+ * @param hashDigest - SHA-256 hash digest of the file or merkle root (hex string)
+ * @param otsData - The OpenTimestamps proof data
+ * @returns Promise with verification result or null on critical failure
+ *
+ * @example
+ * // Verify a timestamp proof
+ * const hashDigest = "8a9d..."; // SHA-256 digest in hex format
+ * const result = await verifyTimestamp(hashDigest, otsBuffer);
+ *
+ * if (result) {
+ *   if (result.error) {
+ *     console.error("Verification failed:", result.error);
+ *   } else {
+ *     console.log("Verification succeeded:", result.verified);
+ *
+ *     if (result.upgradedOts) {
+ *       // Save the upgraded timestamp
+ *     }
+ *   }
+ * }
+ */
+export declare function verifyTimestamp(hashDigest: string | null, ots: ArrayBuffer | null): Promise<TimestampResult | {
+    error: string;
+} | null>;
+/**
+ * Creates a timestamp proof for a file hash using OpenTimestamps
+ *
+ * @param hashDigest - SHA-256 hash digest of the file or merkle root (hex string)
+ * @returns Promise containing the OpenTimestamps proof or null on failure
+ *
+ * @example
+ * // Create a timestamp for a file hash
+ * const hashDigest = "8a9d..."; // SHA-256 digest in hex format
+ * const timestampProof = await createTimestamp(hashDigest);
+ *
+ * if (timestampProof) {
+ *   // Save the timestamp proof to storage
+ * }
+ */
+export declare function createTimestamp(hashDigest: string | null): Promise<Buffer | null>;
+/**
+ * Result of deserializing an OpenTimestamps proof
+ */
+export interface DeserializeOtsResult {
+    attestStr: string | null;
+    needsUpdateMsg: string | null;
+    attestationValues: any[];
+}
+/**
+ * Deserializes timestamp metadata to extract attestation information
+ * Used for generating timestamp certificates and displaying verification details
+ *
+ * @param tsResult - Timestamp verification result to deserialize
+ * @returns JSON string of deserialized data or null on failure
+ */
+export declare function deserializeOts(tsResult: TimestampResult): Promise<string | null>;
+export declare function parseVerifyResult(verifyResult: TimestampResult): Promise<TimestampInfo>;