neozip-cli 0.70.0-alpha

package/dist/src/neozip.js

@@ -0,0 +1,785 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * NEOZIP - Standalone ZIP creation tool with blockchain tokenization
+ * Usage: neozip [options] <archive> <files...>
+ *
+ * Configuration: Use `neozip init` to set up wallet credentials
+ * For blockchain features, wallet key can be provided via:
+ *   1. CLI flag: -w 0x...
+ *   2. Config file: ~/.neozip/wallet.json (recommended)
+ *   3. ENV var: NEOZIP_WALLET_PASSKEY
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+exports.parseArgs = parseArgs;
+exports.showHelp = showHelp;
+exports.showExtendedHelp = showExtendedHelp;
+// Load environment variables from .env.local (if it exists)
+// This allows users to set NEOZIP_NETWORK and other config via .env.local
+const dotenv = __importStar(require("dotenv"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+// Try to load .env.local first, then .env as fallback
+const envLocalPath = path.join(process.cwd(), '.env.local');
+const envPath = path.join(process.cwd(), '.env');
+if (fs.existsSync(envLocalPath)) {
+    dotenv.config({ path: envLocalPath });
+}
+else if (fs.existsSync(envPath)) {
+    dotenv.config({ path: envPath });
+}
+const utils_1 = require("./neozip/utils");
+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 contracts_1 = require('../neozipkit-wrappers/blockchain/core/contracts');
+const ConfigStore_1 = require("./config/ConfigStore");
+const exit_codes_1 = require("./exit-codes");
+const version_1 = require("./version");
+/**
+ * Parse command line arguments
+ */
+function parseArgs(args) {
+    const options = {
+        verbose: false,
+        quiet: false,
+        level: 6,
+        blockchain: false, // Blockchain disabled by default
+        blockchainOts: false, // OpenTimestamp disabled by default
+        blockchainDefault: false, // Auto-select default option disabled by default
+        blockchainMint: false, // Force mint new token disabled by default
+        network: 'base-sepolia',
+        walletPasskey: process.env.NEOZIP_WALLET_PASSKEY,
+        compression: 'zstd',
+        blockSize: 128 * 1024, // 128KB default
+        enableProgress: true,
+        junkPaths: false,
+        update: false,
+        freshen: false,
+        move: false,
+        interactiveComments: false,
+        walletKey: undefined
+    };
+    const files = [];
+    let archive = '';
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '-h':
+                showHelp();
+                process.exit(0);
+                break;
+            case '-h2':
+            case '--help-extended':
+                showExtendedHelp();
+                process.exit(0);
+                break;
+            case '--help':
+                showHelp();
+                process.exit(0);
+                break;
+            case '-V':
+            case '--version':
+                console.log(`NeoZip Version: ${version_1.APP_VERSION} (${version_1.APP_RELEASE_DATE})`);
+                process.exit(0);
+                break;
+            case '-v':
+            case '--verbose':
+                options.verbose = true;
+                break;
+            case '-q':
+            case '--quiet':
+                options.quiet = true;
+                break;
+            case '-0':
+                options.level = 0; // Store only (no compression)
+                break;
+            case '-1':
+                options.level = 1; // Fastest compression
+                break;
+            case '-2':
+                options.level = 2;
+                break;
+            case '-3':
+                options.level = 3;
+                break;
+            case '-4':
+                options.level = 4;
+                break;
+            case '-5':
+                options.level = 5;
+                break;
+            case '-6':
+                options.level = 6; // Default compression
+                break;
+            case '-7':
+                options.level = 7;
+                break;
+            case '-8':
+                options.level = 8;
+                break;
+            case '-9':
+                options.level = 9; // Best compression
+                break;
+            case '-l':
+            case '--level':
+                const level = parseInt(args[++i]);
+                if (isNaN(level) || level < 0 || level > 9) {
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR, 'Error: Compression level must be between 0 and 9 (0=store, 1=fastest, 9=best)');
+                }
+                options.level = level;
+                break;
+            case '-ots':
+            case '--opentimestamp':
+                options.blockchainOts = true;
+                break;
+            case '-bt':
+            case '--blockchain-token':
+                options.blockchain = true;
+                break;
+            case '-bd':
+            case '--blockchain-default':
+                options.blockchain = true;
+                options.blockchainDefault = true;
+                break;
+            case '-bm':
+            case '--blockchain-mint':
+                options.blockchain = true;
+                options.blockchainMint = true;
+                break;
+            case '-n':
+            case '--network':
+                const network = args[++i];
+                if ((0, contracts_1.getChainIdByName)(network) === null) {
+                    const supportedNetworks = (0, contracts_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);
+                }
+                options.network = network;
+                break;
+            case '--wallet-key':
+                options.walletPasskey = args[++i];
+                break;
+            case '-b':
+            case '--blockchain':
+                options.blockchain = true;
+                // Tokenization is automatically enabled when blockchain is enabled
+                break;
+            case '-w':
+                options.walletKey = args[++i];
+                break;
+            case '--compression':
+                const compression = args[++i];
+                if (compression === 'zstd' || compression === 'deflate') {
+                    options.compression = compression;
+                }
+                else {
+                    console.error('Error: Compression must be "zstd" or "deflate"');
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+                }
+                break;
+            case '--deflate':
+            case '--pkzip-compress':
+                options.compression = 'deflate';
+                break;
+            case '-c':
+                // Add one-line comments for files
+                options.fileCommentsOnly = true;
+                break;
+            case '--block-size':
+                const blockSize = parseInt(args[++i], 10);
+                if (isNaN(blockSize) || blockSize < 1024) {
+                    console.error('Error: Block size must be at least 1024 bytes');
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+                }
+                options.blockSize = blockSize;
+                break;
+            case '--no-progress':
+                options.enableProgress = false;
+                break;
+            case '--progress':
+                options.progress = true;
+                options.enableProgress = true;
+                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)
+                }
+                // Only prompt for password if not already provided
+                if (!options.password) {
+                    options.password = 'PROMPT'; // Will prompt for password
+                }
+                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
+                }
+                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 '--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
+                }
+                break;
+            case '-x':
+            case '--exclude':
+                if (!options.exclude)
+                    options.exclude = [];
+                options.exclude.push(args[++i]);
+                break;
+            case '-i':
+            case '--include':
+                if (!options.include)
+                    options.include = [];
+                options.include.push(args[++i]);
+                break;
+            case '--in-memory':
+                options.inMemory = true;
+                break;
+            case '-r':
+            case '--recurse':
+                options.recurse = true;
+                break;
+            case '-j':
+            case '--junk-paths':
+                options.junkPaths = true;
+                break;
+            case '-u':
+            case '--update':
+                options.update = true;
+                break;
+            case '-f':
+            case '--freshen':
+                options.freshen = true;
+                break;
+            case '-m':
+            case '--move':
+                options.move = true;
+                break;
+            case '-z':
+            case '--archive-comment':
+                options.archiveComment = args[++i];
+                if (!options.archiveComment) {
+                    console.error('Error: --archive-comment requires a comment text');
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+                }
+                break;
+            case '--comment-file':
+                options.commentFile = args[++i];
+                if (!options.commentFile) {
+                    console.error('Error: --comment-file requires a file path');
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+                }
+                break;
+            case '--interactive-comments':
+                options.interactiveComments = true;
+                break;
+            case '--suffixes':
+                if (!options.suffixes)
+                    options.suffixes = [];
+                options.suffixes.push(args[++i]);
+                break;
+            case '-d':
+                options.delete = true;
+                break;
+            case '--debug':
+                options.debug = true;
+                break;
+            case '-sf':
+            case '--show-files':
+                options.showFiles = true;
+                break;
+            case '-l':
+            case '--to-crlf':
+                options.toCrlf = true;
+                break;
+            case '-ll':
+            case '--from-crlf':
+                options.fromCrlf = true;
+                break;
+            case '-X':
+            case '--preserve-perms':
+                options.preservePerms = true;
+                break;
+            case '-y':
+            case '--symlinks':
+                options.symlinks = true;
+                break;
+            case '-H':
+            case '--hard-links':
+                options.hardLinks = true;
+                break;
+            case '-o':
+            case '--old-timestamp':
+                options.oldTimestamp = true;
+                break;
+            case '--temp-path':
+                options.tempPath = args[++i];
+                if (!options.tempPath) {
+                    console.error('Error: --temp-path requires a directory path');
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+                }
+                break;
+            case '-T':
+            case '--test-integrity':
+                options.testIntegrity = true;
+                break;
+            case '--non-interactive':
+                options.nonInteractive = true;
+                break;
+            case '--upgrade':
+                options.upgrade = true;
+                options.blockchain = true; // Upgrade implies blockchain tokenization
+                break;
+            case '--overwrite':
+                options.overwrite = true;
+                break;
+            case '-@':
+                options.stdinFilenames = true;
+                break;
+            default:
+                if (arg.startsWith('-')) {
+                    console.error(`Error: Unknown option ${arg}`);
+                    showHelp();
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+                }
+                else if (!archive) {
+                    archive = arg;
+                }
+                else {
+                    files.push(arg);
+                }
+                break;
+        }
+    }
+    if (!archive) {
+        console.error('Error: Archive name is required');
+        showHelp();
+        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+    }
+    // Apply PKZIP-style extension behavior: default to .nzip if no extension
+    // If archive name ends with a period, don't add extension (suppress default)
+    if (archive.endsWith('.')) {
+        // Remove trailing period to get the base name without extension
+        archive = archive.slice(0, -1);
+    }
+    else {
+        // Check if archive has an extension (has a dot followed by at least one character)
+        const ext = path.extname(archive);
+        if (!ext) {
+            // No extension found, add .nzip
+            archive = archive + '.nzip';
+        }
+    }
+    // Skip file validation for upgrade mode (only needs archive path)
+    if (files.length === 0 && !options.stdinFilenames && !options.upgrade) {
+        console.error('Error: At least one file or directory must be specified');
+        showHelp();
+        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+    }
+    return { archive, files, options };
+}
+/**
+ * Show help information
+ */
+function showHelp() {
+    console.log(`
+NeoZip Version: ${version_1.APP_VERSION} (${version_1.APP_RELEASE_DATE})
+
+Usage: neozip [options] <archive> <files...>
+
+Configuration Commands:
+  neozip init                 Interactive wallet setup wizard
+  neozip config               Show current configuration and manage settings (interactive menu)
+
+Options:
+  -h, --help              Show this help message
+  -V, --version           Show version information
+  -v, --verbose           Enable verbose output
+  -q, --quiet             Suppress output
+  -d                      Delete specified files from archive
+      --debug             Enable debug output
+  -sf, --show-files       Show files as they are processed
+  -l, --to-crlf           Convert line endings to CRLF (Windows style)
+  -ll, --from-crlf        Convert line endings from CRLF to LF (Unix style)
+  -X, --preserve-perms    Preserve file permissions and ownership (UID/GID)
+  -y, --symlinks          Store symbolic links as links (don't follow them)
+  -H, --hard-links        Handle hard links efficiently (detect and deduplicate)
+  -o, --old-timestamp     Make zipfile as old as latest entry
+      --temp-path <dir>   Specify temporary file directory
+  -T, --test-integrity    Test archive integrity after creation
+      --non-interactive   Skip interactive prompts (exit on minting errors)
+      --upgrade           Upgrade existing ZIP file for tokenization (add SHA-256 hashes)
+      --overwrite         Overwrite input file when upgrading (default: create new file)
+  -@                      Read file names from stdin (one per line)
+  -0                      Store only (no compression)
+  -1 to -9                Compression level (1=fastest, 9=best, default: 6)
+  --level <level>         Compression level (0-9, 0=store, default: 6)
+  -b, --blockchain        Enable blockchain operations with tokenization
+  -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
+  -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
+      --compression <alg> Compression algorithm (zstd, deflate, default: zstd)
+      --deflate           Use deflate compression (same as --compression deflate)
+      --pkzip-compress    Use deflate compression (same as --compression deflate)
+      --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
+  -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)
+  -r, --recurse           Include subdirectories recursively
+  -j, --junk-paths        Store only filenames, not directory paths
+  -u, --update            Update existing archive (only newer files)
+  -f, --freshen           Freshen existing archive (only existing files, no new files)
+  -m, --move              Move files into archive (delete originals after compression)
+  -z, --archive-comment <text> Set archive comment
+      --comment-file <file>     Read comments from file (archive and file comments)
+      --interactive-comments    Prompt for comments interactively
+      --in-memory               Use in-memory compression (browser compatible)
+
+Arguments:
+  <archive>               Output ZIP file name
+  <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/
+`);
+}
+/**
+ * Show extended help information (equivalent to InfoZip's -h2)
+ */
+function showExtendedHelp() {
+    console.log('Extended Help for NeoZip');
+    console.log('');
+    console.log('NeoZip is a next-generation ZIP utility that builds upon the strengths of the ZIP format');
+    console.log('while incorporating blockchain technology, advanced compression, and modern features.');
+    console.log('');
+    console.log('Basic command line:');
+    console.log('  neozip [options] archive_name file file ...');
+    console.log('');
+    console.log('Some examples:');
+    console.log('  Add file.txt to z.nzip (create z if needed):      neozip z file.txt');
+    console.log('  Zip all files in current dir:                     neozip z *');
+    console.log('  Zip files in current dir and subdirs also:        neozip -r z .');
+    console.log('');
+    console.log('Basic modes:');
+    console.log(' External modes (selects files from file system):');
+    console.log('        add      - add new files/update existing files in archive (default)');
+    console.log('  -u    update   - add new files/update existing files only if later date');
+    console.log('  -f    freshen  - update existing files only (no files added)');
+    console.log(' Internal modes (selects entries in archive):');
+    console.log('  -d    delete   - delete files from archive');
+    console.log('');
+    console.log('Basic options:');
+    console.log('  -r        recurse into directories');
+    console.log('  -m        after archive created, delete original files (move into archive)');
+    console.log('  -j        junk directory names (store just file names)');
+    console.log('  -q        quiet operation');
+    console.log('  -v        verbose operation');
+    console.log('  -c        prompt for one-line comment for each entry');
+    console.log('  -z        prompt for comment for archive');
+    console.log('  -@        read names to zip from stdin (one path per line)');
+    console.log('  -o        make zipfile as old as latest entry');
+    console.log('');
+    console.log('Syntax:');
+    console.log('  The full command line syntax is:');
+    console.log('');
+    console.log('    neozip [-shortopts ...] [--longopt ...] [zipfile [path path ...]] [-xi list]');
+    console.log('');
+    console.log('  Any number of short option and long option arguments are allowed');
+    console.log('  as well as any number of path arguments for files to zip up.');
+    console.log('');
+    console.log('Options and Values:');
+    console.log('  For short options that take values, use -ovalue or -o value or -o=value');
+    console.log('  For long option values, use either --longoption=value or --longoption value');
+    console.log('  For example:');
+    console.log('    neozip --temp-path=/tmp --exclude pattern pattern zipfile path1 path2');
+    console.log('');
+    console.log('Wildcards:');
+    console.log('  NeoZip supports the following wildcards:');
+    console.log('    ?       matches any single character');
+    console.log('    *       matches any number of characters, including zero');
+    console.log('    [list]  matches char in list (regex), can do range [a-f], all but [!bf]');
+    console.log('');
+    console.log('Include and Exclude:');
+    console.log('  -i pattern pattern ...   include files that match a pattern');
+    console.log('  -x pattern pattern ...   exclude files that match a pattern');
+    console.log('  Patterns are paths with optional wildcards and match paths as stored in');
+    console.log('  archive. Exclude and include lists end at next option, @, or end of line.');
+    console.log('');
+    console.log('End Of Line Translation (text files only):');
+    console.log('  -l        change LF to CR LF (Unix->Windows)');
+    console.log('  -ll       change CR LF to LF (Windows->Unix)');
+    console.log('  If first buffer read from file contains binary the translation is skipped');
+    console.log('');
+    console.log('Recursion:');
+    console.log('  -r        recurse paths, include files in subdirs:  neozip -r a path path ...');
+    console.log('  Use -i and -x with either to include or exclude paths');
+    console.log('');
+    console.log('Date filtering:');
+    console.log('  -t date   exclude before (include files modified on this date and later)');
+    console.log('  -tt date  include before (include files modified before date)');
+    console.log('  Can use both at same time to set a date range');
+    console.log('  Dates are mmddyyyy or yyyy-mm-dd');
+    console.log('');
+    console.log('Deletion:');
+    console.log('  -d        delete files');
+    console.log('  Delete archive entries matching internal archive paths in list');
+    console.log('    neozip archive -d pattern pattern ...');
+    console.log('');
+    console.log('Compression:');
+    console.log('  -0        store files (no compression)');
+    console.log('  -1 to -9  compress fastest to compress best (default is 6)');
+    console.log('  --compression <method>  set compression method:');
+    console.log('              store   - store without compression, same as option -0');
+    console.log('              deflate - original zip deflate, same as -1 to -9');
+    console.log('              zstd    - Zstandard compression (default)');
+    console.log('              lz4     - LZ4 compression');
+    console.log('  --deflate              use deflate compression (same as --compression deflate)');
+    console.log('  --pkzip-compress       use deflate compression (same as --compression deflate)');
+    console.log('              brotli  - Brotli compression');
+    console.log('');
+    console.log('Encryption:');
+    console.log('  -e, --encrypt        encrypt files (InfoZip-compatible), prompt for password');
+    console.log('  -P, --password pswd  encrypt files with password (InfoZip-compatible)');
+    console.log('  --pkzip-encrypt      use legacy PKZip 2.0 encryption (same as -e)');
+    console.log('');
+    console.log('Progress:');
+    console.log('  -p, --show-progress  show progress during compression (InfoZip-compatible)');
+    console.log('');
+    console.log('Blockchain Features:');
+    console.log('  -b, --blockchain        enable blockchain tokenization');
+    console.log('  --skip-blockchain       disable blockchain features');
+    console.log('  --network <network>     specify blockchain network (base-sepolia, ethereum, etc.)');
+    console.log('  --wallet <address>      specify wallet address');
+    console.log('  --private-key <key>     specify private key (not recommended)');
+    console.log('  --gas-limit <limit>     set gas limit for transactions');
+    console.log('  --gas-price <price>     set gas price for transactions');
+    console.log('');
+    console.log('Testing archives:');
+    console.log('  -T        test completed archive with neounzip before finalizing');
+    console.log('  --test-integrity  same as -T');
+    console.log('');
+    console.log('Archive Management:');
+    console.log('  -o        make zipfile as old as latest entry');
+    console.log('  --temp-path <dir>  specify temporary file directory');
+    console.log('  --comment-file <file>  add comments from file');
+    console.log('');
+    console.log('Symbolic Links and Hard Links:');
+    console.log('  -y        store symbolic links as links (don\'t follow them)');
+    console.log('  -H        handle hard links efficiently (detect and deduplicate)');
+    console.log('');
+    console.log('File Permissions:');
+    console.log('  -X        preserve file permissions and ownership (UID/GID)');
+    console.log('');
+    console.log('Progress and Verbosity:');
+    console.log('  -v        verbose operation');
+    console.log('  -q        quiet operation');
+    console.log('  --progress show progress bar');
+    console.log('  --debug   show debug information');
+    console.log('');
+    console.log('More option highlights:');
+    console.log('  --temp-path <dir>  when creating or updating archive, create the temp archive in');
+    console.log('                     dir, which allows using seekable temp file when writing to a');
+    console.log('                     write once CD, such archives compatible with more unzips');
+    console.log('  --show-files       show files to operate on and exit');
+    console.log('  --suffixes <list>  specify file suffixes to compress');
+    console.log('  --block-size <size>  set compression block size');
+    console.log('');
+    console.log('For more information, visit: https://github.com/NeoWareInc/neozip-cli');
+    console.log('For detailed API documentation, see: https://docs.neoware.io/neozip');
+}
+/**
+ * Main function
+ */
+async function main() {
+    try {
+        // Parse command line arguments
+        const args = process.argv.slice(2);
+        // Handle configuration commands first
+        if (args.length > 0) {
+            const command = args[0];
+            // Handle `neozip init` - interactive setup wizard
+            if (command === 'init') {
+                // Lazy-load ConfigSetup only when needed
+                const { ConfigSetup } = await import('./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);
+            }
+            // Handle `neozip config` - show interactive menu
+            if (command === 'config') {
+                // Lazy-load ConfigSetup only when needed
+                const { ConfigSetup } = await import('./config/ConfigSetup.js');
+                await ConfigSetup.showAndManage();
+                // showAndManage handles its own exit
+            }
+        }
+        let { archive, files, options } = parseArgs(args);
+        // If network not explicitly provided via CLI, use from ConfigStore (which reads from ENV or wallet.json)
+        const networkProvidedViaCLI = args.includes('--network') || args.includes('-n');
+        if (!networkProvidedViaCLI) {
+            const config = ConfigStore_1.ConfigStore.getConfig();
+            if (config.network) {
+                options.network = config.network;
+            }
+        }
+        // Handle stdin filenames
+        if (options.stdinFilenames) {
+            if (files.length > 0) {
+                console.error('Error: Cannot specify both files and -@ (stdin filenames)');
+                (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+            }
+            if (options.debug) {
+                (0, utils_1.logDebug)('Reading filenames from stdin...', options);
+            }
+            try {
+                files = await (0, user_interaction_1.readFilenamesFromStdin)();
+                if (options.debug) {
+                    (0, utils_1.logDebug)(`Read ${files.length} filenames from stdin: ${files.join(', ')}`, options);
+                }
+                if (files.length === 0) {
+                    console.error('Error: No filenames provided via stdin');
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+                }
+            }
+            catch (error) {
+                console.error(`Error reading from stdin: ${error instanceof Error ? error.message : String(error)}`);
+                (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+            }
+        }
+        // Handle upgrade operation
+        if (options.upgrade) {
+            // Validate: upgrade requires exactly one argument (the ZIP file path)
+            if (files.length > 0) {
+                console.error('Error: --upgrade requires exactly one argument (the ZIP file path)');
+                console.error('   Usage: neozip --upgrade <existing-zip-file>');
+                (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+            }
+            if (!archive) {
+                console.error('Error: --upgrade requires a ZIP file path');
+                console.error('   Usage: neozip --upgrade <existing-zip-file>');
+                (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+            }
+            // Validate input file exists
+            if (!fs.existsSync(archive)) {
+                (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_FIND_ARCHIVE, `Error: ZIP file not found: ${archive}`);
+            }
+            // Call upgrade function
+            await (0, createZip_1.upgradeZipForTokenization)(archive, options);
+            (0, utils_1.log)('✓ Upgrade operation completed successfully', options);
+            process.exit(exit_codes_1.ZIP_EXIT_CODES.SUCCESS);
+        }
+        // Handle delete operation
+        if (options.delete) {
+            await (0, file_operations_1.deleteFromArchive)(archive, files, options);
+            (0, utils_1.log)('✓ Delete operation completed successfully', options);
+            return;
+        }
+        // Create ZIP archive
+        await (0, createZip_1.createZip)(archive, files, options);
+        // Move files if requested (delete originals after successful compression)
+        if (options.move) {
+            await (0, file_operations_1.moveFiles)(files, options);
+        }
+        (0, utils_1.log)('✓ NeoZip completed successfully', options);
+        // Explicitly exit to ensure process terminates (provider cleanup should allow this)
+        process.exit(exit_codes_1.ZIP_EXIT_CODES.SUCCESS);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        (0, utils_1.logError)(`Error: ${errorMessage}`);
+        // Determine appropriate exit code based on error type
+        if (errorMessage.includes('ENOENT') || errorMessage.includes('not found')) {
+            (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_FIND_ARCHIVE, `Error: ${errorMessage}`);
+        }
+        else if (errorMessage.includes('EACCES') || errorMessage.includes('permission')) {
+            (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_WRITE_ARCHIVE, `Error: ${errorMessage}`);
+        }
+        else if (errorMessage.includes('ENOSPC') || errorMessage.includes('disk full')) {
+            (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.WRITE_ERROR, `Error: ${errorMessage}`);
+        }
+        else if (errorMessage.includes('memory') || errorMessage.includes('allocation')) {
+            (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.MEMORY_ERROR, `Error: ${errorMessage}`);
+        }
+        else {
+            (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_WRITE_ARCHIVE, `Error: ${errorMessage}`);
+        }
+    }
+}
+// Always run main when this module is loaded
+// This allows it to work both when called directly and when imported by index.js
+main().catch(err => {
+    console.error('Fatal error:', err);
+    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_WRITE_ARCHIVE);
+});
+//# sourceMappingURL=neozip.js.map