roxify 1.2.2 → 1.2.4

package/dist/cli.js

@@ -2,9 +2,9 @@
 import cliProgress from 'cli-progress';
 import { mkdirSync, readFileSync, statSync, writeFileSync } from 'fs';
 import { basename, dirname, join, resolve } from 'path';
-import { DataFormatError, decodePngToBinary, encodeBinaryToPng, IncorrectPassphraseError, listFilesInPng, PassphraseRequiredError, } from './index.js';
+import { DataFormatError, decodePngToBinary, encodeBinaryToPng, hasPassphraseInPng, IncorrectPassphraseError, listFilesInPng, PassphraseRequiredError, } from './index.js';
 import { packPaths, unpackBuffer } from './pack.js';
-const VERSION = '1.1.9';
+const VERSION = '1.2.4';
 function showHelp() {
     console.log(`
 ROX CLI — Encode/decode binary in PNG
@@ -15,7 +15,8 @@ Usage:
 Commands:
   encode <input>... [output]   Encode one or more files/directories into a PNG
   decode <input> [output]   Decode PNG to original file
-  list <input>               List files in a Rox PNG archive
+  list <input>               List files in a Rox PNG archive
+  havepassphrase <input>     Check whether the PNG requires a passphrase
 
 Options:
   -p, --passphrase <pass>   Use passphrase (AES-256-GCM)
@@ -207,7 +208,7 @@ async function encodeCommand(args) {
             if (st.isDirectory()) {
                 console.log(`Packing directory...`);
                 currentEncodeStep = 'Reading files';
-                const packResult = packPaths([resolvedInput], resolvedInput, onProgress);
+                const packResult = packPaths([resolvedInput], dirname(resolvedInput), onProgress);
                 inputBuffer = packResult.buf;
                 console.log('');
                 console.log(`Packed ${packResult.list.length} files -> ${(inputBuffer.length /
@@ -221,6 +222,8 @@ async function encodeCommand(args) {
                 inputBuffer = readFileSync(resolvedInput);
                 console.log('');
                 displayName = basename(resolvedInput);
+                options.includeFileList = true;
+                options.fileList = [basename(resolvedInput)];
             }
         }
         Object.assign(options, {
@@ -402,12 +405,20 @@ async function decodeCommand(args) {
         }
         if (result.files) {
             const baseDir = parsed.output || outputPath || '.';
+            const totalBytes = result.files.reduce((s, f) => s + f.buf.length, 0);
+            const extractBar = new cliProgress.SingleBar({ format: ' {bar} {percentage}% | {step} | {elapsed}s' }, cliProgress.Presets.shades_classic);
+            extractBar.start(totalBytes, 0, { step: 'Writing files' });
+            let written = 0;
             for (const file of result.files) {
                 const fullPath = join(baseDir, file.path);
                 const dir = dirname(fullPath);
                 mkdirSync(dir, { recursive: true });
                 writeFileSync(fullPath, file.buf);
+                written += file.buf.length;
+                extractBar.update(written, { step: `Writing ${file.path}` });
             }
+            extractBar.update(totalBytes, { step: 'Done' });
+            extractBar.stop();
             console.log(`\nSuccess!`);
             console.log(`Unpacked ${result.files.length} files to directory : ${resolve(baseDir)}`);
             console.log(`Time: ${decodeTime}ms`);
@@ -416,12 +427,20 @@ async function decodeCommand(args) {
             const unpacked = unpackBuffer(result.buf);
             if (unpacked) {
                 const baseDir = parsed.output || outputPath || '.';
+                const totalBytes = unpacked.files.reduce((s, f) => s + f.buf.length, 0);
+                const extractBar = new cliProgress.SingleBar({ format: ' {bar} {percentage}% | {step} | {elapsed}s' }, cliProgress.Presets.shades_classic);
+                extractBar.start(totalBytes, 0, { step: 'Writing files' });
+                let written = 0;
                 for (const file of unpacked.files) {
                     const fullPath = join(baseDir, file.path);
                     const dir = dirname(fullPath);
                     mkdirSync(dir, { recursive: true });
                     writeFileSync(fullPath, file.buf);
+                    written += file.buf.length;
+                    extractBar.update(written, { step: `Writing ${file.path}` });
                 }
+                extractBar.update(totalBytes, { step: 'Done' });
+                extractBar.stop();
                 console.log(`\nSuccess!`);
                 console.log(`Time: ${decodeTime}ms`);
                 console.log(`Unpacked ${unpacked.files.length} files to current directory`);
@@ -511,6 +530,29 @@ async function listCommand(args) {
         process.exit(1);
     }
 }
+async function havePassphraseCommand(args) {
+    const parsed = parseArgs(args);
+    const [inputPath] = parsed._;
+    if (!inputPath) {
+        console.log(' ');
+        console.error('Error: Input PNG file required');
+        console.log('Usage: npx rox havepassphrase <input>');
+        process.exit(1);
+    }
+    const resolvedInput = resolve(inputPath);
+    try {
+        const inputBuffer = readFileSync(resolvedInput);
+        const has = await hasPassphraseInPng(inputBuffer);
+        console.log(has ? 'Passphrase detected.' : 'No passphrase detected.');
+    }
+    catch (err) {
+        console.log(' ');
+        console.error('Failed to check passphrase. Use --verbose for details.');
+        if (parsed.verbose)
+            console.error('Details:', err.stack || err.message);
+        process.exit(1);
+    }
+}
 async function main() {
     const args = process.argv.slice(2);
     if (args.length === 0 || args[0] === 'help' || args[0] === '--help') {
@@ -533,6 +575,9 @@ async function main() {
         case 'list':
             await listCommand(commandArgs);
             break;
+        case 'havepassphrase':
+            await havePassphraseCommand(commandArgs);
+            break;
         default:
             console.error(`Unknown command: ${command}`);
             console.log('Run "npx rox help" for usage information');

package/dist/index.d.ts

@@ -127,3 +127,8 @@ export { packPaths, unpackBuffer } from './pack.js';
  * @public
  */
 export declare function listFilesInPng(pngBuf: Buffer): Promise<string[] | null>;
+/**
+ * Detect if a PNG/ROX buffer contains an encrypted payload (requires passphrase)
+ * Returns true if encryption flag indicates AES or XOR.
+ */
+export declare function hasPassphraseInPng(pngBuf: Buffer): Promise<boolean>;

package/dist/index.js

@@ -87,7 +87,7 @@ function deltaDecode(data) {
     }
     return out;
 }
-async function parallelZstdCompress(payload, level = 22, onProgress) {
+async function parallelZstdCompress(payload, level = 11, onProgress) {
     const chunkSize = 1024 * 1024 * 1024;
     if (payload.length <= chunkSize) {
         if (onProgress)
@@ -245,9 +245,10 @@ export async function optimizePngBuffer(pngBuf, fast = false) {
         const inPath = join(tmpdir(), `rox_zop_in_${Date.now()}_${Math.random().toString(36).slice(2)}.png`);
         const outPath = inPath + '.out.png';
         writeFileSync(inPath, pngBuf);
+        const iterations = fast ? 15 : 40;
         const args = [
             '-y',
-            '--iterations=500',
+            `--iterations=${iterations}`,
             '--filters=01234mepb',
             inPath,
             outPath,
@@ -1277,7 +1278,7 @@ export async function encodeBinaryToPng(input, opts = {}) {
         opts.onProgress({ phase: 'compress_start', total: payload.length });
     const useDelta = mode !== 'screenshot';
     const deltaEncoded = useDelta ? deltaEncode(payload) : payload;
-    payload = await parallelZstdCompress(deltaEncoded, 22, (loaded, total) => {
+    payload = await parallelZstdCompress(deltaEncoded, 11, (loaded, total) => {
         if (opts.onProgress) {
             opts.onProgress({
                 phase: 'compress_progress',
@@ -1465,10 +1466,10 @@ export async function encodeBinaryToPng(input, opts = {}) {
             raw: { width, height, channels: 3 },
         })
             .png({
-            compressionLevel: 9,
+            compressionLevel: 6,
             palette: false,
-            effort: 10,
-            adaptiveFiltering: true,
+            effort: 1,
+            adaptiveFiltering: false,
         })
             .toBuffer();
         if (opts.onProgress)
@@ -1476,13 +1477,10 @@ export async function encodeBinaryToPng(input, opts = {}) {
         if (opts.onProgress)
             opts.onProgress({ phase: 'optimizing', loaded: 0, total: 100 });
         let optInterval = null;
-        const MIN_OPT_MS = 8000;
-        let optStart = Date.now();
         if (opts.onProgress) {
             let optLoaded = 0;
-            optStart = Date.now();
             optInterval = setInterval(() => {
-                optLoaded = Math.min(optLoaded + 2, 99);
+                optLoaded = Math.min(optLoaded + 5, 95);
                 opts.onProgress?.({
                     phase: 'optimizing',
                     loaded: optLoaded,
@@ -1491,12 +1489,7 @@ export async function encodeBinaryToPng(input, opts = {}) {
             }, 100);
         }
         try {
-            const optimizedPromise = optimizePngBuffer(bufScr, !!opts.onProgress);
-            const optimized = await optimizedPromise;
-            const elapsedOpt = Date.now() - optStart;
-            if (elapsedOpt < MIN_OPT_MS) {
-                await new Promise((r) => setTimeout(r, MIN_OPT_MS - elapsedOpt));
-            }
+            const optimized = await optimizePngBuffer(bufScr, true);
             clearInterval(progressInterval);
             if (optInterval) {
                 clearInterval(optInterval);
@@ -1504,18 +1497,13 @@ export async function encodeBinaryToPng(input, opts = {}) {
             }
             if (opts.onProgress)
                 opts.onProgress({ phase: 'optimizing', loaded: 100, total: 100 });
-            try {
-                const verified = await decodePngToBinary(optimized);
-                if (verified.buf && verified.buf.equals(input)) {
-                    progressBar?.stop();
-                    return optimized;
-                }
-            }
-            catch (e) { }
             progressBar?.stop();
-            return bufScr;
+            return optimized;
         }
         catch (e) {
+            clearInterval(progressInterval);
+            if (optInterval)
+                clearInterval(optInterval);
             progressBar?.stop();
             return bufScr;
         }
@@ -2559,3 +2547,95 @@ export async function listFilesInPng(pngBuf) {
     catch (e) { }
     return null;
 }
+/**
+ * Detect if a PNG/ROX buffer contains an encrypted payload (requires passphrase)
+ * Returns true if encryption flag indicates AES or XOR.
+ */
+export async function hasPassphraseInPng(pngBuf) {
+    try {
+        if (pngBuf.slice(0, MAGIC.length).equals(MAGIC)) {
+            let offset = MAGIC.length;
+            if (offset >= pngBuf.length)
+                return false;
+            const nameLen = pngBuf.readUInt8(offset);
+            offset += 1 + nameLen;
+            if (offset >= pngBuf.length)
+                return false;
+            const flag = pngBuf[offset];
+            return flag === ENC_AES || flag === ENC_XOR;
+        }
+        try {
+            const chunksRaw = extract(pngBuf);
+            const target = chunksRaw.find((c) => c.name === CHUNK_TYPE);
+            if (target) {
+                const data = Buffer.isBuffer(target.data)
+                    ? target.data
+                    : Buffer.from(target.data);
+                if (data.length >= 1) {
+                    const nameLen = data.readUInt8(0);
+                    const payloadStart = 1 + nameLen;
+                    if (payloadStart < data.length) {
+                        const flag = data[payloadStart];
+                        return flag === ENC_AES || flag === ENC_XOR;
+                    }
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const sharpLib = await import('sharp');
+            const { data } = await sharpLib
+                .default(pngBuf)
+                .raw()
+                .toBuffer({ resolveWithObject: true });
+            const rawRGB = Buffer.from(data);
+            const markerLen = MARKER_COLORS.length * 3;
+            for (let i = 0; i <= rawRGB.length - markerLen; i += 3) {
+                let ok = true;
+                for (let m = 0; m < MARKER_COLORS.length; m++) {
+                    const j = i + m * 3;
+                    if (rawRGB[j] !== MARKER_COLORS[m].r ||
+                        rawRGB[j + 1] !== MARKER_COLORS[m].g ||
+                        rawRGB[j + 2] !== MARKER_COLORS[m].b) {
+                        ok = false;
+                        break;
+                    }
+                }
+                if (!ok)
+                    continue;
+                const headerStart = i + markerLen;
+                if (headerStart + PIXEL_MAGIC.length >= rawRGB.length)
+                    continue;
+                if (!rawRGB
+                    .slice(headerStart, headerStart + PIXEL_MAGIC.length)
+                    .equals(PIXEL_MAGIC))
+                    continue;
+                const metaStart = headerStart + PIXEL_MAGIC.length;
+                if (metaStart + 2 >= rawRGB.length)
+                    continue;
+                const nameLen = rawRGB[metaStart + 1];
+                const payloadLenOff = metaStart + 2 + nameLen;
+                const payloadStart = payloadLenOff + 4;
+                if (payloadStart >= rawRGB.length)
+                    continue;
+                const flag = rawRGB[payloadStart];
+                return flag === ENC_AES || flag === ENC_XOR;
+            }
+        }
+        catch (e) { }
+        try {
+            await decodePngToBinary(pngBuf, { showProgress: false });
+            return false;
+        }
+        catch (e) {
+            if (e instanceof PassphraseRequiredError)
+                return true;
+            if (e.message && e.message.toLowerCase().includes('passphrase'))
+                return true;
+            return false;
+        }
+    }
+    catch (e) {
+        return false;
+    }
+}

package/dist/minpng.js

@@ -75,7 +75,7 @@ export async function encodeMinPng(rgb, width, height) {
         transformed.push(g, r, b);
     }
     const transformedBuf = Buffer.from(transformed);
-    const compressed = Buffer.from(await zstdCompress(transformedBuf, 22));
+    const compressed = Buffer.from(await zstdCompress(transformedBuf, 11));
     const header = Buffer.alloc(4 + 1 + 4 + 4);
     PIXEL_MAGIC.copy(header, 0);
     header[4] = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Encode binary data into PNG images with Zstd compression and decode them back. Supports CLI and programmatic API (Node.js ESM).",
   "type": "module",
   "main": "dist/index.js",