stegdoc 5.7.0 → 6.1.0

package/src/commands/encode.js

@@ -3,44 +3,146 @@ const fs = require('fs');
 const { pipeline } = require('stream/promises');
 const chalk = require('chalk');
 const ora = require('ora');
-const AdmZip = require('adm-zip');
-const { createDocxWithBase64, createDocxV5 } = require('../lib/docx-handler');
+const { createDocxV5 } = require('../lib/docx-handler');
 const { createXlsxPartV5 } = require('../lib/xlsx-handler');
 const { createMetadata, serializeMetadata } = require('../lib/metadata');
 const crypto = require('crypto');
 const { generateHash, parseSizeToBytes, formatBytes, generateFilename } = require('../lib/utils');
 const { packEncryptionMeta, generateSalt, createEncryptStream } = require('../lib/crypto');
-const { isCompressedMime, createCompressStream, createBrotliCompressStream } = require('../lib/compression');
+const { createBrotliCompressStream } = require('../lib/compression');
 const { resetTimeWindow } = require('../lib/decoy-generator');
 const { resetTimeState, BYTES_PER_DATA_LINE, calculateDataLineCount } = require('../lib/log-generator');
 const { shouldRunInteractive, promptEncodeOptions } = require('../lib/interactive');
-const { Base64EncodeTransform, ChunkCollector, BinaryChunkCollector, ProgressTransform } = require('../lib/streams');
+const { BinaryChunkCollector, ProgressTransform } = require('../lib/streams');
+const { loadNative } = require('../lib/native');
 
 /**
- * Zip a folder into a buffer
+ * Load the native engine, failing loudly when it is unavailable. Bundling has
+ * no JavaScript implementation any more: the archive is built by the core.
+ *
+ * @returns {object} The native binding.
+ */
+function requireNative() {
+  const native = loadNative();
+  if (!native || typeof native.zip !== 'function') {
+    throw new Error(
+      'Bundling inputs requires the native engine, which is not installed. ' +
+      'Reinstall stegdoc, or build it with `pnpm build:native`.'
+    );
+  }
+  return native;
+}
+
+/**
+ * Recursively collect a directory's files as archive entries under `prefix`.
+ *
+ * @param {string} dirPath Directory to walk.
+ * @param {string} prefix Forward-slash entry path prefix.
+ * @param {Array<{name: string, bytes: Buffer}>} entries Accumulator.
+ */
+function collectDirectory(dirPath, prefix, entries) {
+  for (const dirent of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    const full = path.join(dirPath, dirent.name);
+    const name = `${prefix}/${dirent.name}`;
+    if (dirent.isDirectory()) {
+      collectDirectory(full, name, entries);
+    } else {
+      entries.push({ name, bytes: fs.readFileSync(full) });
+    }
+  }
+}
+
+/**
+ * Zip a folder into a buffer, keeping the folder's basename as a prefix.
+ *
+ * @param {string} folderPath Folder to archive.
+ * @returns {Buffer} The archive bytes.
  */
 function zipFolder(folderPath) {
-  const zip = new AdmZip();
-  zip.addLocalFolder(folderPath);
-  return zip.toBuffer();
+  const native = requireNative();
+  const entries = [];
+  collectDirectory(folderPath, path.basename(folderPath), entries);
+  return native.zip(entries);
 }
 
 /**
- * Detect file type from the first 4KB
+ * Pick an archive entry name that is not taken yet, disambiguating inputs that
+ * share a basename by inserting a counter before the extension.
+ *
+ * @param {string} name Preferred entry name.
+ * @param {Set<string>} used Names already placed in the archive.
+ * @returns {string} A free entry name, which is added to `used`.
  */
