neozip-cli 0.80.0 → 0.95.0

package/dist/src/archive/recipient-lookup.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spkiBase64ToRawHex = spkiBase64ToRawHex;
+exports.resolveTokenServiceBaseUrl = resolveTokenServiceBaseUrl;
+exports.lookupRecipientByEmail = lookupRecipientByEmail;
+exports.resolveRecipientsFromEmails = resolveRecipientsFromEmails;
+const token_service_1 = require("neozip-blockchain/token-service");
+const wallet_identity_1 = require("../constants/wallet-identity");
+function spkiBase64ToRawHex(spkiBase64) {
+    const spkiDer = Buffer.from(spkiBase64, "base64");
+    if (spkiDer.length !== 44) {
+        throw new Error(`Unexpected SPKI DER length ${spkiDer.length}, expected 44 bytes for X25519`);
+    }
+    return spkiDer.subarray(12).toString("hex");
+}
+function resolveTokenServiceBaseUrl(config, serverUrl) {
+    return (0, token_service_1.getTokenServiceUrl)({
+        serverUrl: serverUrl || config.tokenServiceUrl || undefined,
+    }).replace(/\/+$/, "");
+}
+async function lookupRecipientByEmail(email, config, options) {
+    const trimmed = email.trim().toLowerCase();
+    if (!trimmed.includes("@")) {
+        throw new Error(`Invalid recipient email: ${email}`);
+    }
+    const baseUrl = resolveTokenServiceBaseUrl(config, options?.serverUrl);
+    const url = `${baseUrl}/crypto/public?email=${encodeURIComponent(trimmed)}`;
+    const response = await fetch(url, { method: "GET" });
+    const data = (await response.json());
+    if (!response.ok || !data.success || !data.crypto?.x25519PublicKey) {
+        throw new Error(data.error ||
+            `No public key found for ${trimmed} (HTTP ${response.status})`);
+    }
+    const publicKeyHex = spkiBase64ToRawHex(data.crypto.x25519PublicKey);
+    return {
+        identity: {
+            identity: trimmed,
+            identityType: wallet_identity_1.TOKEN_SERVICE_RECIPIENT_IDENTITY_TYPE,
+            address: data.crypto.evmAddress || "",
+            publicKeyHex,
+            keyFormat: "x25519",
+        },
+        evmAddress: data.crypto.evmAddress || "",
+        recipientSuites: data.crypto.recipientSuites,
+        cryptoProvisionedAt: data.crypto.cryptoProvisionedAt,
+    };
+}
+async function resolveRecipientsFromEmails(emails, config, options) {
+    const seen = new Set();
+    const recipients = [];
+    for (const email of emails) {
+        const normalized = email.trim().toLowerCase();
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        const { identity } = await lookupRecipientByEmail(normalized, config, options);
+        recipients.push(identity);
+    }
+    return recipients;
+}
+//# sourceMappingURL=recipient-lookup.js.map

