neozip-cli 0.70.0-alpha

package/dist/src/neozip/CommentManager.js

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ * CommentManager - Handles archive and file comments for ZIP files
+ */
+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.CommentManager = void 0;
+const fs = __importStar(require("fs"));
+const readline = __importStar(require("readline"));
+class CommentManager {
+    static setArchiveComment(zip, comment) {
+        try {
+            if (zip && typeof zip.setZipComment === 'function') {
+                zip.setZipComment(comment);
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            console.error('Error setting archive comment:', error);
+            return false;
+        }
+    }
+    static getArchiveComment(zip) {
+        try {
+            if (zip && typeof zip.getZipComment === 'function') {
+                return zip.getZipComment();
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('Error getting archive comment:', error);
+            return null;
+        }
+    }
+    static setFileComment(entry, comment) {
+        try {
+            if (entry && typeof entry.comment !== 'undefined') {
+                entry.comment = comment;
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            console.error('Error setting file comment:', error);
+            return false;
+        }
+    }
+    static getFileComment(entry) {
+        try {
+            if (entry && typeof entry.comment !== 'undefined') {
+                return entry.comment || null;
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('Error getting file comment:', error);
+            return null;
+        }
+    }
+    static async readCommentsFromFile(filePath) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                return { success: false, error: `Comment file not found: ${filePath}` };
+            }
+            const content = fs.readFileSync(filePath, 'utf8');
+            const lines = content.split('\n');
+            let archiveComment = '';
+            const fileComments = {};
+            let currentFile = '';
+            let currentComment = '';
+            for (const line of lines) {
+                const trimmedLine = line.trim();
+                if (!trimmedLine) {
+                    if (currentFile && currentComment) {
+                        fileComments[currentFile] = currentComment.trim();
+                        currentFile = '';
+                        currentComment = '';
+                    }
+                    continue;
+                }
+                if (trimmedLine.includes(':')) {
+                    if (currentFile && currentComment) {
+                        fileComments[currentFile] = currentComment.trim();
+                    }
+                    const colonIndex = trimmedLine.indexOf(':');
+                    currentFile = trimmedLine.substring(0, colonIndex).trim();
+                    currentComment = trimmedLine.substring(colonIndex + 1).trim();
+                }
+                else {
+                    if (currentFile) {
+                        currentComment += (currentComment ? '\n' : '') + trimmedLine;
+                    }
+                    else {
+                        archiveComment += (archiveComment ? '\n' : '') + trimmedLine;
+                    }
+                }
+            }
+            if (currentFile && currentComment) {
+                fileComments[currentFile] = currentComment.trim();
+            }
+            return {
+                success: true,
+                archiveComment: archiveComment || undefined,
+                fileComments: Object.keys(fileComments).length > 0 ? fileComments : undefined
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Error reading comment file: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    static async promptForArchiveComment() {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        return new Promise((resolve) => {
+            rl.question('Enter archive comment (press Enter twice to finish):\n', (comment) => {
+                const lines = [comment];
+                const readLine = () => {
+                    rl.question('', (line) => {
+                        if (line.trim() === '') {
+                            rl.close();
+                            resolve(lines.join('\n').trim());
+                        }
+                        else {
+                            lines.push(line);
+                            readLine();
+                        }
+                    });
+                };
+                readLine();
+            });
+        });
+    }
+    static async promptForFileComments(filenames) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const fileComments = {};
+        for (const filename of filenames) {
+            const comment = await new Promise((resolve) => {
+                rl.question(`Enter comment for ${filename}: `, (input) => resolve(input.trim()));
+            });
+            if (comment)
+                fileComments[filename] = comment;
+        }
+        rl.close();
+        return fileComments;
+    }
+    static async promptForFileCommentsOnly(filenames) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const fileComments = {};
+        for (const filename of filenames) {
+            const comment = await new Promise((resolve) => {
+                rl.question(`Enter comment for ${filename}: `, (input) => resolve(input.trim()));
+            });
+            if (comment)
+                fileComments[filename] = comment;
+        }
+        rl.close();
+        return fileComments;
+    }
+    static applyComments(zip, entries, options) {
+        try {
+            let success = true;
+            const errors = [];
+            if (options.archiveComment) {
+                if (!this.setArchiveComment(zip, options.archiveComment)) {
+                    success = false;
+                    errors.push('Failed to set archive comment');
+                }
+            }
+            if (options.fileComments) {
+                for (const [filename, comment] of Object.entries(options.fileComments)) {
+                    const entry = entries.find((e) => e.filename === filename);
+                    if (entry) {
+                        if (!this.setFileComment(entry, comment)) {
+                            success = false;
+                            errors.push(`Failed to set comment for ${filename}`);
+                        }
+                    }
+                    else {
+                        success = false;
+                        errors.push(`File not found: ${filename}`);
+                    }
+                }
+            }
+            return { success, archiveComment: options.archiveComment, fileComments: options.fileComments, error: errors.length > 0 ? errors.join('; ') : undefined };
+        }
+        catch (error) {
+            return { success: false, error: `Error applying comments: ${error instanceof Error ? error.message : String(error)}` };
+        }
+    }
+    static applyFileCommentToEntry(entry, filename, fileComments) {
+        try {
+            if (fileComments[filename]) {
+                return this.setFileComment(entry, fileComments[filename]);
+            }
+            return true;
+        }
+        catch (error) {
+            console.error(`Error applying file comment to ${filename}:`, error);
+            return false;
+        }
+    }
+}
+exports.CommentManager = CommentManager;
+exports.default = CommentManager;
+//# sourceMappingURL=CommentManager.js.map

package/dist/src/neozip/blockchain.js

@@ -0,0 +1,383 @@
+"use strict";
+/**
+ * Blockchain-related functions for NeoZip CLI
+ */
+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.isSupportedNetwork = isSupportedNetwork;
+exports.getWalletPasskey = getWalletPasskey;
+exports.addTokenMetaToZip = addTokenMetaToZip;
+exports.handleTokenMinting = handleTokenMinting;
+const src_1 = require('../../neozipkit-wrappers');
+const blockchain_1 = require('../../neozipkit-wrappers/blockchain');
+const contracts_1 = require('../../neozipkit-wrappers/blockchain/core/contracts');
+const ConfigStore_1 = require("../config/ConfigStore");
+const readline = __importStar(require("readline"));
+/**
+ * Check if the network is supported (uses nameAliases from CONTRACT_CONFIGS)
+ */
+function isSupportedNetwork(network) {
+    return (0, contracts_1.getChainIdByName)(network) !== null;
+}
+/**
+ * Check if the required wallet passkey is available and valid
+ * Priority: CLI arg > wallet.json > ENV var
+ * @param cliWalletKey - Optional wallet key from CLI
+ * @param showError - Whether to show error messages (default: true)
+ */
+function getWalletPasskey(cliWalletKey, showError = true) {
+    // Get config with CLI wallet key taking precedence
+    const config = ConfigStore_1.ConfigStore.getConfig(cliWalletKey);
+    const passkey = config.walletKey;
+    if (!passkey) {
+        if (showError) {
+            console.error('❌ Error: Wallet private key is required for blockchain operations');
+            console.error('');
+            console.error('   Option 1 (Recommended): Run interactive setup');
+            console.error('   $ neozip init');
+            console.error('');
+            console.error('   Option 2: Use command-line flag');
+            console.error('   $ neozip -b -w 0x... <archive> <files>');
+            console.error('');
+            console.error('   Option 3: Set environment variable');
+            console.error('   $ export NEOZIP_WALLET_PASSKEY="0x..."');
+            console.error('');
+            console.error('   Get testnet ETH from: https://www.coinbase.com/faucets/base-ethereum-sepolia-faucet');
+        }
+        return null;
+    }
+    // Validate the private key format
+    if (!(0, blockchain_1.validatePrivateKey)(passkey)) {
+        if (showError) {
+            console.error('❌ Error: Invalid private key format');
+            console.error('   Private key should be a 64-character hex string starting with 0x');
+            console.error('   Example: 0x1234567890abcdef...');
+        }
+        return null;
+    }
+    return passkey;
+}
+/**
+ * Add token metadata to ZIP file using the constant
+ */
+async function addTokenMetaToZip(zip, tokenMeta) {
+    const tokenContent = JSON.stringify(tokenMeta, null, 2);
+    const tokenBuffer = Buffer.from(tokenContent, 'utf8');
+    const tokenPath = src_1.TOKENIZED_METADATA;
+    // Create new token entry
+    const tokenEntry = zip.createZipEntry(tokenPath);
+    tokenEntry.timeDateDOS = tokenEntry.setDateTime(new Date());
+    tokenEntry.compressedSize = tokenBuffer.length;
+    tokenEntry.uncompressedSize = tokenBuffer.length;
+    tokenEntry.cmpMethod = 0; // STORED
+    tokenEntry.crc = (0, src_1.crc32)(tokenBuffer);
+    tokenEntry.fileBuffer = tokenBuffer;
+    tokenEntry.isUpdated = true;
+    console.log('✅ Token metadata prepared for ZIP');
+    console.log(`📄 Token content:\n${tokenContent}`);
+    return tokenEntry;
+}
+/**
+ * Prompt user for action when minting timeout/error occurs
+ */
+async function promptForMintingTimeoutAction(networkConfig, currentRpcIndex, nonInteractive) {
+    if (nonInteractive) {
+        return 'exit';
+    }
+    const rpcUrls = networkConfig.rpcUrls || [];
+    const hasMoreRpcs = currentRpcIndex + 1 < rpcUrls.length;
+    console.log('\n⏱️  Minting timeout/error occurred');
+    console.log(`   Current RPC: ${rpcUrls[currentRpcIndex] || 'unknown'}`);
+    if (hasMoreRpcs) {
+        console.log(`   ${rpcUrls.length - currentRpcIndex - 1} more RPC URL(s) available`);
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        console.log('\nChoose an option:');
+        console.log('  1. Retry minting with same RPC');
+        if (hasMoreRpcs) {
+            console.log('  2. Try next RPC URL');
+        }
+        console.log('  3. Exit (continue without token metadata)');
+        rl.question('Enter your choice (1-3): ', (answer) => {
+            rl.close();
+            const choice = answer.trim();
+            if (choice === '1') {
+                resolve('retry');
+            }
+            else if (choice === '2' && hasMoreRpcs) {
+                resolve('next-rpc');
+            }
+            else if (choice === '3') {
+                resolve('exit');
+            }
+            else {
+                // Invalid choice, default to exit
+                console.log('Invalid choice, exiting...');
+                resolve('exit');
+            }
+        });
+    });
+}
+/**
+ * Handle token minting process with retry logic and RPC switching
+ */
+async function handleTokenMinting(initialMinter, zip, nonInteractive = false, initialRpcUrlIndex = 0) {
+    // Get network config from minter
+    const networkConfig = initialMinter.networkConfig;
+    const network = initialMinter.networkConfig?.network || 'unknown';
+    const merkleRoot = initialMinter.merkleRoot;
+    const walletPrivateKey = initialMinter.wallet?.privateKey;
+    const debug = initialMinter.debug;
+    const verbose = process.env.NEOZIP_VERBOSE === 'true';
+    let currentRpcIndex = initialRpcUrlIndex;
+    let maxRetries = 3; // Maximum retries per RPC
+    let retryCount = 0;
+    let minter = null;
+    // Cleanup helper
+    const cleanup = () => {
+        if (minter) {
+            try {
+                minter.destroy();
+            }
+            catch (error) {
+                // Ignore cleanup errors
+            }
+        }
+    };
+    try {
+        while (true) {
+            try {
+                // Cleanup previous minter if switching RPCs
+                if (minter && minter !== initialMinter) {
+                    cleanup();
+                }
+                // Create new minter with current RPC index (or reuse initial if first attempt)
+                if (currentRpcIndex === initialRpcUrlIndex && retryCount === 0) {
+                    minter = initialMinter;
+                }
+                else {
+                    // ZipkitMinter uses getChainIdByName internally which handles all nameAliases
+                    // So we can pass the original network name directly
+                    minter = new src_1.ZipkitMinter(merkleRoot, {
+                        network: network,
+                        walletPrivateKey: walletPrivateKey,
+                        verbose: verbose,
+                        debug: debug,
+                        rpcUrlIndex: currentRpcIndex
+                    });
+                }
+                console.log('\n⏳ Minting token on blockchain...');
+                // Enable debug logging
+                const debugMode = debug || process.env.NEOZIP_DEBUG === 'true' || process.env.NEOZIP_VERBOSE === 'true';
+                if (debugMode) {
+                    console.log('[DEBUG] Starting completeMinting()...');
+                    if (networkConfig) {
+                        console.log('[DEBUG] Network:', networkConfig.network || 'unknown');
+                        console.log('[DEBUG] Chain ID:', networkConfig.chainId || 'unknown');
+                        console.log('[DEBUG] Contract Address:', networkConfig.address || 'unknown');
+                        console.log('[DEBUG] RPC URL:', networkConfig.rpcUrls?.[currentRpcIndex] || 'unknown');
+                        console.log('[DEBUG] Explorer URL:', networkConfig.explorerUrl || 'unknown');
+                    }
+                }
+                // Complete the minting process
+                const mintResult = await minter.completeMinting();
+                if (mintResult.mintingResult.success) {
+                    console.log(`✅ Token minted successfully!`);
+                    console.log(`   Token ID: ${mintResult.tokenMetadata?.tokenId}`);
+                    console.log(`   Transaction: ${mintResult.tokenMetadata?.transactionHash}`);
+                    console.log(`   Contract: ${mintResult.tokenMetadata?.contractAddress}`);
+                    // Create TokenMetadata from minting result
+                    if (mintResult.tokenMetadata) {
+                        const tokenMeta = {
+                            version: '1.0',
+                            tokenId: mintResult.tokenMetadata.tokenId,
+                            contractAddress: mintResult.tokenMetadata.contractAddress,
+                            network: mintResult.tokenMetadata.network,
+                            networkChainId: mintResult.tokenMetadata.networkChainId || networkConfig?.chainId || 84532,
+                            transactionHash: mintResult.tokenMetadata.transactionHash,
+                            merkleRoot: mintResult.tokenMetadata.merkleRoot,
+                            mintedAt: mintResult.tokenMetadata.mintDate
+                        };
+                        // Cleanup before returning
+                        if (minter !== initialMinter) {
+                            cleanup();
+                        }
+                        return { success: true, tokenInfo: tokenMeta, entry: null };
+                    }
+                }
+                else {
+                    // Minting failed - check if it's a retryable error
+                    const errorMessage = mintResult.mintingResult.message ||
+                        mintResult.mintingResult.error ||
+                        'Unknown minting error';
+                    // Check if this is a timeout or retryable error
+                    const isTimeout = errorMessage.toLowerCase().includes('timeout');
+                    const isNetworkError = errorMessage.toLowerCase().includes('network') ||
+                        errorMessage.toLowerCase().includes('connection') ||
+                        errorMessage.toLowerCase().includes('rpc') ||
+                        errorMessage.toLowerCase().includes('failed to connect');
+                    const isRetryable = isTimeout || isNetworkError;
+                    if (isRetryable && !nonInteractive && networkConfig) {
+                        // Display the error first
+                        console.log(`❌ ${errorMessage}`);
+                        console.log(`   Network: ${networkConfig.network}`);
+                        console.log(`   RPC URL: ${networkConfig.rpcUrls[currentRpcIndex] || 'unknown'}`);
+                        console.log(`   Contract: ${networkConfig.address}`);
+                        // Prompt user for action
+                        const action = await promptForMintingTimeoutAction(networkConfig, currentRpcIndex, nonInteractive);
+                        if (action === 'exit') {
+                            // User chose to exit - continue without token metadata
+                            if (minter !== initialMinter) {
+                                cleanup();
+                            }
+                            return { success: false };
+                        }
+                        else if (action === 'retry') {
+                            // Retry with same RPC
+                            retryCount++;
+                            if (retryCount >= maxRetries) {
+                                console.log(`\n❌ Maximum retries (${maxRetries}) reached for current RPC`);
+                                if (minter !== initialMinter) {
+                                    cleanup();
+                                }
+                                return { success: false };
+                            }
+                            console.log(`\n🔄 Retrying minting (attempt ${retryCount + 1}/${maxRetries})...`);
+                            continue;
+                        }
+                        else if (action === 'next-rpc') {
+                            // Try next RPC URL
+                            currentRpcIndex++;
+                            retryCount = 0; // Reset retry count for new RPC
+                            if (currentRpcIndex >= networkConfig.rpcUrls.length) {
+                                console.log('\n❌ No more RPC URLs available');
+                                if (minter !== initialMinter) {
+                                    cleanup();
+                                }
+                                return { success: false };
+                            }
+                            console.log(`\n🔄 Trying next RPC URL (${currentRpcIndex + 1}/${networkConfig.rpcUrls.length})...`);
+                            continue;
+                        }
+                    }
+                    else {
+                        // Not retryable or non-interactive - show error and return
+                        console.error(`❌ Token minting failed!`);
+                        if (mintResult.mintingResult.error) {
+                            console.error(`   Error: ${mintResult.mintingResult.error}`);
+                        }
+                        if (mintResult.mintingResult.message) {
+                            console.error(`   Message: ${mintResult.mintingResult.message}`);
+                        }
+                        if (minter !== initialMinter) {
+                            cleanup();
+                        }
+                        return { success: false };
+                    }
+                }
+            }
+            catch (error) {
+                // Handle unexpected errors
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                const isTimeout = errorMessage.toLowerCase().includes('timeout');
+                const isNetworkError = errorMessage.toLowerCase().includes('network') ||
+                    errorMessage.toLowerCase().includes('connection') ||
+                    errorMessage.toLowerCase().includes('rpc') ||
+                    errorMessage.toLowerCase().includes('failed to connect');
+                const isRetryable = isTimeout || isNetworkError;
+                if (isRetryable && !nonInteractive && networkConfig) {
+                    // Display the error first
+                    console.log(`❌ Minting error: ${errorMessage}`);
+                    console.log(`   Network: ${networkConfig.network}`);
+                    console.log(`   RPC URL: ${networkConfig.rpcUrls[currentRpcIndex] || 'unknown'}`);
+                    console.log(`   Contract: ${networkConfig.address}`);
+                    const action = await promptForMintingTimeoutAction(networkConfig, currentRpcIndex, nonInteractive);
+                    if (action === 'exit') {
+                        if (minter && minter !== initialMinter) {
+                            cleanup();
+                        }
+                        return { success: false };
+                    }
+                    else if (action === 'retry') {
+                        retryCount++;
+                        if (retryCount >= maxRetries) {
+                            if (minter && minter !== initialMinter) {
+                                cleanup();
+                            }
+                            return { success: false };
+                        }
+                        console.log(`\n🔄 Retrying minting (attempt ${retryCount + 1}/${maxRetries})...`);
+                        continue;
+                    }
+                    else if (action === 'next-rpc') {
+                        currentRpcIndex++;
+                        retryCount = 0;
+                        if (currentRpcIndex >= networkConfig.rpcUrls.length) {
+                            if (minter && minter !== initialMinter) {
+                                cleanup();
+                            }
+                            return { success: false };
+                        }
+                        console.log(`\n🔄 Trying next RPC URL (${currentRpcIndex + 1}/${networkConfig.rpcUrls.length})...`);
+                        continue;
+                    }
+                }
+                else {
+                    // Not retryable or non-interactive - show error and return
+                    console.error(`❌ Token minting error: ${errorMessage}`);
+                    if (error instanceof Error && error.stack && debug) {
+                        console.error(`   Stack trace: ${error.stack}`);
+                    }
+                    if (minter && minter !== initialMinter) {
+                        cleanup();
+                    }
+                    return { success: false };
+                }
+            }
+        }
+    }
+    finally {
+        // Ensure cleanup of any minter we created (but not the initial one)
+        if (minter && minter !== initialMinter) {
+            cleanup();
+        }
+    }
+    return { success: false };
+}
+//# sourceMappingURL=blockchain.js.map