neozip-cli 0.75.2-beta → 0.90.0

package/dist/src/neozip/upgradeZip.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Upgrade Zipstamp timestamp from pending (TS-SUBMIT.NZIP) to confirmed (TIMESTAMP.NZIP)
+ */
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upgradeZipForTimestamp = upgradeZipForTimestamp;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const node_1 = __importDefault(require("neozipkit/node"));
+const node_2 = require("neozipkit/node");
+const zipstamp_server_1 = require("neozip-blockchain/zipstamp-server");
+const exit_codes_1 = require("../exit-codes");
+/**
+ * Extract timestamp metadata from a ZIP entry.
+ * Tries the library's extractTimestampData first; if it fails (e.g. file-based ZIP),
+ * fall back to extracting to a temp file and parsing JSON.
+ */
+async function extractTimestampMetadata(zip, entry) {
+    let metadata = await (0, zipstamp_server_1.extractTimestampData)(zip, entry);
+    if (metadata)
+        return metadata;
+    // Fallback for file-based ZIPs where zip.extract() may not work
+    try {
+        const tmpPath = path.join(os.tmpdir(), `neozip-upgrade-meta-${Date.now()}.json`);
+        await zip.extractToFile(entry, tmpPath, { skipHashCheck: true });
+        try {
+            const buf = fs.readFileSync(tmpPath);
+            return JSON.parse(buf.toString('utf-8'));
+        }
+        finally {
+            if (fs.existsSync(tmpPath))
+                fs.unlinkSync(tmpPath);
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Upgrade a ZIP file with pending Zipstamp timestamp to confirmed status.
+ * Replaces TS-SUBMIT.NZIP with TIMESTAMP.NZIP when the batch is confirmed on the blockchain.
+ */
+async function upgradeZipForTimestamp(inputPath, outputPath, options = {}) {
+    const { wait = false, verbose = false, debug = false } = options;
+    if (!fs.existsSync(inputPath)) {
+        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_FIND_ARCHIVE, `Error: ZIP file not found: ${inputPath}`);
+    }
+    const zip = new node_1.default();
+    await zip.loadZipFile(inputPath);
+    const entries = zip.getDirectory() || [];
+    const metadataResult = (0, zipstamp_server_1.findMetadataEntry)(entries);
+    if (!metadataResult) {
+        console.log('No Zipstamp timestamp found in ZIP file');
+        return;
+    }
+    if (metadataResult.type === 'confirmed') {
+        console.log('✓ Timestamp already confirmed - no upgrade needed');
+        return;
+    }
+    const metadata = await extractTimestampMetadata(zip, metadataResult.entry);
+    if (!metadata || !metadata.digest) {
+        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT, 'Error: Failed to extract timestamp metadata');
+    }
+    if (!(0, zipstamp_server_1.shouldUpgrade)(metadata, metadataResult.type)) {
+        console.log('✓ Timestamp does not need upgrade');
+        return;
+    }
+    const digest = metadata.digest;
+    const chainId = metadata.chainId && metadata.chainId > 0 ? metadata.chainId : undefined;
+    const batchId = metadata.batchId ?? undefined;
+    let verified = null;
+    if (wait) {
+        if (verbose || debug)
+            console.log('Polling for confirmation (--wait)...');
+        verified = await (0, zipstamp_server_1.pollForConfirmation)(digest, chainId, batchId, 300000, 5000, { debug });
+    }
+    else {
+        const verifyRes = await (0, zipstamp_server_1.verifyDigest)(digest, chainId, batchId, undefined, { debug });
+        if (verifyRes.verified) {
+            verified = verifyRes;
+        }
+    }
+    if (!verified || !verified.verified) {
+        console.log('⏳ Timestamp not yet confirmed on blockchain');
+        console.log('   Run with --wait to poll until confirmed, or try again later');
+        return;
+    }
+    console.log('✓ Timestamp confirmed on blockchain');
+    if (verified.transactionHash && (verbose || debug)) {
+        console.log(`   Transaction: ${verified.transactionHash}`);
+    }
+    const confirmedMetadata = {
+        ...metadata,
+        status: 'confirmed',
+        merkleProof: verified.merkleProof ?? metadata.merkleProof,
+        merkleRoot: verified.merkleRoot ?? metadata.merkleRoot,
+        transactionHash: verified.transactionHash ?? metadata.transactionHash,
+        blockNumber: verified.blockNumber ?? metadata.blockNumber,
+        timestamp: verified.timestamp ?? metadata.timestamp
+    };
+    const metadataFiles = (0, zipstamp_server_1.getMetadataFileNames)();
+    const outPath = outputPath ?? inputPath.replace(/(\.nzip|\.zip)$/i, '-upgrade$1');
+    const tempDir = path.dirname(outPath) || '.';
+    const tempPath = path.join(tempDir, `.neozip-upgrade-${Date.now()}.tmp`);
+    try {
+        const zipCopy = new node_2.ZipCopyNode(new node_1.default());
+        const { destPath, dataEndOffset, copiedEntries } = await zipCopy.copyZipEntriesOnly(inputPath, tempPath, {
+            entryFilter: (entry) => !metadataFiles.includes(entry.filename || '')
+        });
+        const newEntry = (0, zipstamp_server_1.createTimestampMetadataEntry)(zip, confirmedMetadata);
+        if (!newEntry) {
+            throw new Error('Failed to create timestamp metadata entry');
+        }
+        newEntry.localHdrOffset = dataEndOffset;
+        newEntry.cmpMethod = 0;
+        newEntry.compressedSize = newEntry.fileBuffer?.length ?? newEntry.uncompressedSize ?? 0;
+        const localHdr = newEntry.createLocalHdr();
+        const data = newEntry.fileBuffer ?? Buffer.alloc(0);
+        const fd = fs.openSync(destPath, 'r+');
+        try {
+            fs.writeSync(fd, localHdr, 0, localHdr.length, dataEndOffset);
+            fs.writeSync(fd, data, 0, data.length, dataEndOffset + localHdr.length);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        const allEntries = [...copiedEntries, newEntry];
+        zipCopy.writeCentralDirectoryAndEOCD(destPath, allEntries, { zipComment: '' });
+        fs.renameSync(destPath, outPath);
+        console.log(`✓ Upgraded ZIP written to: ${outPath}`);
+    }
+    catch (error) {
+        if (fs.existsSync(tempPath)) {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        const msg = error instanceof Error ? error.message : String(error);
+        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_WRITE_ARCHIVE, `Error upgrading ZIP: ${msg}`);
+    }
+}
+//# sourceMappingURL=upgradeZip.js.map

package/dist/src/neozip.js

@@ -67,10 +67,19 @@ const user_interaction_1 = require("./neozip/user-interaction");
 const createZip_1 = require("./neozip/createZip");
 const file_operations_1 = require("./neozip/file-operations");
 // ConfigSetup is lazy-loaded only when needed (init/config commands)
-const blockchain_1 = require("neozipkit/blockchain");
+const neozip_blockchain_1 = require("neozip-blockchain");
 const ConfigStore_1 = require("./config/ConfigStore");
 const exit_codes_1 = require("./exit-codes");
 const version_1 = require("./version");
+/**
+ * Resolve dynamic import path so ts-node loads .ts and compiled dist loads .js
+ */
+function resolveScriptPath(jsPath) {
+    if (typeof __filename !== 'undefined' && __filename.endsWith('.ts')) {
+        return jsPath.replace(/\.js$/, '.ts');
+    }
+    return jsPath;
+}
 /**
  * Parse command line arguments
  */
@@ -85,6 +94,7 @@ function parseArgs(args) {
         blockchainMint: false, // Force mint new token disabled by default
         network: 'base-sepolia',
         walletPasskey: process.env.NEOZIP_WALLET_PASSKEY,
+        timestampEmail: process.env.NEOZIP_TIMESTAMP_EMAIL,
         compression: 'zstd',
         blockSize: 128 * 1024, // 128KB default
         enableProgress: true,
@@ -168,6 +178,17 @@ function parseArgs(args) {
             case '--opentimestamp':
                 options.blockchainOts = true;
                 break;
+            case '-ts':
+            case '--timestamp':
+                options.blockchainZipstamp = true;
+                break;
+            case '--timestamp-email':
+                options.timestampEmail = args[++i];
+                if (!options.timestampEmail) {
+                    console.error('Error: --timestamp-email requires an email address');
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+                }
+                break;
             case '-bt':
             case '--blockchain-token':
                 options.blockchain = true;
@@ -185,8 +206,8 @@ function parseArgs(args) {
             case '-n':
             case '--network':
                 const network = args[++i];
-                if ((0, blockchain_1.getChainIdByName)(network) === null) {
-                    const supportedNetworks = (0, blockchain_1.getSupportedNetworkNames)();
+                if ((0, neozip_blockchain_1.getChainIdByName)(network) === null) {
+                    const supportedNetworks = (0, neozip_blockchain_1.getSupportedNetworkNames)();
                     console.error(`Error: Unsupported network: "${network}"`);
                     console.error(`Supported networks: ${supportedNetworks.join(', ')}`);
                     (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
@@ -239,45 +260,45 @@ function parseArgs(args) {
                 break;
             case '-e':
             case '--encrypt':
-                // InfoZip-compatible encryption option
                 options.encrypt = true;
-                // Only set encryption method if not already set
                 if (!options.encryptionMethod) {
-                    options.encryptionMethod = 'pkzip'; // Default to PKZIP (InfoZip compatible)
+                    options.encryptionMethod = 'aes256';
                 }
-                // Only prompt for password if not already provided
                 if (!options.password) {
-                    options.password = 'PROMPT'; // Will prompt for password
+                    options.password = 'PROMPT';
                 }
                 break;
             case '-P':
             case '--password':
-                // InfoZip-compatible password option (uppercase P)
                 options.encrypt = true;
-                // Only set encryption method if not already set (e.g., by --pkzip-encrypt)
                 if (!options.encryptionMethod) {
-                    options.encryptionMethod = 'pkzip'; // Default to PKZIP
+                    options.encryptionMethod = 'aes256';
                 }
                 if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
-                    // Password provided directly
                     options.password = args[++i];
                 }
                 else {
-                    // No password provided, will prompt later
                     options.password = 'PROMPT';
                 }
                 break;
             case '-p':
             case '--show-progress':
-                // InfoZip-compatible show-progress option (lowercase p)
                 options.showFiles = true;
                 break;
+            case '--aes256':
+            case '--aes-256':
+                options.encrypt = true;
+                options.encryptionMethod = 'aes256';
+                if (!options.password) {
+                    options.password = 'PROMPT';
+                }
+                break;
+            case '--pkzip':
             case '--pkzip-encrypt':
                 options.encrypt = true;
                 options.encryptionMethod = 'pkzip';
-                // Only prompt for password if not already provided
                 if (!options.password) {
-                    options.password = 'PROMPT'; // Will prompt for password
+                    options.password = 'PROMPT';
                 }
                 break;
             case '-x':
@@ -411,6 +432,12 @@ function parseArgs(args) {
                 break;
         }
     }
+    // -ots and -ts are mutually exclusive (choose Bitcoin OTS or Ethereum Zipstamp)
+    if (options.blockchainOts && options.blockchainZipstamp) {
+        console.error('Error: Cannot use both -ots (OpenTimestamps) and -ts (Zipstamp) in the same run');
+        console.error('   Use -ts for Zipstamp timestamping or -ots for Bitcoin timestamping');
+        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+    }
     if (!archive) {
         console.error('Error: Archive name is required');
         showHelp();
@@ -450,6 +477,9 @@ Usage: neozip [options] <archive> <files...>
 Configuration Commands:
   neozip init                 Interactive wallet setup wizard
   neozip config               Show current configuration and manage settings (interactive menu)
+  neozip upgrade <archive> [output] [--wait]  Upgrade pending Zipstamp timestamp to confirmed
+  neozip mint <archive> [output]  Mint TimestampProofNFT from confirmed timestamped ZIP
+  neozip verify-email [--email <email>] [--set-default]  Configure email for Zipstamp timestamping
 
 Options:
   -h, --help              Show this help message
@@ -478,6 +508,8 @@ Options:
   -bd, --blockchain-default Auto-select default token option (use existing or mint new)
   -bm, --blockchain-mint  Force mint new token (skip existing token selection)
   -ots, --opentimestamp   Enable OpenTimestamp proof on Bitcoin blockchain
+  -ts, --timestamp       Enable Ethereum Zipstamp timestamp (blockchain)
+      --timestamp-email <email>  Email for Zipstamp server (some servers require verified email)
   -n, --network <network> Blockchain network (base-sepolia, base-mainnet, default: base-sepolia)
   -w, --wallet-key <key>  Wallet private key (overrides NEOZIP_WALLET_PASSKEY)
   -c                      Add one-line comments for files
@@ -487,10 +519,11 @@ Options:
       --block-size <bytes> Block size for streaming (default: 131072)
       --no-progress       Disable progress reporting
       --progress          Enable enhanced progress reporting
-  -e, --encrypt           Encrypt files (InfoZip-compatible). Will prompt for password
-  -P, --password [pwd]    Encrypt files with password (InfoZip-compatible). Provide password or will prompt
+  -e, --encrypt           Encrypt files with AES-256 (default). Will prompt for password
+  -P, --password [pwd]    Encrypt files with password. Provide password or will prompt
+      --aes256            Use AES-256 encryption (default, recommended)
+      --pkzip, --pkzip-encrypt  Use legacy PKZIP encryption (weak, for compatibility only)
   -p, --show-progress     Show progress during compression (InfoZip-compatible)
-      --pkzip-encrypt     Use PKZIP encryption (legacy compatibility only, same as -e)
   -x, --exclude <pattern> Exclude files matching pattern (can be used multiple times)
   -i, --include <pattern> Include only files matching pattern (can be used multiple times)
       --suffixes <list>   Don't compress files with these suffixes (can be used multiple times)
@@ -509,9 +542,9 @@ Arguments:
   <files...>              Files and directories to compress
 
 Examples:
-  neozip output/test.nzip file1.txt file2.txt
-  neozip output/simple.nzip ./data/
-  neozip -r output/recursive.nzip ./project/
+  neozip tests/output/test.nzip file1.txt file2.txt
+  neozip tests/output/simple.nzip ./data/
+  neozip -r tests/output/recursive.nzip ./project/
 `);
 }
 /**
@@ -671,7 +704,7 @@ async function main() {
             // Handle `neozip init` - interactive setup wizard
             if (command === 'init') {
                 // Lazy-load ConfigSetup only when needed
-                const { ConfigSetup } = await import('./config/ConfigSetup.js');
+                const { ConfigSetup } = await import(resolveScriptPath('./config/ConfigSetup.js'));
                 const wizard = new ConfigSetup();
                 const success = await wizard.run();
                 process.exit(success ? exit_codes_1.ZIP_EXIT_CODES.SUCCESS : exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT);
@@ -679,10 +712,113 @@ async function main() {
             // Handle `neozip config` - show interactive menu
             if (command === 'config') {
                 // Lazy-load ConfigSetup only when needed
-                const { ConfigSetup } = await import('./config/ConfigSetup.js');
+                const { ConfigSetup } = await import(resolveScriptPath('./config/ConfigSetup.js'));
                 await ConfigSetup.showAndManage();
                 // showAndManage handles its own exit
             }
+            // Handle `neozip verify-email` - configure email for Zipstamp timestamping
+            if (command === 'verify-email') {
+                const verifyArgs = args.slice(1);
+                let email;
+                let setDefaultOnly = false;
+                let debug = false;
+                for (let i = 0; i < verifyArgs.length; i++) {
+                    const arg = verifyArgs[i];
+                    if (arg === '--email' && verifyArgs[i + 1]) {
+                        email = verifyArgs[++i];
+                    }
+                    else if (arg === '--set-default') {
+                        setDefaultOnly = true;
+                    }
+                    else if (arg === '--debug') {
+                        debug = true;
+                    }
+                }
+                const { runVerifyEmail } = await import(resolveScriptPath('./commands/verifyEmail.js'));
+                const success = await runVerifyEmail({ email, setDefaultOnly, debug });
+                process.exit(success ? exit_codes_1.ZIP_EXIT_CODES.SUCCESS : exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT);
+            }
+            // Handle `neozip upgrade` - upgrade pending Zipstamp timestamp to confirmed
+            if (command === 'upgrade') {
+                const upgradeArgs = args.slice(1);
+                let inputPath = '';
+                let outputPath;
+                let wait = false;
+                let verbose = false;
+                let debug = false;
+                for (let i = 0; i < upgradeArgs.length; i++) {
+                    const arg = upgradeArgs[i];
+                    if (arg === '--wait') {
+                        wait = true;
+                    }
+                    else if (arg === '-v' || arg === '--verbose') {
+                        verbose = true;
+                    }
+                    else if (arg === '--debug') {
+                        debug = true;
+                    }
+                    else if (!arg.startsWith('-')) {
+                        if (!inputPath) {
+                            inputPath = arg;
+                        }
+                        else if (!outputPath) {
+                            outputPath = arg;
+                        }
+                    }
+                }
+                if (!inputPath) {
+                    console.error('Error: neozip upgrade requires an input archive path');
+                    console.error('   Usage: neozip upgrade <archive> [output] [--wait]');
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+                }
+                const { upgradeZipForTimestamp } = await import(resolveScriptPath('./neozip/upgradeZip.js'));
+                await upgradeZipForTimestamp(inputPath, outputPath, { wait, verbose, debug });
+                (0, utils_1.log)('✓ Upgrade completed successfully', { verbose, quiet: false });
+                process.exit(exit_codes_1.ZIP_EXIT_CODES.SUCCESS);
+            }
+            // Handle `neozip mint` - mint TimestampProofNFT from confirmed timestamped ZIP
+            if (command === 'mint') {
+                const mintArgs = args.slice(1);
+                let inputPath = '';
+                let outputPath;
+                let walletKey;
+                let network;
+                let debug = false;
+                for (let i = 0; i < mintArgs.length; i++) {
+                    const arg = mintArgs[i];
+                    if (arg === '-w' || arg === '--wallet-key') {
+                        walletKey = mintArgs[++i];
+                    }
+                    else if (arg === '-n' || arg === '--network') {
+                        network = mintArgs[++i];
+                    }
+                    else if (arg === '--debug') {
+                        debug = true;
+                    }
+                    else if (!arg.startsWith('-')) {
+                        if (!inputPath) {
+                            inputPath = arg;
+                        }
+                        else if (outputPath === undefined) {
+                            outputPath = arg;
+                        }
+                    }
+                }
+                if (!inputPath) {
+                    console.error('Error: neozip mint requires an input archive path');
+                    console.error('   Usage: neozip mint <archive> [output] [-w <wallet-key>] [-n <network>]');
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+                }
+                const { runMintTimestampProof } = await import(resolveScriptPath('./commands/mintTimestampProof.js'));
+                const success = await runMintTimestampProof({
+                    inputPath,
+                    outputPath,
+                    walletKey,
+                    network,
+                    debug
+                });
+                process.exit(success ? exit_codes_1.ZIP_EXIT_CODES.SUCCESS : exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT);
+            }
         }
         let { archive, files, options } = parseArgs(args);
         // If network not explicitly provided via CLI, use from ConfigStore (which reads from ENV or wallet.json)

package/env.example

@@ -55,6 +55,16 @@ NEOZIP_WALLET_PASSKEY=0x1234567890abcdef1234567890abcdef1234567890abcdef12345678
 #   - Arbitrum One: https://arb1.arbitrum.io/rpc
 #   - Ethereum Sepolia: https://rpc.sepolia.ethpandaops.io
 
+# =============================================================================
+# OPTIONAL: Zipstamp Timestamp Configuration
+# =============================================================================
+
+# Zipstamp server URL for Ethereum timestamping (default: https://zipstamp-dev.neozip.io)
+# ZIPSTAMP_SERVER_URL=https://zipstamp-dev.neozip.io
+
+# Email for Zipstamp server (some servers require verified email for stamping)
+# NEOZIP_TIMESTAMP_EMAIL=your@email.com
+
 # =============================================================================
 # OPTIONAL: Debug Configuration
 # =============================================================================