package/dist/src/cli/output.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Shared output layer for agent-friendly machine-readable output.
+ *
+ * Design rules (see dev_doc / AGENTS.md):
+ *  - Human text is the default. JSON is opt-in via `--format json` (or, on
+ *    neolist, the legacy `-j`/`--json` flag).
+ *  - Structured results and structured errors are written to STDOUT as a single
+ *    JSON object so a caller can parse stdout directly.
+ *  - Human hints, progress, and decorative logs go to STDERR (or are suppressed)
+ *    so they never corrupt JSON on stdout.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setOutputFormat = setOutputFormat;
+exports.getOutputFormat = getOutputFormat;
+exports.isJsonOutput = isJsonOutput;
+exports.detectOutputFormat = detectOutputFormat;
+exports.stripFormatFlag = stripFormatFlag;
+exports.emitResult = emitResult;
+exports.emitError = emitError;
+let currentFormat = 'text';
+/** Set the process-wide output format (call once, early, from each binary). */
+function setOutputFormat(format) {
+    currentFormat = format;
+}
+/** Get the current process-wide output format. */
+function getOutputFormat() {
+    return currentFormat;
+}
+/** Convenience predicate: are we emitting machine-readable JSON? */
+function isJsonOutput() {
+    return currentFormat === 'json';
+}
+/**
+ * Detect the desired output format from raw argv.
+ *
+ * Recognizes `--format json|text` and `--format=json|text`. The bare `--json`
+ * flag is intentionally NOT treated as an output switch here because on neozip /
+ * neounzip `--json` carries an input payload value. neolist handles its own
+ * legacy `--json`/`-j` output toggle and maps it to setOutputFormat('json').
+ */
+function detectOutputFormat(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--format') {
+            const value = argv[i + 1];
+            if (value === 'json')
+                return 'json';
+            if (value === 'text')
+                return 'text';
+        }
+        else if (arg.startsWith('--format=')) {
+            const value = arg.slice('--format='.length);
+            if (value === 'json')
+                return 'json';
+            if (value === 'text')
+                return 'text';
+        }
+    }
+    return 'text';
+}
+/**
+ * Remove `--format <value>` / `--format=<value>` tokens from argv so the
+ * existing per-binary parsers don't have to know about them.
+ */
+function stripFormatFlag(argv) {
+    const result = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--format') {
+            // Skip the flag and its value.
+            i++;
+            continue;
+        }
+        if (arg.startsWith('--format=')) {
+            continue;
+        }
+        result.push(arg);
+    }
+    return result;
+}
+/**
+ * Emit a successful structured result as pretty JSON on stdout.
+ *
+ * Writes directly to process.stdout so it bypasses any `quiet` handling used to
+ * silence decorative human logs in JSON mode.
+ */
+function emitResult(result) {
+    const payload = { ok: true, ...result };
+    process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
+}
+/**
+ * Emit a structured error as pretty JSON on stdout. Used by the exit-code
+ * helpers when running in JSON mode.
+ */
+function emitError(error) {
+    const payload = { ok: false, error };
+    process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
+}
+//# sourceMappingURL=output.js.map

package/dist/src/cli/params.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * Agent input parsing: `--params` and `--json`.
+ *
+ *  - `--params '<JSON>'`  control/options object (the "how": level, encrypt,
+ *    blockchain, network, output dir, overwrite policy, ...). Maps onto the
+ *    binary's options object.
+ *  - `--json '<JSON>'`    payload object (the "what": archive + inputs/targets,
+ *    e.g. {archive, files, include, exclude, entries, exdir}). Maps onto
+ *    positional arguments.
+ *
+ * Either flag accepts `-` as its value to read the JSON document from stdin.
+ *
+ * Precedence: values from `--params`/`--json` seed the option/positional state
+ * BEFORE the normal flag loop runs, so explicit CLI flags always win.
+ */
+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.parseJsonObjectArg = parseJsonObjectArg;
+exports.extractAgentInput = extractAgentInput;
+const fs = __importStar(require("fs"));
+const validate_1 = require("./validate");
+/**
+ * Parse a JSON object from a flag value. A value of `-` reads from stdin.
+ * Throws ValidationError on invalid input or non-object JSON.
+ */
+function parseJsonObjectArg(raw, flag) {
+    return readJsonValue(raw, flag);
+}
+function readJsonValue(raw, flag) {
+    let text = raw;
+    if (raw === '-') {
+        try {
+            text = fs.readFileSync(0, 'utf8');
+        }
+        catch (err) {
+            throw new validate_1.ValidationError(`Failed to read ${flag} from stdin: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (err) {
+        throw new validate_1.ValidationError(`Invalid ${flag} JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new validate_1.ValidationError(`${flag} must be a JSON object`);
+    }
+    return parsed;
+}
+/**
+ * Extract `--params` / `--json` from argv. Returns the parsed objects plus argv
+ * with those tokens removed so the existing per-binary parser can run unchanged.
+ *
+ * Supports `--flag value`, `--flag=value`. A `-` value reads from stdin.
+ */
+function extractAgentInput(argv) {
+    const out = { argv: [] };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--params' || arg === '--json') {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                throw new validate_1.ValidationError(`${arg} requires a JSON value (or '-' for stdin)`);
+            }
+            i++;
+            const obj = readJsonValue(value, arg);
+            if (arg === '--params')
+                out.params = obj;
+            else
+                out.payload = obj;
+            continue;
+        }
+        if (arg.startsWith('--params=') || arg.startsWith('--json=')) {
+            const eq = arg.indexOf('=');
+            const flag = arg.slice(0, eq);
+            const value = arg.slice(eq + 1);
+            const obj = readJsonValue(value, flag);
+            if (flag === '--params')
+                out.params = obj;
+            else
+                out.payload = obj;
+            continue;
+        }
+        out.argv.push(arg);
+    }
+    return out;
+}
+//# sourceMappingURL=params.js.map

