roxify 1.2.3 → 1.2.5

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 { packPaths, unpackBuffer } from './pack.js';
-const VERSION = '1.2.3';
+import { DataFormatError, decodePngToBinary, encodeBinaryToPng, hasPassphraseInPng, IncorrectPassphraseError, listFilesInPng, PassphraseRequiredError, } from './index.js';
+import { packPathsGenerator, unpackBuffer } from './pack.js';
+const VERSION = '1.2.4';
 function showHelp() {
     console.log(`
 ROX CLI — Encode/decode binary in PNG
@@ -15,12 +15,12 @@ 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)
-  -m, --mode <mode>         Mode: compact|chunk|pixel|screenshot (default: screenshot)
-  -q, --quality <0-11>      Brotli quality (default: 11)
+  -m, --mode <mode>         Mode: screenshot (default)
   -e, --encrypt <type>      auto|aes|xor|none
   --no-compress             Disable compression
   -o, --output <path>       Output file path
@@ -78,11 +78,6 @@ function parseArgs(args) {
                     i += 2;
                     break;
                 case 'm':
-                    parsed.mode = value;
-                    i += 2;
-                    break;
-                case 'q':
-                    parsed.quality = parseInt(value, 10);
                     i += 2;
                     break;
                 case 'e':
@@ -143,8 +138,6 @@ async function encodeCommand(args) {
     const resolvedOutput = parsed.output || outputPath || outputName;
     let options = {};
     try {
-        let inputBuffer;
-        let displayName;
         const encodeBar = new cliProgress.SingleBar({
             format: ' {bar} {percentage}% | {step} | {elapsed}s',
         }, cliProgress.Presets.shades_classic);
@@ -175,69 +168,63 @@ async function encodeCommand(args) {
                 elapsed: String(Math.floor(elapsed / 1000)),
             });
         }, TICK_MS);
+        const mode = 'screenshot';
+        Object.assign(options, {
+            mode,
+            name: parsed.outputName || 'archive',
+        });
+        if (parsed.verbose)
+            options.verbose = true;
+        if (parsed.noCompress)
+            options.compression = 'none';
+        if (parsed.passphrase) {
+            options.passphrase = parsed.passphrase;
+            options.encrypt = parsed.encrypt || 'aes';
+        }
+        console.log(`Encoding to ${resolvedOutput} (Mode: ${mode})\n`);
+        let inputData;
+        let inputSizeVal = 0;
+        let displayName;
         let totalBytes = 0;
-        let lastShownFile;
         const onProgress = (readBytes, total, currentFile) => {
             if (totalBytes === 0)
                 totalBytes = total;
             const packPct = Math.floor((readBytes / totalBytes) * 25);
             targetPct = Math.max(targetPct, packPct);
-            if (currentFile && currentFile !== lastShownFile) {
-                lastShownFile = currentFile;
-            }
             currentEncodeStep = currentFile
                 ? `Reading files: ${currentFile}`
                 : 'Reading files';
         };
         if (inputPaths.length > 1) {
             currentEncodeStep = 'Reading files';
-            const packResult = packPaths(inputPaths, undefined, onProgress);
-            inputBuffer = packResult.buf;
-            console.log('');
-            console.log(`Packed ${packResult.list.length} files -> ${(inputBuffer.length /
-                1024 /
-                1024).toFixed(2)} MB`);
+            const { index, stream, totalSize } = await packPathsGenerator(inputPaths, undefined, onProgress);
+            inputData = stream;
+            inputSizeVal = totalSize;
             displayName = parsed.outputName || 'archive';
             options.includeFileList = true;
-            options.fileList = packResult.list;
+            options.fileList = index.map((e) => e.path);
         }
         else {
             const resolvedInput = resolvedInputs[0];
             const st = statSync(resolvedInput);
             if (st.isDirectory()) {
-                console.log(`Packing directory...`);
                 currentEncodeStep = 'Reading files';
-                const packResult = packPaths([resolvedInput], resolvedInput, onProgress);
-                inputBuffer = packResult.buf;
-                console.log('');
-                console.log(`Packed ${packResult.list.length} files -> ${(inputBuffer.length /
-                    1024 /
-                    1024).toFixed(2)} MB`);
+                const { index, stream, totalSize } = await packPathsGenerator([resolvedInput], dirname(resolvedInput), onProgress);
+                inputData = stream;
+                inputSizeVal = totalSize;
                 displayName = parsed.outputName || basename(resolvedInput);
                 options.includeFileList = true;
-                options.fileList = packResult.list;
+                options.fileList = index.map((e) => e.path);
             }
             else {
-                inputBuffer = readFileSync(resolvedInput);
-                console.log('');
+                inputData = readFileSync(resolvedInput);
+                inputSizeVal = inputData.length;
                 displayName = basename(resolvedInput);
                 options.includeFileList = true;
                 options.fileList = [basename(resolvedInput)];
             }
         }
-        Object.assign(options, {
-            mode: parsed.mode || 'screenshot',
-            name: displayName,
-            brQuality: parsed.quality !== undefined ? parsed.quality : 11,
-        });
-        if (parsed.noCompress) {
-            options.compression = 'none';
-        }
-        if (parsed.passphrase) {
-            options.passphrase = parsed.passphrase;
-            options.encrypt = parsed.encrypt || 'aes';
-        }
-        console.log(`Encoding ${displayName} -> ${resolvedOutput}\n`);
+        options.name = displayName;
         options.onProgress = (info) => {
             let stepLabel = 'Processing';
             let pct = 0;
@@ -290,6 +277,17 @@ async function encodeCommand(args) {
             targetPct = Math.max(targetPct, pct);
             currentEncodeStep = stepLabel;
         };
+        let inputBuffer;
+        if (typeof inputData[Symbol.asyncIterator] === 'function') {
+            const chunks = [];
+            for await (const chunk of inputData) {
+                chunks.push(chunk);
+            }
+            inputBuffer = Buffer.concat(chunks);
+        }
+        else {
+            inputBuffer = inputData;
+        }
         const output = await encodeBinaryToPng(inputBuffer, options);
         const encodeTime = Date.now() - startEncode;
         clearInterval(encodeHeartbeat);
@@ -302,8 +300,8 @@ async function encodeCommand(args) {
         }
         writeFileSync(resolvedOutput, output);
         const outputSize = (output.length / 1024 / 1024).toFixed(2);
-        const inputSize = (inputBuffer.length / 1024 / 1024).toFixed(2);
-        const ratio = ((output.length / inputBuffer.length) * 100).toFixed(1);
+        const inputSize = (inputSizeVal / 1024 / 1024).toFixed(2);
+        const ratio = ((output.length / inputSizeVal) * 100).toFixed(1);
         console.log(`\nSuccess!`);
         console.log(`  Input:  ${inputSize} MB`);
         console.log(`  Output: ${outputSize} MB (${ratio}% of original)`);
@@ -404,12 +402,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 +424,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`);
@@ -466,8 +480,7 @@ async function decodeCommand(args) {
                 (err.message.includes('decompression failed') ||
                     err.message.includes('missing ROX1') ||
                     err.message.includes('Pixel payload truncated') ||
-                    err.message.includes('Marker START not found') ||
-                    err.message.includes('Brotli decompression failed')))) {
+                    err.message.includes('Marker START not found')))) {
             console.log(' ');
             console.error('Data corrupted or unsupported format. Use --verbose for details.');
         }
