neozip-cli 0.75.1-beta → 0.80.0

package/CHANGELOG.md

@@ -5,6 +5,36 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.80.0] - 2026-03-04
+
+### Added
+
+- **Zipstamp (blockchain timestamping)**
+  - Display Zipstamp server URL when submitting timestamp proof (configurable via `ZIPSTAMP_SERVER_URL`)
+  - `neozip verify-email` command and npm script for Zipstamp email configuration
+  - Post-mint summary after `neozip mint`: status, token ID, network, contract, transaction, block, and block timestamp (minted) in the same style as Zipstamp verification
+- **Scripts**
+  - `scripts/remove-env-from-history.sh` to remove `.env.local` and `.env.local.rem` from git history (see `scripts/README.md`)
+- **Configuration**
+  - `neozip config` and `neozip init` work when run via ts-node (fixed dynamic import resolution for `.ts` vs `.js`)
+
+### Changed
+
+- User-facing copy now uses "blockchain" instead of "Ethereum blockchain" for Zipstamp and mint flows
+- Zipstamp verification in `neounzip` shows "Zipstamp (blockchain timestamp)" instead of "Ethereum timestamp"
+- Help text: `-ts, --timestamp` described as "Enable Zipstamp timestamp (blockchain)"
+
+### Fixed
+
+- `neozip config` / `neozip init` no longer fail with "Cannot find module './config/ConfigSetup.js'" when run via `yarn neozip-config` or ts-node
+
+### Security
+
+- `.env.*` (including `.env.local`, `.env.local.rem`) added to `.gitignore` to avoid committing secrets
+- Documented how to purge env files from git history if they were ever committed
+
+---
+
 ## [0.70.0-alpha] - 2025-11-21
 
 ### ⚠️ Alpha Release Notice

package/DOCUMENTATION.md

@@ -17,7 +17,7 @@ npm install -g neozip-cli@alpha
 neozip archive.nzip file1.txt file2.txt folder/
 
 # Extract files from archive
-neounzip archive.nzip extracted/
+neounzip archive.nzip tests/extracted/
 
 # List archive contents
 neolist archive.nzip
@@ -116,6 +116,11 @@ neolist --help     # Show listing help
   - Cryptographic proof of archive existence
   - Timestamp verification
 
+- **Zipstamp**
+  - Ethereum blockchain timestamping via Zipstamp server
+  - Pending timestamps (TS-SUBMIT.NZIP) can be upgraded to confirmed (TIMESTAMP.NZIP)
+  - Use `neozip upgrade <archive> [output] [--wait]` to upgrade pending timestamps
+
 - **Wallet Integration**
   - Interactive wallet setup wizard (`neozip init`)
   - Configuration management (`neozip config`)
@@ -144,6 +149,9 @@ neozip init
 
 # View or modify configuration
 neozip config
+
+# Upgrade pending Zipstamp timestamp to confirmed
+neozip upgrade archive.nzip [output.nzip] [--wait]
 ```
 
 Configuration is stored in `~/.neozip/wallet.json` and supports:

package/README.md

@@ -49,6 +49,7 @@ NeoZip CLI is a modern, full-featured ZIP utility that provides:
 ### Blockchain Features
 - **Tokenization**: Create on-chain tokens for archives
 - **OpenTimestamp**: Bitcoin blockchain timestamping
+- **Zipstamp**: Ethereum blockchain timestamping (Zipstamp server)
 - **Integrity Verification**: Verify archive integrity on-chain
 - **Network Support**: Base Sepolia, Base Mainnet, Arbitrum, and more
 
@@ -103,7 +104,7 @@ neozip -r archive.nzip ./project/
 neozip -b tokenized.nzip file1.txt file2.txt
 
 # Extract files from archive
-neounzip archive.nzip extracted/
+neounzip archive.nzip tests/extracted/
 
 # Extract and verify tokenized archive
 neounzip -t tokenized.nzip
@@ -144,7 +145,7 @@ neozip -e secure.nzip file.txt
 neozip -e -P "mypassword" secure.nzip file.txt
 
 # Extract encrypted archive
-neounzip -P "mypassword" secure.nzip extracted/
+neounzip -P "mypassword" secure.nzip tests/extracted/
 ```
 
 ### Blockchain Examples
