roxify 1.5.9 → 1.5.10

package/dist/cli.js

@@ -195,6 +195,28 @@ async function encodeCommand(args) {
     catch (e) {
         resolvedOutput = join('/', parsed.output || outputPath || outputName);
     }
+    // Check for empty directories *before* attempting native Rust encoder.
+    try {
+        const anyDir = inputPaths.some((p) => {
+            try {
+                return statSync(resolve(safeCwd, p)).isDirectory();
+            }
+            catch (e) {
+                return false;
+            }
+        });
+        if (anyDir) {
+            const { index } = await packPathsGenerator(inputPaths, undefined, () => { });
+            if (!index || index.length === 0) {
+                console.log(' ');
+                console.error('Error: No files found in specified input paths.');
+                process.exit(1);
+            }
+        }
+    }
+    catch (e) {
+        // ignore errors from the quick pre-check and proceed to try Rust encoding
+    }
     if (isRustBinaryAvailable() && !parsed.forceTs) {
         try {
             console.log(`Encoding to ${resolvedOutput} (Using native Rust encoder)\n`);
@@ -313,6 +335,11 @@ async function encodeCommand(args) {
         if (inputPaths.length > 1) {
             currentEncodeStep = 'Reading files';
             const { index, stream, totalSize } = await packPathsGenerator(inputPaths, undefined, onProgress);
+            if (!index || index.length === 0) {
+                console.log(' ');
+                console.error('Error: No files found in specified input paths.');
+                process.exit(1);
+            }
             inputData = stream;
             inputSizeVal = totalSize;
             displayName = parsed.outputName || 'archive';
@@ -328,6 +355,11 @@ async function encodeCommand(args) {
             if (st.isDirectory()) {
                 currentEncodeStep = 'Reading files';
                 const { index, stream, totalSize } = await packPathsGenerator([resolvedInput], dirname(resolvedInput), onProgress);
+                if (!index || index.length === 0) {
+                    console.log(' ');
+                    console.error(`Error: No files found in ${resolvedInput}`);
+                    process.exit(1);
+                }
                 inputData = stream;
                 inputSizeVal = totalSize;
                 displayName = parsed.outputName || basename(resolvedInput);

package/dist/utils/native.js

@@ -1,8 +1,8 @@
-import { arch, platform } from 'os';
-import { join, dirname, resolve } from 'path';
+import { existsSync } from 'fs';
 import { createRequire } from 'module';
+import { arch, platform } from 'os';
+import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
-import { existsSync } from 'fs';
 function getNativeModule() {
     let moduleDir;
     let nativeRequire;
@@ -59,7 +59,9 @@ function getNativeModule() {
         // @ts-ignore
         console.debug('[native] moduleDir', moduleDir);
         let root = moduleDir && moduleDir !== '.' ? moduleDir : process.cwd();
-        while (root.length > 1 && !existsSync(resolve(root, 'package.json')) && !existsSync(resolve(root, 'Cargo.toml'))) {
+        while (root.length > 1 &&
+            !existsSync(resolve(root, 'package.json')) &&
+            !existsSync(resolve(root, 'Cargo.toml'))) {
             const parent = resolve(root, '..');
             if (parent === root)
                 break;

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

@@ -23,27 +23,51 @@ function findRustBinary() {
     const binNames = process.platform === 'win32'
         ? ['roxify-cli.exe', 'roxify_cli.exe', 'roxify_native.exe']
         : ['roxify-cli', 'roxify_cli', 'roxify_native'];
+    const baseDir = typeof moduleDir !== 'undefined' ? moduleDir : process.cwd();
     // 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, '..', '..'),
+        join(baseDir, '..', '..', 'target', 'release'),
+        join(baseDir, '..', '..', 'dist'),
+        join(baseDir, '..'),
+        join(baseDir, '..', '..'),
+        join(baseDir, '..', 'target', 'release'),
     ];
     for (const dir of relativeDirs) {
         for (const name of binNames) {
             candidates.push(join(dir, name));
         }
     }
-    // Common global paths
+    // Walk up parents to find a workspace-level target/release (repo root may contain target)
+    try {
+        let cur = baseDir;
+        for (let i = 0; i < 8; i++) {
+            for (const name of binNames) {
+                candidates.push(join(cur, '..', '..', '..', '..', '..', '..', '..', 'target', 'release', name));
+                candidates.push(join(cur, '..', '..', '..', '..', '..', 'target', 'release', name));
+                candidates.push(join(cur, '..', '..', '..', 'target', 'release', name));
+                candidates.push(join(cur, '..', '..', 'target', 'release', name));
+                candidates.push(join(cur, '..', 'target', 'release', name));
+                candidates.push(join(cur, 'target', 'release', name));
+            }
+            const parent = join(cur, '..');
+            if (parent === cur)
+                break;
+            cur = parent;
+        }
+    }
+    catch (e) { }
+    // Common global paths (last resort)
     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))
+            if (existsSync(p)) {
+                // eslint-disable-next-line no-console
+                console.log(`Found Rust binary candidate: ${p}`);
                 return p;
+            }
         }
         catch (e) { }
     }
@@ -56,8 +80,11 @@ function findRustBinary() {
                 const out = execSync(`${which} ${name}`, { encoding: 'utf-8' })
                     .split('\n')[0]
                     .trim();
-                if (out && existsSync(out))
+                if (out && existsSync(out)) {
+                    // eslint-disable-next-line no-console
+                    console.debug(`Found Rust binary in PATH: ${out}`);
                     return out;
+                }
             }
             catch (e) {
                 // ignore
@@ -76,30 +103,66 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
         throw new Error('Rust CLI binary not found. Run: cargo build --release');
     }
     return new Promise((resolve, reject) => {
-        const args = ['encode', '--level', String(compressionLevel)];
-        if (name) {
-            args.push('--name', name);
-        }
-        if (passphrase) {
-            args.push('--passphrase', passphrase);
-            args.push('--encrypt', encryptType);
-        }
+        const baseArgs = ['encode', '--level', String(compressionLevel)];
+        const addNameArgs = (arr) => {
+            if (name) {
+                arr.push('--name', name);
+            }
+        };
+        const addPassArgs = (arr) => {
+            if (passphrase) {
+                arr.push('--passphrase', passphrase);
+                arr.push('--encrypt', encryptType);
+            }
+        };
+        const args = [...baseArgs];
+        addNameArgs(args);
+        addPassArgs(args);
         args.push(inputPath, outputPath);
-        const proc = spawn(cliPath, args);
-        let stderr = '';
-        proc.stderr.on('data', (data) => {
-            stderr += data.toString();
-        });
-        proc.on('error', (err) => {
-            reject(new Error(`Failed to spawn Rust CLI: ${err.message}`));
-        });
-        proc.on('close', (code) => {
-            if (code === 0) {
-                resolve();
+        const spawnAndWait = (argsToUse) => {
+            return new Promise((res, rej) => {
+                const proc = spawn(cliPath, argsToUse);
+                let stderr = '';
+                proc.stderr.on('data', (data) => {
+                    stderr += data.toString();
+                });
+                proc.on('error', (err) => rej(err));
+                proc.on('close', (code) => res({ code, stderr }));
+            });
+        };
+        (async () => {
+            try {
+                const debugMsg = `Rust CLI: ${cliPath} ${args.join(' ')}`;
+                // eslint-disable-next-line no-console
+                console.log(debugMsg);
+                let result = await spawnAndWait(args);
+                if (result.code === 0)
+                    return resolve();
+                // If the error mentions an unexpected '--name' arg (older binary), retry without name
+                if (name &&
+                    result.stderr &&
+                    (/unexpected argument.*--name/.test(result.stderr) ||
+                        /unexpected argument .*'--name'/.test(result.stderr) ||
+                        result.stderr.includes("'--name'"))) {
+                    const argsNoName = [...baseArgs];
+                    addPassArgs(argsNoName);
+                    argsNoName.push(inputPath, outputPath);
+                    // eslint-disable-next-line no-console
+                    console.log('Rust CLI rejected --name; retrying without --name');
+                    const retryDebug = `Retrying Rust CLI: ${cliPath} ${argsNoName.join(' ')}`;
+                    // eslint-disable-next-line no-console
+                    console.log(retryDebug);
+                    result = await spawnAndWait(argsNoName);
+                    // eslint-disable-next-line no-console
+                    console.log(`Rust retry exited with code ${result.code}`);
+                    if (result.code === 0)
+                        return resolve();
+                }
+                reject(new Error(`Rust CLI exited with code ${result.code}: ${result.stderr}`));
             }
-            else {
-                reject(new Error(`Rust CLI exited with code ${code}: ${stderr}`));
+            catch (err) {
+                reject(new Error(`Failed to spawn Rust CLI: ${err.message || err}`));
             }
-        });
+        })();
     });
 }

package/package.json

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