roxify 1.5.8 → 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;
@@ -13,11 +13,24 @@ function getNativeModule() {
         nativeRequire = require;
     }
     else {
-        // Mode ESM - utiliser import.meta.url
-        // @ts-ignore - import.meta.url existe en ESM
-        const __filename = fileURLToPath(import.meta.url);
-        moduleDir = dirname(__filename);
-        nativeRequire = createRequire(import.meta.url);
+        // Try ESM import.meta.url first (may throw in CJS/bundled contexts), otherwise fallback to CWD
+        try {
+            // @ts-ignore - import.meta.url exists in proper ESM contexts
+            const __filename = fileURLToPath(import.meta.url);
+            moduleDir = dirname(__filename);
+            nativeRequire = createRequire(import.meta.url);
+        }
+        catch {
+            // Fallback (bundled CJS without __dirname): use current working directory
+            moduleDir = process.cwd();
+            try {
+                // @ts-ignore
+                nativeRequire = require;
+            }
+            catch {
+                nativeRequire = createRequire(process.cwd());
+            }
+        }
     }
     function getNativePath() {
         const platformMap = {
@@ -46,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

@@ -2,34 +2,72 @@ import { spawn } from 'child_process';
 import { existsSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+let moduleDir;
+try {
+    // CJS bundlers may provide __dirname; prefer it when available
+    if (typeof __dirname !== 'undefined') {
+        // @ts-ignore
+        moduleDir = __dirname;
+    }
+    else {
+        // @ts-ignore - import.meta.url exists in ESM
+        const __filename = fileURLToPath(import.meta.url);
+        moduleDir = dirname(__filename);
+    }
+}
+catch {
+    moduleDir = process.cwd();
+}
 function findRustBinary() {
     const candidates = [];
     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) { }
     }
@@ -42,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
@@ -62,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.8",
+  "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",