neozip-cli 0.80.0 → 0.95.0

package/dist/src/connection/wallet-setup.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WALLET_SETUP_HINT = void 0;
+exports.fetchServerLinkedWalletAddress = fetchServerLinkedWalletAddress;
+exports.validateWalletImportAgainstServer = validateWalletImportAgainstServer;
+exports.requireWalletPreconditions = requireWalletPreconditions;
+exports.requirePhonePreconditions = requirePhonePreconditions;
+exports.walletAlreadyConfigured = walletAlreadyConfigured;
+exports.saveImportedWallet = saveImportedWallet;
+exports.createLocalWalletIdentity = createLocalWalletIdentity;
+exports.importWalletFromMnemonic = importWalletFromMnemonic;
+exports.importWalletFromPrivateKey = importWalletFromPrivateKey;
+exports.activeWalletContext = activeWalletContext;
+const ethers_1 = require("ethers");
+const crypto_self_1 = require("../archive/crypto-self");
+const wallet_evm_1 = require("../account/wallet-evm");
+const store_1 = require("./store");
+const phone_1 = require("./phone");
+exports.WALLET_SETUP_HINT = "Configure a Data Wallet first: neozip connect wallet create --ack-backup, wallet import-mnemonic, or wallet import-key. Or use finish --create-wallet to generate one (no recovery phrase shown).";
+async function fetchServerLinkedWalletAddress(baseUrl, accessToken) {
+    const result = await (0, crypto_self_1.fetchCryptoSelf)({
+        tokenServiceAccessToken: accessToken,
+        tokenServiceUrl: baseUrl,
+    }, { serverUrl: baseUrl });
+    if (!result.ok)
+        return null;
+    try {
+        return (0, ethers_1.getAddress)(result.data.evmAddress);
+    }
+    catch {
+        return null;
+    }
+}
+async function validateWalletImportAgainstServer(input) {
+    if (input.force)
+        return;
+    const serverAddress = await fetchServerLinkedWalletAddress(input.origin, input.accessToken);
+    if (!serverAddress)
+        return;
+    const derived = (0, ethers_1.getAddress)(input.derivedAddress);
+    if (derived.toLowerCase() !== serverAddress.toLowerCase()) {
+        throw new Error(`Imported wallet (${derived}) differs from the wallet linked on Token Service (${serverAddress}). ` +
+            "Restore the correct recovery phrase or private key, or pass --force to replace the server wallet.");
+    }
+}
+function requireWalletPreconditions(conn, secrets) {
+    if (!secrets?.accessToken || !conn.emailVerified) {
+        throw new Error("Verify email first. Run neozip connect verify.");
+    }
+}
+async function requirePhonePreconditions(conn, origin) {
+    if (await (0, phone_1.needsPhoneVerification)(conn, origin)) {
+        throw new Error("Phone verification required. Run neozip connect phone request and phone verify.");
+    }
+}
+function walletAlreadyConfigured(conn, secrets) {
+    return Boolean(secrets?.evmPrivateKeyHex && conn.evmAddress);
+}
+async function saveImportedWallet(connectionId, evm) {
+    return (0, store_1.saveEvmWallet)(connectionId, evm.privateKey, evm.address);
+}
+function createLocalWalletIdentity() {
+    const evm = (0, wallet_evm_1.generateEvmIdentity)();
+    if (!evm.mnemonic) {
+        throw new Error("Failed to generate recovery phrase for new Data Wallet");
+    }
+    return evm;
+}
+function importWalletFromMnemonic(mnemonic) {
+    return (0, wallet_evm_1.evmIdentityFromMnemonic)(mnemonic);
+}
+function importWalletFromPrivateKey(privateKey) {
+    return (0, wallet_evm_1.evmIdentityFromPrivateKey)(privateKey);
+}
+function activeWalletContext() {
+    const conn = (0, store_1.getActiveConnection)();
+    const secrets = (0, store_1.readActiveConnectionSecrets)();
+    if (!conn || !secrets) {
+        throw new Error("No active connection. Run neozip connect first.");
+    }
+    return { conn, secrets, origin: conn.tokenServiceOrigin };
+}
+//# sourceMappingURL=wallet-setup.js.map

