roxify 1.3.0 → 1.3.2

package/dist/cli.js

@@ -5,7 +5,8 @@ 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';
-const VERSION = '1.2.9';
+import { encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
+const VERSION = '1.3.2';
 async function readLargeFile(filePath) {
     const st = statSync(filePath);
     if (st.size <= 2 * 1024 * 1024 * 1024) {
@@ -47,6 +48,7 @@ Options:
   -m, --mode <mode>         Mode: screenshot (default)
   -e, --encrypt <type>      auto|aes|xor|none
   --no-compress             Disable compression
+  --force-ts                Force TypeScript encoder (slower but supports encryption)
   -o, --output <path>       Output file path
   -s, --sizes               Show file sizes in 'list' output (default)
   --no-sizes                Disable file size reporting in 'list'
@@ -89,6 +91,10 @@ function parseArgs(args) {
                 parsed.debug = true;
                 i++;
             }
+            else if (key === 'force-ts') {
+                parsed.forceTs = true;
+                i++;
+            }
             else if (key === 'debug-dir') {
                 parsed.debugDir = args[i + 1];
                 i += 2;
@@ -166,7 +172,15 @@ async function encodeCommand(args) {
         console.log('Usage: npx rox encode <input> [output] [options]');
         process.exit(1);
     }
-    const resolvedInputs = inputPaths.map((p) => resolve(p));
+    let safeCwd = '/';
+    try {
+        safeCwd = process.cwd();
+    }
+    catch (e) {
+        // ENOENT: fallback sur racine
+        safeCwd = '/';
+    }
+    const resolvedInputs = inputPaths.map((p) => resolve(safeCwd, p));
     let outputName = inputPaths.length === 1 ? basename(firstInput) : 'archive';
     if (inputPaths.length === 1 && !statSync(resolvedInputs[0]).isDirectory()) {
         outputName = outputName.replace(/(\.[^.]+)?$/, '.png');
@@ -174,7 +188,65 @@ async function encodeCommand(args) {
     else {
         outputName += '.png';
     }
-    const resolvedOutput = parsed.output || outputPath || outputName;
+    let resolvedOutput;
+    try {
+        resolvedOutput = resolve(safeCwd, parsed.output || outputPath || outputName);
+    }
+    catch (e) {
+        resolvedOutput = join('/', parsed.output || outputPath || outputName);
+    }
+    if (isRustBinaryAvailable() && !parsed.forceTs) {
+        try {
+            console.log(`Encoding to ${resolvedOutput} (Using native Rust encoder)\n`);
+            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);
+                const elapsed = Math.floor((Date.now() - startTime) / 1000);
+                encodeBar.update(barValue, {
+                    step: 'Encoding',
+                    elapsed: String(elapsed),
+                });
+            }, 500);
+            const encryptType = parsed.encrypt === 'xor' ? 'xor' : 'aes';
+            await encodeWithRustCLI(inputPaths.length === 1 ? resolvedInputs[0] : resolvedInputs[0], resolvedOutput, 3, parsed.passphrase, encryptType);
+            clearInterval(progressInterval);
+            const encodeTime = Date.now() - startTime;
+            encodeBar.update(100, {
+                step: 'done',
+                elapsed: String(Math.floor(encodeTime / 1000)),
+            });
+            encodeBar.stop();
+            const { statSync: fstatSync } = await import('fs');
+            let inputSize = 0;
+            if (inputPaths.length === 1 &&
+                fstatSync(resolvedInputs[0]).isDirectory()) {
+                const { execSync } = await import('child_process');
+                const sizeOutput = execSync(`du -sb "${resolvedInputs[0]}"`, {
+                    encoding: 'utf-8',
+                });
+                inputSize = parseInt(sizeOutput.split(/\s+/)[0]);
+            }
+            else {
+                inputSize = fstatSync(resolvedInputs[0]).size;
+            }
+            const outputSize = fstatSync(resolvedOutput).size;
+            const ratio = ((outputSize / inputSize) * 100).toFixed(1);
+            console.log(`\nSuccess!`);
+            console.log(`  Input:  ${(inputSize / 1024 / 1024).toFixed(2)} MB`);
+            console.log(`  Output: ${(outputSize / 1024 / 1024).toFixed(2)} MB (${ratio}% of original)`);
+            console.log(`  Time:   ${encodeTime}ms`);
+            console.log(`  Saved:  ${resolvedOutput}`);
+            console.log(' ');
+            return;
+        }
+        catch (err) {
+            console.warn('\nRust encoder failed, falling back to TypeScript encoder...');
+            console.warn(`Reason: ${err.message}\n`);
+        }
+    }
     let options = {};
     try {
         const encodeBar = new cliProgress.SingleBar({
@@ -212,6 +284,7 @@ async function encodeCommand(args) {
             mode,
             name: parsed.outputName || 'archive',
             skipOptimization: true,
+            compressionLevel: 19,
         });
         if (parsed.verbose)
             options.verbose = true;

package/dist/utils/encoder.js

@@ -53,7 +53,7 @@ export async function encodeBinaryToPng(input, opts = {}) {
     }
     if (opts.onProgress)
         opts.onProgress({ phase: 'compress_start', total: totalLen });
-    const compressionLevel = opts.compressionLevel ?? 7;
+    const compressionLevel = opts.compressionLevel ?? 19;
     let payload = await parallelZstdCompress(payloadInput, compressionLevel, (loaded, total) => {
         if (opts.onProgress) {
             opts.onProgress({

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

@@ -1 +1,2 @@
-export declare function encodeWithRustCLI(inputPath: string, outputPath: string, compressionLevel?: number): Promise<void>;
+export declare function isRustBinaryAvailable(): boolean;
+export declare function encodeWithRustCLI(inputPath: string, outputPath: string, compressionLevel?: number, passphrase?: string, encryptType?: 'aes' | 'xor'): Promise<void>;

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

@@ -4,19 +4,76 @@ import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel = 3) {
-    const cliPath = join(__dirname, '..', 'dist', 'roxify-cli');
-    if (!existsSync(cliPath)) {
-        throw new Error('Rust CLI binary not found. Run: npm run build:native');
+function findRustBinary() {
+    const candidates = [];
+    const binNames = process.platform === 'win32'
+        ? ['roxify-cli.exe', 'roxify_cli.exe', 'roxify_native.exe']
+        : ['roxify-cli', 'roxify_cli', 'roxify_native'];
+    // Possible locations relative to this file (works in repo and in packaged dist)
+    const relativeDirs = [
+        join(__dirname, '..', '..', 'target', 'release'),
+        join(__dirname, '..', '..', 'dist'),
+        join(__dirname, '..'),
+        join(__dirname, '..', '..'),
+    ];
+    for (const dir of relativeDirs) {
+        for (const name of binNames) {
+            candidates.push(join(dir, name));
+        }
+    }
+    // Common global paths
+    if (process.platform !== 'win32') {
+        candidates.push('/usr/local/bin/roxify_native');
+        candidates.push('/usr/bin/roxify_native');
+    }
+    for (const p of candidates) {
+        try {
+            if (existsSync(p))
+                return p;
+        }
+        catch (e) { }
+    }
+    // Search in PATH for common binary names
+    try {
+        const which = process.platform === 'win32' ? 'where' : 'which';
+        const { execSync } = require('child_process');
+        for (const name of binNames) {
+            try {
+                const out = execSync(`${which} ${name}`, { encoding: 'utf-8' })
+                    .split('\n')[0]
+                    .trim();
+                if (out && existsSync(out))
+                    return out;
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+    }
+    catch (e) { }
+    return null;
+}
+export function isRustBinaryAvailable() {
+    return findRustBinary() !== null;
+}
+export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel = 3, passphrase, encryptType = 'aes') {
+    const cliPath = findRustBinary();
+    if (!cliPath) {
+        throw new Error('Rust CLI binary not found. Run: cargo build --release');
     }
     return new Promise((resolve, reject) => {
-        const proc = spawn(cliPath, [
+        const args = [
             'encode',
             inputPath,
             outputPath,
             '--level',
             String(compressionLevel),
-        ]);
+        ];
+        if (passphrase) {
+            args.push('--passphrase', passphrase);
+            args.push('--encrypt', encryptType);
+        }
+        const proc = spawn(cliPath, args);
         let stderr = '';
         proc.stderr.on('data', (data) => {
             stderr += data.toString();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Encode binary data into PNG images and decode them back. CLI and programmatic API with native Rust acceleration.",
   "type": "module",
   "main": "dist/index.js",