package/dist/src/cli/schema.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * Machine-readable schema introspection.
+ *
+ * Unlike a REST CLI with a Discovery document, NeoZip's commands are described
+ * by a hand-authored registry. `neozip schema <command>` emits the accepted
+ * `--params` fields, the `--json` payload shape, output shape, and exit codes so
+ * an agent can construct calls without scraping `--help`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommandSchema = getCommandSchema;
+exports.listSchemaCommands = listSchemaCommands;
+exports.handleSchemaCommand = handleSchemaCommand;
+const NEOZIP_SCHEMA = {
+    command: 'neozip',
+    summary: 'Create or update an archive, optionally with blockchain tokenization.',
+    output: 'Human text by default. Pass --format json for a structured result. --dry-run previews without writing.',
+    params: [
+        { name: 'level', type: 'number', description: 'Compression level 0-9 (0=store).', default: 6, legacySafe: true },
+        { name: 'compression', type: 'string', enum: ['zstd', 'deflate'], description: 'Compression algorithm.', default: 'zstd', legacySafe: false },
+        { name: 'legacy', type: 'boolean', description: 'Produce an InfoZip/PKZIP-compatible archive (forces deflate/store + PKZIP, disables NeoZip extensions).', default: false, legacySafe: true },
+        { name: 'encrypt', type: 'boolean', description: 'Encrypt entries (prompts for password unless password is given).', default: false, legacySafe: true },
+        { name: 'password', type: 'string', description: 'Encryption password. Use with care (visible in process list).', legacySafe: true },
+        { name: 'encryptionMethod', type: 'string', enum: ['aes256', 'pkzip'], description: 'Encryption method. --legacy forces pkzip.', default: 'aes256', legacySafe: false },
+        { name: 'blockchain', type: 'boolean', description: 'Enable blockchain tokenization. Incompatible with legacy.', default: false, legacySafe: false },
+        { name: 'blockchainOts', type: 'boolean', description: 'Add an OpenTimestamps (Bitcoin) proof. Incompatible with legacy.', default: false, legacySafe: false },
+        { name: 'blockchainTokenService', type: 'boolean', description: 'Add a Token Service timestamp (requires neozip connect). Incompatible with legacy.', default: false, legacySafe: false },
+        { name: 'network', type: 'string', description: 'Blockchain network name (e.g. base-sepolia).', default: 'base-sepolia', legacySafe: false },
+        { name: 'recurse', type: 'boolean', description: 'Recurse into directories.', default: false, legacySafe: true },
+        { name: 'junkPaths', type: 'boolean', description: 'Store only file names, not directory paths.', default: false, legacySafe: true },
+        { name: 'include', type: 'string[]', description: 'Glob patterns to include.', legacySafe: true },
+        { name: 'exclude', type: 'string[]', description: 'Glob patterns to exclude.', legacySafe: true },
+        { name: 'inMemory', type: 'boolean', description: 'Use in-memory compression.', default: false, legacySafe: true },
+        { name: 'testIntegrity', type: 'boolean', description: 'Test the archive after creation.', default: false, legacySafe: true },
+        { name: 'verbose', type: 'boolean', description: 'Verbose output.', default: false, legacySafe: true },
+        { name: 'quiet', type: 'boolean', description: 'Suppress output.', default: false, legacySafe: true },
+    ],
+    payload: [
+        { name: 'archive', type: 'string', description: 'Output archive path (positional arg 1).' },
+        { name: 'files', type: 'string[]', description: 'Files/directories to add (positional args 2+).' },
+        { name: 'include', type: 'string[]', description: 'Glob patterns to include.' },
+        { name: 'exclude', type: 'string[]', description: 'Glob patterns to exclude.' },
+    ],
+    exitCodes: [
+        { code: 0, meaning: 'Success' },
+        { code: 10, meaning: 'Parameter error' },
+        { code: 15, meaning: "Can't write archive" },
+        { code: 18, meaning: "Can't find archive" },
+        { code: 26, meaning: 'Blockchain configuration error' },
+    ],
+    notes: [
+        'Output format is selected with --format json (not --json). --json supplies the payload.',
+        'Example: neozip --format json --params \'{"level":9,"legacy":true}\' --json \'{"files":["a.txt","dir/"]}\' out.zip',
+    ],
+};
+const NEOUNZIP_SCHEMA = {
+    command: 'neounzip',
+    summary: 'Extract, test, or list an archive.',
+    output: 'Human text by default. Pass --format json for a structured result. --dry-run previews the extraction plan.',
+    params: [
+        { name: 'exdir', type: 'string', description: 'Extraction directory (zip-slip validated).' },
+        { name: 'overwrite', type: 'boolean', description: 'Overwrite existing files.', default: false },
+        { name: 'never', type: 'boolean', description: 'Never overwrite existing files.', default: false },
+        { name: 'junkPaths', type: 'boolean', description: 'Strip directory paths on extraction.', default: false },
+        { name: 'testOnly', type: 'boolean', description: 'Test archive integrity only.', default: false },
+        { name: 'listOnly', type: 'boolean', description: 'List archive contents only.', default: false },
+        { name: 'preVerify', type: 'boolean', description: 'Verify integrity/blockchain before extracting.', default: false },
+        { name: 'password', type: 'string', description: 'Decryption password.' },
+        { name: 'include', type: 'string[]', description: 'Glob patterns to include.' },
+        { name: 'exclude', type: 'string[]', description: 'Glob patterns to exclude.' },
+        { name: 'skipBlockchain', type: 'boolean', description: 'Skip blockchain verification.', default: false },
+        { name: 'inMemory', type: 'boolean', description: 'Use in-memory processing.', default: false },
+        { name: 'verbose', type: 'boolean', description: 'Verbose output.', default: false },
+        { name: 'quiet', type: 'boolean', description: 'Suppress output.', default: false },
+    ],
+    payload: [
+        { name: 'archive', type: 'string', description: 'Archive path (positional arg 1).' },
+        { name: 'exdir', type: 'string', description: 'Extraction directory (positional arg 2 or exdir).' },
+        { name: 'filePatterns', type: 'string[]', description: 'Entry name patterns to extract (positional args 3+).' },
+    ],
+    exitCodes: [
+        { code: 0, meaning: 'Success' },
+        { code: 1, meaning: 'Warning (completed with issues)' },
+        { code: 9, meaning: 'Files not found' },
+        { code: 10, meaning: 'Invalid options' },
+        { code: 82, meaning: 'Bad password' },
+    ],
+    notes: [
+        'Extraction refuses entries that escape the target directory (zip-slip protection).',
+        'Example: neounzip --format json --params \'{"exdir":"out","overwrite":true}\' archive.zip',
+    ],
+};
+const NEOLIST_SCHEMA = {
+    command: 'neolist',
+    summary: 'List the contents of an archive.',
+    output: 'Human text by default. Pass --format json (or the legacy -j/--json) for JSON.',
+    params: [
+        { name: 'sortBy', type: 'string', enum: ['name', 'size', 'date'], description: 'Sort order.' },
+        { name: 'include', type: 'string[]', description: 'Glob patterns to include.' },
+        { name: 'exclude', type: 'string[]', description: 'Glob patterns to exclude.' },
+        { name: 'noComments', type: 'boolean', description: 'Suppress comments.', default: false },
+        { name: 'inMemory', type: 'boolean', description: 'Use in-memory processing.', default: false },
+        { name: 'verbose', type: 'boolean', description: 'Verbose output.', default: false },
+    ],
+    exitCodes: [
+        { code: 0, meaning: 'Success' },
+        { code: 9, meaning: 'Files not found' },
+        { code: 10, meaning: 'Invalid options' },
+        { code: 82, meaning: 'Password-protected (cannot list)' },
+    ],
+    notes: ['Example: neolist --format json archive.zip'],
+};
+const CONNECT_SCHEMA = {
+    command: 'connect',
+    summary: 'Token Service account + wallet setup. Shares ~/.neozip/connection/ with NeoZip Desktop and MCP.',
+    output: 'Pass --json on any subcommand for a structured ConnectCliResult.',
+    params: [
+        { name: 'email', type: 'string', description: 'Account email for register/verify.' },
+        { name: 'code', type: 'string', description: 'Verification code.' },
+        { name: 'phone', type: 'string', description: 'E.164 phone number for phone verification.' },
+        { name: 'connectionId', type: 'string', description: 'Target a specific connection.' },
+        { name: 'tokenServiceUrl', type: 'string', description: 'Override the Token Service URL.' },
+        { name: 'label', type: 'string', description: 'Friendly label for the connection.' },
+        { name: 'network', type: 'string', description: 'Network name for connect fund (e.g. base-sepolia).' },
+        { name: 'chain', type: 'number', description: 'Chain id for connect fund (overrides --network).' },
+    ],
+    exitCodes: [
+        { code: 0, meaning: 'Success' },
+        { code: 12, meaning: 'Command failed' },
+    ],
+    notes: [
+        'Subcommands: status, register, verify, refresh, fund, phone, wallet, finish, select, rename, dump, settings, migrate, logout, delete, reset.',
+        'connect refresh renews an expired access token (silent wallet-signature login, else email OTP).',
+        'connect fund [request|status|policy] requests native gas for the Data Wallet from the Token Service funding API.',
+        'Non-interactive subcommands accept --json for structured output. The bare wizard requires a TTY.',
+    ],
+};
+const REGISTRY = {
+    neozip: NEOZIP_SCHEMA,
+    zip: NEOZIP_SCHEMA,
+    neounzip: NEOUNZIP_SCHEMA,
+    unzip: NEOUNZIP_SCHEMA,
+    neolist: NEOLIST_SCHEMA,
+    list: NEOLIST_SCHEMA,
+    connect: CONNECT_SCHEMA,
+};
+/** Look up a command schema by name (case-insensitive, with aliases). */
+function getCommandSchema(command) {
+    return REGISTRY[command.toLowerCase()];
+}
+/** List the canonical introspectable command names. */
+function listSchemaCommands() {
+    return ['neozip', 'neounzip', 'neolist', 'connect'];
+}
+/**
+ * Handle `neozip schema [command]`. Prints JSON to stdout. Returns the process
+ * exit code (0 on success, 10 on a bad command name).
+ */
+function handleSchemaCommand(args) {
+    const target = args[0];
+    if (!target) {
+        // No command given: emit an index of available commands.
+        const index = {
+            ok: true,
+            commands: listSchemaCommands(),
+            usage: 'neozip schema <neozip|neounzip|neolist|connect>',
+        };
+        process.stdout.write(JSON.stringify(index, null, 2) + '\n');
+        return 0;
+    }
+    const schema = getCommandSchema(target);
+    if (!schema) {
+        process.stdout.write(JSON.stringify({
+            ok: false,
+            error: {
+                code: 'UNKNOWN_COMMAND',
+                message: `Unknown command "${target}"`,
+                commands: listSchemaCommands(),
+            },
+        }, null, 2) + '\n');
+        return 10;
+    }
+    process.stdout.write(JSON.stringify({ ok: true, schema }, null, 2) + '\n');
+    return 0;
+}
+//# sourceMappingURL=schema.js.map