package/dist/src/constants/wallet-identity.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOKEN_SERVICE_RECIPIENT_IDENTITY_TYPE = exports.X25519_SPKI_PREFIX = exports.WRAP_IV_LEN = exports.WRAP_KDF_SALT_LEN = exports.WRAP_AEAD = exports.WRAP_KDF_INFO = exports.WRAP_FORMAT_VERSION = void 0;
+/** Wallet-encrypted X25519 identity key wrap format (Token Service API_IDENTITY.md). */
+exports.WRAP_FORMAT_VERSION = 1;
+exports.WRAP_KDF_INFO = "NeoZip/WalletEncIK/v1";
+exports.WRAP_AEAD = "AES-256-GCM";
+exports.WRAP_KDF_SALT_LEN = 32;
+exports.WRAP_IV_LEN = 12;
+/** SPKI-DER prefix for X25519 public keys (12 bytes). */
+exports.X25519_SPKI_PREFIX = Buffer.from("302a300506032b656e032100", "hex");
+/** neozipkit-pro identity type for Token Service email recipients. */
+exports.TOKEN_SERVICE_RECIPIENT_IDENTITY_TYPE = "zipstamp";
+//# sourceMappingURL=wallet-identity.js.map

package/dist/src/exit-codes.js

@@ -11,6 +11,7 @@ exports.exitZip = exitZip;
 exports.exitUnzip = exitUnzip;
 exports.exitZipinfo = exitZipinfo;
 exports.getExitCodeDescription = getExitCodeDescription;
+const output_1 = require("./cli/output");
 /**
  * Exit codes for NEOZIP application
  * Based on InfoZip ZIP exit codes
@@ -97,31 +98,74 @@ exports.ZIPINFO_EXIT_CODES = {
     OTS_VERIFY_FAILED: 89, // OpenTimestamp verification failed
 };
 /**
- * Helper function to exit with a ZIP exit code
+ * Reverse lookup: numeric exit code -> symbolic name, per application.
  */
