roxify 1.9.1 → 1.9.3

package/Cargo.toml

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

package/dist/cli.js

@@ -6,7 +6,7 @@ import { DataFormatError, decodePngToBinary, encodeBinaryToPng, hasPassphraseInP
 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.8.0';
+const VERSION = '1.9.2';
 function getDirectorySize(dirPath) {
     let totalSize = 0;
     try {

package/dist/utils/native.js

@@ -69,7 +69,6 @@ function getNativeModule() {
         // --- 1. Platform-specific candidates (checked FIRST) ---
         // These are the ONLY safe candidates — they match the current OS+arch.
         const candidates = [];
-        candidates.push(resolve(root, 'roxify_native.node'), resolve(moduleDir, '..', 'roxify_native.node'));
         for (const triple of triples) {
             const name = `roxify_native-${triple}.node`;
             const libName = `libroxify_native-${triple}.node`;

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

@@ -1,18 +1,35 @@
 import { execSync, spawn } from 'child_process';
 import { existsSync } from 'fs';
 import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 let moduleDir;
 if (typeof __dirname !== 'undefined') {
     moduleDir = __dirname;
 }
 else {
-    moduleDir = process.cwd();
+    try {
+        moduleDir = dirname(fileURLToPath(import.meta.url));
+    }
+    catch {
+        moduleDir = process.cwd();
+    }
 }
 function findRustBinary() {
     const binNames = process.platform === 'win32'
         ? ['roxify_native.exe', 'roxify-cli.exe', 'roxify_cli.exe']
         : ['roxify_native', 'roxify-cli', 'roxify_cli'];
-    const baseDir = typeof moduleDir !== 'undefined' ? moduleDir : process.cwd();
+    const baseDir = moduleDir;
+    for (const name of binNames) {
+        const sameDirPath = join(baseDir, name);
+        if (existsSync(sameDirPath))
+            return sameDirPath;
+        const parentPath = join(baseDir, '..', name);
+        if (existsSync(parentPath))
+            return parentPath;
+        const parentDistPath = join(baseDir, '..', 'dist', name);
+        if (existsSync(parentDistPath))
+            return parentDistPath;
+    }
     if (process.pkg) {
         const snapshotPaths = [
             join(baseDir, '..', '..', 'target', 'release'),
@@ -22,9 +39,8 @@ function findRustBinary() {
         for (const basePath of snapshotPaths) {
             for (const name of binNames) {
                 const binPath = join(basePath, name);
-                if (existsSync(binPath)) {
+                if (existsSync(binPath))
                     return binPath;
-                }
             }
         }
         try {
@@ -35,40 +51,35 @@ function findRustBinary() {
                     join(execDir, 'tools', 'roxify'),
                     join(execDir, '..', 'tools', 'roxify', 'dist'),
                     join(execDir, '..', 'tools', 'roxify'),
-                    join(execDir, 'tools', 'roxify', 'roxify_native.exe'),
                 ];
                 for (const c of execCandidates) {
                     for (const name of binNames) {
-                        const p = c.endsWith(name) ? c : join(c, name);
-                        if (existsSync(p)) {
+                        const p = join(c, name);
+                        if (existsSync(p))
                             return p;
-                        }
                     }
                 }
             }
         }
-        catch (e) { }
+        catch { }
     }
     try {
         let paths = [];
         if (process.platform === 'win32') {
             try {
-                const out = execSync('where rox', { encoding: 'utf-8' }).trim();
+                const out = execSync('where rox', { encoding: 'utf-8', timeout: 5000 }).trim();
                 if (out)
-                    paths = out
-                        .split(/\r?\n/)
-                        .map((s) => s.trim())
-                        .filter(Boolean);
+                    paths = out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
             }
-            catch (e) { }
+            catch { }
         }
         else {
             try {
-                const out = execSync('which rox', { encoding: 'utf-8' }).trim();
+                const out = execSync('which rox', { encoding: 'utf-8', timeout: 5000 }).trim();
                 if (out)
                     paths = [out.trim()];
             }
-            catch (e) { }
+            catch { }
         }
         for (const p of paths) {
             try {
@@ -78,44 +89,33 @@ function findRustBinary() {
                     join(d, 'dist'),
                     join(d, '..', 'dist'),
                     join(d, '..'),
+                    join(d, 'node_modules', 'roxify', 'dist'),
                 ];
                 for (const c of candidates) {
                     for (const name of binNames) {
                         const candidate = join(c, name);
-                        if (existsSync(candidate)) {
+                        if (existsSync(candidate))
                             return candidate;
-                        }
                     }
                 }
             }
-            catch (e) { }
+            catch { }
         }
     }
-    catch (e) { }
+    catch { }
     for (const name of binNames) {
-        const local = join(baseDir, name);
-        if (existsSync(local)) {
-            return local;
-        }
-        const parentLocal = join(baseDir, '..', name);
-        if (existsSync(parentLocal)) {
-            return parentLocal;
-        }
         const parentParentLocal = join(baseDir, '..', '..', name);
-        if (existsSync(parentParentLocal)) {
+        if (existsSync(parentParentLocal))
             return parentParentLocal;
-        }
         const nodeModulesPath = join(baseDir, '..', '..', '..', '..', name);
-        if (existsSync(nodeModulesPath)) {
+        if (existsSync(nodeModulesPath))
             return nodeModulesPath;
-        }
     }
     const targetRelease = join(baseDir, '..', '..', 'target', 'release');
     for (const name of binNames) {
         const targetPath = join(targetRelease, name);
-        if (existsSync(targetPath)) {
+        if (existsSync(targetPath))
             return targetPath;
-        }
     }
     return null;
 }

package/native/png_utils.rs

@@ -138,12 +138,22 @@ pub fn get_png_metadata(png_data: &[u8]) -> Result<(u32, u32, u8, u8), String> {
 
 pub fn extract_payload_from_png(png_data: &[u8]) -> Result<Vec<u8>, String> {
     if let Ok(payload) = extract_payload_direct(png_data) {
-        return Ok(payload);
+        if validate_payload_deep(&payload) {
+            return Ok(payload);
+        }
     }
     let reconst = crate::reconstitution::crop_and_reconstitute(png_data)?;
     extract_payload_direct(&reconst)
 }
 
+fn validate_payload_deep(payload: &[u8]) -> bool {
+    if payload.len() < 5 { return false; }
+    if payload[0] == 0x01 || payload[0] == 0x02 { return true; }
+    let compressed = if payload[0] == 0x00 { &payload[1..] } else { payload };
+    if compressed.starts_with(b"ROX1") { return true; }
+    crate::core::zstd_decompress_bytes(compressed, None).is_ok()
+}
+
 fn find_pixel_header(raw: &[u8]) -> Result<usize, String> {
     let magic = b"PXL1";
     for i in 0..(raw.len().saturating_sub(magic.len())) {

package/native/reconstitution.rs

@@ -373,9 +373,31 @@ pub fn crop_and_reconstitute(png_data: &[u8]) -> Result<Vec<u8>, String> {
     let mut out = RgbaImage::from_pixel(best_logical_w, best_logical_h, Rgba([0, 0, 0, 255]));
     for ly in 0..best_logical_h {
         for lx in 0..best_logical_w {
-            let px = (sx as f64 + (lx as f64 + 0.5) * scale_x) as u32;
-            let py = (sy as f64 + (ly as f64 + 0.5) * scale_y) as u32;
-            out.put_pixel(lx, ly, Rgba(get_pixel(min(px, width - 1), min(py, height - 1))));
+            let bx0 = (sx as f64 + lx as f64 * scale_x).round() as u32;
+            let bx1 = (sx as f64 + (lx + 1) as f64 * scale_x).round() as u32;
+            let by0 = (sy as f64 + ly as f64 * scale_y).round() as u32;
+            let by1 = (sy as f64 + (ly + 1) as f64 * scale_y).round() as u32;
+            let bx0 = min(bx0, width - 1);
+            let bx1 = min(bx1, width).max(bx0 + 1);
+            let by0 = min(by0, height - 1);
+            let by1 = min(by1, height).max(by0 + 1);
+
+            let mut rs: Vec<u8> = Vec::new();
+            let mut gs: Vec<u8> = Vec::new();
+            let mut bs: Vec<u8> = Vec::new();
+            for py in by0..by1 {
+                for px in bx0..bx1 {
+                    let p = get_pixel(px, py);
+                    rs.push(p[0]);
+                    gs.push(p[1]);
+                    bs.push(p[2]);
+                }
+            }
+            rs.sort_unstable();
+            gs.sort_unstable();
+            bs.sort_unstable();
+            let mid = rs.len() / 2;
+            out.put_pixel(lx, ly, Rgba([rs[mid], gs[mid], bs[mid], 255]));
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.9.1",
+  "version": "1.9.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",
@@ -11,8 +11,6 @@
   },
   "files": [
     "dist",
-    "roxify_native.node",
-    "libroxify_native.node",
     "roxify_native-x86_64-unknown-linux-gnu.node",
     "roxify_native-i686-unknown-linux-gnu.node",
     "roxify_native-aarch64-unknown-linux-gnu.node",

package/scripts/postinstall.cjs

@@ -1,6 +1,7 @@
 const { execSync } = require('child_process');
 const { existsSync, copyFileSync, mkdirSync } = require('fs');
-const { join, dirname } = require('path');
+const { join } = require('path');
+const { platform, arch } = require('os');
 
 const root = join(__dirname, '..');
 const distDir = join(root, 'dist');
@@ -12,90 +13,149 @@ function hasCargo() {
       } catch { return false; }
 }
 
+function getTriples() {
+      const os = platform();
+      const cpu = arch();
+      const map = {
+            linux: { x64: ['x86_64-unknown-linux-gnu'], arm64: ['aarch64-unknown-linux-gnu'] },
+            win32: { x64: ['x86_64-pc-windows-msvc', 'x86_64-pc-windows-gnu'], arm64: ['aarch64-pc-windows-msvc'] },
+            darwin: { x64: ['x86_64-apple-darwin'], arm64: ['aarch64-apple-darwin'] },
+      };
+      return (map[os] && map[os][cpu]) || [];
+}
+
+function getLibExt() {
+      if (platform() === 'win32') return 'dll';
+      if (platform() === 'darwin') return 'dylib';
+      return 'so';
+}
+
 function getBinaryName() {
-      return process.platform === 'win32' ? 'roxify_native.exe' : 'roxify_native';
+      return platform() === 'win32' ? 'roxify_native.exe' : 'roxify_native';
 }
 
 function findExistingBinary() {
       const name = getBinaryName();
-      const candidates = [
-            join(distDir, name),
-            join(root, 'target', 'release', name),
-      ];
-
-      if (process.platform === 'win32') {
-            candidates.push(join(root, 'target', 'x86_64-pc-windows-gnu', 'release', name));
-            candidates.push(join(root, 'target', 'x86_64-pc-windows-msvc', 'release', name));
-      } else if (process.platform === 'linux') {
-            candidates.push(join(root, 'target', 'x86_64-unknown-linux-gnu', 'release', name));
-      } else if (process.platform === 'darwin') {
-            candidates.push(join(root, 'target', 'x86_64-apple-darwin', 'release', name));
-            candidates.push(join(root, 'target', 'aarch64-apple-darwin', 'release', name));
+      const triples = getTriples();
+      const candidates = [join(distDir, name), join(root, 'target', 'release', name)];
+      for (const t of triples) {
+            candidates.push(join(root, 'target', t, 'release', name));
       }
-
       for (const c of candidates) {
             if (existsSync(c)) return c;
       }
       return null;
 }
 
+function findExistingNativeLib() {
+      const triples = getTriples();
+      const ext = getLibExt();
+      const prefix = platform() === 'win32' ? '' : 'lib';
+      for (const t of triples) {
+            const specific = join(root, `roxify_native-${t}.node`);
+            if (existsSync(specific)) return { path: specific, triple: t };
+      }
+      for (const t of triples) {
+            for (const profile of ['release', 'fastdev']) {
+                  const paths = [
+                        join(root, 'target', t, profile, `${prefix}roxify_native.${ext}`),
+                        join(root, 'target', profile, `${prefix}roxify_native.${ext}`),
+                  ];
+                  for (const p of paths) {
+                        if (existsSync(p)) return { path: p, triple: t };
+                  }
+            }
+      }
+      return null;
+}
+
+function buildNative(target) {
+      if (!hasCargo()) return false;
+      const args = target ? ` --target ${target}` : '';
+      console.log(`roxify: Building native lib${args}...`);
+      try {
+            execSync(`cargo build --release --lib${args}`, { cwd: root, stdio: 'inherit', timeout: 600000 });
+            return true;
+      } catch {
+            console.log('roxify: Native lib build failed');
+            return false;
+      }
+}
+
 function buildBinary() {
       if (!hasCargo()) {
-            console.log('roxify: Cargo not found, skipping native binary build (TypeScript fallback will be used)');
+            console.log('roxify: Cargo not found, skipping native build (TypeScript fallback will be used)');
             return false;
       }
-
-      console.log('roxify: Building native CLI binary with Cargo...');
+      console.log('roxify: Building native CLI binary...');
       try {
-            execSync('cargo build --release --bin roxify_native', {
-                  cwd: root,
-                  stdio: 'inherit',
-                  timeout: 600000,
-            });
+            execSync('cargo build --release --bin roxify_native', { cwd: root, stdio: 'inherit', timeout: 600000 });
             return true;
-      } catch (e) {
+      } catch {
             console.log('roxify: Native build failed, TypeScript fallback will be used');
             return false;
       }
 }
 
-function run() {
-      if (!existsSync(distDir)) {
-            mkdirSync(distDir, { recursive: true });
-      }
-
+function ensureCliBinary() {
+      if (!existsSync(distDir)) mkdirSync(distDir, { recursive: true });
       const dest = join(distDir, getBinaryName());
-      if (existsSync(dest)) {
-            return;
-      }
+      if (existsSync(dest)) return;
 
       const existing = findExistingBinary();
       if (existing && existing !== dest) {
             copyFileSync(existing, dest);
-            if (process.platform !== 'win32') {
+            if (platform() !== 'win32') {
                   try { require('fs').chmodSync(dest, 0o755); } catch { }
             }
-            console.log(`roxify: Copied native binary from ${existing}`);
+            console.log(`roxify: Copied CLI binary from ${existing}`);
             return;
       }
-
       if (existing) return;
-
-      if (process.env.ROXIFY_SKIP_BUILD === '1') {
-            console.log('roxify: ROXIFY_SKIP_BUILD=1, skipping native build');
-            return;
-      }
+      if (process.env.ROXIFY_SKIP_BUILD === '1') return;
 
       if (buildBinary()) {
             const built = join(root, 'target', 'release', getBinaryName());
             if (existsSync(built)) {
                   copyFileSync(built, dest);
-                  if (process.platform !== 'win32') {
+                  if (platform() !== 'win32') {
                         try { require('fs').chmodSync(dest, 0o755); } catch { }
                   }
-                  console.log('roxify: Native binary built and copied to dist/');
+                  console.log('roxify: CLI binary built and copied to dist/');
+            }
+      }
+}
+
+function ensureNativeLib() {
+      const triples = getTriples();
+      if (!triples.length) return;
+
+      for (const t of triples) {
+            if (existsSync(join(root, `roxify_native-${t}.node`))) return;
+      }
+
+      const found = findExistingNativeLib();
+      if (found) {
+            const dest = join(root, `roxify_native-${found.triple}.node`);
+            copyFileSync(found.path, dest);
+            console.log(`roxify: Copied native lib → ${dest}`);
+            return;
+      }
+
+      if (process.env.ROXIFY_SKIP_BUILD === '1') return;
+
+      const triple = triples[0];
+      if (buildNative(null)) {
+            const ext = getLibExt();
+            const prefix = platform() === 'win32' ? '' : 'lib';
+            const built = join(root, 'target', 'release', `${prefix}roxify_native.${ext}`);
+            if (existsSync(built)) {
+                  const dest = join(root, `roxify_native-${triple}.node`);
+                  copyFileSync(built, dest);
+                  console.log(`roxify: Native lib built → ${dest}`);
             }
       }
 }
 
-run();
+ensureCliBinary();
+ensureNativeLib();