stegdoc 1.0.1 → 4.0.0

package/src/commands/encode.js

@@ -1,16 +1,19 @@
 const path = require('path');
 const fs = require('fs');
+const { pipeline } = require('stream/promises');
 const chalk = require('chalk');
 const ora = require('ora');
 const AdmZip = require('adm-zip');
 const { createDocxWithBase64 } = require('../lib/docx-handler');
-const { createXlsxWithBase64 } = require('../lib/xlsx-handler');
+const { createXlsxPartStreaming } = require('../lib/xlsx-handler');
 const { createMetadata, serializeMetadata } = require('../lib/metadata');
-const { generateHash, generateContentHash, parseSizeToBytes, formatBytes, generateFilename } = require('../lib/utils');
-const { encrypt, packEncryptionMeta } = require('../lib/crypto');
-const { compress, isCompressedMime } = require('../lib/compression');
+const crypto = require('crypto');
+const { generateHash, parseSizeToBytes, formatBytes, generateFilename } = require('../lib/utils');
+const { packEncryptionMeta, generateSalt, createEncryptStream } = require('../lib/crypto');
+const { isCompressedMime, createCompressStream } = require('../lib/compression');
 const { resetTimeWindow } = require('../lib/decoy-generator');
 const { shouldRunInteractive, promptEncodeOptions } = require('../lib/interactive');
