node-liblzma 2.2.0 → 3.1.0

package/lib/cli/nxz.js

@@ -3,10 +3,25 @@
  * nxz - Node.js XZ compression CLI
  * A portable xz-like command line tool using node-liblzma
  */
-import { createReadStream, createWriteStream, existsSync, readFileSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { closeSync, createReadStream, createWriteStream, existsSync, fstatSync, openSync, readFileSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { performance } from 'node:perf_hooks';
 import { pipeline } from 'node:stream/promises';
 import { parseArgs } from 'node:util';
 import { check, createUnxz, createXz, hasThreads, isXZ, parseFileIndex, preset, unxzSync, versionString, xzSync, } from '../lzma.js';
+let tarXzModule = null;
+async function loadTarXz() {
+    if (!tarXzModule) {
+        try {
+            // Variable import specifier prevents TypeScript from resolving at compile time
+            const modName = 'tar-xz';
+            tarXzModule = (await import(modName));
+        }
+        catch {
+            throw new Error('tar-xz package not available. Install it with: pnpm add tar-xz');
+        }
+    }
+    return tarXzModule;
+}
 /** Size threshold for using streams vs sync (1 MB) */
 const STREAM_THRESHOLD_BYTES = 1024 * 1024;
 /** Exit codes matching xz conventions */
@@ -65,10 +80,13 @@ function parseCliArgs(args) {
             compress: { type: 'boolean', short: 'z', default: false },
             decompress: { type: 'boolean', short: 'd', default: false },
             list: { type: 'boolean', short: 'l', default: false },
+            benchmark: { type: 'boolean', short: 'B', default: false },
+            tar: { type: 'boolean', short: 'T', default: false },
             keep: { type: 'boolean', short: 'k', default: false },
             force: { type: 'boolean', short: 'f', default: false },
             stdout: { type: 'boolean', short: 'c', default: false },
             output: { type: 'string', short: 'o' },
+            strip: { type: 'string', default: '0' },
             verbose: { type: 'boolean', short: 'v', default: false },
             quiet: { type: 'boolean', short: 'q', default: false },
             help: { type: 'boolean', short: 'h', default: false },
@@ -82,6 +100,8 @@ function parseCliArgs(args) {
         compress: values.compress === true,
         decompress: values.decompress === true,
         list: values.list === true,
+        benchmark: values.benchmark === true,
+        tar: values.tar === true,
         keep: values.keep === true,
         force: values.force === true,
         stdout: values.stdout === true,
@@ -92,6 +112,7 @@ function parseCliArgs(args) {
         version: values.version === true,
         preset: presetLevel,
         extreme: values.extreme === true,
+        strip: Number.parseInt(String(values.strip ?? '0'), 10),
         files: positionals,
     };
 }
@@ -109,12 +130,18 @@ Operation mode:
   -z, --compress    force compression
   -d, --decompress  force decompression
   -l, --list        list information about .xz files
+  -B, --benchmark   benchmark native vs WASM compression
+
+Archive mode (tar.xz):
+  -T, --tar         treat file as tar.xz archive
+                    Auto-detected for .tar.xz and .txz files
+  --strip=N         strip N leading path components on extract (default: 0)
 
 Operation modifiers:
   -k, --keep        keep (don't delete) input files
   -f, --force       force overwrite of output file
   -c, --stdout      write to standard output and don't delete input files
-  -o, --output=FILE write output to FILE
+  -o, --output=FILE write output to FILE (or directory for tar extract)
 
 Compression presets:
   -0 ... -9         compression preset level (default: 6)
@@ -128,6 +155,14 @@ Other options:
 
 With no FILE, or when FILE is -, read standard input.
 
+Examples:
+  nxz file.txt              compress file.txt to file.txt.xz
+  nxz -d file.xz            decompress file.xz
+  nxz -T -z dir/            create archive.tar.xz from dir/
+  nxz -l archive.tar.xz     list contents of archive
+  nxz -d archive.tar.xz     extract archive to current directory
+  nxz -d -o dest/ arch.txz  extract archive to dest/
+
 Report bugs at: https://github.com/oorabona/node-liblzma/issues`);
 }
 /**
@@ -153,10 +188,33 @@ Thread support: ${threadSupport}
 Copyright (C) ${year} Olivier ORABONA
 License: LGPL-3.0`);
 }
+/**
+ * Check if file is a tar.xz archive based on extension
+ */
+function isTarXzFile(filename) {
+    return filename.endsWith('.tar.xz') || filename.endsWith('.txz');
+}
 /**
  * Determine operation mode based on options and file extension
  */
 function determineMode(options, filename) {
+    if (options.benchmark)
+        return 'benchmark';
+    // Tar mode: explicit -T flag or auto-detected from extension
+    const isTar = options.tar || isTarXzFile(filename);
+    if (isTar) {
+        if (options.list)
+            return 'tar-list';
+        if (options.decompress)
+            return 'tar-extract';
+        if (options.compress)
+            return 'tar-create';
+        // Auto-detect: if file exists and is .tar.xz/.txz, extract; otherwise create
+        if (isTarXzFile(filename)) {
+            return options.list ? 'tar-list' : 'tar-extract';
+        }
+        return 'tar-create';
+    }
     if (options.list)
         return 'list';
     if (options.decompress)
@@ -240,71 +298,96 @@ function listFile(filename, options) {
 /**
  * Compress a file
  */
+/** Resolve output file and check for overwrites. Returns null for stdout mode. */
+function resolveOutputFile(inputFile, mode, options) {
+    if (options.stdout)
+        return null;
+    return options.output ?? getOutputFilename(inputFile, mode);
+}
+/** Attach verbose progress tracking to a stream. */
+function attachProgress(stream, inputFile, totalSize) {
+    let lastPercent = -1;
+    stream.on('progress', ({ bytesRead, bytesWritten }) => {
+        const percent = Math.floor((bytesRead / totalSize) * 100);
+        if (percent !== lastPercent) {
+            lastPercent = percent;
+            process.stderr.write(`\r${inputFile}: ${percent}% (${formatBytes(bytesRead)} -> ${formatBytes(bytesWritten)})`);
+        }
+    });
+}
+/** Clean up a partial output file and reset tracking state. */
+function cleanupPartialOutput(outputFile) {
+    if (outputFile && existsSync(outputFile)) {
+        try {
+            unlinkSync(outputFile);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+    currentOutputFile = null;
+}
+/** Read file content using fd-based operations (avoids TOCTOU race). Returns [data, fileSize]. */
+function readFileSafe(inputFile) {
+    const fd = openSync(inputFile, 'r');
+    try {
+        const size = fstatSync(fd).size;
+        const data = readFileSync(fd);
+        return { data, size };
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Write compressed/decompressed output to stdout or file. */
+function writeOutput(output, outputFile) {
+    if (outputFile) {
+        writeFileSync(outputFile, output);
+    }
+    else {
+        process.stdout.write(output);
+    }
+}
+/** Delete the original file after successful compression/decompression. */
+function removeOriginalIfNeeded(inputFile, options) {
+    if (!options.keep && !options.stdout) {
+        unlinkSync(inputFile);
+    }
+}
 async function compressFile(inputFile, options) {
-    const outputFile = options.stdout
-        ? null
-        : (options.output ?? getOutputFilename(inputFile, 'compress'));
-    // Check if output exists
+    const outputFile = resolveOutputFile(inputFile, 'compress', options);
     if (outputFile && existsSync(outputFile) && !options.force) {
         warn(`nxz: ${outputFile}: File already exists; use -f to overwrite`);
         return EXIT_ERROR;
     }
-    // Track output file for SIGINT cleanup
     currentOutputFile = outputFile;
     try {
-        const stat = statSync(inputFile);
+        const { data, size } = readFileSafe(inputFile);
         const presetValue = options.extreme ? options.preset | preset.EXTREME : options.preset;
-        if (options.stdout) {
-            // Write to stdout
-            const input = readFileSync(inputFile);
-            const compressed = xzSync(input, { preset: presetValue });
-            process.stdout.write(compressed);
-        }
-        else if (stat.size <= STREAM_THRESHOLD_BYTES) {
-            // Small file: use sync
-            const input = readFileSync(inputFile);
-            const compressed = xzSync(input, { preset: presetValue });
-            writeFileSync(outputFile, compressed);
+        if (!outputFile || size <= STREAM_THRESHOLD_BYTES) {
+            // Stdout or small file: sync compression
+            const compressed = xzSync(data, { preset: presetValue });
+            writeOutput(compressed, outputFile);
         }
         else {
-            // Large file: use streams
+            // Large file: stream compression with optional progress
             const compressor = createXz({ preset: presetValue });
             if (options.verbose) {
-                let lastPercent = -1;
-                compressor.on('progress', ({ bytesRead, bytesWritten }) => {
-                    const percent = Math.floor((bytesRead / stat.size) * 100);
-                    if (percent !== lastPercent) {
-                        lastPercent = percent;
-                        process.stderr.write(`\r${inputFile}: ${percent}% (${formatBytes(bytesRead)} -> ${formatBytes(bytesWritten)})`);
-                    }
-                });
+                attachProgress(compressor, inputFile, size);
             }
             await pipeline(createReadStream(inputFile), compressor, createWriteStream(outputFile));
             if (options.verbose) {
                 process.stderr.write('\n');
             }
         }
-        // Delete original unless -k or -c
-        if (!options.keep && !options.stdout) {
-            unlinkSync(inputFile);
-        }
-        // Clear tracking after successful completion
+        removeOriginalIfNeeded(inputFile, options);
         currentOutputFile = null;
         return EXIT_SUCCESS;
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         warn(`nxz: ${inputFile}: ${message}`);
-        // Cleanup partial output
-        if (outputFile && existsSync(outputFile)) {
-            try {
-                unlinkSync(outputFile);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-        currentOutputFile = null;
+        cleanupPartialOutput(outputFile);
         return EXIT_ERROR;
     }
 }
@@ -312,99 +395,333 @@ async function compressFile(inputFile, options) {
  * Decompress a file
  */
 async function decompressFile(inputFile, options) {
-    const outputFile = options.stdout
-        ? null
-        : (options.output ?? getOutputFilename(inputFile, 'decompress'));
-    // Check if output exists
+    const outputFile = resolveOutputFile(inputFile, 'decompress', options);
     if (outputFile && existsSync(outputFile) && !options.force) {
         warn(`nxz: ${outputFile}: File already exists; use -f to overwrite`);
         return EXIT_ERROR;
     }
-    // Track output file for SIGINT cleanup
     currentOutputFile = outputFile;
     try {
-        // Validate XZ format
-        const fd = readFileSync(inputFile);
-        if (!isXZ(fd)) {
+        const { data, size } = readFileSafe(inputFile);
+        if (!isXZ(data)) {
             warn(`nxz: ${inputFile}: File format not recognized`);
             currentOutputFile = null;
             return EXIT_ERROR;
         }
-        const stat = statSync(inputFile);
-        if (options.stdout) {
-            // Write to stdout
-            const decompressed = unxzSync(fd);
-            process.stdout.write(decompressed);
-        }
-        else if (stat.size <= STREAM_THRESHOLD_BYTES) {
-            // Small file: use sync
-            const decompressed = unxzSync(fd);
-            writeFileSync(outputFile, decompressed);
+        if (!outputFile || size <= STREAM_THRESHOLD_BYTES) {
+            // Stdout or small file: sync decompression
+            const decompressed = unxzSync(data);
+            writeOutput(decompressed, outputFile);
         }
         else {
-            // Large file: use streams with progress
+            // Large file: stream decompression with optional progress
             const decompressor = createUnxz();
             if (options.verbose) {
-                let lastPercent = -1;
-                decompressor.on('progress', ({ bytesRead, bytesWritten }) => {
-                    const percent = Math.floor((bytesRead / stat.size) * 100);
-                    if (percent !== lastPercent) {
-                        lastPercent = percent;
-                        process.stderr.write(`\r${inputFile}: ${percent}% (${formatBytes(bytesRead)} -> ${formatBytes(bytesWritten)})`);
-                    }
-                });
+                attachProgress(decompressor, inputFile, size);
             }
             await pipeline(createReadStream(inputFile), decompressor, createWriteStream(outputFile));
             if (options.verbose) {
                 process.stderr.write('\n');
             }
         }
-        // Delete original unless -k or -c
-        if (!options.keep && !options.stdout) {
-            unlinkSync(inputFile);
-        }
-        // Clear tracking after successful completion
+        removeOriginalIfNeeded(inputFile, options);
         currentOutputFile = null;
         return EXIT_SUCCESS;
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         warn(`nxz: ${inputFile}: ${message}`);
-        // Cleanup partial output
-        if (outputFile && existsSync(outputFile)) {
-            try {
-                unlinkSync(outputFile);
+        cleanupPartialOutput(outputFile);
+        return EXIT_ERROR;
+    }
+}
+/**
+ * Process a single file
+ */
+/** Measure execution time of an async function in milliseconds. */
+async function measureAsync(fn) {
+    const start = performance.now();
+    const result = await fn();
+    return { result, ms: performance.now() - start };
+}
+/** Measure execution time of a sync function in milliseconds. */
+function measureSync(fn) {
+    const start = performance.now();
+    const result = fn();
+    return { result, ms: performance.now() - start };
+}
+/** Format milliseconds for display. */
+function formatMs(ms) {
+    if (ms < 1)
+        return `${(ms * 1000).toFixed(0)} µs`;
+    if (ms < 1000)
+        return `${ms.toFixed(1)} ms`;
+    return `${(ms / 1000).toFixed(2)} s`;
+}
+/** Format a ratio as "Nx faster" or "Nx slower". */
+function formatSpeedup(baseline, candidate) {
+    if (candidate === 0 || baseline === 0)
+        return 'N/A';
+    const ratio = baseline / candidate;
+    if (ratio >= 1)
+        return `${ratio.toFixed(1)}x faster`;
+    return `${(1 / ratio).toFixed(1)}x slower`;
+}
+/**
+ * Benchmark native vs WASM compression/decompression on a file.
+ */
+async function benchmarkFile(inputFile, options) {
+    // Initialize WASM module with Node.js file-based loader
+    const { initModule, resetModule } = await import('../wasm/bindings.js');
+    const { xzAsync: wasmXzAsync, unxzAsync: wasmUnxzAsync } = await import('../wasm/index.js');
+    const { readFileSync: fsReadFileSync } = await import('node:fs');
+    const { fileURLToPath } = await import('node:url');
+    const { dirname, join } = await import('node:path');
+    const wasmDir = dirname(fileURLToPath(import.meta.url));
+    const wasmPath = join(wasmDir, '..', 'wasm', 'liblzma.wasm');
+    resetModule();
+    await initModule(async () => {
+        const { default: createLZMA } = await import('../wasm/liblzma.js');
+        const wasmBinary = fsReadFileSync(wasmPath);
+        return (await createLZMA({ wasmBinary }));
+    });
+    const { data, size } = readFileSafe(inputFile);
+    const presetValue = options.extreme ? options.preset | preset.EXTREME : options.preset;
+    console.error(`\nBenchmark: ${inputFile} (${formatBytes(size)}, preset ${options.preset}${options.extreme ? 'e' : ''})\n`);
+    // --- Compression ---
+    const nativeCompress = measureSync(() => xzSync(data, { preset: presetValue }));
+    const wasmCompress = await measureAsync(() => wasmXzAsync(data, { preset: presetValue }));
+    // --- Decompression ---
+    const nativeDecompress = measureSync(() => unxzSync(nativeCompress.result));
+    const wasmDecompress = await measureAsync(() => wasmUnxzAsync(wasmCompress.result));
+    // --- Verify correctness ---
+    const nativeOk = Buffer.compare(nativeDecompress.result, data) === 0;
+    const wasmOk = Buffer.compare(Buffer.from(wasmDecompress.result), data) === 0;
+    // --- Cross-decompression ---
+    const crossNativeToWasm = await measureAsync(() => wasmUnxzAsync(nativeCompress.result));
+    const crossWasmToNative = measureSync(() => unxzSync(Buffer.from(wasmCompress.result)));
+    const crossOk1 = Buffer.compare(Buffer.from(crossNativeToWasm.result), data) === 0;
+    const crossOk2 = Buffer.compare(crossWasmToNative.result, data) === 0;
+    // --- Output table ---
+    const col1 = 22;
+    const col2 = 16;
+    const col3 = 16;
+    const col4 = 18;
+    const sep = '-'.repeat(col1 + col2 + col3 + col4 + 7);
+    const row = (label, native, wasm, diff) => `  ${label.padEnd(col1)} ${native.padStart(col2)} ${wasm.padStart(col3)} ${diff.padStart(col4)}`;
+    console.error(sep);
+    console.error(row('', 'Native', 'WASM', 'Comparison'));
+    console.error(sep);
+    console.error(row('Compress time', formatMs(nativeCompress.ms), formatMs(wasmCompress.ms), formatSpeedup(wasmCompress.ms, nativeCompress.ms)));
+    console.error(row('Compressed size', formatBytes(nativeCompress.result.length), formatBytes(wasmCompress.result.length), nativeCompress.result.length === wasmCompress.result.length
+        ? 'identical'
+        : `${((wasmCompress.result.length / nativeCompress.result.length - 1) * 100).toFixed(1)}%`));
+    console.error(row('Decompress time', formatMs(nativeDecompress.ms), formatMs(wasmDecompress.ms), formatSpeedup(wasmDecompress.ms, nativeDecompress.ms)));
+    console.error(row('Roundtrip OK', nativeOk ? 'YES' : 'FAIL', wasmOk ? 'YES' : 'FAIL', ''));
+    console.error(sep);
+    console.error(row('Cross: Native→WASM', '', formatMs(crossNativeToWasm.ms), crossOk1 ? 'OK' : 'FAIL'));
+    console.error(row('Cross: WASM→Native', formatMs(crossWasmToNative.ms), '', crossOk2 ? 'OK' : 'FAIL'));
+    console.error(sep);
+    const allOk = nativeOk && wasmOk && crossOk1 && crossOk2;
+    console.error(`\n  Verdict: ${allOk ? 'ALL PASS — Both backends produce valid output' : 'FAIL — Data mismatch detected'}\n`);
+    // Reset WASM module to not interfere with other operations
+    resetModule();
+    return allOk ? EXIT_SUCCESS : EXIT_ERROR;
+}
+/**
+ * List contents of a tar.xz archive
+ */
+async function listTarFile(filename, options) {
+    try {
+        const tarXz = await loadTarXz();
+        const entries = await tarXz.list({ file: filename });
+        if (options.verbose) {
+            // Verbose format with permissions, size, date
+            for (const entry of entries) {
+                const typeChar = entry.type === '5' ? 'd' : '-';
+                const modeStr = entry.mode?.toString(8).padStart(4, '0') ?? '0644';
+                const size = formatBytes(entry.size).padStart(10);
+                const date = entry.mtime ? new Date(entry.mtime * 1000).toISOString().slice(0, 16) : '';
+                console.log(`${typeChar}${modeStr} ${size} ${date} ${entry.name}`);
             }
-            catch {
-                // Ignore cleanup errors
+        }
+        else {
+            // Simple format: just names
+            for (const entry of entries) {
+                console.log(entry.name);
+            }
+        }
+        if (!options.quiet) {
+            console.error(`\nTotal: ${entries.length} entries`);
+        }
+        return EXIT_SUCCESS;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        warn(`nxz: ${filename}: ${message}`);
+        return EXIT_ERROR;
+    }
+}
+/**
+ * Create a tar.xz archive from files/directories
+ */
+function findCommonParent(paths) {
+    if (paths.length === 0)
+        return process.cwd();
+    if (paths.length === 1)
+        return paths[0];
+    const parts = paths.map((p) => p.split('/'));
+    const common = [];
+    for (let i = 0; i < parts[0].length; i++) {
+        const segment = parts[0][i];
+        if (parts.every((p) => p[i] === segment)) {
+            common.push(segment);
+        }
+        else {
+            break;
+        }
+    }
+    return common.join('/') || '/';
+}
+async function createTarFile(files, options) {
+    try {
+        const tarXz = await loadTarXz();
+        const path = await import('node:path');
+        // Determine output filename
+        let outputFile = options.output;
+        if (!outputFile) {
+            // Use first file/dir name as base
+            const base = path.basename(files[0]).replace(/\/$/, '');
+            outputFile = `${base}.tar.xz`;
+        }
+        if (existsSync(outputFile) && !options.force) {
+            warn(`nxz: ${outputFile}: File already exists; use -f to overwrite`);
+            return EXIT_ERROR;
+        }
+        currentOutputFile = outputFile;
+        // Resolve all files to absolute paths for consistent handling
+        const resolvedFiles = files.map((f) => path.resolve(f));
+        // Determine cwd (common parent directory)
+        let cwd;
+        if (resolvedFiles.length === 1 && statSync(resolvedFiles[0]).isDirectory()) {
+            cwd = resolvedFiles[0];
+        }
+        else {
+            // Find common parent of all files
+            const parents = resolvedFiles.map((f) => (statSync(f).isDirectory() ? f : path.dirname(f)));
+            // Use the first file's parent as cwd for simple cases
+            cwd = parents.length === 1 ? parents[0] : findCommonParent(parents);
+        }
+        // Collect files to archive (relative to cwd)
+        const filesToArchive = [];
+        for (const file of resolvedFiles) {
+            if (statSync(file).isDirectory()) {
+                const { readdirSync } = await import('node:fs');
+                const entries = readdirSync(file, { recursive: true, withFileTypes: true });
+                const dirRelative = path.relative(cwd, file);
+                for (const entry of entries) {
+                    if (entry.isFile()) {
+                        const entryPath = entry.parentPath === file
+                            ? entry.name
+                            : `${entry.parentPath.slice(file.length + 1)}/${entry.name}`;
+                        filesToArchive.push(dirRelative ? `${dirRelative}/${entryPath}` : entryPath);
+                    }
+                }
+            }
+            else {
+                filesToArchive.push(path.relative(cwd, file));
             }
         }
+        const presetValue = options.extreme ? options.preset | preset.EXTREME : options.preset;
+        if (options.verbose) {
+            console.error(`Creating ${outputFile} from ${filesToArchive.length} files...`);
+        }
+        await tarXz.create({
+            file: outputFile,
+            cwd,
+            files: filesToArchive,
+            preset: presetValue,
+        });
+        if (options.verbose) {
+            const stats = statSync(outputFile);
+            console.error(`Created ${outputFile} (${formatBytes(stats.size)})`);
+        }
         currentOutputFile = null;
+        return EXIT_SUCCESS;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        warn(`nxz: ${message}`);
+        cleanupPartialOutput(currentOutputFile);
         return EXIT_ERROR;
     }
 }
 /**
- * Process a single file
+ * Extract a tar.xz archive
  */
+async function extractTarFile(filename, options) {
+    try {
+        const tarXz = await loadTarXz();
+        // Determine output directory
+        const outputDir = options.output ?? process.cwd();
+        // Create output directory if it doesn't exist
+        if (!existsSync(outputDir)) {
+            const { mkdirSync } = await import('node:fs');
+            mkdirSync(outputDir, { recursive: true });
+        }
+        if (options.verbose) {
+            console.error(`Extracting ${filename} to ${outputDir}...`);
+        }
+        const entries = await tarXz.extract({
+            file: filename,
+            cwd: outputDir,
+            strip: options.strip,
+        });
+        if (options.verbose) {
+            for (const entry of entries) {
+                console.error(`  ${entry.name}`);
+            }
+            console.error(`\nExtracted ${entries.length} entries`);
+        }
+        // Delete original if not keeping
+        removeOriginalIfNeeded(filename, options);
+        return EXIT_SUCCESS;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        warn(`nxz: ${filename}: ${message}`);
+        return EXIT_ERROR;
+    }
+}
 async function processFile(filename, options) {
     // Check file exists
     if (!existsSync(filename)) {
         warn(`nxz: ${filename}: No such file or directory`);
         return EXIT_ERROR;
     }
-    // Check if it's a directory
-    if (statSync(filename).isDirectory()) {
+    const isDir = statSync(filename).isDirectory();
+    const mode = determineMode(options, filename);
+    // Directories are only allowed for tar-create mode
+    if (isDir && mode !== 'tar-create') {
         warn(`nxz: ${filename}: Is a directory, skipping`);
         return EXIT_ERROR;
     }
-    const mode = determineMode(options, filename);
     switch (mode) {
         case 'list':
             return listFile(filename, options);
+        case 'benchmark':
+            return benchmarkFile(filename, options);
         case 'compress':
             return compressFile(filename, options);
         case 'decompress':
             return decompressFile(filename, options);
+        case 'tar-list':
+            return listTarFile(filename, options);
+        case 'tar-extract':
+            return extractTarFile(filename, options);
+        case 'tar-create':
+            // tar-create is handled separately since it takes multiple files
+            return EXIT_SUCCESS;
     }
 }
 /**
@@ -462,6 +779,14 @@ async function main() {
         const exitCode = await processStdin(options);
         process.exit(exitCode);
     }
+    // Check for tar-create mode: -T with files that aren't .tar.xz archives
+    if (options.files.length > 0) {
+        const mode = determineMode(options, options.files[0]);
+        if (mode === 'tar-create') {
+            const exitCode = await createTarFile(options.files, options);
+            process.exit(exitCode);
+        }
+    }
     // Process each file
     let exitCode = EXIT_SUCCESS;
     for (const file of options.files) {