package/dist/src/cli/validate.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Input hardening for agent-driven (and adversarial) input.
+ *
+ * Agents hallucinate. Treat all CLI/JSON-supplied strings as untrusted:
+ *  - Reject control characters and dangerous Unicode (zero-width, bidi
+ *    overrides) that can hide intent in file names and paths.
+ *  - Prevent zip-slip: extracted entries must resolve inside the target dir.
+ *
+ * Adapted from the patterns in the Google Workspace CLI `validate.rs`.
+ */
+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.ValidationError = void 0;
+exports.rejectControlChars = rejectControlChars;
+exports.assertSafeArchiveName = assertSafeArchiveName;
+exports.validateSafeOutputDir = validateSafeOutputDir;
+exports.resolveSafeExtractPath = resolveSafeExtractPath;
+const path = __importStar(require("path"));
+/** Raised when input fails a hardening check. */
+class ValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+// C0 controls (0x00-0x1F), DEL (0x7F), and C1 controls (0x80-0x9F).
+const CONTROL_CHARS = /[\u0000-\u001F\u007F-\u009F]/;
+// Zero-width and bidirectional-override characters that can disguise paths.
+const DANGEROUS_UNICODE = /[\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF]/;
+/**
+ * Reject control characters and dangerous Unicode in a value. Returns the value
+ * unchanged when it is safe.
+ */
+function rejectControlChars(value, label) {
+    if (CONTROL_CHARS.test(value)) {
+        throw new ValidationError(`${label} contains control characters`);
+    }
+    if (DANGEROUS_UNICODE.test(value)) {
+        throw new ValidationError(`${label} contains disallowed Unicode characters`);
+    }
+    return value;
+}
+/**
+ * Validate an archive name / file path for control characters. Does not enforce
+ * a sandbox (archives may legitimately live anywhere the user can write).
+ */
+function assertSafeArchiveName(name) {
+    return rejectControlChars(name, 'Archive name');
+}
+/**
+ * Validate an output directory string. Rejects control chars and returns the
+ * resolved absolute path.
+ */
+function validateSafeOutputDir(dir, label = 'Output directory') {
+    rejectControlChars(dir, label);
+    return path.resolve(dir);
+}
+/**
+ * Resolve an archive entry name against a target extraction directory and ensure
+ * the result stays inside that directory (zip-slip protection).
+ *
+ * - Rejects control characters / dangerous Unicode in the entry name.
+ * - Rejects absolute entry paths.
+ * - Rejects `..` traversal that escapes the target directory.
+ *
+ * Returns the safe absolute destination path for the entry.
+ */
+function resolveSafeExtractPath(targetDir, entryName) {
+    rejectControlChars(entryName, `Entry "${entryName}"`);
+    // Normalize Windows separators so checks are consistent cross-platform.
+    const normalizedEntry = entryName.replace(/\\/g, '/');
+    if (path.isAbsolute(normalizedEntry) || /^[A-Za-z]:[\\/]/.test(normalizedEntry)) {
+        throw new ValidationError(`Entry "${entryName}" uses an absolute path (refusing to extract)`);
+    }
+    const resolvedTarget = path.resolve(targetDir);
+    const destination = path.resolve(resolvedTarget, normalizedEntry);
+    const withSep = resolvedTarget.endsWith(path.sep)
+        ? resolvedTarget
+        : resolvedTarget + path.sep;
+    if (destination !== resolvedTarget && !destination.startsWith(withSep)) {
+        throw new ValidationError(`Entry "${entryName}" escapes the extraction directory (path traversal)`);
+    }
+    return destination;
+}
+//# sourceMappingURL=validate.js.map