@@ -153,11 +154,17 @@ neounzip -P "mypassword" secure.nzip extracted/
 # Tokenize archive on Base Sepolia (default)
 neozip -b tokenized.nzip file.txt
 
-# Tokenize with OpenTimestamp proof
+# Tokenize with OpenTimestamp proof (Bitcoin)
 neozip -ots timestamped.nzip file.txt
 
+# Create Zipstamp timestamp (Ethereum)
+neozip -ts zipstamp.nzip file.txt
+
+# Upgrade pending Zipstamp timestamp to confirmed
+neozip upgrade zipstamp.nzip [output.nzip] [--wait]
+
 # Extract and verify blockchain integrity
-neounzip tokenized.nzip extracted/
+neounzip tokenized.nzip tests/extracted/
 ```
 
 ## Commands
@@ -179,7 +186,9 @@ neozip [options] <archive> [files...]
 - `-e, --encrypt` - Encrypt files (will prompt for password)
 - `-P, --password <pwd>` - Encrypt with password
 - `-b, --blockchain` - Enable blockchain tokenization
-- `-ots, --opentimestamp` - Enable OpenTimestamp proof
+- `-ots, --opentimestamp` - Enable OpenTimestamp proof (Bitcoin)
+- `-ts, --timestamp` - Enable Zipstamp timestamp (Ethereum)
+- `--timestamp-email <email>` - Email for Zipstamp server (some servers require verified email)
 - `-T, --test-integrity` - Test archive after creation
 - `-v, --verbose` - Enable verbose output
 - `-q, --quiet` - Suppress output
@@ -187,7 +196,8 @@ neozip [options] <archive> [files...]
 **Configuration Commands:**
 ```bash
 neozip init      # Interactive wallet setup wizard
-neozip config     # Show current configuration
+neozip config    # Show current configuration
+neozip upgrade <archive> [output] [--wait]  # Upgrade pending Zipstamp timestamp to confirmed
 ```
 
 **Examples:**
@@ -235,16 +245,16 @@ neounzip [options] <archive> [output]
 neounzip archive.nzip
 
 # Extract to specific directory
-neounzip archive.nzip ./extracted/
+neounzip archive.nzip tests/extracted/
 
 # Test archive integrity
 neounzip -t archive.nzip
 
 # Extract with exclusions
-neounzip -x "*.log" archive.nzip extracted/
+neounzip -x "*.log" archive.nzip tests/extracted/
 
 # Extract encrypted archive
-neounzip --password "mypassword" secure.nzip extracted/
+neounzip --password "mypassword" secure.nzip tests/extracted/
 ```
 
 ### `neolist` - List Archive Contents
@@ -303,6 +313,8 @@ You can also configure via environment variables:
 ```bash
 export NEOZIP_WALLET_PASSKEY="your-wallet-key"
 export NEOZIP_NETWORK="base-sepolia"  # or base-mainnet, arbitrum-sepolia, etc.
+export ZIPSTAMP_SERVER_URL="https://zipstamp-dev.neozip.io"  # Zipstamp server (optional)
+export NEOZIP_TIMESTAMP_EMAIL="your@email.com"  # Email for Zipstamp (some servers require verified email)
 ```
 
 ### Configuration File
@@ -329,7 +341,7 @@ neozip project.nzip src/ docs/ README.md
 neolist project.nzip
 
 # Extract files
-neounzip project.nzip extracted/
+neounzip project.nzip tests/extracted/
 
 # Test integrity
 neounzip -t project.nzip

package/dist/src/commands/mintTimestampProof.js

