roxify 1.2.3 → 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.2.3';
+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 /
@@ -404,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`);
@@ -418,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`);
@@ -513,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') {
@@ -535,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

@@ -2547,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.2.3",
+  "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",