roxify 1.2.4 → 1.2.6

package/dist/cli.js

@@ -3,8 +3,8 @@ import cliProgress from 'cli-progress';
 import { mkdirSync, readFileSync, statSync, writeFileSync } from 'fs';
 import { basename, dirname, join, resolve } from 'path';
 import { DataFormatError, decodePngToBinary, encodeBinaryToPng, hasPassphraseInPng, IncorrectPassphraseError, listFilesInPng, PassphraseRequiredError, } from './index.js';
-import { packPaths, unpackBuffer } from './pack.js';
-const VERSION = '1.2.4';
+import { packPathsGenerator, unpackBuffer } from './pack.js';
+const VERSION = '1.2.6';
 function showHelp() {
     console.log(`
 ROX CLI — Encode/decode binary in PNG
@@ -20,11 +20,12 @@ Commands:
 
 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
+  -s, --sizes               Show file sizes in 'list' output (default)
+  --no-sizes                Disable file size reporting in 'list'
   --files <list>            Extract only specified files (comma-separated)
   --view-reconst            Export the reconstituted PNG for debugging
   --debug                   Export debug images (doubled.png, reconstructed.png)
@@ -52,6 +53,14 @@ function parseArgs(args) {
                 parsed.viewReconst = true;
                 i++;
             }
+            else if (key === 'sizes') {
+                parsed.sizes = true;
+                i++;
+            }
+            else if (key === 'no-sizes') {
+                parsed.sizes = false;
+                i++;
+            }
             else if (key === 'debug') {
                 parsed.debug = true;
                 i++;
@@ -79,11 +88,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':
@@ -98,6 +102,11 @@ function parseArgs(args) {
                     parsed.verbose = true;
                     i += 1;
                     break;
+                case 's':
+                    parsed.sizes = true;
+                    i += 1;
+                    break;
+                    break;
                 case 'd':
                     parsed.debugDir = value;
                     i += 2;
@@ -144,8 +153,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);
@@ -176,69 +183,69 @@ 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) => ({
+                name: e.path,
+                size: e.size,
+            }));
         }
         else {
             const resolvedInput = resolvedInputs[0];
             const st = statSync(resolvedInput);
             if (st.isDirectory()) {
-                console.log(`Packing directory...`);
                 currentEncodeStep = 'Reading files';
-                const packResult = packPaths([resolvedInput], dirname(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) => ({
+                    name: e.path,
+                    size: e.size,
+                }));
             }
             else {
-                inputBuffer = readFileSync(resolvedInput);
-                console.log('');
+                inputData = readFileSync(resolvedInput);
+                inputSizeVal = inputData.length;
                 displayName = basename(resolvedInput);
                 options.includeFileList = true;
-                options.fileList = [basename(resolvedInput)];
+                options.fileList = [{ name: basename(resolvedInput), size: st.size }];
             }
         }
-        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;
@@ -291,6 +298,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);
@@ -303,8 +321,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)`);
@@ -407,7 +425,8 @@ async function decodeCommand(args) {
             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' });
+            const extractStart = Date.now();
+            extractBar.start(totalBytes, 0, { step: 'Writing files', elapsed: '0' });
             let written = 0;
             for (const file of result.files) {
                 const fullPath = join(baseDir, file.path);
@@ -415,9 +434,15 @@ async function decodeCommand(args) {
                 mkdirSync(dir, { recursive: true });
                 writeFileSync(fullPath, file.buf);
                 written += file.buf.length;
-                extractBar.update(written, { step: `Writing ${file.path}` });
+                extractBar.update(written, {
+                    step: `Writing ${file.path}`,
+                    elapsed: String(Math.floor((Date.now() - extractStart) / 1000)),
+                });
             }
-            extractBar.update(totalBytes, { step: 'Done' });
+            extractBar.update(totalBytes, {
+                step: 'Done',
+                elapsed: String(Math.floor((Date.now() - extractStart) / 1000)),
+            });
             extractBar.stop();
             console.log(`\nSuccess!`);
             console.log(`Unpacked ${result.files.length} files to directory : ${resolve(baseDir)}`);
@@ -427,20 +452,12 @@ 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`);
@@ -483,8 +500,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.');
         }
@@ -510,11 +526,18 @@ async function listCommand(args) {
     const resolvedInput = resolve(inputPath);
     try {
         const inputBuffer = readFileSync(resolvedInput);
-        const fileList = await listFilesInPng(inputBuffer);
+        const fileList = await listFilesInPng(inputBuffer, {
+            includeSizes: parsed.sizes !== false,
+        });
         if (fileList) {
             console.log(`Files in ${resolvedInput}:`);
             for (const file of fileList) {
-                console.log(`  ${file}`);
+                if (typeof file === 'string') {
+                    console.log(`  ${file}`);
+                }
+                else {
+                    console.log(`  ${file.name} (${file.size} bytes)`);
+                }
             }
         }
         else {

package/dist/index.d.ts

@@ -1,134 +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>;
-/**
- * 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>;