roxify 1.13.0 → 1.13.1

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roxify_native"
-version = "1.13.0"
+version = "1.13.1"
 edition = "2021"
 publish = false
 

package/dist/cli.js

@@ -2,11 +2,25 @@
 import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, } from 'fs';
 import { open } from 'fs/promises';
 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, havepassphraseWithRustCLI, isRustBinaryAvailable, listWithRustCLI, } from './utils/rust-cli-wrapper.js';
+async function loadJsEngine() {
+    const indexMod = await import('./index.js');
+    const packMod = await import('./pack.js');
+    return {
+        decodePngToBinary: indexMod.decodePngToBinary,
+        encodeBinaryToPng: indexMod.encodeBinaryToPng,
+        hasPassphraseInPng: indexMod.hasPassphraseInPng,
+        listFilesInPng: indexMod.listFilesInPng,
+        DataFormatError: indexMod.DataFormatError,
+        IncorrectPassphraseError: indexMod.IncorrectPassphraseError,
+        PassphraseRequiredError: indexMod.PassphraseRequiredError,
+        packPathsGenerator: packMod.packPathsGenerator,
+        unpackBuffer: packMod.unpackBuffer,
+        VFSIndexEntry: undefined,
+    };
+}
+const VERSION = '1.13.1';
 function getDirectorySize(dirPath) {
     let totalSize = 0;
     try {
@@ -280,8 +294,9 @@ async function encodeCommand(args) {
                 return false;
             }
         });
