roxify 1.12.1 → 1.12.3

package/dist/cli.js

@@ -5,8 +5,8 @@ import { basename, dirname, join, resolve } from 'path';
 import { DataFormatError, decodePngToBinary, encodeBinaryToPng, hasPassphraseInPng, IncorrectPassphraseError, listFilesInPng, PassphraseRequiredError, } from './index.js';
 import { packPathsGenerator, unpackBuffer } from './pack.js';
 import * as cliProgress from './stub-progress.js';
-import { encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
-const VERSION = '1.12.0';
+import { decodeWithRustCLI, encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
+const VERSION = '1.12.3';
 function getDirectorySize(dirPath) {
     let totalSize = 0;
     try {
@@ -303,22 +303,35 @@ async function encodeCommand(args) {
             const startTime = Date.now();
             const encodeBar = new cliProgress.SingleBar({ format: ' {bar} {percentage}% | {step} | {elapsed}s' }, cliProgress.Presets.shades_classic);
             let barValue = 0;
-            encodeBar.start(100, 0, { step: 'Encoding', elapsed: '0' });
-            const progressInterval = setInterval(() => {
-                barValue = Math.min(barValue + 1, 99);
+            encodeBar.start(100, 0, { step: 'Starting', elapsed: '0' });
+            const onProgress = (pct) => {
+                barValue = Math.max(barValue, pct);
                 const elapsed = Math.floor((Date.now() - startTime) / 1000);
-                encodeBar.update(barValue, {
-                    step: 'Encoding',
-                    elapsed: String(elapsed),
-                });
-            }, 500);
+                let step = 'Encoding';
+                if (pct < 30)
+                    step = 'Packing files';
+                else if (pct < 80)
+                    step = 'Compressing';
+                else if (pct < 100)
+                    step = 'Writing PNG';
+                else
+                    step = 'Done';
+                encodeBar.update(Math.min(barValue, 99), { step, elapsed: String(elapsed) });
+            };
+            const smoothInterval = setInterval(() => {
+                if (barValue < 99) {
+                    barValue = Math.min(barValue + 1, 99);
+                    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+                    encodeBar.update(barValue, { step: barValue < 30 ? 'Packing files' : barValue < 80 ? 'Compressing' : 'Writing PNG', elapsed: String(elapsed) });
+                }
+            }, 2000);
             const encryptType = parsed.encrypt === 'xor' ? 'xor' : 'aes';
             const fileName = basename(inputPaths[0]);
-            await encodeWithRustCLI(inputPaths.length === 1 ? resolvedInputs[0] : resolvedInputs[0], resolvedOutput, 19, parsed.passphrase, encryptType, fileName);
-            clearInterval(progressInterval);
+            await encodeWithRustCLI(inputPaths.length === 1 ? resolvedInputs[0] : resolvedInputs[0], resolvedOutput, 12, parsed.passphrase, encryptType, fileName, onProgress);
+            clearInterval(smoothInterval);
             const encodeTime = Date.now() - startTime;
             encodeBar.update(100, {
-                step: 'done',
+                step: 'Done',
                 elapsed: String(Math.floor(encodeTime / 1000)),
             });
             encodeBar.stop();
@@ -360,28 +373,18 @@ async function encodeCommand(args) {
         const encodeBar = new cliProgress.SingleBar({
             format: ' {bar} {percentage}% | {step} | {elapsed}s',
         }, cliProgress.Presets.shades_classic);
-        let barStarted = false;
         const startEncode = Date.now();
         let currentEncodeStep = 'Starting';
         let displayedPct = 0;
         let targetPct = 0;
         const TICK_MS = 100;
         const PCT_STEP = 1;
+        encodeBar.start(100, 0, { step: currentEncodeStep, elapsed: '0' });
         const encodeHeartbeat = setInterval(() => {
             const elapsed = Date.now() - startEncode;
-            if (!barStarted) {
-                encodeBar.start(100, Math.floor(displayedPct), {
-                    step: currentEncodeStep,
-                    elapsed: '0',
-                });
-                barStarted = true;
-            }
             if (displayedPct < targetPct) {
                 displayedPct = Math.min(displayedPct + PCT_STEP, targetPct);
             }
-            else if (displayedPct < 99) {
-                displayedPct = Math.min(displayedPct + PCT_STEP, 99);
-            }
             encodeBar.update(Math.floor(displayedPct), {
                 step: currentEncodeStep,
                 elapsed: String(Math.floor(elapsed / 1000)),
@@ -538,13 +541,11 @@ async function encodeCommand(args) {
         const output = await encodeBinaryToPng(inputBuffer, options);
         const encodeTime = Date.now() - startEncode;
         clearInterval(encodeHeartbeat);
-        if (barStarted) {
-            encodeBar.update(100, {
-                step: 'done',
-                elapsed: String(Math.floor(encodeTime / 1000)),
-            });
-            encodeBar.stop();
-        }
+        encodeBar.update(100, {
+            step: 'Done',
+            elapsed: String(Math.floor(encodeTime / 1000)),
+        });
+        encodeBar.stop();
         writeFileSync(resolvedOutput, output);
         const outputSize = (output.length / 1024 / 1024).toFixed(2);
         const inputSize = (inputSizeVal / 1024 / 1024).toFixed(2);
@@ -575,6 +576,42 @@ async function decodeCommand(args) {
     }
     const resolvedInput = resolve(inputPath);
     const resolvedOutput = parsed.output || outputPath || 'decoded.bin';
+    const inputFileSize = statSync(resolvedInput).size;
+    if (isRustBinaryAvailable() && !parsed.dict && inputFileSize > 10 * 1024 * 1024) {
+        try {
+            console.log(' ');
+            console.log(`Decoding... (Using native Rust decoder)\n`);
+            const decodeBar = new cliProgress.SingleBar({ format: ' {bar} {percentage}% | {step} | {elapsed}s' }, cliProgress.Presets.shades_classic);
+            const startDecode = Date.now();
+            let barValue = 0;
+            decodeBar.start(100, 0, { step: 'Reading PNG', elapsed: '0' });
+            const onProgress = (pct) => {
+                barValue = Math.max(barValue, pct);
+                const elapsed = Math.floor((Date.now() - startDecode) / 1000);
+                let step = 'Reading PNG';
+                if (pct >= 10 && pct < 60)
+                    step = 'Decompressing';
+                else if (pct >= 60 && pct < 100)
+                    step = 'Extracting files';
+                else if (pct >= 100)
+                    step = 'Done';
+                decodeBar.update(Math.min(barValue, 99), { step, elapsed: String(elapsed) });
+            };
+            await decodeWithRustCLI(resolvedInput, resolvedOutput, parsed.passphrase, parsed.files, onProgress);
+            const decodeTime = Date.now() - startDecode;
+            decodeBar.update(100, { step: 'Done', elapsed: String(Math.floor(decodeTime / 1000)) });
+            decodeBar.stop();
+            console.log(`\nSuccess!`);
+            console.log(`  Time: ${decodeTime}ms`);
+            console.log(`  Output: ${resolve(resolvedOutput)}`);
+            console.log(' ');
+            return;
+        }
+        catch (err) {
+            console.warn('\nRust decoder failed, falling back to TypeScript decoder...');
+            console.warn(`Reason: ${err.message}\n`);
+        }
+    }
     try {
         const options = {};
         if (parsed.passphrase) {
@@ -601,28 +638,19 @@ async function decodeCommand(args) {
         const decodeBar = new cliProgress.SingleBar({
             format: ' {bar} {percentage}% | {step} | {elapsed}s',
         }, cliProgress.Presets.shades_classic);
-        let barStarted = false;
         const startDecode = Date.now();
         let currentPct = 0;
         let targetPct = 0;
-        let currentStep = 'Decoding';
+        let currentStep = 'Reading PNG';
+        decodeBar.start(100, 0, { step: currentStep, elapsed: '0' });
         const heartbeat = setInterval(() => {
             if (currentPct < targetPct) {
                 currentPct = Math.min(currentPct + 2, targetPct);
             }
-            if (!barStarted && targetPct > 0) {
-                decodeBar.start(100, Math.floor(currentPct), {
-                    step: currentStep,
-                    elapsed: String(Math.floor((Date.now() - startDecode) / 1000)),
-                });
-                barStarted = true;
-            }
-            else if (barStarted) {
-                decodeBar.update(Math.floor(currentPct), {
-                    step: currentStep,
-                    elapsed: String(Math.floor((Date.now() - startDecode) / 1000)),
-                });
-            }
+            decodeBar.update(Math.floor(currentPct), {
+                step: currentStep,
+                elapsed: String(Math.floor((Date.now() - startDecode) / 1000)),
+            });
         }, 100);
         options.onProgress = (info) => {
             if (info.phase === 'decompress_start') {
@@ -633,7 +661,7 @@ async function decodeCommand(args) {
                 info.loaded &&
                 info.total) {
                 targetPct = 50 + Math.floor((info.loaded / info.total) * 40);
-                currentStep = `Decompressing (${info.loaded}/${info.total})`;
+                currentStep = 'Decompressing';
             }
             else if (info.phase === 'decompress_done') {
                 targetPct = 90;
@@ -648,14 +676,12 @@ async function decodeCommand(args) {
         const result = await decodePngToBinary(inputBuffer, options);
         const decodeTime = Date.now() - startDecode;
         clearInterval(heartbeat);
-        if (barStarted) {
-            currentPct = 100;
-            decodeBar.update(100, {
-                step: 'done',
-                elapsed: String(Math.floor(decodeTime / 1000)),
-            });
-            decodeBar.stop();
-        }
+        currentPct = 100;
+        decodeBar.update(100, {
+            step: 'Done',
+            elapsed: String(Math.floor(decodeTime / 1000)),
+        });
+        decodeBar.stop();
         if (result.files) {
             const baseDir = parsed.output || outputPath || '.';
             const totalBytes = result.files.reduce((s, f) => s + f.buf.length, 0);

package/dist/stub-progress.d.ts

@@ -1,9 +1,14 @@
+import cliProgress from 'cli-progress';
 export declare class SingleBar {
-    constructor(...args: any[]);
-    start(...args: any[]): void;
-    update(...args: any[]): void;
-    stop(...args: any[]): void;
+    private bar;
+    constructor(opts?: any, preset?: any);
+    start(total: number, startValue: number, payload?: any): void;
+    update(value: number, payload?: any): void;
+    stop(): void;
 }
 export declare const Presets: {
-    shades_classic: {};
+    legacy: cliProgress.Preset;
+    rect: cliProgress.Preset;
+    shades_classic: cliProgress.Preset;
+    shades_grey: cliProgress.Preset;
 };

package/dist/stub-progress.js

@@ -1,9 +1,22 @@
+import cliProgress from 'cli-progress';
 export class SingleBar {
-    constructor(...args) { }
-    start(...args) { }
-    update(...args) { }
-    stop(...args) { }
+    constructor(opts, preset) {
+        this.bar = new cliProgress.SingleBar({
+            ...opts,
+            hideCursor: true,
+            forceRedraw: true,
+            barCompleteChar: '\u2588',
+            barIncompleteChar: '\u2591',
+        }, preset || cliProgress.Presets.shades_classic);
+    }
+    start(total, startValue, payload) {
+        this.bar.start(total, startValue, payload);
+    }
+    update(value, payload) {
+        this.bar.update(value, payload);
+    }
+    stop() {
+        this.bar.stop();
+    }
 }
-export const Presets = {
-    shades_classic: {},
-};
+export const Presets = cliProgress.Presets;

package/dist/utils/rust-cli-wrapper.d.ts

@@ -1,4 +1,7 @@
 declare function findRustBinary(): string | null;
 export { findRustBinary };
 export declare function isRustBinaryAvailable(): boolean;
-export declare function encodeWithRustCLI(inputPath: string, outputPath: string, compressionLevel?: number, passphrase?: string, encryptType?: 'aes' | 'xor', name?: string): Promise<void>;
+export declare function encodeWithRustCLI(inputPath: string, outputPath: string, compressionLevel?: number, passphrase?: string, encryptType?: 'aes' | 'xor', name?: string, onProgress?: (pct: number) => void): Promise<void>;
+export declare function decodeWithRustCLI(inputPath: string, outputPath: string, passphrase?: string, files?: string[], onProgress?: (pct: number) => void): Promise<{
+    usedRust: boolean;
+}>;

package/dist/utils/rust-cli-wrapper.js

@@ -128,7 +128,7 @@ export function isRustBinaryAvailable() {
 }
 import { chmodSync, mkdtempSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
 import { tmpdir } from 'os';
-export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel = 3, passphrase, encryptType = 'aes', name) {
+export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel = 3, passphrase, encryptType = 'aes', name, onProgress) {
     const cliPath = findRustBinary();
     if (!cliPath) {
         throw new Error('Rust CLI binary not found');
@@ -145,7 +145,7 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
         return dest;
     }
     return new Promise((resolve, reject) => {
-        const args = ['encode', '--level', String(compressionLevel)];
+        const args = ['encode', '--level', String(compressionLevel), '--progress'];
         let supportsName = false;
         if (name) {
             try {
@@ -173,7 +173,9 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
         const runSpawn = (exePath) => {
             let proc;
             try {
-                proc = spawn(exePath, args, { stdio: 'inherit' });
+                proc = spawn(exePath, args, {
+                    stdio: ['inherit', 'inherit', 'pipe'],
+                });
             }
             catch (err) {
                 if (!triedExtract) {
@@ -188,6 +190,20 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
                 }
                 return reject(err);
             }
+            if (proc.stderr && onProgress) {
+                let stderrBuf = '';
+                proc.stderr.on('data', (chunk) => {
+                    stderrBuf += chunk.toString();
+                    const lines = stderrBuf.split('\n');
+                    stderrBuf = lines.pop() || '';
+                    for (const line of lines) {
+                        const match = line.match(/PROGRESS:(\d+)/);
+                        if (match) {
+                            onProgress(parseInt(match[1], 10));
+                        }
+                    }
+                });
+            }
             proc.on('error', (err) => {
                 if (!triedExtract) {
                     triedExtract = true;
@@ -219,3 +235,53 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
         runSpawn(cliPath);
     });
 }
+export async function decodeWithRustCLI(inputPath, outputPath, passphrase, files, onProgress) {
+    const cliPath = findRustBinary();
+    if (!cliPath) {
+        throw new Error('Rust CLI binary not found');
+    }
+    return new Promise((resolve, reject) => {
+        const args = ['decompress', '--progress'];
+        if (passphrase) {
+            args.push('--passphrase', passphrase);
+        }
+        if (files && files.length > 0) {
+            args.push('--files', JSON.stringify(files));
+        }
+        args.push(inputPath, outputPath);
+        const proc = spawn(cliPath, args, {
+            stdio: ['inherit', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        if (proc.stdout) {
+            proc.stdout.on('data', (chunk) => {
+                const text = chunk.toString();
+                stdout += text;
+                process.stdout.write(text);
+            });
+        }
+        if (proc.stderr && onProgress) {
+            let stderrBuf = '';
+            proc.stderr.on('data', (chunk) => {
+                stderrBuf += chunk.toString();
+                const lines = stderrBuf.split('\n');
+                stderrBuf = lines.pop() || '';
+                for (const line of lines) {
+                    const match = line.match(/PROGRESS:(\d+)/);
+                    if (match) {
+                        onProgress(parseInt(match[1], 10));
+                    }
+                }
+            });
+        }
+        proc.on('error', (err) => reject(err));
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve({ usedRust: true });
+            }
+            else {
+                reject(new Error(`Rust decoder exited with status ${code}`));
+            }
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.12.1",
+  "version": "1.12.3",
   "type": "module",
   "description": "Ultra-lightweight PNG steganography with native Rust acceleration. Encode binary data into PNG images with zstd compression.",
   "main": "dist/index.js",
@@ -99,11 +99,15 @@
   "author": "",
   "license": "SEE LICENSE IN LICENSE",
   "devDependencies": {
+    "@types/cli-progress": "^3.11.6",
     "@types/node": "^22.0.0",
     "pkg": "^5.8.1",
     "typescript": "^5.6.0"
   },
   "engines": {
     "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "cli-progress": "^3.12.0"
   }
 }