neozip-cli 0.80.0 → 0.95.0

package/dist/src/neozip/upgradeZip.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Upgrade Zipstamp timestamp from pending (TS-SUBMIT.NZIP) to confirmed (TIMESTAMP.NZIP)
+ * Upgrade Token Service timestamp from pending (TS-SUBMIT.NZIP) to confirmed (TIMESTAMP.NZIP)
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -45,15 +45,16 @@ const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const node_1 = __importDefault(require("neozipkit/node"));
 const node_2 = require("neozipkit/node");
-const zipstamp_server_1 = require("neozip-blockchain/zipstamp-server");
+const token_service_1 = require("neozip-blockchain/token-service");
 const exit_codes_1 = require("../exit-codes");
+const bootstrap_1 = require("../connection/bootstrap");
 /**
  * Extract timestamp metadata from a ZIP entry.
  * Tries the library's extractTimestampData first; if it fails (e.g. file-based ZIP),
  * fall back to extracting to a temp file and parsing JSON.
  */
 async function extractTimestampMetadata(zip, entry) {
-    let metadata = await (0, zipstamp_server_1.extractTimestampData)(zip, entry);
+    let metadata = await (0, token_service_1.extractTimestampData)(zip, entry);
     if (metadata)
         return metadata;
     // Fallback for file-based ZIPs where zip.extract() may not work
@@ -74,7 +75,7 @@ async function extractTimestampMetadata(zip, entry) {
     }
 }
 /**
- * Upgrade a ZIP file with pending Zipstamp timestamp to confirmed status.
+ * Upgrade a ZIP file with pending Token Service timestamp to confirmed status.
  * Replaces TS-SUBMIT.NZIP with TIMESTAMP.NZIP when the batch is confirmed on the blockchain.
  */
 async function upgradeZipForTimestamp(inputPath, outputPath, options = {}) {
@@ -85,9 +86,9 @@ async function upgradeZipForTimestamp(inputPath, outputPath, options = {}) {
     const zip = new node_1.default();
     await zip.loadZipFile(inputPath);
     const entries = zip.getDirectory() || [];
-    const metadataResult = (0, zipstamp_server_1.findMetadataEntry)(entries);
+    const metadataResult = (0, token_service_1.findMetadataEntry)(entries);
     if (!metadataResult) {
-        console.log('No Zipstamp timestamp found in ZIP file');
+        console.log('No Token Service timestamp found in ZIP file');
         return;
     }
     if (metadataResult.type === 'confirmed') {
@@ -98,21 +99,23 @@ async function upgradeZipForTimestamp(inputPath, outputPath, options = {}) {
     if (!metadata || !metadata.digest) {
         (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT, 'Error: Failed to extract timestamp metadata');
     }
-    if (!(0, zipstamp_server_1.shouldUpgrade)(metadata, metadataResult.type)) {
+    if (!(0, token_service_1.shouldUpgrade)(metadata, metadataResult.type)) {
         console.log('✓ Timestamp does not need upgrade');
         return;
     }
     const digest = metadata.digest;
     const chainId = metadata.chainId && metadata.chainId > 0 ? metadata.chainId : undefined;
     const batchId = metadata.batchId ?? undefined;
+    const serverUrl = (0, bootstrap_1.resolveVerifyServerUrl)(metadata.serverUrl);
+    const verifyOpts = { debug, serverUrl };
     let verified = null;
     if (wait) {
         if (verbose || debug)
             console.log('Polling for confirmation (--wait)...');
-        verified = await (0, zipstamp_server_1.pollForConfirmation)(digest, chainId, batchId, 300000, 5000, { debug });
+        verified = await (0, token_service_1.pollForConfirmation)(digest, chainId, batchId, 300000, 5000, verifyOpts);
     }
     else {
-        const verifyRes = await (0, zipstamp_server_1.verifyDigest)(digest, chainId, batchId, undefined, { debug });
+        const verifyRes = await (0, token_service_1.verifyDigest)(digest, chainId, batchId, undefined, verifyOpts);
         if (verifyRes.verified) {
             verified = verifyRes;
         }
@@ -135,7 +138,7 @@ async function upgradeZipForTimestamp(inputPath, outputPath, options = {}) {
         blockNumber: verified.blockNumber ?? metadata.blockNumber,
         timestamp: verified.timestamp ?? metadata.timestamp
     };
-    const metadataFiles = (0, zipstamp_server_1.getMetadataFileNames)();
+    const metadataFiles = (0, token_service_1.getMetadataFileNames)();
     const outPath = outputPath ?? inputPath.replace(/(\.nzip|\.zip)$/i, '-upgrade$1');
     const tempDir = path.dirname(outPath) || '.';
     const tempPath = path.join(tempDir, `.neozip-upgrade-${Date.now()}.tmp`);
@@ -144,7 +147,7 @@ async function upgradeZipForTimestamp(inputPath, outputPath, options = {}) {
         const { destPath, dataEndOffset, copiedEntries } = await zipCopy.copyZipEntriesOnly(inputPath, tempPath, {
             entryFilter: (entry) => !metadataFiles.includes(entry.filename || '')
         });
-        const newEntry = (0, zipstamp_server_1.createTimestampMetadataEntry)(zip, confirmedMetadata);
+        const newEntry = (0, token_service_1.createTimestampMetadataEntry)(zip, confirmedMetadata);
         if (!newEntry) {
             throw new Error('Failed to create timestamp metadata entry');
         }

package/dist/src/neozip.js

@@ -4,11 +4,7 @@
  * 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
+ * Configuration: neozip connect (alias: neozip init) — Token Service account + wallet
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -56,11 +52,13 @@ 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');
+// quiet: true suppresses dotenv's startup banner so it never pollutes
+// machine-readable JSON written to stdout.
 if (fs.existsSync(envLocalPath)) {
-    dotenv.config({ path: envLocalPath });
+    dotenv.config({ path: envLocalPath, quiet: true });
 }
 else if (fs.existsSync(envPath)) {
-    dotenv.config({ path: envPath });
+    dotenv.config({ path: envPath, quiet: true });
 }
 const utils_1 = require("./neozip/utils");
 const user_interaction_1 = require("./neozip/user-interaction");
@@ -68,8 +66,13 @@ 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 neozip_blockchain_1 = require("neozip-blockchain");
-const ConfigStore_1 = require("./config/ConfigStore");
+const bootstrap_1 = require("./connection/bootstrap");
+const cli_prefs_1 = require("./connection/cli-prefs");
 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");
+const schema_1 = require("./cli/schema");
 const version_1 = require("./version");
 /**
  * Resolve dynamic import path so ts-node loads .ts and compiled dist loads .js
@@ -80,10 +83,49 @@ function resolveScriptPath(jsPath) {
     }
     return jsPath;
 }
+/**
+ * Map an agent-supplied `--params` object onto ZipOptions (whitelisted keys).
+ */
+function zipParamsToOptions(params) {
+    const allowed = [
+        'verbose', 'quiet', 'level', 'blockchain', 'blockchainOts', 'blockchainTokenService',
+        'blockchainDefault', 'blockchainMint', 'network', 'walletPasskey', 'walletKey',
+        'compression', 'blockSize', 'encrypt', 'password', 'encryptionMethod', 'exclude',
+        'include', 'inMemory', 'recurse', 'junkPaths', 'update', 'freshen', 'move',
+        'archiveComment', 'commentFile', 'suffixes', 'debug', 'showFiles', 'toCrlf',
+        'fromCrlf', 'preservePerms', 'symlinks', 'hardLinks', 'oldTimestamp', 'tempPath',
+        'testIntegrity', 'nonInteractive', 'legacy', 'dryRun',
+    ];
+    const out = {};
+    for (const key of allowed) {
+        if (key in params) {
+            out[key] = params[key];
+        }
+    }
+    return out;
+}
+/**
+ * Map an agent-supplied `--json` payload onto seed positional args.
+ */
+function zipPayloadToSeed(payload) {
+    const seed = {};
+    if (typeof payload.archive === 'string')
+        seed.archive = payload.archive;
+    if (Array.isArray(payload.files))
+        seed.files = payload.files.map(String);
+    const options = {};
+    if (Array.isArray(payload.include))
+        options.include = payload.include.map(String);
+    if (Array.isArray(payload.exclude))
+        options.exclude = payload.exclude.map(String);
+    if (Object.keys(options).length > 0)
+        seed.options = options;
+    return seed;
+}
 /**
  * Parse command line arguments
  */
-function parseArgs(args) {
+function parseArgs(args, seed) {
     const options = {
         verbose: false,
         quiet: false,
@@ -93,8 +135,7 @@ function parseArgs(args) {
         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,
-        timestampEmail: process.env.NEOZIP_TIMESTAMP_EMAIL,
+        walletPasskey: undefined,
         compression: 'zstd',
         blockSize: 128 * 1024, // 128KB default
         enableProgress: true,
@@ -103,10 +144,12 @@ function parseArgs(args) {
         freshen: false,
         move: false,
         interactiveComments: false,
-        walletKey: undefined
+        walletKey: undefined,
+        // Seed from agent --params/--json first; explicit CLI flags below override.
+        ...(seed?.options ?? {}),
     };
-    const files = [];
-    let archive = '';
+    const files = seed?.files ? [...seed.files] : [];
+    let archive = seed?.archive ?? '';
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         switch (arg) {
@@ -180,14 +223,7 @@ function parseArgs(args) {
                 break;
             case '-ts':
             case '--timestamp':
-                options.blockchainZipstamp = true;
-                break;
-            case '--timestamp-email':
-                options.timestampEmail = args[++i];
-                if (!options.timestampEmail) {
-                    console.error('Error: --timestamp-email requires an email address');
-                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
-                }
+                options.blockchainTokenService = true;
                 break;
             case '-bt':
             case '--blockchain-token':
@@ -260,45 +296,45 @@ function parseArgs(args) {
                 break;
             case '-e':
             case '--encrypt':
-                // InfoZip-compatible encryption option
                 options.encrypt = true;
-                // Only set encryption method if not already set
                 if (!options.encryptionMethod) {
-                    options.encryptionMethod = 'pkzip'; // Default to PKZIP (InfoZip compatible)
+                    options.encryptionMethod = 'aes256';
                 }
-                // Only prompt for password if not already provided
                 if (!options.password) {
-                    options.password = 'PROMPT'; // Will prompt for password
+                    options.password = 'PROMPT';
                 }
                 break;
             case '-P':
             case '--password':
-                // InfoZip-compatible password option (uppercase P)
                 options.encrypt = true;
-                // Only set encryption method if not already set (e.g., by --pkzip-encrypt)
                 if (!options.encryptionMethod) {
-                    options.encryptionMethod = 'pkzip'; // Default to PKZIP
+                    options.encryptionMethod = 'aes256';
                 }
                 if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
-                    // Password provided directly
                     options.password = args[++i];
                 }
                 else {
-                    // No password provided, will prompt later
                     options.password = 'PROMPT';
                 }
                 break;
             case '-p':
             case '--show-progress':
-                // InfoZip-compatible show-progress option (lowercase p)
                 options.showFiles = true;
                 break;
+            case '--aes256':
+            case '--aes-256':
+                options.encrypt = true;
+                options.encryptionMethod = 'aes256';
+                if (!options.password) {
+                    options.password = 'PROMPT';
+                }
+                break;
+            case '--pkzip':
             case '--pkzip-encrypt':
                 options.encrypt = true;
                 options.encryptionMethod = 'pkzip';
-                // Only prompt for password if not already provided
                 if (!options.password) {
-                    options.password = 'PROMPT'; // Will prompt for password
+                    options.password = 'PROMPT';
                 }
                 break;
             case '-x':
@@ -414,6 +450,12 @@ function parseArgs(args) {
             case '--overwrite':
                 options.overwrite = true;
                 break;
+            case '--legacy':
+                options.legacy = true;
+                break;
+            case '--dry-run':
+                options.dryRun = true;
+                break;
             case '-@':
                 options.stdinFilenames = true;
                 break;
@@ -432,12 +474,34 @@ function parseArgs(args) {
                 break;
         }
     }
-    // -ots and -ts are mutually exclusive (choose Bitcoin OTS or Zipstamp)
-    if (options.blockchainOts && options.blockchainZipstamp) {
-        console.error('Error: Cannot use both -ots (OpenTimestamps) and -ts (Zipstamp) in the same run');
-        console.error('   Use -ots for Bitcoin timestamping or -ts for Zipstamp timestamping');
+    // -ots and -ts are mutually exclusive (choose Bitcoin OTS or Token Service)
+    if (options.blockchainOts && options.blockchainTokenService) {
+        console.error('Error: Cannot use both -ots (OpenTimestamps) and -ts (Token Service) in the same run');
+        console.error('   Use -ts for Token Service timestamping or -ots for Bitcoin timestamping');
         (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
     }
+    // --legacy: produce an InfoZip/PKZIP-compatible archive.
+    if (options.legacy) {
+        if (options.blockchain ||
+            options.blockchainOts ||
+            options.blockchainTokenService ||
+            options.blockchainMint ||
+            options.blockchainDefault ||
+            options.upgrade) {
+            (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR, 'Error: --legacy cannot be combined with blockchain features (-b, -bd, -bm, -ots, -ts, --upgrade)');
+        }
+        // Force standard deflate (or store at level 0); zstd is not InfoZip-compatible.
+        if (options.compression !== 'deflate') {
+            options.compression = 'deflate';
+        }
+        // AES-256 is not readable by stock InfoZip unzip; fall back to PKZIP.
+        if (options.encrypt && options.encryptionMethod !== 'pkzip') {
+            if (!(0, output_1.isJsonOutput)()) {
+                console.error('Warning: --legacy forces PKZIP encryption (AES-256 is not InfoZip-compatible)');
+            }
+            options.encryptionMethod = 'pkzip';
+        }
+    }
     if (!archive) {
         console.error('Error: Archive name is required');
         showHelp();
@@ -457,6 +521,16 @@ function parseArgs(args) {
             archive = archive + '.nzip';
         }
     }
+    // Input hardening: reject control characters / dangerous Unicode in the name.
+    try {
+        (0, validate_1.assertSafeArchiveName)(archive);
+    }
+    catch (err) {
+        if (err instanceof validate_1.ValidationError) {
+            (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR, `Error: ${err.message}`);
+        }
+        throw err;
+    }
     // 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');
@@ -469,17 +543,20 @@ function parseArgs(args) {
  * Show help information
  */
 function showHelp() {
+    // In JSON mode, never print human help to stdout (keeps stdout pure JSON).
+    if ((0, output_1.isJsonOutput)())
+        return;
     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)
-  neozip upgrade <archive> [output] [--wait]  Upgrade pending Zipstamp timestamp to confirmed
+  neozip connect [subcommand]  Token Service account setup (alias: neozip init)
+  neozip config                Connection dashboard (status, prefs, migrate)
+  neozip skills [subcommand]   Install bundled Agent Skills for Claude/Cursor
+  neozip upgrade <archive> [output] [--wait]  Upgrade pending Token Service timestamp to confirmed
   neozip mint <archive> [output]  Mint TimestampProofNFT from confirmed timestamped ZIP
-  neozip verify-email [--email <email>] [--set-default]  Configure email for Zipstamp timestamping
 
 Options:
   -h, --help              Show this help message
@@ -500,6 +577,12 @@ Options:
       --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)
+      --legacy            Create an InfoZip/PKZIP-compatible archive (deflate/store + PKZIP,
+                          no blockchain/zstd; readable by stock unzip)
+      --dry-run           Show what would be created without writing the archive
+      --format <fmt>      Output format: text (default) or json (machine-readable)
+      --params <json>     Provide options as a JSON object (agent input; '-' = stdin)
+      --json <json>       Provide payload {archive, files, include, exclude} as JSON ('-' = stdin)
   -@                      Read file names from stdin (one per line)
   -0                      Store only (no compression)
   -1 to -9                Compression level (1=fastest, 9=best, default: 6)
@@ -508,10 +591,9 @@ Options:
   -bd, --blockchain-default Auto-select default token option (use existing or mint new)
   -bm, --blockchain-mint  Force mint new token (skip existing token selection)
   -ots, --opentimestamp   Enable OpenTimestamp proof on Bitcoin blockchain
-  -ts, --timestamp       Enable Zipstamp timestamp (blockchain)
-      --timestamp-email <email>  Email for Zipstamp server (some servers require verified email)
+  -ts, --timestamp       Enable Token Service timestamp (blockchain; requires neozip connect)
   -n, --network <network> Blockchain network (base-sepolia, base-mainnet, default: base-sepolia)
-  -w, --wallet-key <key>  Wallet private key (overrides NEOZIP_WALLET_PASSKEY)
+  -w, --wallet-key <key>  Wallet private key (one-off override; default: connection store)
   -c                      Add one-line comments for files
       --compression <alg> Compression algorithm (zstd, deflate, default: zstd)
       --deflate           Use deflate compression (same as --compression deflate)
@@ -519,10 +601,11 @@ Options:
       --block-size <bytes> Block size for streaming (default: 131072)
       --no-progress       Disable progress reporting
       --progress          Enable enhanced progress reporting
-  -e, --encrypt           Encrypt files (InfoZip-compatible). Will prompt for password
-  -P, --password [pwd]    Encrypt files with password (InfoZip-compatible). Provide password or will prompt
+  -e, --encrypt           Encrypt files with AES-256 (default). Will prompt for password
+  -P, --password [pwd]    Encrypt files with password. Provide password or will prompt
+      --aes256            Use AES-256 encryption (default, recommended)
+      --pkzip, --pkzip-encrypt  Use legacy PKZIP encryption (weak, for compatibility only)
   -p, --show-progress     Show progress during compression (InfoZip-compatible)
-      --pkzip-encrypt     Use PKZIP encryption (legacy compatibility only, same as -e)
   -x, --exclude <pattern> Exclude files matching pattern (can be used multiple times)
   -i, --include <pattern> Include only files matching pattern (can be used multiple times)
       --suffixes <list>   Don't compress files with these suffixes (can be used multiple times)
@@ -550,6 +633,8 @@ Examples:
  * Show extended help information (equivalent to InfoZip's -h2)
  */
 function showExtendedHelp() {
+    if ((0, output_1.isJsonOutput)())
+        return;
     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');
@@ -650,12 +735,23 @@ function showExtendedHelp() {
     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('  -bd, --blockchain-default  auto-select default token option');
+    console.log('  -bm, --blockchain-mint  force mint a new token');
+    console.log('  -ots, --opentimestamp   add an OpenTimestamps (Bitcoin) proof');
+    console.log('  -ts, --timestamp        add a Token Service timestamp (requires neozip connect)');
+    console.log('  -n, --network <network> specify blockchain network (base-sepolia, base-mainnet, etc.)');
+    console.log('  -w, --wallet-key <key>  one-off wallet private key (default: connection store)');
+    console.log('');
+    console.log('Legacy / InfoZip compatibility:');
+    console.log('  --legacy   create a standard ZIP readable by stock InfoZip unzip');
+    console.log('             (forces deflate/store + PKZIP, disables zstd and blockchain extensions)');
+    console.log('');
+    console.log('Agent / automation:');
+    console.log('  --format json   emit a machine-readable JSON result on stdout');
+    console.log('  --params <json> supply options as a JSON object ("-" reads stdin)');
+    console.log('  --json <json>   supply payload {archive, files, include, exclude} ("-" reads stdin)');
+    console.log('  --dry-run       resolve and print the plan without writing');
+    console.log('  neozip schema neozip   print the machine-readable command schema');
     console.log('');
     console.log('Testing archives:');
     console.log('  -T        test completed archive with neounzip before finalizing');
@@ -695,49 +791,56 @@ function showExtendedHelp() {
  */
 async function main() {
     try {
+        (0, bootstrap_1.bootstrapConnectionContext)();
         // Parse command line arguments
         const args = process.argv.slice(2);
+        // Resolve machine-readable output mode early so error exits are structured.
+        (0, output_1.setOutputFormat)((0, output_1.detectOutputFormat)(args));
         // Handle configuration commands first
         if (args.length > 0) {
             const command = args[0];
-            // Handle `neozip init` - interactive setup wizard
+            // `neozip schema <command>` — machine-readable command introspection
+            if (command === 'schema') {
+                const code = (0, schema_1.handleSchemaCommand)(args.slice(1));
+                process.exit(code);
+            }
+            // `neozip init` is an alias for `neozip connect`
             if (command === 'init') {
-                // Lazy-load ConfigSetup only when needed
-                const { ConfigSetup } = await import(resolveScriptPath('./config/ConfigSetup.js'));
-                const wizard = new ConfigSetup();
-                const success = await wizard.run();
-                process.exit(success ? exit_codes_1.ZIP_EXIT_CODES.SUCCESS : exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT);
+                console.error('Note: neozip init is an alias for neozip connect.\n');
+                const { runConnectCommand } = await import(resolveScriptPath('./connect/command.js'));
+                const code = await runConnectCommand([]);
+                process.exit(code === 0 ? exit_codes_1.ZIP_EXIT_CODES.SUCCESS : exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT);
             }
-            // Handle `neozip config` - show interactive menu
+            // Handle `neozip config` — connection dashboard
             if (command === 'config') {
-                // Lazy-load ConfigSetup only when needed
                 const { ConfigSetup } = await import(resolveScriptPath('./config/ConfigSetup.js'));
                 await ConfigSetup.showAndManage();
-                // showAndManage handles its own exit
             }
-            // Handle `neozip verify-email` - configure email for Zipstamp timestamping
-            if (command === 'verify-email') {
-                const verifyArgs = args.slice(1);
-                let email;
-                let setDefaultOnly = false;
-                let debug = false;
-                for (let i = 0; i < verifyArgs.length; i++) {
-                    const arg = verifyArgs[i];
-                    if (arg === '--email' && verifyArgs[i + 1]) {
-                        email = verifyArgs[++i];
-                    }
-                    else if (arg === '--set-default') {
-                        setDefaultOnly = true;
-                    }
-                    else if (arg === '--debug') {
-                        debug = true;
-                    }
+            // Handle `neozip connect` — Token Service account setup
+            if (command === 'connect') {
+                const { runConnectCommand, connectUsage } = await import(resolveScriptPath('./connect/command.js'));
+                const connectArgv = args.slice(1);
+                if (connectArgv.length === 1 && (connectArgv[0] === '--help' || connectArgv[0] === '-h')) {
+                    connectUsage();
+                    process.exit(exit_codes_1.ZIP_EXIT_CODES.SUCCESS);
                 }
-                const { runVerifyEmail } = await import(resolveScriptPath('./commands/verifyEmail.js'));
-                const success = await runVerifyEmail({ email, setDefaultOnly, debug });
-                process.exit(success ? exit_codes_1.ZIP_EXIT_CODES.SUCCESS : exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT);
+                const code = await runConnectCommand(connectArgv);
+                process.exit(code === 0 ? exit_codes_1.ZIP_EXIT_CODES.SUCCESS : exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT);
+            }
+            // Handle `neozip skills` — install bundled Agent Skills
+            if (command === 'skills') {
+                const { runSkillsCommand, skillsUsage } = await import(resolveScriptPath('./skills/command.js'));
+                const skillsArgv = args.slice(1);
+                if (skillsArgv.length === 0 ||
+                    skillsArgv.includes('--help') ||
+                    skillsArgv.includes('-h')) {
+                    skillsUsage();
+                    process.exit(exit_codes_1.ZIP_EXIT_CODES.SUCCESS);
+                }
+                const code = runSkillsCommand(skillsArgv);
+                process.exit(code === 0 ? exit_codes_1.ZIP_EXIT_CODES.SUCCESS : exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
             }
-            // Handle `neozip upgrade` - upgrade pending Zipstamp timestamp to confirmed
+            // Handle `neozip upgrade` - upgrade pending Token Service timestamp to confirmed
             if (command === 'upgrade') {
                 const upgradeArgs = args.slice(1);
                 let inputPath = '';
@@ -819,14 +922,30 @@ async function main() {
                 process.exit(success ? exit_codes_1.ZIP_EXIT_CODES.SUCCESS : exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT);
             }
         }
-        let { archive, files, options } = parseArgs(args);
-        // If network not explicitly provided via CLI, use from ConfigStore (which reads from ENV or wallet.json)
+        // Extract agent input (--params/--json) and strip the --format flag, then
+        // parse the remaining argv. Seed values are overridden by explicit flags.
+        const agent = (0, params_1.extractAgentInput)((0, output_1.stripFormatFlag)(args));
+        const seed = {};
+        if (agent.params)
+            seed.options = zipParamsToOptions(agent.params);
+        if (agent.payload) {
+            const payloadSeed = zipPayloadToSeed(agent.payload);
+            if (payloadSeed.archive)
+                seed.archive = payloadSeed.archive;
+            if (payloadSeed.files)
+                seed.files = payloadSeed.files;
+            if (payloadSeed.options) {
+                seed.options = { ...(seed.options ?? {}), ...payloadSeed.options };
+            }
+        }
+        let { archive, files, options } = parseArgs(agent.argv, seed);
+        // In JSON mode, suppress decorative human logs so stdout stays pure JSON.
+        if ((0, output_1.isJsonOutput)()) {
+            options.quiet = true;
+        }
         const networkProvidedViaCLI = args.includes('--network') || args.includes('-n');
         if (!networkProvidedViaCLI) {
-            const config = ConfigStore_1.ConfigStore.getConfig();
-            if (config.network) {
-                options.network = config.network;
-            }
+            options.network = (0, cli_prefs_1.resolveNetwork)(options.network);
         }
         // Handle stdin filenames
         if (options.stdinFilenames) {
@@ -852,6 +971,41 @@ async function main() {
                 (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
             }
         }
+        // Dry-run: resolve and report the plan without writing anything.
+        if (options.dryRun) {
+            const action = options.delete ? 'delete' : options.upgrade ? 'upgrade' : 'create';
+            const plan = {
+                command: 'neozip',
+                action,
+                dryRun: true,
+                archive,
+                files: options.delete ? undefined : files,
+                deleteFiles: options.delete ? files : undefined,
+                legacy: !!options.legacy,
+                resolvedOptions: {
+                    level: options.level,
+                    compression: options.level === 0 ? 'store' : options.compression,
+                    encrypt: !!options.encrypt,
+                    encryptionMethod: options.encrypt ? options.encryptionMethod : undefined,
+                    blockchain: !!options.blockchain,
+                    blockchainOts: !!options.blockchainOts,
+                    blockchainTokenService: !!options.blockchainTokenService,
+                    network: options.network,
+                    recurse: !!options.recurse,
+                    junkPaths: !!options.junkPaths,
+                    include: options.include,
+                    exclude: options.exclude,
+                },
+            };
+            if ((0, output_1.isJsonOutput)()) {
+                (0, output_1.emitResult)(plan);
+            }
+            else {
+                console.log('Dry run — no archive will be written.');
+                console.log(JSON.stringify(plan, null, 2));
+            }
+            process.exit(exit_codes_1.ZIP_EXIT_CODES.SUCCESS);
+        }
         // Handle upgrade operation
         if (options.upgrade) {
             // Validate: upgrade requires exactly one argument (the ZIP file path)
@@ -878,6 +1032,9 @@ async function main() {
         if (options.delete) {
             await (0, file_operations_1.deleteFromArchive)(archive, files, options);
             (0, utils_1.log)('✓ Delete operation completed successfully', options);
+            if ((0, output_1.isJsonOutput)()) {
+                (0, output_1.emitResult)({ command: 'neozip', action: 'delete', archive, deleteFiles: files });
+            }
             return;
         }
         // Create ZIP archive
@@ -887,6 +1044,27 @@ async function main() {
             await (0, file_operations_1.moveFiles)(files, options);
         }
         (0, utils_1.log)('✓ NeoZip completed successfully', options);
+        if ((0, output_1.isJsonOutput)()) {
+            let size;
+            try {
+                size = fs.existsSync(archive) ? fs.statSync(archive).size : undefined;
+            }
+            catch {
+                size = undefined;
+            }
+            (0, output_1.emitResult)({
+                command: 'neozip',
+                action: 'create',
+                archive,
+                size,
+                fileCount: files.length,
+                legacy: !!options.legacy,
+                compression: options.level === 0 ? 'store' : options.compression,
+                encrypted: !!options.encrypt,
+                encryptionMethod: options.encrypt ? options.encryptionMethod : undefined,
+                blockchain: !!options.blockchain,
+            });
+        }
         // Explicitly exit to ensure process terminates (provider cleanup should allow this)
         process.exit(exit_codes_1.ZIP_EXIT_CODES.SUCCESS);
     }