+const { Base64EncodeTransform, ChunkCollector, BinaryChunkCollector } = require('../lib/streams');
 
 /**
  * Zip a folder into a buffer
@@ -24,16 +27,43 @@ function zipFolder(folderPath) {
 }
 
 /**
- * Encode a file to XLSX/DOCX format with optional AES encryption and compression
+ * Detect file type from the first 4KB without reading the entire file
+ * @param {string} filePath - Path to file
+ * @returns {Promise<object|null>} File type result or null
+ */
+async function detectFileType(filePath) {
+  try {
+    const { fileTypeFromBuffer } = await import('file-type');
+    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 fileTypeFromBuffer(buf);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Compute SHA-256 hash of a file using streaming (no full file in memory)
+ * @param {string} filePath - Path to file
+ * @returns {Promise<string>} Hex SHA-256 hash
+ */
+async function computeFileHash(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash('sha256');
+    const stream = fs.createReadStream(filePath);
+    stream.on('data', (chunk) => hash.update(chunk));
+    stream.on('end', () => resolve(hash.digest('hex')));
+    stream.on('error', reject);
+  });
+}
+
+/**
+ * Encode a file to XLSX/DOCX format with optional AES encryption and compression.
+ * Uses streaming pipeline for XLSX to support multi-GB files.
  * @param {string} inputFile - Path to input file
  * @param {object} options - Command options
- * @param {string} options.outputDir - Output directory
- * @param {string} options.chunkSize - Chunk size (e.g., "5MB")
- * @param {string} options.format - Output format ('xlsx' or 'docx')
- * @param {string} options.password - Encryption password (optional)
- * @param {boolean} options.force - Overwrite existing files without asking
- * @param {boolean} options.quiet - Minimal output
- * @param {boolean} options.yes - Skip interactive prompts, use defaults
  */
 async function encodeCommand(inputFile, options) {
   // Check if we should run interactive mode
@@ -69,261 +99,227 @@ async function encodeCommand(inputFile, options) {
     }
 
     const useEncryption = !!options.password;
-
-    // Store chunk input for later processing (after we know content size)
     const chunkInput = (options.chunkSize || '').toString().trim();
 
-    let fileBuffer;
+    let streamSource;
     let filename;
     let extension;
-    let size;
+    let fileSize;
+    let tempZipPath = null;
 
     if (isDirectory) {
-      // Zip the folder
+      // Zip the folder to a temp file, then stream from it
       spinner.text = 'Zipping folder...';
       const folderName = path.basename(inputFile);
-      fileBuffer = zipFolder(inputFile);
+      const zipBuffer = zipFolder(inputFile);
       filename = `${folderName}.zip`;
       extension = '.zip';
-      size = fileBuffer.length;
-      spinner.succeed && spinner.succeed(`Folder zipped: ${folderName}/ → ${formatBytes(size)}`);
+      fileSize = zipBuffer.length;
+
+      // Write zip to temp file for streaming
+      tempZipPath = path.join(require('os').tmpdir(), `stegdoc_${Date.now()}.zip`);
+      fs.writeFileSync(tempZipPath, zipBuffer);
+      streamSource = tempZipPath;
+
+      spinner.succeed && spinner.succeed(`Folder zipped: ${folderName}/ → ${formatBytes(fileSize)}`);
     } else {
-      // Read file as buffer
-      spinner.text = 'Reading file...';
-      fileBuffer = fs.readFileSync(inputFile);
+      streamSource = inputFile;
       filename = path.basename(inputFile);
       extension = path.extname(inputFile);
-      size = fileBuffer.length;
-      spinner.succeed && spinner.succeed(`File read: ${filename} (${formatBytes(size)})`);
+      fileSize = fs.statSync(inputFile).size;
+      spinner.succeed && spinner.succeed(`File detected: ${filename} (${formatBytes(fileSize)})`);
     }
 
-    // Generate content hash for integrity verification
-    const contentHash = generateContentHash(fileBuffer);
-
-    // Detect if file is already compressed
+    // Detect file type for compression decision (read only first 4KB)
     spinner.text = 'Checking file type...';
-    let fileType = null;
     let useCompression = true;
+    const fileType = await detectFileType(streamSource);
 
-    try {
-      // file-type is ESM-only, need dynamic import
-      const { fileTypeFromBuffer } = await import('file-type');
-      fileType = await fileTypeFromBuffer(fileBuffer);
-
-      if (fileType && isCompressedMime(fileType.mime)) {
-        useCompression = false;
-        spinner.info && spinner.info(`Skipping compression (${fileType.ext} is already compressed)`);
-      }
-    } catch {
-      // If file-type detection fails, still try compression
+    if (fileType && isCompressedMime(fileType.mime)) {
+      useCompression = false;
+      spinner.info && spinner.info(`Skipping compression (${fileType.ext} is already compressed)`);
     }
 
-    // Compress if beneficial
-    let processedBuffer = fileBuffer;
-    if (useCompression) {
-      spinner.text = 'Compressing...';
-      const compressedBuffer = await compress(fileBuffer);
-
-      // Only use compression if it actually reduces size
-      if (compressedBuffer.length < fileBuffer.length) {
-        const savedPercent = ((1 - compressedBuffer.length / fileBuffer.length) * 100).toFixed(1);
-        processedBuffer = compressedBuffer;
-        spinner.succeed && spinner.succeed(`Compressed: ${formatBytes(fileBuffer.length)} → ${formatBytes(compressedBuffer.length)} (${savedPercent}% saved)`);
-      } else {
-        useCompression = false;
-        spinner.info && spinner.info('Compression skipped (no size benefit)');
+    // For DOCX format, warn about large files and use legacy in-memory path
+    if (format === 'docx') {
+      if (fileSize > 200 * 1024 * 1024) {
+        spinner.info && spinner.info('Warning: DOCX format is not recommended for files >200MB. Consider using XLSX.');
       }
+      // Use legacy in-memory path for DOCX
+      await encodeLegacyDocx(streamSource, filename, extension, fileSize, options, useCompression, useEncryption, spinner, quiet, createdFiles);
+      if (tempZipPath) cleanupTemp(tempZipPath);
+      return;
     }
 
-    // Convert to base64
-    const base64 = processedBuffer.toString('base64');
-
-    let contentToStore;
-    let encryptionMeta = null;
-
-    if (useEncryption) {
-      spinner.text = 'Encrypting content...';
-
-      // Encrypt the base64 content
-      const { ciphertext, iv, salt, authTag } = encrypt(base64, options.password);
-      encryptionMeta = packEncryptionMeta({ iv, salt, authTag });
-      contentToStore = ciphertext;
-
-      spinner.succeed && spinner.succeed('Content encrypted with AES-256-GCM');
-    } else {
-      contentToStore = base64;
-      spinner.info && spinner.info('No password provided - content will NOT be encrypted');
-    }
-
-    spinner.text = 'Preparing output...';
-
-    // Generate hash for this encoding session
+    // === XLSX Streaming Pipeline ===
     const hash = generateHash();
-
-    // Determine output directory
     const outputDir = options.outputDir || process.cwd();
 
-    // Now parse chunk size (we need content size for "X parts" format)
-    const contentSize = contentToStore.length;
-    const defaultChunkSize = 5 * 1024 * 1024; // 5MB default
-    let chunkSizeBytes;
+    // Parse chunk size
     const chunkInputLower = chunkInput.toLowerCase();
+    let chunkSizeBytes;
 
     if (chunkInputLower === '0' || chunkInputLower === 'max' || chunkInputLower === 'single' || chunkInputLower === 'none' || chunkInputLower === '') {
-      chunkSizeBytes = Infinity; // No splitting
+      chunkSizeBytes = Infinity;
     } else if (/^\d+\s*parts?$/i.test(chunkInput)) {
-      // "X parts" format - divide content evenly
       const numParts = parseInt(chunkInput, 10);
       if (numParts < 1) {
         throw new Error('Number of parts must be at least 1');
       }
-      chunkSizeBytes = Math.ceil(contentSize / numParts);
-      spinner.info && spinner.info(`Splitting into ${numParts} parts (~${formatBytes(chunkSizeBytes)} content each)`);
+      // Estimate output size for part calculation
+      const estimatedBase64Size = Math.ceil(fileSize * 4 / 3);
+      chunkSizeBytes = Math.ceil(estimatedBase64Size / numParts);
+      spinner.info && spinner.info(`Splitting into ~${numParts} parts (~${formatBytes(chunkSizeBytes)} content each)`);
     } else if (chunkInput) {
       chunkSizeBytes = parseSizeToBytes(chunkInput);
     } else {
-      chunkSizeBytes = defaultChunkSize;
+      chunkSizeBytes = 5 * 1024 * 1024; // 5MB default
     }
 
-    // Check if we need to split
-    const needsSplit = contentSize > chunkSizeBytes;
+    // Pre-compute content hash (fast streaming SHA-256 pass)
+    spinner.text = 'Computing file hash...';
+    const contentHash = await computeFileHash(streamSource);
 
-    // Helper to check file exists and handle overwrite
-    const checkOverwrite = (filePath) => {
-      if (fs.existsSync(filePath) && !options.force) {
-        throw new Error(`File already exists: ${filePath}. Use --force to overwrite.`);
-      }
-    };
-
-    if (needsSplit) {
-      // Split into chunks
-      const chunks = [];
-      let offset = 0;
-      while (offset < contentToStore.length) {
-        chunks.push(contentToStore.slice(offset, offset + chunkSizeBytes));
-        offset += chunkSizeBytes;
-      }
-      const totalParts = chunks.length;
+    // Generate session salt for encryption (shared across all parts)
+    const sessionSalt = useEncryption ? generateSalt() : null;
 
-      spinner.succeed && spinner.succeed(`File will be split into ${totalParts} parts`);
+    spinner.text = useCompression ? 'Compressing and encoding...' : 'Encoding...';
 
-      // Create output file for each chunk
-      for (let i = 0; i < chunks.length; i++) {
-        const partNumber = i + 1;
-        const partSpinner = quiet ? spinner : ora(`Creating part ${partNumber} of ${totalParts}...`).start();
+    // We don't know totalParts upfront (depends on compression ratio).
+    // We write each part with partNumber set, and totalParts as null.
+    // Decode discovers all parts by filename pattern matching (already supported).
+    const partFiles = [];
+
+    if (useEncryption) {
+      // Encrypted pipeline: compress → collect binary chunks → encrypt per-part → base64 → xlsx
+      // Binary chunk size accounts for base64 expansion (~4/3x)
+      const binaryChunkSize = chunkSizeBytes === Infinity ? Infinity : Math.floor(chunkSizeBytes * 3 / 4);
+
+      const onBinaryChunkReady = async (binaryBuffer, index) => {
+        const partNumber = index + 1;
+        const partSpinner = quiet ? spinner : ora(`Creating part ${partNumber}...`).start();
+
+        // Encrypt this chunk independently
+        const { stream: cipher, iv, salt, getAuthTag } = createEncryptStream(options.password, sessionSalt);
+        const encrypted = Buffer.concat([cipher.update(binaryBuffer), cipher.final()]);
+        const authTag = getAuthTag();
+        const base64Chunk = encrypted.toString('base64');
 
         const metadata = createMetadata({
           originalFilename: filename,
           originalExtension: extension,
           hash,
           partNumber,
-          totalParts,
-          originalSize: size,
+          totalParts: null,
+          originalSize: fileSize,
           format,
-          encrypted: useEncryption,
+          encrypted: true,
           compressed: useCompression,
           contentHash,
         });
 
-        const outputFilename = generateFilename(hash, partNumber, totalParts, format);
+        const encryptionMeta = packEncryptionMeta({ iv, salt, authTag });
+        const outputFilename = generateFilename(hash, partNumber, null, format);
         const outputPath = path.join(outputDir, outputFilename);
 
-        checkOverwrite(outputPath);
-
-        if (format === 'xlsx') {
-          await createXlsxWithBase64({
-            base64Content: chunks[i],
-            encryptionMeta: encryptionMeta || '',
-            metadata: serializeMetadata(metadata),
-            outputPath,
-          });
-        } else {
-          // For DOCX, include encryption meta in the content if encrypted
-          const docxContent = useEncryption
-            ? `${encryptionMeta}|||${chunks[i]}`
-            : chunks[i];
-          await createDocxWithBase64({
-            base64Content: docxContent,
-            metadata,
-            outputPath,
-          });
+        if (fs.existsSync(outputPath) && !options.force) {
+          throw new Error(`File already exists: ${outputPath}. Use --force to overwrite.`);
         }
 
+        await createXlsxPartStreaming({
+          base64Content: base64Chunk,
+          encryptionMeta,
+          metadataJson: serializeMetadata(metadata),
+          outputPath,
+        });
+
+        partFiles.push(outputPath);
         createdFiles.push(outputPath);
-        partSpinner.succeed && partSpinner.succeed(`Created: ${outputFilename} (${formatBytes(chunks[i].length)})`);
-      }
+        partSpinner.succeed && partSpinner.succeed(`Created: ${outputFilename} (${formatBytes(base64Chunk.length)} encoded)`);
+      };
 
-      if (!quiet) {
-        console.log();
-        console.log(chalk.green.bold('✓ Encoding complete!'));
-        console.log(chalk.cyan(`  Format: ${format.toUpperCase()}`));
-        console.log(chalk.cyan(`  Hash: ${hash}`));
-        console.log(chalk.cyan(`  Parts: ${totalParts}`));
-        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!`));
-        }
+      const collector = new BinaryChunkCollector(binaryChunkSize, onBinaryChunkReady);
+
+      // Build pipeline
+      const streams = [fs.createReadStream(streamSource)];
+      if (useCompression) {
+        streams.push(createCompressStream());
       }
+      streams.push(collector);
+
+      await pipeline(...streams);
     } else {
-      // Single file
-      spinner.text = `Creating ${format.toUpperCase()} file...`;
-
-      const metadata = createMetadata({
-        originalFilename: filename,
-        originalExtension: extension,
-        hash,
-        partNumber: null,
-        totalParts: null,
-        originalSize: size,
-        format,
-        encrypted: useEncryption,
-        compressed: useCompression,
-        contentHash,
-      });
-
-      const outputFilename = generateFilename(hash, null, null, format);
-      const outputPath = path.join(outputDir, outputFilename);
-
-      checkOverwrite(outputPath);
-
-      if (format === 'xlsx') {
-        await createXlsxWithBase64({
-          base64Content: contentToStore,
-          encryptionMeta: encryptionMeta || '',
-          metadata: serializeMetadata(metadata),
-          outputPath,
+      // Unencrypted pipeline: compress → base64 → collect string chunks → xlsx
+      const onChunkReady = async (base64Chunk, index) => {
+        const partNumber = index + 1;
+        const partSpinner = quiet ? spinner : ora(`Creating part ${partNumber}...`).start();
+
+        const metadata = createMetadata({
+          originalFilename: filename,
+          originalExtension: extension,
+          hash,
+          partNumber,
+          totalParts: null,
+          originalSize: fileSize,
+          format,
+          encrypted: false,
+          compressed: useCompression,
+          contentHash,
         });
-      } else {
-        // For DOCX, include encryption meta in the content if encrypted
-        const docxContent = useEncryption
-          ? `${encryptionMeta}|||${contentToStore}`
-          : contentToStore;
-        await createDocxWithBase64({
-          base64Content: docxContent,
-          metadata,
+
+        const outputFilename = generateFilename(hash, partNumber, 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.`);
+        }
+
+        await createXlsxPartStreaming({
+          base64Content: base64Chunk,
+          encryptionMeta: '',
+          metadataJson: serializeMetadata(metadata),
           outputPath,
         });
+
+        partFiles.push(outputPath);
+        createdFiles.push(outputPath);
+        partSpinner.succeed && partSpinner.succeed(`Created: ${outputFilename} (${formatBytes(base64Chunk.length)} encoded)`);
+      };
+
+      const collector = new ChunkCollector(chunkSizeBytes, onChunkReady);
+
+      // Build pipeline
+      const streams = [fs.createReadStream(streamSource)];
+      if (useCompression) {
+        streams.push(createCompressStream());
       }
+      streams.push(new Base64EncodeTransform());
+      streams.push(collector);
 
-      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: ${format.toUpperCase()}`));
-        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!`));
-        }
+      await pipeline(...streams);
+    }
+
+    const totalParts = partFiles.length;
+
+    spinner.succeed && spinner.succeed('Encoding complete!');
+
+    if (!quiet) {
+      console.log();
+      console.log(chalk.green.bold('✓ File encoded successfully!'));
+      console.log(chalk.cyan(`  Format: ${format.toUpperCase()}`));
+      console.log(chalk.cyan(`  Hash: ${hash}`));
+      if (totalParts > 1) {
+        console.log(chalk.cyan(`  Parts: ${totalParts}`));
+      }
+      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!`));
       }
     }
+
+    if (tempZipPath) cleanupTemp(tempZipPath);
   } catch (error) {
     spinner.fail && spinner.fail('Encoding failed');
 
@@ -343,4 +339,111 @@ async function encodeCommand(inputFile, options) {
   }
 }
 
+/**
+ * Legacy in-memory encode path for DOCX format
+ */
+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 { createDocxWithBase64 } = require('../lib/docx-handler');
+
+  const fileBuffer = fs.readFileSync(inputPath);
+  const contentHash = generateContentHash(fileBuffer);
+
+  // Compress if beneficial
+  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)');
+    }
+  }
+
+  // Convert to base64
+  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`));
+    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!`));
+    }
+  }
+}
+
+/**
+ * Cleanup temporary file
+ */
+function cleanupTemp(tempPath) {
+  try {
+    if (fs.existsSync(tempPath)) {
+      fs.unlinkSync(tempPath);
+    }
+  } catch {
+    // Ignore
+  }
+}
+
 module.exports = encodeCommand;

package/src/commands/info.js

@@ -63,20 +63,21 @@ async function infoCommand(inputFile, options) {
     }
     console.log();
 
-    // Multi-part info
-    if (isMultiPart(metadata)) {
+    // Multi-part info — check both totalParts and partNumber (v4 may have null totalParts)
+    const hasMultipleParts = isMultiPart(metadata) || metadata.partNumber !== null;
+    if (hasMultipleParts) {
       console.log(chalk.bold.white('Multi-part File:'));
-      console.log(chalk.cyan(`  This is part: ${metadata.partNumber} of ${metadata.totalParts}`));
-      console.log(chalk.cyan(`  Hash: ${metadata.hash}`));
-
-      // Find other parts
       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 <= metadata.totalParts; i++) {
+      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}`));
@@ -85,12 +86,12 @@ async function infoCommand(inputFile, options) {
         }
       }
 
-      if (allParts.length === metadata.totalParts) {
+      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 ${metadata.totalParts - allParts.length} part(s)`));
+        console.log(chalk.yellow.bold(`Missing ${totalParts - allParts.length} part(s)`));
       }
     } else {
       console.log(chalk.bold.white('Single File:'));