dir-archiver 2.2.0 → 3.0.1

package/dist/cli.js

@@ -1,51 +1,137 @@
 #!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = __importDefault(require("./index"));
-const argv_flags_1 = __importDefault(require("argv-flags"));
-const parseBooleanFlag = (flag) => {
-    const rawValue = (0, argv_flags_1.default)(flag, 'string');
-    if (typeof rawValue === 'string' && rawValue.length > 0 && !rawValue.startsWith('-')) {
-        const normalized = rawValue.toLowerCase();
-        if (normalized === 'true') {
-            return true;
-        }
-        if (normalized === 'false') {
-            return false;
+import { audit, detect, extract, list, normalize, open, write } from './index.js';
+import { DirArchiverError } from './errors.js';
+import { parseCliArgs } from './cli-args.js';
+const usage = `Usage:
+  dir-archiver write --source <path> --output <archive> [--format <format>] [--include-base-directory] [--exclude <path>...]
+  dir-archiver open --input <archive> [--profile compat|strict|agent]
+  dir-archiver detect --input <archive>
+  dir-archiver list --input <archive>
+  dir-archiver audit --input <archive> [--profile compat|strict|agent]
+  dir-archiver extract --input <archive> --output <directory> [--profile compat|strict|agent] [--max-entry-bytes <n>] [--max-total-extracted-bytes <n>]
+  dir-archiver normalize --input <archive> --output <archive> [--profile compat|strict|agent]
+
+Common options:
+  --format <format>                     zip|tar|tgz|tar.gz|gz|bz2|tar.bz2|zst|tar.zst|br|tar.br|xz|tar.xz
+  --profile <profile>                   compat|strict|agent
+  --json                                emit machine-readable JSON
+  --allow-symlinks                      enable symlink extraction
+  --allow-hardlinks                     enable hardlink extraction (currently unsupported)
+`;
+const run = async () => {
+    const parsed = await parseCliArgs(process.argv.slice(2));
+    const command = parsed.command;
+    if (!parsed.ok || !command) {
+        const payload = {
+            schemaVersion: '1',
+            code: 'DIRARCHIVER_USAGE',
+            message: 'Invalid CLI arguments.',
+            issues: parsed.issues
+        };
+        if (parsed.json) {
+            console.log(JSON.stringify(payload));
+        }
+        else {
+            console.error(usage);
+            for (const issue of parsed.issues) {
+                console.error(`- [${issue.code}] ${issue.message}`);
+            }
+        }
+        return 2;
+    }
+    const commonOptions = {
+        profile: parsed.profile,
+        ...(parsed.format ? { format: parsed.format } : {})
+    };
+    switch (command) {
+        case 'write': {
+            const result = await write(requireString(parsed.source, 'write requires --source/--src'), requireString(parsed.output, 'write requires --output/--dest'), {
+                ...commonOptions,
+                includeBaseDirectory: parsed.includeBaseDirectory,
+                followSymlinks: parsed.followSymlinks,
+                exclude: parsed.exclude
+            });
+            outputResult(parsed.json, result);
+            return 0;
+        }
+        case 'open': {
+            const reader = await open(requireString(parsed.input, 'open requires --input'), commonOptions);
+            outputResult(parsed.json, {
+                format: reader.format,
+                detection: reader.detection
+            });
+            return 0;
+        }
+        case 'detect': {
+            const result = await detect(requireString(parsed.input, 'detect requires --input'), commonOptions);
+            outputResult(parsed.json, result);
+            return 0;
+        }
+        case 'list': {
+            const result = await list(requireString(parsed.input, 'list requires --input'), commonOptions);
+            outputResult(parsed.json, result);
+            return 0;
+        }
+        case 'audit': {
+            const result = await audit(requireString(parsed.input, 'audit requires --input'), commonOptions);
+            outputResult(parsed.json, result);
+            return 0;
+        }
+        case 'extract': {
+            const result = await extract(requireString(parsed.input, 'extract requires --input'), requireString(parsed.output, 'extract requires --output'), {
+                ...commonOptions,
+                allowSymlinks: parsed.allowSymlinks,
+                allowHardlinks: parsed.allowHardlinks,
+                ...(typeof parsed.maxEntryBytes === 'number' ? { maxEntryBytes: parsed.maxEntryBytes } : {}),
+                ...(typeof parsed.maxTotalExtractedBytes === 'number'
+                    ? { maxTotalExtractedBytes: parsed.maxTotalExtractedBytes }
+                    : {})
+            });
+            outputResult(parsed.json, result);
+            return 0;
+        }
+        case 'normalize': {
+            const result = await normalize(requireString(parsed.input, 'normalize requires --input'), requireString(parsed.output, 'normalize requires --output'), {
+                ...commonOptions
+            });
+            outputResult(parsed.json, result);
+            return 0;
         }
+        default:
+            break;
     }
-    return (0, argv_flags_1.default)(flag, 'boolean') === true;
+    const unreachable = command;
+    throw new Error(`Unhandled command: ${String(unreachable)}`);
 };
-const directoryPath = (0, argv_flags_1.default)('--src', 'string');
-const zipPath = (0, argv_flags_1.default)('--dest', 'string');
-const includeBaseDirectory = parseBooleanFlag('--includebasedir');
-const followSymlinks = parseBooleanFlag('--followsymlinks');
-const excludeValues = (0, argv_flags_1.default)('--exclude', 'array');
-const excludes = Array.isArray(excludeValues) ? excludeValues : [];
-if (typeof directoryPath !== 'string' || typeof zipPath !== 'string') {
-    console.log(` Dir Archiver could not be executed. Some arguments are missing.
-
-    Options:
-      --src            The path of the folder to archive.                            [string][required]
-      --dest           The path of the zip file to create.                           [string][required]
-      --includebasedir Includes a base directory at the root of the archive.
-                       For example, if the root folder of your project is named
-                       "your-project", setting this option to true will create
-                       an archive that includes this base directory.
-                       If this option is set to false the archive created will
-                       unzip its content to the current directory.                               [bool]
-      --followsymlinks Follow symlinks when traversing directories.                              [bool]
-      --exclude        A list with the names of the files and folders to exclude.               [array]`);
-    process.exitCode = 1;
-}
-else {
-    const archive = new index_1.default(directoryPath, zipPath, includeBaseDirectory, excludes, followSymlinks);
-    archive.createZip().catch((err) => {
-        const normalizedError = err instanceof Error ? err : new Error(String(err));
-        console.error(normalizedError);
+const outputResult = (asJson, payload) => {
+    if (asJson) {
+        console.log(JSON.stringify(payload));
+        return;
+    }
+    console.log(payload);
+};
+const requireString = (value, message) => {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new DirArchiverError('DIRARCHIVER_USAGE', message);
+    }
+    return value;
+};
+void run()
+    .then((exitCode) => {
+    process.exitCode = exitCode;
+})
+    .catch((error) => {
+    var _a;
+    if (error instanceof DirArchiverError) {
+        console.error(JSON.stringify(error.toJSON()));
         process.exitCode = 1;
-    });
-}
+        return;
+    }
+    if (error instanceof Error) {
+        console.error((_a = error.stack) !== null && _a !== void 0 ? _a : error.message);
+    }
+    else {
+        console.error(String(error));
+    }
+    process.exitCode = 1;
+});

package/dist/core.d.ts

@@ -0,0 +1,33 @@
+import type { ArchiveAuditReport, ArchiveReader } from '@ismail-elkorchi/bytefold';
+import type { DetectResult, DirArchiverInput, ExtractOptions, ExtractResult, ListResult, NormalizeOptions, NormalizeResult, OpenOptions, WriteOptions, WriteResult } from './types.js';
+/**
+ * Opens an archive input with bytefold runtime bindings.
+ */
+export declare const open: (input: DirArchiverInput, options?: OpenOptions) => Promise<ArchiveReader>;
+/**
+ * Detects archive format and exposes bytefold detection metadata.
+ */
+export declare const detect: (input: DirArchiverInput, options?: OpenOptions) => Promise<DetectResult>;
+/**
+ * Lists archive entries without extracting to disk.
+ */
+export declare const list: (input: DirArchiverInput, options?: OpenOptions) => Promise<ListResult>;
+/**
+ * Runs bytefold audit checks for the selected safety profile.
+ */
+export declare const audit: (input: DirArchiverInput, options?: OpenOptions) => Promise<ArchiveAuditReport>;
+/**
+ * Writes a normalized deterministic archive when supported by the format.
+ */
+export declare const normalize: (input: DirArchiverInput, destination: string, options?: NormalizeOptions) => Promise<NormalizeResult>;
+/**
+ * Extracts entries to a destination directory with safety enforcement.
+ */
+export declare const extract: (input: DirArchiverInput, destination: string, options?: ExtractOptions) => Promise<ExtractResult>;
+/**
+ * Writes an archive from a file or directory source.
+ */
+export declare const write: (source: string, destination: string, options?: WriteOptions) => Promise<WriteResult>;
+export declare const copyStreamToFile: (source: string, destination: string) => Promise<void>;
+export declare const pathExists: (value: string) => boolean;
+export declare const fileSize: (value: string) => number;