stegdoc 5.0.1 → 5.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stegdoc",
-  "version": "5.0.1",
+  "version": "5.2.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

@@ -14,7 +14,7 @@ const { isCompressedMime, createCompressStream, createBrotliCompressStream } = r
 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 } = require('../lib/streams');
+const { Base64EncodeTransform, ChunkCollector, BinaryChunkCollector, ProgressTransform } = require('../lib/streams');
 
 /**
  * Zip a folder into a buffer
@@ -268,6 +268,19 @@ async function encodeCommand(inputFile, options) {
     const collector = new BinaryChunkCollector(binaryChunkSize, onBinaryChunkReady);
 
     const streams = [fs.createReadStream(streamSource)];
+
+    // 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);
+    }
+
     if (useCompression) {
       streams.push(createBrotliCompressStream());
     }
@@ -396,6 +409,12 @@ async function encodeLegacyXlsx(inputPath, filename, extension, fileSize, option
 
     const collector = new BinaryChunkCollector(binaryChunkSize, onBinaryChunkReady);
     const streams = [fs.createReadStream(inputPath)];
+    if (!quiet) {
+      streams.push(new ProgressTransform(fileSize, (processed, total) => {
+        const pct = Math.min(100, Math.round((processed / total) * 100));
+        spinner.text = `Compressing (legacy v4)... ${formatBytes(processed)} / ${formatBytes(total)} (${pct}%)`;
+      }));
+    }
     if (useCompression) streams.push(createCompressStream());
     streams.push(collector);
     await pipeline(...streams);
@@ -438,6 +457,12 @@ async function encodeLegacyXlsx(inputPath, filename, extension, fileSize, option
 
     const collector = new ChunkCollector(chunkSizeBytes, onChunkReady);
     const streams = [fs.createReadStream(inputPath)];
+    if (!quiet) {
+      streams.push(new ProgressTransform(fileSize, (processed, total) => {
+        const pct = Math.min(100, Math.round((processed / total) * 100));
+        spinner.text = `Encoding (legacy v4)... ${formatBytes(processed)} / ${formatBytes(total)} (${pct}%)`;
+      }));
+    }
     if (useCompression) streams.push(createCompressStream());
     streams.push(new Base64EncodeTransform());
     streams.push(collector);

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.2.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,

package/src/lib/streams.js

@@ -188,10 +188,43 @@ class BinaryChunkCollector extends Writable {
   }
 }
 
+/**
+ * Transform stream that passes data through unchanged while reporting progress.
+ * Calls onProgress(bytesProcessed, totalBytes) periodically.
+ */
+class ProgressTransform extends Transform {
+  constructor(totalBytes, onProgress, intervalMs = 200) {
+    super();
+    this._totalBytes = totalBytes;
+    this._bytesProcessed = 0;
+    this._onProgress = onProgress;
+    this._lastReport = 0;
+    this._intervalMs = intervalMs;
+  }
+
+  _transform(chunk, encoding, callback) {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+    this._bytesProcessed += buf.length;
+    const now = Date.now();
+    if (now - this._lastReport >= this._intervalMs) {
+      this._lastReport = now;
+      this._onProgress(this._bytesProcessed, this._totalBytes);
+    }
+    this.push(buf);
+    callback();
+  }
+
+  _flush(callback) {
+    this._onProgress(this._bytesProcessed, this._totalBytes);
+    callback();
+  }
+}
+
 module.exports = {
   Base64EncodeTransform,
   Base64DecodeTransform,
   HashPassthrough,
   ChunkCollector,
   BinaryChunkCollector,
+  ProgressTransform,
 };