stegdoc 5.1.0 → 5.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stegdoc",
-  "version": "5.1.0",
+  "version": "5.3.0",
   "description": "Hide files inside Office documents (XLSX/DOCX) with AES-256 encryption and steganography",
   "main": "src/index.js",
   "bin": {

package/src/commands/encode.js

@@ -178,16 +178,52 @@ async function encodeCommand(inputFile, options) {
     // Generate session salt for encryption
     const sessionSalt = useEncryption ? generateSalt() : null;
 
-    spinner.text = useCompression ? 'Compressing (Brotli) and encoding...' : 'Encoding...';
+    // === Phase 1: Compress and collect all chunks ===
+    spinner.text = useCompression ? 'Compressing...' : 'Reading...';
 
     const partFiles = [];
-
-    // v5 pipeline: compress (brotli) → collect binary chunks → encrypt per-part → embed in log lines
     const binaryChunkSize = chunkSizeBytes === Infinity ? Infinity : Math.floor(chunkSizeBytes * 3 / 4);
 
-    const onBinaryChunkReady = async (binaryBuffer, index) => {
+    // Collect all chunks first (enables parallel part creation + known total)
+    const collectedChunks = [];
+    const collectChunk = async (binaryBuffer, index) => {
+      collectedChunks.push({ buffer: Buffer.from(binaryBuffer), index });
+    };
+
+    const collector = new BinaryChunkCollector(binaryChunkSize, collectChunk);
+
+    const streams = [fs.createReadStream(streamSource)];
+
+    // Add progress tracking (tracks input bytes read)
+    if (!quiet) {
+      const progressStream = new ProgressTransform(fileSize, (processed, total) => {
+        const pct = Math.min(100, Math.round((processed / total) * 100));
+        const processedFmt = formatBytes(processed);
+        const totalFmt = formatBytes(total);
+        const phase = useCompression ? 'Compressing' : 'Reading';
+        spinner.text = `${phase}... ${processedFmt} / ${totalFmt} (${pct}%)`;
+      });
+      streams.push(progressStream);
+    }
+
+    if (useCompression) {
+      streams.push(createBrotliCompressStream());
+    }
+    streams.push(collector);
+
+    await pipeline(...streams);
+
+    const totalParts = collectedChunks.length;
+    spinner.succeed && spinner.succeed(`${useCompression ? 'Compressed' : 'Read'}: ${totalParts} part${totalParts !== 1 ? 's' : ''} to create`);
+
+    // === Phase 2: Create parts in parallel ===
+    const os = require('os');
+    const concurrency = Math.min(totalParts, Math.max(1, os.cpus().length));
+    let completedParts = 0;
+    const partSpinner = quiet ? spinner : ora(`Creating parts... 0/${totalParts}`).start();
+
+    const createPart = async ({ buffer: binaryBuffer, index }) => {
       const partNumber = index + 1;
-      const partSpinner = quiet ? spinner : ora(`Creating part ${partNumber}...`).start();
 
       let payloadBuffer;
       let encryptionMeta = '';
@@ -208,7 +244,7 @@ async function encodeCommand(inputFile, options) {
         originalExtension: extension,
         hash,
         partNumber,
-        totalParts: null,
+        totalParts,
         originalSize: fileSize,
         format,
         encrypted: useEncryption,
@@ -262,35 +298,26 @@ async function encodeCommand(inputFile, options) {
 
       partFiles.push(outputPath);
       createdFiles.push(outputPath);
-      partSpinner.succeed && partSpinner.succeed(`Created: ${outputFilename} (${formatBytes(payloadBuffer.length)} payload, ${dataLineCount} data lines)`);
-    };
-
-    const collector = new BinaryChunkCollector(binaryChunkSize, onBinaryChunkReady);
 
-    const streams = [fs.createReadStream(streamSource)];
+      completedParts++;
+      const pct = Math.round((completedParts / totalParts) * 100);
+      partSpinner.text = `Creating parts... ${completedParts}/${totalParts} (${pct}%)`;
+    };
 
-    // Add progress tracking before compression (tracks input bytes read)
-    if (!quiet) {
-      const progressStream = new ProgressTransform(fileSize, (processed, total) => {
-        const pct = Math.min(100, Math.round((processed / total) * 100));
-        const processedFmt = formatBytes(processed);
-        const totalFmt = formatBytes(total);
-        const phase = useCompression ? 'Compressing' : 'Processing';
-        spinner.text = `${phase}... ${processedFmt} / ${totalFmt} (${pct}%)`;
-      });
-      streams.push(progressStream);
-    }
+    // Run part creation in parallel with limited concurrency
+    const chunks = [...collectedChunks];
+    const executing = new Set();
 
-    if (useCompression) {
-      streams.push(createBrotliCompressStream());
+    for (const chunk of chunks) {
+      const promise = createPart(chunk).then(() => executing.delete(promise));
+      executing.add(promise);
+      if (executing.size >= concurrency) {
+        await Promise.race(executing);
+      }
     }
-    streams.push(collector);
-
-    await pipeline(...streams);
-
-    const totalParts = partFiles.length;
+    await Promise.all(executing);
 
-    spinner.succeed && spinner.succeed('Encoding complete!');
+    partSpinner.succeed && partSpinner.succeed(`Created ${totalParts} part${totalParts !== 1 ? 's' : ''}`);
 
     if (!quiet) {
       console.log();

package/src/index.js

@@ -11,7 +11,7 @@ const verifyCommand = require('./commands/verify');
 program
   .name('stegdoc')
   .description('CLI tool to encode files into Office documents with AES-256 encryption')
-  .version('5.0.0');
+  .version('5.3.0');
 
 // Encode command
 program

package/src/lib/compression.js

@@ -3,15 +3,24 @@ const zlib = require('zlib');
 // ─── Brotli Compression (v5+) ──────────────────────────────────────────────
 
 /**
- * Compress data using Brotli (best compression, used in v5+)
+ * Default Brotli quality level.
+ * Quality 6 offers ~10x faster compression than max (11) with only
+ * marginally larger output — a good trade-off for large files.
+ */
+const BROTLI_DEFAULT_QUALITY = 6;
+
+/**
+ * Compress data using Brotli (used in v5+)
  * @param {Buffer} buffer - Data to compress
+ * @param {number} [quality] - Compression quality (0-11, default 6)
  * @returns {Promise<Buffer>} Compressed data
  */
-function compressBrotli(buffer) {
+function compressBrotli(buffer, quality) {
+  const q = quality !== undefined ? quality : BROTLI_DEFAULT_QUALITY;
   return new Promise((resolve, reject) => {
     zlib.brotliCompress(buffer, {
       params: {
-        [zlib.constants.BROTLI_PARAM_QUALITY]: zlib.constants.BROTLI_MAX_QUALITY,
+        [zlib.constants.BROTLI_PARAM_QUALITY]: q,
       },
     }, (err, result) => {
       if (err) reject(err);
@@ -36,11 +45,11 @@ function decompressBrotli(buffer) {
 
 /**
  * Create a streaming Brotli compression transform
- * @param {number} [quality] - Compression quality (0-11, default 11)
+ * @param {number} [quality] - Compression quality (0-11, default 6)
  * @returns {zlib.BrotliCompress} Brotli transform stream
  */
 function createBrotliCompressStream(quality) {
-  const q = quality !== undefined ? quality : zlib.constants.BROTLI_MAX_QUALITY;
+  const q = quality !== undefined ? quality : BROTLI_DEFAULT_QUALITY;
   return zlib.createBrotliCompress({
     params: {
       [zlib.constants.BROTLI_PARAM_QUALITY]: q,