-        if (anyDir) {
-            const { index } = await packPathsGenerator(inputPaths, undefined, () => { });
+        if (anyDir && !isRustBinaryAvailable()) {
+            const js = await loadJsEngine();
+            const { index } = await js.packPathsGenerator(inputPaths, undefined, () => { });
             if (!index || index.length === 0) {
                 console.log(' ');
                 console.error('Error: No files found in specified input paths.');
@@ -357,6 +372,7 @@ async function encodeCommand(args) {
         }
     }
     try {
+        const js = await loadJsEngine();
         const encodeBar = new cliProgress.SingleBar({
             format: ' {bar} {percentage}% | {step} | {elapsed}s',
         }, cliProgress.Presets.shades_classic);
@@ -428,7 +444,7 @@ async function encodeCommand(args) {
         };
         if (inputPaths.length > 1) {
             currentEncodeStep = 'Reading files';
-            const { index, stream, totalSize } = await packPathsGenerator(inputPaths, undefined, onProgress);
+            const { index, stream, totalSize } = await js.packPathsGenerator(inputPaths, undefined, onProgress);
             if (!index || index.length === 0) {
                 console.log(' ');
                 console.error('Error: No files found in specified input paths.');
@@ -448,7 +464,7 @@ async function encodeCommand(args) {
             const st = statSync(resolvedInput);
             if (st.isDirectory()) {
                 currentEncodeStep = 'Reading files';
-                const { index, stream, totalSize } = await packPathsGenerator([resolvedInput], dirname(resolvedInput), onProgress);
+                const { index, stream, totalSize } = await js.packPathsGenerator([resolvedInput], dirname(resolvedInput), onProgress);
                 if (!index || index.length === 0) {
                     console.log(' ');
                     console.error(`Error: No files found in ${resolvedInput}`);
@@ -535,7 +551,7 @@ async function encodeCommand(args) {
         else {
             inputBuffer = inputData;
         }
-        const output = await encodeBinaryToPng(inputBuffer, options);
+        const output = await js.encodeBinaryToPng(inputBuffer, options);
         const encodeTime = Date.now() - startEncode;
         clearInterval(encodeHeartbeat);
         if (barStarted) {
@@ -574,7 +590,38 @@ async function decodeCommand(args) {
         process.exit(1);
     }
     const resolvedInput = resolve(inputPath);
-    const resolvedOutput = parsed.output || outputPath || 'decoded.bin';
+    const resolvedOutput = parsed.output || outputPath || '.';
+    if (isRustBinaryAvailable() && !parsed.forceTs && !parsed.lossyResilient) {
+        try {
+            console.log(' ');
+            console.log('Decoding... (Using native Rust decoder)\n');
+            const startTime = Date.now();
+            const decodeBar = new cliProgress.SingleBar({ format: ' {bar} {percentage}% | {step} | {elapsed}s' }, cliProgress.Presets.shades_classic);
+            let barValue = 0;
+            decodeBar.start(100, 0, { step: 'Decoding', elapsed: '0' });
+            const progressInterval = setInterval(() => {
+                barValue = Math.min(barValue + 2, 99);
+                decodeBar.update(barValue, {
+                    step: 'Decoding',
+                    elapsed: String(Math.floor((Date.now() - startTime) / 1000)),
+                });
+            }, 300);
+            await decodeWithRustCLI(resolvedInput, resolvedOutput, parsed.passphrase, parsed.files, parsed.dict);
+            clearInterval(progressInterval);
+            const decodeTime = Date.now() - startTime;
+            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) {
@@ -645,7 +692,8 @@ async function decodeCommand(args) {
             }
         };
         const inputBuffer = await readLargeFile(resolvedInput);
-        const result = await decodePngToBinary(inputBuffer, options);
+        const js = await loadJsEngine();
+        const result = await js.decodePngToBinary(inputBuffer, options);
         const decodeTime = Date.now() - startDecode;
         clearInterval(heartbeat);
         if (barStarted) {
@@ -684,7 +732,7 @@ async function decodeCommand(args) {
             console.log(`Time: ${decodeTime}ms`);
         }
         else if (result.buf) {
-            const unpacked = unpackBuffer(result.buf);
+            const unpacked = js.unpackBuffer(result.buf);
             if (unpacked) {
                 const baseDir = parsed.output || outputPath || '.';
                 for (const file of unpacked.files) {
@@ -720,17 +768,17 @@ async function decodeCommand(args) {
         console.log(' ');
     }
     catch (err) {
-        if (err instanceof PassphraseRequiredError ||
+        if ((err.message && err.message.includes('passphrase required')) ||
             (err.message && err.message.includes('passphrase') && !parsed.passphrase)) {
             console.log(' ');
             console.error('File appears to be encrypted. Provide a passphrase with -p');
         }
-        else if (err instanceof IncorrectPassphraseError ||
+        else if ((err.message && err.message.includes('Incorrect passphrase')) ||
             (err.message && err.message.includes('Incorrect passphrase'))) {
             console.log(' ');
             console.error('Incorrect passphrase');
         }
-        else if (err instanceof DataFormatError ||
+        else if ((err.message && err.message.includes('data format error')) ||
             (err.message &&
                 (err.message.includes('decompression failed') ||
                     err.message.includes('missing ROX1') ||
@@ -761,40 +809,25 @@ async function listCommand(args) {
     const resolvedInput = resolve(inputPath);
     if (isRustBinaryAvailable()) {
         try {
-            const { findRustBinary } = await import('./utils/rust-cli-wrapper.js');
-            const cliPath = findRustBinary();
-            if (cliPath) {
-                const { execSync } = await import('child_process');
-                try {
-                    const help = execSync(`"${cliPath}" --help`, { encoding: 'utf-8' });
-                    if (!help.includes('list')) {
-                        throw new Error('native CLI does not support list');
-                    }
-                    const output = execSync(`"${cliPath}" list "${resolvedInput}"`, {
-                        encoding: 'utf-8',
-                        stdio: ['pipe', 'pipe', 'inherit'],
-                        timeout: 30000,
-                    });
-                    const fileList = JSON.parse(output.trim());
-                    console.log(`Files in ${resolvedInput}:`);
-                    for (const file of fileList) {
-                        if (typeof file === 'string') {
-                            console.log(`  ${file}`);
-                        }
-                        else {
-                            console.log(`  ${file.name} (${file.size} bytes)`);
-                        }
-                    }
-                    return;
+            const output = await listWithRustCLI(resolvedInput);
+            const fileList = JSON.parse(output.trim());
+            console.log(`Files in ${resolvedInput}:`);
+            for (const file of fileList) {
+                if (typeof file === 'string') {
+                    console.log(`  ${file}`);
+                }
+                else {
+                    console.log(`  ${file.name} (${file.size} bytes)`);
                 }
-                catch (e) { }
             }
+            return;
         }
-        catch (err) { }
+        catch (e) { }
     }
     try {
         const inputBuffer = readFileSync(resolvedInput);
-        const fileList = await listFilesInPng(inputBuffer, {
+        const js = await loadJsEngine();
+        const fileList = await js.listFilesInPng(inputBuffer, {
             includeSizes: parsed.sizes !== false,
         });
         if (fileList) {
@@ -831,9 +864,18 @@ async function havePassphraseCommand(args) {
         process.exit(1);
     }
     const resolvedInput = resolve(inputPath);
+    if (isRustBinaryAvailable()) {
+        try {
+            const output = await havepassphraseWithRustCLI(resolvedInput);
+            console.log(output.trim());
+            return;
+        }
+        catch (e) { }
+    }
     try {
         const inputBuffer = readFileSync(resolvedInput);
-        const has = await hasPassphraseInPng(inputBuffer);
+        const js = await loadJsEngine();
+        const has = await js.hasPassphraseInPng(inputBuffer);
         console.log(has ? 'Passphrase detected.' : 'No passphrase detected.');
     }
     catch (err) {

package/dist/index.d.ts

@@ -12,7 +12,7 @@ export * from './utils/optimization.js';
 export * from './utils/reconstitution.js';
 export * from './utils/robust-audio.js';
 export * from './utils/robust-image.js';
-export { encodeWithRustCLI, isRustBinaryAvailable } from './utils/rust-cli-wrapper.js';
+export { decodeWithRustCLI, encodeWithRustCLI, havepassphraseWithRustCLI, isRustBinaryAvailable, listWithRustCLI, } from './utils/rust-cli-wrapper.js';
 export * from './utils/types.js';
 export * from './utils/zstd.js';
 export { packPaths, packPathsToParts, unpackBuffer } from './pack.js';

package/dist/index.js

@@ -12,7 +12,7 @@ export * from './utils/optimization.js';
 export * from './utils/reconstitution.js';
 export * from './utils/robust-audio.js';
 export * from './utils/robust-image.js';
-export { encodeWithRustCLI, isRustBinaryAvailable } from './utils/rust-cli-wrapper.js';
+export { decodeWithRustCLI, encodeWithRustCLI, havepassphraseWithRustCLI, isRustBinaryAvailable, listWithRustCLI, } from './utils/rust-cli-wrapper.js';
 export * from './utils/types.js';
 export * from './utils/zstd.js';
 export { packPaths, packPathsToParts, unpackBuffer } from './pack.js';

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

@@ -2,3 +2,6 @@ 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 decodeWithRustCLI(inputPath: string, outputPath: string, passphrase?: string, files?: string[], dict?: string): Promise<void>;
+export declare function listWithRustCLI(inputPath: string): Promise<string>;
+export declare function havepassphraseWithRustCLI(inputPath: string): Promise<string>;

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

@@ -1,5 +1,5 @@
 import { execSync, spawn } from 'child_process';
-import { existsSync } from 'fs';
+import { accessSync, constants, existsSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 let moduleDir;
@@ -14,6 +14,19 @@ else {
         moduleDir = process.cwd();
     }
 }
+function canExecute(p) {
+    if (!existsSync(p))
+        return false;
+    if (process.platform === 'win32')
+        return true;
+    try {
+        accessSync(p, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function findRustBinary() {
     const platformBins = {
         win32: ['roxify_native.exe', 'roxify-cli.exe', 'roxify_cli.exe'],
@@ -24,13 +37,13 @@ function findRustBinary() {
     const baseDir = moduleDir;
     for (const name of binNames) {
         const sameDirPath = join(baseDir, name);
-        if (existsSync(sameDirPath))
+        if (canExecute(sameDirPath))
             return sameDirPath;
         const parentPath = join(baseDir, '..', name);
-        if (existsSync(parentPath))
+        if (canExecute(parentPath))
             return parentPath;
         const parentDistPath = join(baseDir, '..', 'dist', name);
-        if (existsSync(parentDistPath))
+        if (canExecute(parentDistPath))
             return parentDistPath;
     }
     if (process.pkg) {
@@ -42,7 +55,7 @@ function findRustBinary() {
         for (const basePath of snapshotPaths) {
             for (const name of binNames) {
                 const binPath = join(basePath, name);
-                if (existsSync(binPath))
+                if (canExecute(binPath))
                     return binPath;
             }
         }
@@ -58,7 +71,7 @@ function findRustBinary() {
                 for (const c of execCandidates) {
                     for (const name of binNames) {
                         const p = join(c, name);
-                        if (existsSync(p))
+                        if (canExecute(p))
                             return p;
                     }
                 }
@@ -97,7 +110,7 @@ function findRustBinary() {
                 for (const c of candidates) {
                     for (const name of binNames) {
                         const candidate = join(c, name);
-                        if (existsSync(candidate))
+                        if (canExecute(candidate))
                             return candidate;
                     }
                 }
@@ -108,16 +121,16 @@ function findRustBinary() {
     catch { }
     for (const name of binNames) {
         const parentParentLocal = join(baseDir, '..', '..', name);
-        if (existsSync(parentParentLocal))
+        if (canExecute(parentParentLocal))
             return parentParentLocal;
         const nodeModulesPath = join(baseDir, '..', '..', '..', '..', name);
-        if (existsSync(nodeModulesPath))
+        if (canExecute(nodeModulesPath))
             return nodeModulesPath;
     }
     const targetRelease = join(baseDir, '..', '..', 'target', 'release');
     for (const name of binNames) {
         const targetPath = join(targetRelease, name);
-        if (existsSync(targetPath))
+        if (canExecute(targetPath))
             return targetPath;
     }
     return null;
@@ -128,52 +141,32 @@ 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) {
+function extractToTemp(pathToRead) {
+    const buf = readFileSync(pathToRead);
+    const tmp = mkdtempSync(join(tmpdir(), 'roxify-'));
+    const dest = join(tmp, pathToRead.replace(/.*[\\/]/, ''));
+    writeFileSync(dest, buf);
+    try {
+        chmodSync(dest, 0o755);
+    }
+    catch (e) { }
+    return dest;
+}
+function spawnRustCLI(args, options) {
     const cliPath = findRustBinary();
-    if (!cliPath) {
+    if (!cliPath)
         throw new Error('Rust CLI binary not found');
-    }
-    function extractToTemp(pathToRead) {
-        const buf = readFileSync(pathToRead);
-        const tmp = mkdtempSync(join(tmpdir(), 'roxify-'));
-        const dest = join(tmp, pathToRead.replace(/.*[\\/]/, ''));
-        writeFileSync(dest, buf);
-        try {
-            chmodSync(dest, 0o755);
-        }
-        catch (e) { }
-        return dest;
-    }
     return new Promise((resolve, reject) => {
-        const args = ['encode', '--level', String(compressionLevel)];
-        let supportsName = false;
-        if (name) {
-            try {
-                const helpOut = execSync(`"${cliPath}" --help`, {
-                    encoding: 'utf8',
-                    timeout: 2000,
-                });
-                if (helpOut && helpOut.includes('--name'))
-                    supportsName = true;
-            }
-            catch (e) {
-                supportsName = false;
-            }
-            if (supportsName) {
-                args.push('--name', name);
-            }
-        }
-        if (passphrase) {
-            args.push('--passphrase', passphrase);
-            args.push('--encrypt', encryptType);
-        }
-        args.push(inputPath, outputPath);
         let triedExtract = false;
         let tempExe;
+        let stdout = '';
         const runSpawn = (exePath) => {
             let proc;
+            const stdio = options?.collectStdout
+                ? ['pipe', 'pipe', 'inherit']
+                : 'inherit';
             try {
-                proc = spawn(exePath, args, { stdio: 'inherit' });
+                proc = spawn(exePath, args, { stdio });
             }
             catch (err) {
                 if (!triedExtract) {
@@ -188,6 +181,9 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
                 }
                 return reject(err);
             }
+            if (options?.collectStdout && proc.stdout) {
+                proc.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+            }
             proc.on('error', (err) => {
                 if (!triedExtract) {
                     triedExtract = true;
@@ -201,21 +197,55 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
                 }
                 reject(err);
             });
-            proc.on('close', (code) => {
+            proc.on('close', (code, signal) => {
                 if (tempExe) {
                     try {
                         unlinkSync(tempExe);
                     }
                     catch (e) { }
                 }
-                if (code === 0) {
-                    resolve();
-                }
-                else {
-                    reject(new Error(`Rust encoder exited with status ${code}`));
-                }
+                if (code === 0 || (code === null && signal === null))
+                    resolve(stdout);
+                else
+                    reject(new Error(`Rust CLI exited with status ${code ?? signal}`));
             });
         };
         runSpawn(cliPath);
     });
 }
+export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel = 3, passphrase, encryptType = 'aes', name) {
+    const cliPath = findRustBinary();
+    if (!cliPath)
+        throw new Error('Rust CLI binary not found');
+    const args = ['encode', '--level', String(compressionLevel)];
+    if (name) {
+        try {
+            const helpOut = execSync(`"${cliPath}" --help`, { encoding: 'utf8', timeout: 2000 });
+            if (helpOut && helpOut.includes('--name'))
+                args.push('--name', name);
+        }
+        catch (e) { }
+    }
+    if (passphrase) {
+        args.push('--passphrase', passphrase);
+        args.push('--encrypt', encryptType);
+    }
+    args.push(inputPath, outputPath);
+    await spawnRustCLI(args);
+}
+export async function decodeWithRustCLI(inputPath, outputPath, passphrase, files, dict) {
+    const args = ['decompress', inputPath, outputPath];
+    if (passphrase)
+        args.push('--passphrase', passphrase);
+    if (files && files.length > 0)
+        args.push('--files', JSON.stringify(files));
+    if (dict)
+        args.push('--dict', dict);
+    await spawnRustCLI(args);
+}
+export async function listWithRustCLI(inputPath) {
+    return spawnRustCLI(['list', inputPath], { collectStdout: true });
+}
+export async function havepassphraseWithRustCLI(inputPath) {
+    return spawnRustCLI(['havepassphrase', inputPath], { collectStdout: true });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.13.0",
+  "version": "1.13.1",
   "type": "module",
   "description": "Ultra-lightweight PNG steganography with native Rust acceleration. Encode binary data into PNG images with zstd compression.",
   "main": "dist/index.js",