@@ -513,6 +526,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 +571,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

@@ -1,129 +1,13 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { PackedFile } from './pack.js';
-export declare class PassphraseRequiredError extends Error {
-    constructor(message?: string);
-}
-export declare class IncorrectPassphraseError extends Error {
-    constructor(message?: string);
-}
-export declare class DataFormatError extends Error {
-    constructor(message?: string);
-}
-/**
- * Options for encoding binary data into PNG format.
- * @public
- */
-export interface EncodeOptions {
-    compression?: 'zstd';
-    passphrase?: string;
-    name?: string;
-    mode?: 'compact' | 'pixel' | 'screenshot';
-    encrypt?: 'auto' | 'aes' | 'xor' | 'none';
-    _skipAuto?: boolean;
-    output?: 'auto' | 'png' | 'rox';
-    includeName?: boolean;
-    includeFileList?: boolean;
-    fileList?: string[];
-    brQuality?: number;
-    onProgress?: (info: {
-        phase: string;
-        loaded?: number;
-        total?: number;
-    }) => void;
-    showProgress?: boolean;
-}
-/**
- * Result of decoding a PNG back to binary data.
- * @public
- */
-export interface DecodeResult {
-    buf?: Buffer;
-    meta?: {
-        name?: string;
-    };
-    files?: PackedFile[];
-}
-export declare function optimizePngBuffer(pngBuf: Buffer, fast?: boolean): Promise<Buffer>;
-/**
- * Path to write decoded output directly to disk (streamed) to avoid high memory usage.
- */
-export interface DecodeOptions {
-    /**
-     * Passphrase for encrypted inputs.
-     */
-    passphrase?: string;
-    /**
-     * Directory to save debug images (doubled.png, reconstructed.png).
-     */
-    debugDir?: string;
-    /**
-     * Path to write decoded output directly to disk (streamed) to avoid high memory usage.
-     */
-    outPath?: string;
-    /**
-     * List of files to extract selectively from archives.
-     */
-    files?: string[];
-    /**
-     * Progress callback for decoding phases.
-     */
-    onProgress?: (info: {
-        phase: string;
-        loaded?: number;
-        total?: number;
-    }) => void;
-    /**
-     * Whether to display a progress bar in the console.
-     * @defaultValue `false`
-     */
-    showProgress?: boolean;
-}
-export declare function cropAndReconstitute(input: Buffer, debugDir?: string): Promise<Buffer>;
-/**
- * Encode a Buffer into a PNG wrapper. Supports optional compression and
- * encryption. Defaults are chosen for a good balance between speed and size.
- *
- * @param input - Data to encode
- * @param opts - Encoding options
- * @public
- * @example
- * ```typescript
-* import { readFileSync, writeFileSync } from 'fs';
-* import { encodeBinaryToPng } from 'roxify';
-*
-* const fileName = 'input.bin'; //Path of your input file here
-* const inputBuffer = readFileSync(fileName);
-* const pngBuffer = await encodeBinaryToPng(inputBuffer, {
-*   name: fileName,
-* });
-* writeFileSync('output.png', pngBuffer);
-
- * ```
- */
-export declare function encodeBinaryToPng(input: Buffer, opts?: EncodeOptions): Promise<Buffer>;
-/**
- * Decode a PNG produced by this library back to the original Buffer.
- * Supports the ROX binary format, rXDT chunk, and pixel encodings.
- *
- * @param pngBuf - PNG data
- * @param opts - Options (passphrase for encrypted inputs)
- * @public
- * @example
- * import { readFileSync, writeFileSync } from 'fs';
- * import { decodePngToBinary } from 'roxify';
- *
- * const pngFromDisk = readFileSync('output.png'); //Path of the encoded PNG here
- * const { buf, meta } = await decodePngToBinary(pngFromDisk);
- * writeFileSync(meta?.name ?? 'decoded.txt', buf);
- */
-export declare function decodePngToBinary(pngBuf: Buffer, opts?: DecodeOptions): Promise<DecodeResult>;
+export * from './utils/constants.js';
+export * from './utils/crc.js';
+export * from './utils/decoder.js';
+export * from './utils/encoder.js';
+export * from './utils/errors.js';
+export * from './utils/helpers.js';
+export * from './utils/inspection.js';
+export * from './utils/optimization.js';
+export * from './utils/reconstitution.js';
+export * from './utils/types.js';
+export * from './utils/zstd.js';
 export { decodeMinPng, encodeMinPng } from './minpng.js';
 export { packPaths, unpackBuffer } from './pack.js';
-/**
- * List files in a Rox PNG archive without decoding the full payload.
- * Returns the file list if available, otherwise null.
- * @param pngBuf - PNG data
- * @public
- */
-export declare function listFilesInPng(pngBuf: Buffer): Promise<string[] | null>;