neozip-cli 0.70.0-alpha

package/dist/src/neozip/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Type definitions for NeoZip CLI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/src/neozip/user-interaction.js

@@ -0,0 +1,256 @@
+"use strict";
+/**
+ * User interaction 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.readFilenamesFromStdin = readFilenamesFromStdin;
+exports.promptUser = promptUser;
+exports.promptPassword = promptPassword;
+exports.getUserTokenChoice = getUserTokenChoice;
+const readline = __importStar(require("readline"));
+/**
+ * Read filenames from stdin (one per line)
+ */
+async function readFilenamesFromStdin() {
+    return new Promise((resolve, reject) => {
+        const filenames = [];
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: false
+        });
+        rl.on('line', (line) => {
+            const filename = line.trim();
+            if (filename) {
+                filenames.push(filename);
+            }
+        });
+        rl.on('close', () => {
+            resolve(filenames);
+        });
+        rl.on('error', (error) => {
+            reject(error);
+        });
+        // Handle case where stdin is empty or closed immediately
+        process.stdin.on('end', () => {
+            rl.close();
+        });
+    });
+}
+/**
+ * Generic user prompt function
+ */
+async function promptUser(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+/**
+ * Prompt for password with masking
+ */
+async function promptPassword(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        let password = '';
+        // Check if setRawMode is available (not available in some environments)
+        if (process.stdin.setRawMode) {
+            process.stdout.write(question);
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.setEncoding('utf8');
+            process.stdin.on('data', (char) => {
+                const charStr = char.toString();
+                if (charStr === '\r' || charStr === '\n') {
+                    process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                    process.stdout.write('\n');
+                    rl.close();
+                    resolve(password);
+                }
+                else if (charStr === '\u0003') { // Ctrl+C
+                    process.exit(0);
+                }
+                else if (charStr === '\u007f') { // Backspace
+                    if (password.length > 0) {
+                        password = password.slice(0, -1);
+                        process.stdout.write('\b \b');
+                    }
+                }
+                else {
+                    password += charStr;
+                    process.stdout.write('*');
+                }
+            });
+        }
+        else {
+            // Fallback to regular readline if setRawMode is not available
+            rl.question(question, (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+        }
+    });
+}
+/**
+ * Get user's token choice from available options
+ */
+async function getUserTokenChoice(duplicateCheck) {
+    // Display owned tokens
+    if (duplicateCheck.userOwnedTokens.length > 0) {
+        console.log('\nYour tokens:');
+        duplicateCheck.userOwnedTokens.forEach((token, index) => {
+            console.log(`  ${index + 1}. Token ID ${token.tokenId}`);
+        });
+    }
+    // Display tokens owned by others
+    if (duplicateCheck.othersTokens.length > 0) {
+        console.log('\nTokens owned by others:');
+        duplicateCheck.othersTokens.forEach((token, index) => {
+            const shortOwner = `${token.owner.substring(0, 6)}...${token.owner.substring(38)}`;
+            console.log(`  ${duplicateCheck.userOwnedTokens.length + index + 1}. Token ID ${token.tokenId} (owned by ${shortOwner})`);
+        });
+    }
+    console.log('\nChoose an option:');
+    let optionNumber = 1;
+    const options = {};
+    // Option 1: Use earliest owned token (default if user owns exactly one)
+    if (duplicateCheck.userOwnedTokens.length === 1) {
+        console.log(`  ${optionNumber}. Use your token (ID ${duplicateCheck.userOwnedTokens[0].tokenId}) [DEFAULT]`);
+        options[optionNumber.toString()] = async () => {
+            return {
+                action: 'use-existing',
+                selectedToken: duplicateCheck.userOwnedTokens[0]
+            };
+        };
+        optionNumber++;
+    }
+    else if (duplicateCheck.userOwnedTokens.length > 1) {
+        console.log(`  ${optionNumber}. Use your earliest token (ID ${duplicateCheck.userOwnedTokens[0].tokenId}) [DEFAULT]`);
+        options[optionNumber.toString()] = async () => {
+            return {
+                action: 'use-existing',
+                selectedToken: duplicateCheck.userOwnedTokens[0]
+            };
+        };
+        optionNumber++;
+    }
+    // Option 2: Choose from all owned tokens (if more than one)
+    if (duplicateCheck.userOwnedTokens.length > 1) {
+        console.log(`  ${optionNumber}. Choose from your tokens`);
+        options[optionNumber.toString()] = async () => {
+            console.log('\nYour tokens:');
+            duplicateCheck.userOwnedTokens.forEach((token, index) => {
+                console.log(`  ${index + 1}. Token ID ${token.tokenId}`);
+            });
+            const tokenChoice = await promptUser('Enter token number: ');
+            const tokenIndex = parseInt(tokenChoice) - 1;
+            if (tokenIndex >= 0 && tokenIndex < duplicateCheck.userOwnedTokens.length) {
+                return {
+                    action: 'use-existing',
+                    selectedToken: duplicateCheck.userOwnedTokens[tokenIndex]
+                };
+            }
+            else {
+                console.log('❌ Invalid selection');
+                return { action: 'cancel' };
+            }
+        };
+        optionNumber++;
+    }
+    // Option 3: Choose from tokens owned by others (with warning)
+    if (duplicateCheck.othersTokens.length > 0) {
+        console.log(`  ${optionNumber}. Choose from tokens owned by others (⚠️  WARNING: You don't own these)`);
+        options[optionNumber.toString()] = async () => {
+            console.log('\n⚠️  WARNING: These tokens are owned by other users!');
+            console.log('Using someone else\'s token may have legal or ownership implications.');
+            console.log('\nAvailable tokens owned by others:');
+            duplicateCheck.othersTokens.forEach((token, index) => {
+                const shortOwner = `${token.owner.substring(0, 6)}...${token.owner.substring(38)}`;
+                console.log(`  ${index + 1}. Token ID ${token.tokenId} (owned by ${shortOwner})`);
+            });
+            const tokenChoice = await promptUser('Enter token number: ');
+            const tokenIndex = parseInt(tokenChoice) - 1;
+            if (tokenIndex >= 0 && tokenIndex < duplicateCheck.othersTokens.length) {
+                return {
+                    action: 'use-existing',
+                    selectedToken: duplicateCheck.othersTokens[tokenIndex]
+                };
+            }
+            else {
+                console.log('❌ Invalid selection');
+                return { action: 'cancel' };
+            }
+        };
+        optionNumber++;
+    }
+    // Option: Mint new token
+    console.log(`  ${optionNumber}. Mint a new token`);
+    options[optionNumber.toString()] = async () => {
+        return { action: 'mint-new' };
+    };
+    optionNumber++;
+    // Option: Skip tokenization
+    console.log(`  ${optionNumber}. Skip tokenization (create ZIP without token metadata)`);
+    options[optionNumber.toString()] = async () => {
+        return { action: 'skip-tokenization' };
+    };
+    optionNumber++;
+    // Option: Cancel
+    console.log(`  ${optionNumber}. Cancel`);
+    options[optionNumber.toString()] = async () => {
+        return { action: 'cancel' };
+    };
+    const choice = await promptUser('Enter your choice: ');
+    const selectedOption = options[choice];
+    if (selectedOption) {
+        return await selectedOption();
+    }
+    else {
+        console.log('❌ Invalid choice');
+        return { action: 'cancel' };
+    }
+}
+//# sourceMappingURL=user-interaction.js.map

package/dist/src/neozip/utils.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Utility functions for NeoZip CLI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBytes = formatBytes;
+exports.log = log;
+exports.logError = logError;
+exports.logDebug = logDebug;
+exports.convertLineEndings = convertLineEndings;
+exports.isTextFile = isTextFile;
+exports.getTempDir = getTempDir;
+/**
+ * Format bytes into human readable string
+ */
+function formatBytes(bytes) {
+    const units = ['B', 'KB', 'MB', 'GB'];
+    let i = 0;
+    let v = bytes;
+    while (v >= 1024 && i < units.length - 1) {
+        v /= 1024;
+        i++;
+    }
+    return `${v.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+/**
+ * Logging function that respects quiet mode
+ */
+function log(message, options = { verbose: false, quiet: false }) {
+    if (!options.quiet) {
+        console.log(message);
+    }
+}
+/**
+ * Error logging function (always shows errors)
+ */
+function logError(message) {
+    console.error(message);
+}
+/**
+ * Debug logging function (only shows in debug mode)
+ */
+function logDebug(message, options = { verbose: false, quiet: false }) {
+    if (options.debug && !options.quiet) {
+        console.log(`🐛 DEBUG: ${message}`);
+    }
+}
+/**
+ * Convert line endings in text content
+ */
+function convertLineEndings(content, options) {
+    if (!options.toCrlf && !options.fromCrlf) {
+        return content;
+    }
+    // Convert to string for line ending processing
+    let text = content.toString('utf8');
+    if (options.toCrlf) {
+        // Convert LF to CRLF (Unix to Windows)
+        text = text.replace(/\r?\n/g, '\r\n');
+    }
+    else if (options.fromCrlf) {
+        // Convert CRLF to LF (Windows to Unix)
+        text = text.replace(/\r\n/g, '\n');
+    }
+    return Buffer.from(text, 'utf8');
+}
+/**
+ * Check if a file is likely a text file based on extension
+ */
+function isTextFile(filename) {
+    const textExtensions = [
+        '.txt', '.md', '.json', '.js', '.ts', '.jsx', '.tsx', '.css', '.scss', '.sass', '.less',
+        '.html', '.htm', '.xml', '.yaml', '.yml', '.ini', '.cfg', '.conf', '.config',
+        '.py', '.rb', '.php', '.java', '.c', '.cpp', '.h', '.hpp', '.cs', '.go', '.rs',
+        '.sh', '.bash', '.zsh', '.fish', '.ps1', '.bat', '.cmd',
+        '.sql', '.r', '.m', '.pl', '.pm', '.t', '.pod',
+        '.log', '.diff', '.patch', '.gitignore', '.dockerignore',
+        '.env', '.properties', '.gradle', '.maven', '.pom',
+        '.dockerfile', '.makefile', '.cmake', '.ninja',
+        '.tex', '.rst', '.adoc', '.org', '.wiki'
+    ];
+    const ext = filename.toLowerCase().substring(filename.lastIndexOf('.'));
+    return textExtensions.includes(ext);
+}
+/**
+ * Get temporary directory for operations
+ */
+function getTempDir(options) {
+    if (options.tempPath) {
+        return options.tempPath;
+    }
+    // Use system temp directory
+    const os = require('os');
+    return os.tmpdir();
+}
+//# sourceMappingURL=utils.js.map