-async function detectFileType(filePath) {
-  try {
-    const fileType = await import('file-type');
-    const fromBuffer = fileType.fileTypeFromBuffer || fileType.default?.fromBuffer;
-    if (!fromBuffer) return null;
-    const fd = await fs.promises.open(filePath, 'r');
-    const buf = Buffer.alloc(4100);
-    await fd.read(buf, 0, 4100, 0);
-    await fd.close();
-    return await fromBuffer(buf);
-  } catch {
-    return null;
+function uniqueEntryName(name, used) {
+  if (!used.has(name)) {
+    used.add(name);
+    return name;
+  }
+  const extension = path.extname(name);
+  const stem = name.slice(0, name.length - extension.length);
+  let counter = 2;
+  let candidate = `${stem}-${counter}${extension}`;
+  while (used.has(candidate)) {
+    counter += 1;
+    candidate = `${stem}-${counter}${extension}`;
+  }
+  used.add(candidate);
+  return candidate;
+}
+
+/**
+ * Zip several inputs into one buffer. Files land at the archive root under
+ * their basename; a folder keeps its own name as a prefix.
+ *
+ * @param {string[]} inputs Absolute or relative paths to files and folders.
+ * @returns {Buffer} The archive bytes.
+ */
+function zipInputs(inputs) {
+  const native = requireNative();
+  const entries = [];
+  const used = new Set();
+  for (const input of inputs) {
+    const base = path.basename(input.replace(/[\\/]+$/, ''));
+    const entry = uniqueEntryName(base, used);
+    if (fs.statSync(input).isDirectory()) {
+      collectDirectory(input, entry, entries);
+    } else {
+      entries.push({ name: entry, bytes: fs.readFileSync(input) });
+    }
   }
+  return native.zip(entries);
+}
+
+/**
+ * Normalise a bundle name: no path segments, always a `.zip` extension.
+ *
+ * @param {string} name Requested name, possibly empty.
+ * @returns {string} The filename recorded in metadata for the bundle.
+ */
+function bundleFilename(name) {
+  const base = path.basename((name || '').trim());
+  if (!base || base === '.' || base === '..') return 'bundle.zip';
+  return base.toLowerCase().endsWith('.zip') ? base : `${base}.zip`;
+}
+
+/**
+ * Extensions whose contents are already compressed, so Brotli only wastes CPU.
+ */
+const COMPRESSED_EXTENSIONS = new Set([
+  'zip', 'gz', 'tgz', 'bz2', 'xz', '7z', 'rar',
+  'jpg', 'jpeg', 'png', 'gif', 'webp',
+  'mp3', 'mp4', 'm4a', 'mov', 'avi', 'mkv', 'webm', 'ogg', 'opus', 'flac',
+  'pdf', 'apk', 'jar', 'docx', 'xlsx', 'pptx', 'wasm', 'br',
+]);
+
+/**
+ * Check whether an extension is already compressed.
+ *
+ * @param {string} ext Extension, with or without a leading dot.
+ * @returns {boolean} True when the format needs no further compression.
+ */
+function isCompressedExtension(ext) {
+  return COMPRESSED_EXTENSIONS.has(String(ext || '').toLowerCase().replace(/^\./, ''));
 }
 
 /**
@@ -57,12 +159,24 @@ async function computeFileHash(filePath) {
 }
 
 /**
- * Encode a file to XLSX/DOCX format with optional AES encryption and compression.
+ * Encode one or more inputs to XLSX/DOCX format with optional AES encryption
+ * and compression. Several inputs, or a single folder, are zipped first and the
+ * archive is what gets encoded, so a decode hands back that zip.
+ *
+ * @param {string|string[]} input One path, or several to bundle together.
+ * @param {object} options Commander options for the encode command.
  */
-async function encodeCommand(inputFile, options) {
+async function encodeCommand(input, options) {
+  const inputs = Array.isArray(input) ? input : [input];
+  if (inputs.length === 0) {
+    throw new Error('No input given.');
+  }
+  const bundling = inputs.length > 1;
+  const bundleName = bundleFilename(options.bundleName);
+
   // Check if we should run interactive mode
   if (shouldRunInteractive(options, 'encode')) {
-    const filename = path.basename(inputFile);
+    const filename = bundling ? bundleName : path.basename(inputs[0]);
     console.log(chalk.bold(`\nEncoding: ${filename}`));
 
     const interactiveOptions = await promptEncodeOptions(filename);
@@ -71,7 +185,10 @@ async function encodeCommand(inputFile, options) {
   }
 
   const quiet = options.quiet || false;
-  const legacy = options.legacy || false;
+  if (options.v5 && options.v6) {
+    throw new Error('--v5 and --v6 cannot be combined.');
+  }
+  const version = options.v5 ? 'v5' : 'v6';
   const spinner = quiet ? { start: () => {}, succeed: () => {}, fail: () => {}, info: () => {}, text: '' } : ora('Starting encoding process...').start();
   const createdFiles = [];
 
@@ -80,11 +197,14 @@ async function encodeCommand(inputFile, options) {
   resetTimeState();
 
   try {
-    if (!fs.existsSync(inputFile)) {
-      throw new Error(`Path not found: ${inputFile}`);
+    for (const candidate of inputs) {
+      if (!fs.existsSync(candidate)) {
+        throw new Error(`Path not found: ${candidate}`);
+      }
     }
 
-    const isDirectory = fs.statSync(inputFile).isDirectory();
+    const inputFile = inputs[0];
+    const isDirectory = !bundling && fs.statSync(inputFile).isDirectory();
     const format = (options.format || 'xlsx').toLowerCase();
     if (format !== 'xlsx' && format !== 'docx') {
       throw new Error('Invalid format. Use "xlsx" or "docx".');
@@ -99,7 +219,23 @@ async function encodeCommand(inputFile, options) {
     let fileSize;
     let tempZipPath = null;
 
-    if (isDirectory) {
+    if (bundling) {
+      // One archive keeps the pipeline single-payload: a decode hands back the
+      // zip, so nothing downstream has to know about multiple inputs.
+      spinner.text = `Bundling ${inputs.length} inputs...`;
+      const zipBuffer = zipInputs(inputs);
+      filename = bundleName;
+      extension = '.zip';
+      fileSize = zipBuffer.length;
+
+      tempZipPath = path.join(require('os').tmpdir(), `stegdoc_${Date.now()}.zip`);
+      fs.writeFileSync(tempZipPath, zipBuffer);
+      streamSource = tempZipPath;
+
+      spinner.succeed && spinner.succeed(
+        `Bundled ${inputs.length} inputs into ${filename} (${formatBytes(fileSize)})`
+      );
+    } else if (isDirectory) {
       spinner.text = 'Zipping folder...';
       const folderName = path.basename(inputFile);
       const zipBuffer = zipFolder(inputFile);
@@ -122,34 +258,23 @@ async function encodeCommand(inputFile, options) {
 
     spinner.text = 'Checking file type...';
     let useCompression = true;
-    const fileType = await detectFileType(streamSource);
+    const extensionKey = extension.replace(/^\./, '').toLowerCase();
 
-    if (fileType && isCompressedMime(fileType.mime)) {
+    if (isCompressedExtension(extensionKey)) {
       useCompression = false;
-      spinner.info && spinner.info(`Skipping compression (${fileType.ext} is already compressed)`);
+      spinner.info && spinner.info(`Skipping compression (${extensionKey} is already compressed)`);
     }
 
-    // DOCX v5 size limit (not applicable in legacy mode or with --no-limit)
+    // DOCX v5 size limit (not applicable with --no-limit)
     const noLimit = options.noLimit || options.limit === false;
-    if (format === 'docx' && !legacy && !noLimit && fileSize > 1 * 1024 * 1024) {
+    if (format === 'docx' && !noLimit && fileSize > 1 * 1024 * 1024) {
       throw new Error(
         `DOCX format is limited to files under 1 MB (yours is ${formatBytes(fileSize)}). ` +
         `Use XLSX format (-f xlsx) for larger files, or --no-limit to bypass.`
       );
     }
 
-    // Route to legacy or v5 pipeline
-    if (legacy) {
-      if (format === 'docx') {
-        await encodeLegacyDocx(streamSource, filename, extension, fileSize, options, useCompression, useEncryption, spinner, quiet, createdFiles);
-      } else {
-        throw new Error('Legacy XLSX format (--legacy) is no longer supported. Use v5 format (default) or legacy DOCX (-f docx --legacy).');
-      }
-      if (tempZipPath) cleanupTemp(tempZipPath);
-      return;
-    }
-
-    // === v5 Log-Embed Pipeline ===
+    // === Log-Embed Pipeline ===
     const hash = generateHash();
     const outputDir = options.outputDir || process.cwd();
 
@@ -175,6 +300,49 @@ async function encodeCommand(inputFile, options) {
 
     // Pre-compute content hash
     spinner.text = 'Computing file hash...';
+
+    // Prefer the native engine; the JavaScript encoder only covers v5.
+    const native = loadNative();
+    if (version === 'v6' && !native) {
+      throw new Error(
+        'v6 output requires the native engine (run `pnpm build:native` or install the platform package). Use --v5 for the JavaScript encoder.'
+      );
+    }
+    if (native) {
+      spinner.text = 'Encoding...';
+      const result = native.encode(streamSource, outputDir, {
+        format,
+        version,
+        password: options.password || undefined,
+        chunkSize: chunkSizeBytes === Infinity ? undefined : chunkSizeBytes,
+        compress: useCompression,
+        force: !!options.force,
+        originalFilename: filename,
+        originalExtension: extension,
+      });
+      createdFiles.push(...result.files);
+      spinner.succeed && spinner.succeed(`Encoded ${result.partCount} part${result.partCount !== 1 ? 's' : ''}`);
+
+      if (!quiet) {
+        console.log();
+        console.log(chalk.green.bold('✓ File encoded successfully!'));
+        console.log(chalk.cyan(`  Format: ${format.toUpperCase()} (${version} log-embed)`));
+        console.log(chalk.cyan(`  Hash: ${result.hash}`));
+        if (result.partCount > 1) {
+          console.log(chalk.cyan(`  Parts: ${result.partCount}`));
+        }
+        console.log(chalk.cyan(`  Encrypted: ${result.encrypted ? 'Yes' : 'No'}`));
+        console.log(chalk.cyan(`  Compressed: ${result.compressed ? 'Yes (Brotli)' : 'No'}`));
+        console.log(chalk.cyan(`  Location: ${outputDir}`));
+        if (result.encrypted) {
+          console.log(chalk.yellow(`  Remember your password - it cannot be recovered!`));
+        }
+      }
+
+      if (tempZipPath) cleanupTemp(tempZipPath);
+      return;
+    }
+
     const contentHash = await computeFileHash(streamSource);
 
     // Generate session salt for encryption
@@ -252,7 +420,6 @@ async function encodeCommand(inputFile, options) {
         encrypted: useEncryption,
         compressed: useCompression,
         contentHash,
-        stegoMethod: 'log-embed',
         compressionAlgo: 'brotli',
         payloadSize: payloadBuffer.length,
         dataLineCount,
@@ -356,96 +523,6 @@ async function encodeCommand(inputFile, options) {
   }
 }
 
-// ─── Legacy v4 DOCX Pipeline ────────────────────────────────────────────────
-
-async function encodeLegacyDocx(inputPath, filename, extension, fileSize, options, useCompression, useEncryption, spinner, quiet, createdFiles) {
-  const { compress } = require('../lib/compression');
-  const { encrypt, packEncryptionMeta: packMeta } = require('../lib/crypto');
-  const { generateContentHash } = require('../lib/utils');
-
-  const fileBuffer = fs.readFileSync(inputPath);
-  const contentHash = generateContentHash(fileBuffer);
-
-  let processedBuffer = fileBuffer;
-  if (useCompression) {
-    spinner.text = 'Compressing...';
-    const compressedBuffer = await compress(fileBuffer);
-    if (compressedBuffer.length < fileBuffer.length) {
-      processedBuffer = compressedBuffer;
-      spinner.succeed && spinner.succeed(`Compressed: ${formatBytes(fileBuffer.length)} → ${formatBytes(compressedBuffer.length)}`);
-    } else {
-      useCompression = false;
-      spinner.info && spinner.info('Compression skipped (no size benefit)');
-    }
-  }
-
-  const base64 = processedBuffer.toString('base64');
-
-  let contentToStore;
-  let encryptionMeta = null;
-
-  if (useEncryption) {
-    spinner.text = 'Encrypting content...';
-    const { ciphertext, iv, salt, authTag } = encrypt(base64, options.password);
-    encryptionMeta = packMeta({ iv, salt, authTag });
-    contentToStore = ciphertext;
-    spinner.succeed && spinner.succeed('Content encrypted with AES-256-GCM');
-  } else {
-    contentToStore = base64;
-  }
-
-  const hash = generateHash();
-  const outputDir = options.outputDir || process.cwd();
-  const format = 'docx';
-
-  const metadata = createMetadata({
-    originalFilename: filename,
-    originalExtension: extension,
-    hash,
-    partNumber: null,
-    totalParts: null,
-    originalSize: fileSize,
-    format,
-    encrypted: useEncryption,
-    compressed: useCompression,
-    contentHash,
-  });
-
-  const outputFilename = generateFilename(hash, null, null, format);
-  const outputPath = path.join(outputDir, outputFilename);
-
-  if (fs.existsSync(outputPath) && !options.force) {
-    throw new Error(`File already exists: ${outputPath}. Use --force to overwrite.`);
-  }
-
-  const docxContent = useEncryption
-    ? `${encryptionMeta}|||${contentToStore}`
-    : contentToStore;
-
-  await createDocxWithBase64({
-    base64Content: docxContent,
-    metadata,
-    outputPath,
-  });
-
-  createdFiles.push(outputPath);
-  spinner.succeed && spinner.succeed('Encoding complete!');
-
-  if (!quiet) {
-    console.log();
-    console.log(chalk.green.bold('✓ File encoded successfully!'));
-    console.log(chalk.cyan(`  Format: DOCX (v4 legacy)`));
-    console.log(chalk.cyan(`  Hash: ${hash}`));
-    console.log(chalk.cyan(`  Output: ${outputFilename}`));
-    console.log(chalk.cyan(`  Encrypted: ${useEncryption ? 'Yes' : 'No'}`));
-    console.log(chalk.cyan(`  Compressed: ${useCompression ? 'Yes' : 'No'}`));
-    console.log(chalk.cyan(`  Location: ${outputDir}`));
-    if (useEncryption) {
-      console.log(chalk.yellow(`  Remember your password - it cannot be recovered!`));
-    }
-  }
-}
-
 function cleanupTemp(tempPath) {
   try {
     if (fs.existsSync(tempPath)) {

package/src/commands/info.js

@@ -1,11 +1,53 @@
-const path = require('path');
 const chalk = require('chalk');
 const ora = require('ora');
-const { readDocxBase64 } = require('../lib/docx-handler');
-const { readXlsxBase64 } = require('../lib/xlsx-handler');
-const { validateMetadata, isMultiPart, isLogEmbedFormat } = require('../lib/metadata');
-const { detectFormat, formatBytes } = require('../lib/utils');
-const { extractContent, findMultiPartFiles } = require('../lib/file-utils');
+const { formatBytes } = require('../lib/utils');
+const { loadNative } = require('../lib/native');
+
+const NATIVE_REQUIRED =
+  'Reading file metadata requires the native engine, which is not installed. ' +
+  'Reinstall stegdoc, or build it with `pnpm build:native`.';
+
+const LEGACY_UNSUPPORTED =
+  'The legacy v3/v4 format is no longer supported. Re-encode the file with a current version of stegdoc.';
+
+/**
+ * Print metadata read by the native engine, which handles v5 and v6.
+ */
+function printNativeInfo(info) {
+  console.log();
+  console.log(chalk.bold.white('File Information:'));
+  console.log(chalk.cyan(`  Format: ${info.format.toUpperCase()} (${info.formatVersion})`));
+  console.log(chalk.cyan(`  Stego method: Log-embed (${info.formatVersion})`));
+  console.log(chalk.cyan(`  Authenticated metadata: ${info.authenticated ? 'Yes' : 'No'}`));
+  console.log();
+  console.log(chalk.bold.white('Original File:'));
+  console.log(chalk.cyan(`  Filename: ${info.originalFilename}`));
+  console.log(chalk.cyan(`  Size: ${formatBytes(info.originalSize)}`));
+  console.log();
+  console.log(chalk.bold.white('Encoding Options:'));
+  console.log(chalk.cyan(`  Encrypted: ${info.encrypted ? chalk.yellow('Yes') : 'No'}`));
+  console.log(chalk.cyan(`  Compressed: ${info.compressed ? chalk.green('Yes') : 'No'}`));
+  console.log(chalk.cyan(`  Encoded on: ${info.encodingDate || 'Unknown'}`));
+  if (info.contentHash) {
+    console.log(chalk.cyan(`  Content hash: ${info.contentHash.slice(0, 16)}...`));
+  }
+  console.log();
+  if (info.partCount > 1) {
+    console.log(chalk.bold.white('Multi-part File:'));
+    console.log(chalk.cyan(`  This is part: ${info.partNumber} of ${info.partCount}`));
+    console.log(chalk.cyan(`  Hash: ${info.hash}`));
+    console.log();
+    console.log(chalk.green.bold(`All ${info.partCount} parts required to decode`));
+  } else {
+    console.log(chalk.bold.white('Single File:'));
+    console.log(chalk.cyan(`  Hash: ${info.hash}`));
+    console.log();
+    console.log(chalk.green.bold('Ready to decode'));
+  }
+  if (info.encrypted) {
+    console.log(chalk.yellow('\nNote: Password required for decoding'));
+  }
+}
 
 /**
  * Show information about an encoded file without decoding
@@ -14,100 +56,29 @@ async function infoCommand(inputFile, options) {
   const spinner = ora('Reading file metadata...').start();
 
   try {
-    const format = detectFormat(inputFile);
-    if (!format) {
-      throw new Error('Unknown file format. Supported formats: .xlsx, .docx');
+    const native = loadNative();
+    if (!native) {
+      throw new Error(NATIVE_REQUIRED);
     }
 
-    let readResult;
-    if (format === 'xlsx') {
-      readResult = await readXlsxBase64(inputFile);
-    } else {
-      readResult = await readDocxBase64(inputFile);
+    let probe;
+    try {
+      probe = native.probe(inputFile);
+    } catch {
+      probe = 'unknown';
     }
-
-    const extracted = extractContent(readResult, format);
-    const metadata = extracted.metadata;
-    const encryptionMeta = extracted.encryptionMeta;
-
-    validateMetadata(metadata);
-
-    const isEncrypted = metadata.encrypted || (encryptionMeta && encryptionMeta.length > 0);
-    const isCompressed = metadata.compressed || false;
-    const isV5 = isLogEmbedFormat(metadata);
-
-    spinner.succeed('File metadata read successfully');
-    console.log();
-
-    console.log(chalk.bold.white('File Information:'));
-    console.log(chalk.cyan(`  Format: ${format.toUpperCase()}`));
-    console.log(chalk.cyan(`  Tool version: ${metadata.version || '1.x'}`));
-    if (isV5) {
-      console.log(chalk.cyan(`  Stego method: Log-embed (v5)`));
-      console.log(chalk.cyan(`  Compression: ${metadata.compressionAlgo || 'brotli'}`));
+    if (probe === 'legacy') {
+      throw new Error(LEGACY_UNSUPPORTED);
     }
-    console.log();
-
-    console.log(chalk.bold.white('Original File:'));
-    console.log(chalk.cyan(`  Filename: ${metadata.originalFilename}`));
-    console.log(chalk.cyan(`  Extension: ${metadata.originalExtension}`));
-    console.log(chalk.cyan(`  Size: ${formatBytes(metadata.originalSize)}`));
-    console.log();
-
-    console.log(chalk.bold.white('Encoding Options:'));
-    console.log(chalk.cyan(`  Encrypted: ${isEncrypted ? chalk.yellow('Yes') : 'No'}`));
-    console.log(chalk.cyan(`  Compressed: ${isCompressed ? chalk.green('Yes') : 'No'}`));
-    console.log(chalk.cyan(`  Encoded on: ${metadata.encodingDate || 'Unknown'}`));
-
-    if (metadata.contentHash) {
-      console.log(chalk.cyan(`  Content hash: ${metadata.contentHash.slice(0, 16)}...`));
-    }
-
-    if (isV5 && metadata.dataLineCount) {
-      console.log(chalk.cyan(`  Data lines: ${metadata.dataLineCount}`));
-    }
-    console.log();
-
-    const hasMultipleParts = isMultiPart(metadata) || metadata.partNumber !== null;
-    if (hasMultipleParts) {
-      console.log(chalk.bold.white('Multi-part File:'));
-      const inputDir = path.dirname(inputFile);
-      const allParts = findMultiPartFiles(inputDir, metadata.hash, format);
-      const totalParts = metadata.totalParts || allParts.length;
-
-      console.log(chalk.cyan(`  This is part: ${metadata.partNumber} of ${totalParts}`));
-      console.log(chalk.cyan(`  Hash: ${metadata.hash}`));
-
-      console.log();
-      console.log(chalk.bold.white('Parts found in directory:'));
-
-      for (let i = 1; i <= totalParts; i++) {
-        const part = allParts.find(p => p.partNumber === i);
-        if (part) {
-          console.log(chalk.green(`  ✓ Part ${i}: ${part.filename}`));
-        } else {
-          console.log(chalk.red(`  ✗ Part ${i}: MISSING`));
-        }
-      }
-
-      if (allParts.length >= totalParts) {
-        console.log();
-        console.log(chalk.green.bold('All parts found - ready to decode'));
-      } else {
-        console.log();
-        console.log(chalk.yellow.bold(`Missing ${totalParts - allParts.length} part(s)`));
-      }
-    } else {
-      console.log(chalk.bold.white('Single File:'));
-      console.log(chalk.cyan(`  Hash: ${metadata.hash}`));
-      console.log();
-      console.log(chalk.green.bold('Ready to decode'));
-    }
-
-    if (isEncrypted) {
-      console.log(chalk.yellow('\nNote: Password required for decoding'));
+    if (probe !== 'v5' && probe !== 'archive') {
+      throw new Error(
+        'Unknown file format. Supported formats: .xlsx, .docx, or a zip of them'
+      );
     }
 
+    const info = native.info(inputFile);
+    spinner.succeed('File metadata read successfully');
+    printNativeInfo(info);
   } catch (error) {
     spinner.fail('Failed to read file info');
     console.error(chalk.red(`Error: ${error.message}`));