@@ -0,0 +1,335 @@
+"use strict";
+/**
+ * Mint TimestampProofNFT from a confirmed timestamped ZIP (TIMESTAMP.NZIP)
+ *
+ * Creates TOKEN.NZIP metadata and outputs a new ZIP with NFT proof.
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMintTimestampProof = runMintTimestampProof;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const ethers_1 = require("ethers");
+const node_1 = __importDefault(require("neozipkit/node"));
+const node_2 = require("neozipkit/node");
+const zipstamp_server_1 = require("neozip-blockchain/zipstamp-server");
+const neozip_blockchain_1 = require("neozip-blockchain");
+const blockchain_1 = require("../neozip/blockchain");
+const RPC_BY_CHAIN = {
+    84532: 'https://sepolia.base.org',
+    421614: 'https://sepolia-rollup.arbitrum.io/rpc',
+    11155111: 'https://ethereum-sepolia-rpc.publicnode.com',
+    8453: 'https://mainnet.base.org',
+    42161: 'https://arb1.arbitrum.io/rpc',
+    1: 'https://eth.llamarpc.com',
+};
+/** Get a single string from an error so we can reliably detect "already minted" (ethers v6 puts reason in error.reason). */
+function getErrorMessage(error) {
+    if (error == null)
+        return '';
+    const e = error;
+    const parts = [];
+    if (typeof e.reason === 'string')
+        parts.push(e.reason);
+    if (typeof e.message === 'string')
+        parts.push(e.message);
+    if (parts.length === 0)
+        parts.push(String(error));
+    return parts.join(' ');
+}
+/**
+ * Run the mint flow: load ZIP, extract TIMESTAMP.NZIP, prepare mint, mint NFT, create output ZIP with TOKEN.NZIP
+ */
+async function runMintTimestampProof(options) {
+    const { inputPath, outputPath, walletKey: cliWalletKey, debug = false } = options;
+    if (!fs.existsSync(inputPath)) {
+        console.error(`Error: ZIP file not found: ${inputPath}`);
+        return false;
+    }
+    const walletKey = (0, blockchain_1.getWalletPasskey)(cliWalletKey, true);
+    if (!walletKey) {
+        return false;
+    }
+    const zip = new node_1.default();
+    await zip.loadZipFile(inputPath);
+    const entries = zip.getDirectory() || [];
+    const metadataResult = (0, zipstamp_server_1.findMetadataEntry)(entries);
+    if (!metadataResult) {
+        console.error('No Zipstamp timestamp found in ZIP file');
+        return false;
+    }
+    if (metadataResult.type !== 'confirmed') {
+        console.error('Archive must have confirmed timestamp (TIMESTAMP.NZIP). Run "neozip upgrade <archive>" first.');
+        return false;
+    }
+    let timestampMetadata = await (0, zipstamp_server_1.extractTimestampData)(zip, metadataResult.entry);
+    if (!timestampMetadata || !timestampMetadata.digest) {
+        // Fallback for file-based ZIPs where zip.extract() may not work
+        try {
+            const tmpPath = path.join(os.tmpdir(), `neozip-mint-meta-${Date.now()}.json`);
+            await zip.extractToFile(metadataResult.entry, tmpPath, { skipHashCheck: true });
+            try {
+                const buf = fs.readFileSync(tmpPath);
+                timestampMetadata = JSON.parse(buf.toString('utf-8'));
+            }
+            finally {
+                if (fs.existsSync(tmpPath))
+                    fs.unlinkSync(tmpPath);
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    if (!timestampMetadata || !timestampMetadata.digest) {
+        console.error('Failed to extract timestamp metadata');
+        return false;
+    }
+    const chainId = timestampMetadata.chainId ?? 84532;
+    const batchId = timestampMetadata.batchId ?? undefined;
+    console.log('Checking NFT status...');
+    const nftStatus = await (0, zipstamp_server_1.checkNFTStatus)(timestampMetadata.digest, chainId, { debug });
+    if (nftStatus.isMinted && nftStatus.tokenId) {
+        console.log(`Digest already minted as token #${nftStatus.tokenId}`);
+        console.log('Proceeding to create TOKEN.NZIP with existing token data...');
+    }
+    console.log('Preparing mint data...');
+    const prepareResult = await (0, zipstamp_server_1.prepareMint)(timestampMetadata.digest, chainId, batchId, { debug });
+    if (!prepareResult.success || !prepareResult.mintData) {
+        console.error(`Error: ${prepareResult.error || 'Failed to prepare mint data'}`);
+        return false;
+    }
+    const mintData = prepareResult.mintData;
+    let tokenId;
+    let mintTransactionHash;
+    let mintBlockNumber;
+    let ownerAddress;
+    if (nftStatus.isMinted && nftStatus.tokenId) {
+        tokenId = nftStatus.tokenId;
+        ownerAddress = nftStatus.owner || 'unknown';
+        mintTransactionHash = 'already-minted';
+        mintBlockNumber = 0;
+    }
+    else {
+        const rpcUrl = RPC_BY_CHAIN[chainId] ?? (0, neozip_blockchain_1.getContractConfig)(chainId)?.rpcUrls?.[0];
+        if (!rpcUrl) {
+            console.error(`Error: No RPC URL for chain ID ${chainId}`);
+            return false;
+        }
+        const provider = new ethers_1.ethers.JsonRpcProvider(rpcUrl, chainId);
+        const wallet = new ethers_1.ethers.Wallet(walletKey.startsWith('0x') ? walletKey : `0x${walletKey}`, provider);
+        ownerAddress = wallet.address;
+        const balance = await provider.getBalance(wallet.address);
+        const mintFeeWei = BigInt(mintData.mintFeeWei);
+        if (balance < mintFeeWei) {
+            console.error(`Error: Insufficient balance. Required: ${mintData.mintFee} ETH`);
+            return false;
+        }
+        const nftContract = new ethers_1.ethers.Contract(mintData.nftContractAddress, neozip_blockchain_1.NZIP_CONTRACT_ABI_V250, wallet);
+        console.log('Minting NFT...');
+        try {
+            const tx = await nftContract.mintWithTimestampProof(mintData.digest, mintData.merkleProof, mintData.batchMerkleRoot, { value: mintFeeWei });
+            const receipt = await tx.wait();
+            if (!receipt || receipt.status !== 1) {
+                throw new Error('Transaction failed');
+            }
+            mintTransactionHash = receipt.hash;
+            mintBlockNumber = receipt.blockNumber;
+            tokenId = '0';
+            for (const eventLog of receipt.logs) {
+                try {
+                    const parsed = nftContract.interface.parseLog({
+                        topics: eventLog.topics,
+                        data: eventLog.data,
+                    });
+                    if (parsed?.name === 'TimestampProofMinted') {
+                        tokenId = parsed.args.tokenId.toString();
+                        break;
+                    }
+                }
+                catch {
+                    /* skip */
+                }
+            }
+            console.log(`Token minted: #${tokenId}`);
+        }
+        catch (error) {
+            const msg = getErrorMessage(error);
+            const isAlreadyMinted = /already minted/i.test(msg);
+            if (isAlreadyMinted) {
+                console.log('Contract reports digest already minted; resolving existing token...');
+                let existingTokenId;
+                let existingOwner;
+                let existingBlockNumber;
+                const existingStatus = await (0, zipstamp_server_1.checkNFTStatus)(timestampMetadata.digest, chainId, { debug });
+                if (existingStatus.isMinted && existingStatus.tokenId) {
+                    existingTokenId = existingStatus.tokenId;
+                    existingOwner = existingStatus.owner;
+                    existingBlockNumber = existingStatus.proofData?.batchBlockNumber;
+                }
+                if (!existingTokenId) {
+                    const verifyRes = await (0, zipstamp_server_1.verifyDigest)(timestampMetadata.digest, chainId, batchId ?? undefined, undefined, { debug });
+                    if (verifyRes.verified && verifyRes.tokenId) {
+                        existingTokenId = verifyRes.tokenId;
+                        existingOwner = verifyRes.owner;
+                        existingBlockNumber = verifyRes.blockNumber;
+                    }
+                }
+                if (existingTokenId) {
+                    tokenId = existingTokenId;
+                    ownerAddress = existingOwner ?? 'unknown';
+                    mintTransactionHash = 'already-minted';
+                    mintBlockNumber = existingBlockNumber ?? 0;
+                    console.log(`Using existing token #${tokenId}. Creating TOKEN.NZIP...`);
+                }
+                else {
+                    console.error('Mint failed: digest is already minted on-chain but token details could not be retrieved. Try the Zipstamp server or block explorer for this digest.');
+                    console.error(`Details: ${msg}`);
+                    return false;
+                }
+            }
+            else {
+                console.error(`Mint failed: ${msg}`);
+                return false;
+            }
+        }
+    }
+    const nftMetadata = {
+        tokenId,
+        contractAddress: mintData.nftContractAddress,
+        network: mintData.network,
+        merkleRoot: mintData.digest,
+        networkChainId: chainId,
+        contractVersion: mintData.contractVersion,
+        transactionHash: mintTransactionHash,
+        blockNumber: mintBlockNumber,
+        owner: ownerAddress,
+        mintedAt: new Date().toISOString(),
+        timestampProof: {
+            digest: mintData.digest,
+            merkleProof: mintData.merkleProof,
+            batchMerkleRoot: mintData.batchMerkleRoot,
+            batchNumber: mintData.batchNumber,
+            batchTransactionHash: mintData.batchTransactionHash,
+            batchBlockNumber: mintData.batchBlockNumber,
+            batchTimestamp: mintData.batchTimestamp,
+            registryAddress: mintData.registryAddress,
+            nftContractAddress: mintData.nftContractAddress,
+            serverUrl: (0, zipstamp_server_1.getZipStampServerUrl)(),
+        },
+    };
+    const metadataFiles = (0, zipstamp_server_1.getMetadataFileNames)();
+    const outPath = outputPath ?? inputPath.replace(/(\.nzip|\.zip)$/i, '-nft$1');
+    const tempDir = path.dirname(outPath) || '.';
+    const tempPath = path.join(tempDir, `.neozip-mint-${Date.now()}.tmp`);
+    try {
+        const zipCopy = new node_2.ZipCopyNode(new node_1.default());
+        const { destPath, dataEndOffset, copiedEntries } = await zipCopy.copyZipEntriesOnly(inputPath, tempPath, {
+            entryFilter: (entry) => !metadataFiles.includes(entry.filename || ''),
+        });
+        const tokenContent = JSON.stringify(nftMetadata, null, 2);
+        const tokenBuffer = Buffer.from(tokenContent, 'utf-8');
+        const { crc32 } = await import('neozipkit');
+        const tokenEntry = zip.createZipEntry('META-INF/TOKEN.NZIP');
+        tokenEntry.crc = crc32(tokenBuffer) >>> 0;
+        tokenEntry.compressedSize = tokenBuffer.length;
+        tokenEntry.uncompressedSize = tokenBuffer.length;
+        tokenEntry.cmpMethod = 0;
+        tokenEntry.localHdrOffset = dataEndOffset;
+        tokenEntry.fileBuffer = tokenBuffer;
+        const localHdr = tokenEntry.createLocalHdr();
+        const fd = fs.openSync(destPath, 'r+');
+        try {
+            fs.writeSync(fd, localHdr, 0, localHdr.length, dataEndOffset);
+            fs.writeSync(fd, tokenBuffer, 0, tokenBuffer.length, dataEndOffset + localHdr.length);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        const allEntries = [...copiedEntries, tokenEntry];
+        zipCopy.writeCentralDirectoryAndEOCD(destPath, allEntries, { zipComment: '' });
+        fs.renameSync(destPath, outPath);
+        console.log(`Output: ${outPath}`);
+        // Summary matching Zipstamp verification style
+        console.log('\n🔗 Mint complete:');
+        console.log(' - Status: ✅ MINTED');
+        console.log(' - Stamp type: NZIP-NFT (tokenized archive)');
+        console.log(` - Token ID: #${tokenId}`);
+        console.log(` - Network: ${mintData.network}`);
+        console.log(` - Contract: ${mintData.nftContractAddress}`);
+        if (mintTransactionHash && mintTransactionHash !== 'already-minted') {
+            console.log(` - Transaction: ${mintTransactionHash}`);
+        }
+        if (mintBlockNumber > 0) {
+            console.log(` - Block: ${mintBlockNumber}`);
+        }
+        const batchTs = mintData.batchTimestamp;
+        if (batchTs != null && mintBlockNumber > 0) {
+            const ts = typeof batchTs === 'number' ? (batchTs < 1e12 ? batchTs * 1000 : batchTs) : Date.parse(String(batchTs));
+            if (!isNaN(ts)) {
+                const blockDate = new Date(ts);
+                const mintedStr = blockDate.toLocaleString(undefined, {
+                    month: '2-digit',
+                    day: '2-digit',
+                    year: 'numeric',
+                    hour: '2-digit',
+                    minute: '2-digit',
+                    second: '2-digit',
+                    hour12: true,
+                });
+                console.log(` - Block timestamp (minted): ${mintedStr}`);
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        if (fs.existsSync(tempPath)) {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Error creating output: ${msg}`);
+        return false;
+    }
+}
+//# sourceMappingURL=mintTimestampProof.js.map

package/dist/src/commands/verifyEmail.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Verify email for Zipstamp timestamping
+ *
+ * Sets a default email for Zipstamp timestamps. Checks with the server whether
+ * the email is already verified; if not, sends a magic link. Always saves as default.
+ */
+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.runVerifyEmail = runVerifyEmail;
+const readline = __importStar(require("readline"));
+const zipstamp_server_1 = require("neozip-blockchain/zipstamp-server");
+const ConfigStore_1 = require("../config/ConfigStore");
+const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function isValidEmail(email) {
+    return EMAIL_REGEX.test(email.trim());
+}
+function isAlreadyVerifiedMessage(msg) {
+    if (!msg)
+        return false;
+    const lower = msg.toLowerCase();
+    return ((lower.includes('already') && (lower.includes('verified') || lower.includes('registered'))) ||
+        lower.includes('already verified') ||
+        lower.includes('email already'));
+}
+/**
+ * Run the verify-email flow.
+ * Calls the server to check verification status; if already verified, sets as default.
+ * If not, sends magic link and sets as default. Always saves email to config.
+ */
+async function runVerifyEmail(options) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const prompt = (question, defaultValue) => {
+        return new Promise((resolve) => {
+            const display = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
+            rl.question(display, (answer) => {
+                resolve((answer.trim() || defaultValue || '').trim());
+            });
+        });
+    };
+    try {
+        console.log('\n📧 Zipstamp Email Configuration\n');
+        console.log('Zipstamp requires a verified email to create timestamped ZIP files.');
+        console.log('');
+        const config = ConfigStore_1.ConfigStore.getConfig();
+        const defaultEmail = options?.email || config.timestampEmail || '';
+        const email = await prompt('Email address', defaultEmail || undefined);
+        if (!email) {
+            console.error('❌ Email is required');
+            rl.close();
+            return false;
+        }
+        if (!isValidEmail(email)) {
+            console.error('❌ Invalid email format');
+            rl.close();
+            return false;
+        }
+        // --set-default: skip server check, just save
+        if (options?.setDefaultOnly) {
+            const saved = ConfigStore_1.ConfigStore.set('zipstamp.timestampEmail', email);
+            if (!saved) {
+                console.error('❌ Failed to save email to configuration');
+                rl.close();
+                return false;
+            }
+            console.log(`\n✅ ${email} set as default for Zipstamp timestamps.`);
+            console.log('\n💡 You can now create timestamped ZIPs: neozip -ts <archive> <files>\n');
+            rl.close();
+            return true;
+        }
+        // Check with server: register returns status (already verified vs magic link sent)
+        console.log(`\n📤 Checking verification status for ${email}...`);
+        const registerResult = await (0, zipstamp_server_1.registerEmail)(email, {
+            debug: options?.debug,
+        });
+        if (!registerResult.success) {
+            console.error('❌ Failed to register email:', registerResult.error || 'Unknown error');
+            rl.close();
+            return false;
+        }
+        const res = registerResult;
+        const msg = res.message || '';
+        const alreadyVerified = res.verified === true ||
+            res.alreadyVerified === true ||
+            isAlreadyVerifiedMessage(msg);
+        const saved = ConfigStore_1.ConfigStore.set('zipstamp.timestampEmail', email);
+        if (!saved) {
+            console.error('❌ Failed to save email to configuration');
+            rl.close();
+            return false;
+        }
+        if (alreadyVerified) {
+            console.log('\n✅ Email is already verified. Set as default.');
+        }
+        else {
+            console.log('\n✅ Verification link sent. Check your inbox (and spam folder).');
+            console.log('   Click the magic link in the email to complete verification.');
+            console.log(`   ${email} has been set as default and will work once you've clicked the link.`);
+        }
+        console.log('\n💡 You can now create timestamped ZIPs: neozip -ts <archive> <files>\n');
+        rl.close();
+        return true;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error('❌ Error:', msg);
+        rl.close();
+        return false;
+    }
+}
+//# sourceMappingURL=verifyEmail.js.map