-function exitZip(code, message) {
+function symbolicName(table, code) {
+    for (const [name, value] of Object.entries(table)) {
+        if (value === code)
+            return name;
+    }
+    return 'UNKNOWN_ERROR';
+}
+/**
+ * Suggested recovery command for an agent, keyed by symbolic error name.
+ * Only a subset of codes have a meaningful next step.
+ */
+const NEXT_COMMAND_HINTS = {
+    BLOCKCHAIN_CONFIG_ERROR: 'neozip connect',
+    TOKEN_MINT_FAILED: 'neozip connect status',
+    TOKEN_MINT_TIMEOUT: 'neozip upgrade <archive> --wait',
+    TOKEN_MINT_INSUFFICIENT_BALANCE: 'neozip connect status',
+    TOKEN_MINT_USER_CANCELLED: 'neozip connect status',
+    BAD_PASSWORD: 'neounzip -P <password> <archive>',
+    TOKEN_VERIFY_FAILED: 'neounzip --skip-blockchain <archive>',
+};
+/**
+ * Emit a structured JSON error (when in JSON mode) and exit.
+ *
+ * In text mode this preserves the original behavior: print the message to stderr
+ * and exit with the numeric code. In JSON mode a structured error object is
+ * written to stdout so callers can parse it, and the human message (if any) goes
+ * to stderr as a hint.
+ */
+function exitWithError(app, table, code, message) {
+    if ((0, output_1.isJsonOutput)()) {
+        const name = symbolicName(table, code);
+        const cleanMessage = (message ?? getExitCodeDescription(app, code)).replace(/^Error:\s*/i, '');
+        (0, output_1.emitError)({
+            app,
+            code: name,
+            exitCode: code,
+            message: cleanMessage,
+            ...(NEXT_COMMAND_HINTS[name] ? { nextCommand: NEXT_COMMAND_HINTS[name] } : {}),
+        });
+        if (message) {
+            console.error(message);
+        }
+        process.exit(code);
+    }
     if (message) {
         console.error(message);
     }
     process.exit(code);
 }
+/**
+ * Helper function to exit with a ZIP exit code
+ */
+function exitZip(code, message) {
+    return exitWithError('zip', exports.ZIP_EXIT_CODES, code, message);
+}
 /**
  * Helper function to exit with an UNZIP exit code
  */
 function exitUnzip(code, message) {
-    if (message) {
-        console.error(message);
-    }
-    process.exit(code);
+    return exitWithError('unzip', exports.UNZIP_EXIT_CODES, code, message);
 }
 /**
  * Helper function to exit with a ZIPINFO exit code
  */
 function exitZipinfo(code, message) {
-    if (message) {
-        console.error(message);
-    }
-    process.exit(code);
+    return exitWithError('zipinfo', exports.ZIPINFO_EXIT_CODES, code, message);
 }
 /**
  * Get exit code description for documentation

package/dist/src/neolist.js

@@ -49,11 +49,14 @@ const fs = __importStar(require("fs"));
 const node_1 = __importDefault(require("neozipkit/node"));
 const neozip_blockchain_1 = require("neozip-blockchain");
 const ots_1 = require("neozip-blockchain/ots");
-const zipstamp_server_1 = require("neozip-blockchain/zipstamp-server");
+const token_service_1 = require("neozip-blockchain/token-service");
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
 const version_1 = require("./version");
 const exit_codes_1 = require("./exit-codes");
+const output_1 = require("./cli/output");
+const params_1 = require("./cli/params");
+const validate_1 = require("./cli/validate");
 /**
  * Helper function to check if ZIP is file-based
  */
@@ -259,11 +262,11 @@ function formatEntryName(entry) {
     if (entry.filename === ots_1.TIMESTAMP_SUBMITTED) {
         return `${ots_1.TIMESTAMP_SUBMITTED} (OTS Pending)`;
     }
-    if (entry.filename === zipstamp_server_1.SUBMIT_METADATA) {
-        return `${zipstamp_server_1.SUBMIT_METADATA} (Zipstamp Pending)`;
+    if (entry.filename === token_service_1.SUBMIT_METADATA) {
+        return `${token_service_1.SUBMIT_METADATA} (Token Service Pending)`;
     }
-    if (entry.filename === zipstamp_server_1.TIMESTAMP_METADATA) {
-        return `${zipstamp_server_1.TIMESTAMP_METADATA} (Zipstamp Timestamp)`;
+    if (entry.filename === token_service_1.TIMESTAMP_METADATA) {
+        return `${token_service_1.TIMESTAMP_METADATA} (Token Service Timestamp)`;
     }
     return entry.filename;
 }
@@ -461,8 +464,11 @@ function outputVerbose(entries, archivePath, zip, options = { verbose: false, qu
     entries.forEach((entry, index) => {
         // Use ZipEntry's showVerboseInfo() method for detailed information
         log(`File ${index + 1}: ${formatEntryName(entry)}`, options);
-        // Call showVerboseInfo() directly - it will output to console
         entry.showVerboseInfo();
+        if (entry.isEncrypted) {
+            const method = entry.aesVersion > 0 ? 'AES-256' : 'PKZIP';
+            log(`  Encryption method: ${method}`, options);
+        }
         log('', options);
     });
     // Summary
@@ -715,6 +721,9 @@ function outputJson(entries, archivePath, zip, options = { verbose: false, quiet
             if (entry.isStrongEncrypt !== undefined) {
                 fileInfo.isStrongEncrypt = entry.isStrongEncrypt;
             }
+            if (entry.isEncrypted) {
+                fileInfo.encryptionMethod = entry.aesVersion > 0 ? 'AES-256' : 'PKZIP';
+            }
             // Add symbolic link information if present
             if (entry.isSymlink !== undefined) {
                 fileInfo.isSymlink = entry.isSymlink;
@@ -833,6 +842,44 @@ function parseArgs(args) {
             case '--json':
                 options.json = true;
                 break;
+            case '--format': {
+                const value = args[++i];
+                if (value === 'json') {
+                    options.json = true;
+                }
+                else if (value !== 'text') {
+                    console.error("Error: --format must be 'json' or 'text'");
+                    showHelp();
+                    (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.INVALID_OPTIONS);
+                }
+                break;
+            }
+            case '--params': {
+                const value = args[++i];
+                if (value === undefined) {
+                    console.error("Error: --params requires a JSON value (or '-' for stdin)");
+                    (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.INVALID_OPTIONS);
+                }
+                try {
+                    const params = (0, params_1.parseJsonObjectArg)(value, '--params');
+                    const allowed = [
+                        'verbose', 'quiet', 'json', 'short', 'unix', 'basic', 'include', 'exclude',
+                        'sortBy', 'noComments', 'debug', 'inMemory',
+                    ];
+                    for (const key of allowed) {
+                        if (key in params) {
+                            options[key] = params[key];
+                        }
+                    }
+                }
+                catch (err) {
+                    if (err instanceof validate_1.ValidationError) {
+                        (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.INVALID_OPTIONS, `Error: ${err.message}`);
+                    }
+                    throw err;
+                }
+                break;
+            }
             case '-s':
             case '--short':
                 options.short = true;
@@ -908,7 +955,39 @@ function parseArgs(args) {
                 options.inMemory = true;
                 break;
             default:
-                if (arg.startsWith('-')) {
+                if (arg.startsWith('--format=')) {
+                    const value = arg.slice('--format='.length);
+                    if (value === 'json') {
+                        options.json = true;
+                    }
+                    else if (value !== 'text') {
+                        console.error("Error: --format must be 'json' or 'text'");
+                        showHelp();
+                        (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.INVALID_OPTIONS);
+                    }
+                }
+                else if (arg.startsWith('--params=')) {
+                    const value = arg.slice('--params='.length);
+                    try {
+                        const params = (0, params_1.parseJsonObjectArg)(value, '--params');
+                        const allowed = [
+                            'verbose', 'quiet', 'json', 'short', 'unix', 'basic', 'include', 'exclude',
+                            'sortBy', 'noComments', 'debug', 'inMemory',
+                        ];
+                        for (const key of allowed) {
+                            if (key in params) {
+                                options[key] = params[key];
+                            }
+                        }
+                    }
+                    catch (err) {
+                        if (err instanceof validate_1.ValidationError) {
+                            (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.INVALID_OPTIONS, `Error: ${err.message}`);
+                        }
+                        throw err;
+                    }
+                }
+                else if (arg.startsWith('-')) {
                     console.error(`Error: Unknown option ${arg}`);
                     showHelp();
                     (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.INVALID_OPTIONS);
@@ -934,6 +1013,8 @@ function parseArgs(args) {
  * Show help information
  */
 function showHelp() {
+    if ((0, output_1.isJsonOutput)())
+        return;
     console.log(`
 NeoList Version: ${version_1.APP_VERSION} (${version_1.APP_RELEASE_DATE})
 
@@ -944,7 +1025,9 @@ Options:
   -V, --version       Show version information
   -v, --verbose       Detailed central directory information
   -q, --quiet         Suppress output
-  -j, --json          Output in JSON format
+  -j, --json          Output in JSON format (alias for --format json)
+      --format <fmt>  Output format: text (default) or json (machine-readable)
+      --params <json> Provide options as a JSON object (agent input; '-' = stdin)
   -s, --short         Short output (names only)
   -u, --unix          Unix-style output
   -b, --basic         Basic table output
@@ -972,6 +1055,8 @@ Examples:
  * Show extended help information (equivalent to InfoZip's -h2)
  */
 function showExtendedHelp() {
+    if ((0, output_1.isJsonOutput)())
+        return;
     console.log('Extended Help for NeoList');
     console.log('');
     console.log('NeoList is a next-generation ZIP listing utility that builds upon the strengths');
@@ -1089,6 +1174,11 @@ async function main() {
     try {
         // Parse command line arguments
         const args = process.argv.slice(2);
+        // Resolve machine-readable output mode early so error exits are structured.
+        // neolist's legacy -j/--json flag and the shared --format json both select JSON.
+        if (args.includes('-j') || args.includes('--json') || (0, output_1.detectOutputFormat)(args) === 'json') {
+            (0, output_1.setOutputFormat)('json');
+        }
         const parsed = parseArgs(args);
         const { archive } = parsed;
         options = parsed.options;
@@ -1143,8 +1233,8 @@ async function main() {
             // Default is now the unzip -v format (verbose table)
             outputTable(entries, archive, true, zip, options);
         }
-        // Don't show success message for filenames-only modes
-        if (!options.opt1 && !options.opt2 && !options.optT) {
+        // Don't show success message for filenames-only modes or JSON output
+        if (!options.opt1 && !options.opt2 && !options.optT && !options.json) {
             log('✓ NeoList completed successfully', options);
         }
         // Close file handle if file-based ZIP was loaded