acker-dacker 0.1.0 → 0.2.0

package/src/zip/zip.ts

@@ -0,0 +1,511 @@
+import { lstat, mkdir, open, readdir, readlink, rename, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { createDeflateRaw, deflateRawSync } from 'node:zlib';
+import { compareStableStrings, normalizeArchivePath } from '../pack/path-patterns';
+
+type ZipEntryKind = 'file' | 'symlink';
+
+type ZipFileEntry = {
+    readonly absolutePath: string;
+    readonly archivePath: string;
+    readonly kind: ZipEntryKind;
+    readonly linkTarget?: string;
+    readonly mode?: number;
+    readonly size: number;
+};
+
+type WrittenZipEntry = ZipFileEntry & {
+    readonly compressedSize: number;
+    readonly compressionMethod: number;
+    readonly crc32: number;
+    readonly localHeaderOffset: number;
+    readonly pathBytes: Uint8Array;
+};
+
+export type ZipCreationOptions = {
+    readonly preserveSymlinks: boolean;
+    readonly preserveUnixMetadata: boolean;
+};
+
+export const ZIP_MAX_UINT32 = 0xffffffff;
+export const ZIP_MAX_UINT16 = 0xffff;
+const ZIP_DOS_DATE_1980_01_01 = 0x21;
+const ZIP_DEFLATE_METHOD = 8;
+const ZIP_STORE_METHOD = 0;
+const ZIP_UNIX_CREATOR_VERSION = 0x0314;
+const ZIP_UTF8_FLAG = 0x0800;
+export const MAX_BUFFERED_DEFLATE_BYTES = 64 * 1024 * 1024;
+
+const CRC32_TABLE = new Uint32Array(256);
+for (let index = 0; index < CRC32_TABLE.length; index += 1) {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+        value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+    }
+    CRC32_TABLE[index] = value >>> 0;
+}
+
+const updateCrc32 = (crc: number, chunk: Uint8Array): number => {
+    let current = crc;
+    for (const byte of chunk) {
+        current = CRC32_TABLE[(current ^ byte) & 0xff]! ^ (current >>> 8);
+    }
+    return current >>> 0;
+};
+
+export const validateZipEntryCount = (count: number): void => {
+    if (count > ZIP_MAX_UINT16) {
+        throw new Error(`Zip entry count (${count}) exceeds classic ZIP limit of ${ZIP_MAX_UINT16}`);
+    }
+};
+
+export const validateZipEntrySize = (size: number, pathLabel: string): void => {
+    if (size > ZIP_MAX_UINT32) {
+        throw new Error(`Zip entry size exceeds classic ZIP limit (4 GB): ${pathLabel}`);
+    }
+};
+
+export const assertWithinZip32Limit = (currentOffset: number, bytesToAdd: number, description: string): void => {
+    if (currentOffset + bytesToAdd > ZIP_MAX_UINT32) {
+        throw new Error(`Zip archive size exceeds classic ZIP limit (4 GB) while writing ${description}`);
+    }
+};
+
+
+const collectZipFiles = async ({
+    directory,
+    excludedAbsolutePaths,
+    preserveSymlinks,
+    preserveUnixMetadata,
+    rootDir,
+}: {
+    readonly directory: string;
+    readonly excludedAbsolutePaths: ReadonlySet<string>;
+    readonly preserveSymlinks: boolean;
+    readonly preserveUnixMetadata: boolean;
+    readonly rootDir: string;
+}): Promise<readonly ZipFileEntry[]> => {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files: ZipFileEntry[] = [];
+    for (const entry of entries.sort((left, right) => compareStableStrings(left.name, right.name))) {
+        const absolutePath = path.join(directory, entry.name);
+        if (excludedAbsolutePaths.has(absolutePath)) {
+            continue;
+        }
+
+        if (entry.isSymbolicLink()) {
+            if (!preserveSymlinks) {
+                continue;
+            }
+            const linkTarget = await readlink(absolutePath);
+            const size = new TextEncoder().encode(linkTarget).byteLength;
+            if (size > ZIP_MAX_UINT32) {
+                throw new Error(`Zip entry size exceeds classic ZIP limit (4 GB): ${absolutePath}`);
+            }
+            files.push({
+                absolutePath,
+                archivePath: normalizeArchivePath(path.relative(rootDir, absolutePath)),
+                kind: 'symlink',
+                linkTarget,
+                mode: 0o120777,
+                size,
+            });
+            continue;
+        }
+
+        if (entry.isDirectory()) {
+            files.push(
+                ...(await collectZipFiles({
+                    directory: absolutePath,
+                    excludedAbsolutePaths,
+                    preserveSymlinks,
+                    preserveUnixMetadata,
+                    rootDir,
+                })),
+            );
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+
+        const fileStats = await lstat(absolutePath);
+        if (fileStats.size > ZIP_MAX_UINT32) {
+            throw new Error(`Zip entry size exceeds classic ZIP limit (4 GB): ${absolutePath}`);
+        }
+        files.push({
+            absolutePath,
+            archivePath: normalizeArchivePath(path.relative(rootDir, absolutePath)),
+            kind: 'file',
+            mode: preserveUnixMetadata ? fileStats.mode : undefined,
+            size: fileStats.size,
+        });
+    }
+    return files;
+};
+
+export const writeBuffer = async (
+    handle: { write: (buffer: Uint8Array, offset?: number, length?: number, position?: number | null) => Promise<{ bytesWritten: number }> },
+    buffer: Uint8Array,
+    offset: number,
+): Promise<number> => {
+    let currentBufferOffset = 0;
+    let currentFileOffset = offset;
+
+    while (currentBufferOffset < buffer.length) {
+        const remaining = buffer.length - currentBufferOffset;
+        const result = await handle.write(buffer, currentBufferOffset, remaining, currentFileOffset);
+        if (result.bytesWritten <= 0) {
+            throw new Error(`Write made no progress at offset ${currentFileOffset}`);
+        }
+        currentBufferOffset += result.bytesWritten;
+        currentFileOffset += result.bytesWritten;
+    }
+
+    return currentFileOffset;
+};
+
+const writeZipLocalHeader = async (
+    handle: { write: (buffer: Uint8Array, offset?: number, length?: number, position?: number | null) => Promise<{ bytesWritten: number }> },
+    entry: ZipFileEntry,
+    pathBytes: Uint8Array,
+    crc32: number,
+    compressedSize: number,
+    compressionMethod: number,
+    offset: number,
+): Promise<number> => {
+    assertWithinZip32Limit(offset, 30 + pathBytes.length, `local header for ${entry.archivePath}`);
+    const header = Buffer.alloc(30);
+    header.writeUInt32LE(0x04034b50, 0);
+    header.writeUInt16LE(20, 4);
+    header.writeUInt16LE(ZIP_UTF8_FLAG, 6);
+    header.writeUInt16LE(compressionMethod, 8);
+    header.writeUInt16LE(0, 10);
+    header.writeUInt16LE(ZIP_DOS_DATE_1980_01_01, 12);
+    header.writeUInt32LE(crc32, 14);
+    header.writeUInt32LE(compressedSize, 18);
+    header.writeUInt32LE(entry.size, 22);
+    header.writeUInt16LE(pathBytes.length, 26);
+    header.writeUInt16LE(0, 28);
+    const nextOffset = await writeBuffer(handle, header, offset);
+    return await writeBuffer(handle, pathBytes, nextOffset);
+};
+
+const streamDeflateFile = async (
+    absolutePath: string,
+    spoolDir: string,
+): Promise<{
+    readonly compressedSize: number;
+    readonly compressionMethod: number;
+    readonly crc32: number;
+    readonly spoolFile: string | null;
+}> => {
+    const spoolFile = path.join(
+        spoolDir,
+        `.spool-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`,
+    );
+    const spoolHandle = await open(spoolFile, 'wx');
+    let spoolClosed = false;
+
+    try {
+        const deflater = createDeflateRaw({ level: 9, memLevel: 9 });
+        let compressedSize = 0;
+        let spoolOffset = 0;
+        let writeQueue = Promise.resolve();
+
+        deflater.on('data', (chunk: Buffer) => {
+            compressedSize += chunk.length;
+            writeQueue = writeQueue.then(async () => {
+                await writeBuffer(spoolHandle, chunk, spoolOffset);
+                spoolOffset += chunk.length;
+            });
+        });
+
+        const reader = Bun.file(absolutePath).stream().getReader();
+        let crc = 0xffffffff;
+        let sourceBytes = 0;
+
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                sourceBytes += value.length;
+                crc = updateCrc32(crc, value);
+                if (!deflater.write(value)) {
+                    await new Promise((resolve) => deflater.once('drain', resolve));
+                }
+            }
+        } finally {
+            reader.releaseLock();
+        }
+
+        await new Promise<void>((resolve, reject) => {
+            deflater.on('error', reject);
+            deflater.on('end', resolve);
+            deflater.end();
+        });
+
+        await writeQueue;
+        await spoolHandle.close();
+        spoolClosed = true;
+
+        const finalCrc = (crc ^ 0xffffffff) >>> 0;
+
+        if (compressedSize < sourceBytes) {
+            return {
+                compressedSize,
+                compressionMethod: ZIP_DEFLATE_METHOD,
+                crc32: finalCrc,
+                spoolFile,
+            };
+        }
+
+        await rm(spoolFile, { force: true });
+        return {
+            compressedSize: sourceBytes,
+            compressionMethod: ZIP_STORE_METHOD,
+            crc32: finalCrc,
+            spoolFile: null,
+        };
+    } catch (error) {
+        if (!spoolClosed) {
+            await spoolHandle.close().catch(() => {});
+        }
+        await rm(spoolFile, { force: true }).catch(() => {});
+        throw error;
+    }
+};
+
+type PreparedBytes = {
+    readonly bytes: Uint8Array | null;
+    readonly compressedSize: number;
+    readonly compressionMethod: number;
+    readonly crc32: number;
+    readonly spoolFile: string | null;
+};
+
+const prepareFileBytes = async (entry: ZipFileEntry, spoolDir: string): Promise<PreparedBytes> => {
+    if (entry.kind === 'symlink') {
+        const source = new TextEncoder().encode(entry.linkTarget ?? '');
+        const crc32 = (updateCrc32(0xffffffff, source) ^ 0xffffffff) >>> 0;
+        const compressed = deflateRawSync(source, { level: 9, memLevel: 9 });
+        if (compressed.byteLength < source.byteLength) {
+            return {
+                bytes: compressed,
+                compressedSize: compressed.byteLength,
+                compressionMethod: ZIP_DEFLATE_METHOD,
+                crc32,
+                spoolFile: null,
+            };
+        }
+        return {
+            bytes: source,
+            compressedSize: source.byteLength,
+            compressionMethod: ZIP_STORE_METHOD,
+            crc32,
+            spoolFile: null,
+        };
+    }
+
+    if (entry.size > MAX_BUFFERED_DEFLATE_BYTES) {
+        const streamed = await streamDeflateFile(entry.absolutePath, spoolDir);
+        return {
+            bytes: null,
+            compressedSize: streamed.compressedSize,
+            compressionMethod: streamed.compressionMethod,
+            crc32: streamed.crc32,
+            spoolFile: streamed.spoolFile,
+        };
+    }
+
+    const source = new Uint8Array(await Bun.file(entry.absolutePath).arrayBuffer());
+    const crc32 = (updateCrc32(0xffffffff, source) ^ 0xffffffff) >>> 0;
+    const compressed = deflateRawSync(source, { level: 9, memLevel: 9 });
+    if (compressed.byteLength < source.byteLength) {
+        return {
+            bytes: compressed,
+            compressedSize: compressed.byteLength,
+            compressionMethod: ZIP_DEFLATE_METHOD,
+            crc32,
+            spoolFile: null,
+        };
+    }
+    return {
+        bytes: source,
+        compressedSize: source.byteLength,
+        compressionMethod: ZIP_STORE_METHOD,
+        crc32,
+        spoolFile: null,
+    };
+};
+
+export const createZipFile = async (
+    rootDir: string,
+    outputFile: string,
+    options: ZipCreationOptions = { preserveSymlinks: false, preserveUnixMetadata: false },
+): Promise<void> => {
+    const absoluteOutputFile = path.resolve(outputFile);
+    const absoluteRootDir = path.resolve(rootDir);
+    const outputDir = path.dirname(absoluteOutputFile);
+    await mkdir(outputDir, { recursive: true });
+
+    const tempOutputFile = path.join(
+        outputDir,
+        `.${path.basename(absoluteOutputFile)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`,
+    );
+    const handle = await open(tempOutputFile, 'wx');
+    let handleClosed = false;
+
+    try {
+        let offset = 0;
+        const writtenEntries: WrittenZipEntry[] = [];
+        const files = await collectZipFiles({
+            directory: absoluteRootDir,
+            excludedAbsolutePaths: new Set([absoluteOutputFile, tempOutputFile]),
+            preserveSymlinks: options.preserveSymlinks,
+            preserveUnixMetadata: options.preserveUnixMetadata,
+            rootDir: absoluteRootDir,
+        });
+
+        validateZipEntryCount(files.length);
+
+        for (const entry of files) {
+            const pathBytes = new TextEncoder().encode(entry.archivePath);
+            if (pathBytes.length > ZIP_MAX_UINT16) {
+                throw new Error(`Path exceeds classic ZIP limit of ${ZIP_MAX_UINT16} bytes: ${entry.archivePath}`);
+            }
+
+            validateZipEntrySize(entry.size, entry.archivePath);
+
+            const prepared = await prepareFileBytes(entry, outputDir);
+            try {
+                validateZipEntrySize(prepared.compressedSize, entry.archivePath);
+
+                const localHeaderOffset = offset;
+
+                if (localHeaderOffset > ZIP_MAX_UINT32) {
+                    throw new Error(`Local header offset exceeds classic ZIP limit (4 GB): ${localHeaderOffset}`);
+                }
+
+                offset = await writeZipLocalHeader(
+                    handle,
+                    entry,
+                    pathBytes,
+                    prepared.crc32,
+                    prepared.compressedSize,
+                    prepared.compressionMethod,
+                    offset,
+                );
+
+                if (prepared.bytes) {
+                    assertWithinZip32Limit(offset, prepared.bytes.length, `payload for ${entry.archivePath}`);
+                    offset = await writeBuffer(handle, prepared.bytes, offset);
+                } else if (prepared.spoolFile) {
+                    const reader = Bun.file(prepared.spoolFile).stream().getReader();
+                    try {
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done) {
+                                break;
+                            }
+                            assertWithinZip32Limit(offset, value.length, `payload chunk for ${entry.archivePath}`);
+                            offset = await writeBuffer(handle, value, offset);
+                        }
+                    } finally {
+                        reader.releaseLock();
+                    }
+                } else {
+                    const reader = Bun.file(entry.absolutePath).stream().getReader();
+                    try {
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done) {
+                                break;
+                            }
+                            assertWithinZip32Limit(offset, value.length, `payload chunk for ${entry.archivePath}`);
+                            offset = await writeBuffer(handle, value, offset);
+                        }
+                    } finally {
+                        reader.releaseLock();
+                    }
+                }
+
+                writtenEntries.push({
+                    ...entry,
+                    compressedSize: prepared.compressedSize,
+                    compressionMethod: prepared.compressionMethod,
+                    crc32: prepared.crc32,
+                    localHeaderOffset,
+                    pathBytes,
+                });
+            } finally {
+                if (prepared.spoolFile) {
+                    await rm(prepared.spoolFile, { force: true }).catch(() => {});
+                }
+            }
+        }
+
+        const centralDirectoryOffset = offset;
+        if (centralDirectoryOffset > ZIP_MAX_UINT32) {
+            throw new Error(`Central directory offset exceeds classic ZIP limit (4 GB): ${centralDirectoryOffset}`);
+        }
+
+        for (const entry of writtenEntries) {
+            assertWithinZip32Limit(offset, 46 + entry.pathBytes.length, `central directory entry for ${entry.archivePath}`);
+            const header = Buffer.alloc(46);
+            header.writeUInt32LE(0x02014b50, 0);
+            header.writeUInt16LE(options.preserveUnixMetadata ? ZIP_UNIX_CREATOR_VERSION : 20, 4);
+            header.writeUInt16LE(20, 6);
+            header.writeUInt16LE(ZIP_UTF8_FLAG, 8);
+            header.writeUInt16LE(entry.compressionMethod, 10);
+            header.writeUInt16LE(0, 12);
+            header.writeUInt16LE(ZIP_DOS_DATE_1980_01_01, 14);
+            header.writeUInt32LE(entry.crc32, 16);
+            header.writeUInt32LE(entry.compressedSize, 20);
+            header.writeUInt32LE(entry.size, 24);
+            header.writeUInt16LE(entry.pathBytes.length, 28);
+            header.writeUInt16LE(0, 30);
+            header.writeUInt16LE(0, 32);
+            header.writeUInt16LE(0, 34);
+            header.writeUInt16LE(0, 36);
+            const externalAttributes = options.preserveUnixMetadata
+                ? ((((entry.mode ?? 0o100644) & 0xffff) << 16) >>> 0)
+                : 0;
+            header.writeUInt32LE(externalAttributes, 38);
+            header.writeUInt32LE(entry.localHeaderOffset, 42);
+            offset = await writeBuffer(handle, header, offset);
+            offset = await writeBuffer(handle, entry.pathBytes, offset);
+        }
+
+        const centralDirectorySize = offset - centralDirectoryOffset;
+        if (centralDirectorySize > ZIP_MAX_UINT32) {
+            throw new Error(`Central directory size exceeds classic ZIP limit (4 GB): ${centralDirectorySize}`);
+        }
+
+        assertWithinZip32Limit(offset, 22, 'end of central directory record');
+        const endHeader = Buffer.alloc(22);
+        endHeader.writeUInt32LE(0x06054b50, 0);
+        endHeader.writeUInt16LE(0, 4);
+        endHeader.writeUInt16LE(0, 6);
+        endHeader.writeUInt16LE(writtenEntries.length, 8);
+        endHeader.writeUInt16LE(writtenEntries.length, 10);
+        endHeader.writeUInt32LE(centralDirectorySize, 12);
+        endHeader.writeUInt32LE(centralDirectoryOffset, 16);
+        endHeader.writeUInt16LE(0, 20);
+        await writeBuffer(handle, endHeader, offset);
+
+        await handle.close();
+        handleClosed = true;
+
+        await rename(tempOutputFile, absoluteOutputFile);
+    } catch (error) {
+        if (!handleClosed) {
+            await handle.close().catch(() => {});
+        }
+        await rm(tempOutputFile, { force: true }).catch(() => {});
+        throw error;
+    }
+};

package/src/cli-options.ts

@@ -1,93 +0,0 @@
-export type CliOptions = {
-    readonly excludes: readonly string[];
-    readonly filters: readonly string[];
-    readonly gitHandoff: boolean;
-    readonly includes: readonly string[];
-    readonly outputFile: string | null;
-    readonly profile: string | null;
-    readonly reportFile: string | null;
-    readonly showHelp: boolean;
-    readonly targetDir: string;
-};
-
-export const parseCliArgs = (args: readonly string[]): CliOptions => {
-    const excludes: string[] = [];
-    const filters: string[] = [];
-    const includes: string[] = [];
-    let gitHandoff = false;
-    let outputFile: string | null = null;
-    let profile: string | null = null;
-    let reportFile: string | null = null;
-    let showHelp = false;
-    let targetDir = process.cwd();
-
-    for (let index = 0; index < args.length; index += 1) {
-        const argument = args[index]!;
-        if (argument === '--help' || argument === '-h') {
-            showHelp = true;
-        } else if (argument === '--git-handoff') {
-            gitHandoff = true;
-        } else if (argument.startsWith('--profile=')) {
-            profile = argument.slice(10) || null;
-        } else if (argument === '--profile') {
-            index += 1;
-            profile = args[index] ?? null;
-        } else if (argument.startsWith('--exclude=')) {
-            excludes.push(argument.slice(10));
-        } else if (argument === '--exclude') {
-            index += 1;
-            if (args[index]) {
-                excludes.push(args[index]!);
-            }
-        } else if (argument.startsWith('--output=')) {
-            outputFile = argument.slice(9);
-        } else if (argument === '--output' || argument === '-o') {
-            index += 1;
-            outputFile = args[index] ?? null;
-        } else if (argument.startsWith('--include=')) {
-            includes.push(argument.slice(10));
-        } else if (argument === '--include' || argument === '-i') {
-            index += 1;
-            if (args[index]) {
-                includes.push(args[index]!);
-            }
-        } else if (argument.startsWith('--filter=')) {
-            filters.push(argument.slice(9));
-        } else if (argument === '--filter' || argument === '-f') {
-            index += 1;
-            if (args[index]) {
-                filters.push(args[index]!);
-            }
-        } else if (argument.startsWith('--report=')) {
-            reportFile = argument.slice(9);
-        } else if (argument === '--report') {
-            index += 1;
-            reportFile = args[index] ?? null;
-        } else if (!argument.startsWith('-')) {
-            targetDir = argument;
-        }
-    }
-
-    return { excludes, filters, gitHandoff, includes, outputFile, profile, reportFile, showHelp, targetDir };
-};
-
-export const printUsage = (): void => {
-    console.log(`
-Usage: acker-dacker [targetRepoPath] [options]
-
-Options:
-  --git-handoff          Use Git's tracked + eligible-untracked set and preserve modes/symlinks
-  --profile <name>       Select a named Git handoff profile (currently rust-stage3; requires --git-handoff)
-  --filter, -f <pattern> Include ONLY files matching pattern (e.g. *.md, *.ts; can be specified multiple times)
-  --include, -i <path>   Additional folder path or repo name to include (can be specified multiple times)
-  --exclude <path|glob>  Repeatable root-relative exclusion (only with --git-handoff)
-  --output, -o <path>    Output zip file path (default: ./<targetRepoName>-pack.zip)
-  --report <path>        Write a content-free Git handoff JSON report (only with --git-handoff)
-  --help, -h             Show this help message
-
-Examples:
-  acker-dacker ../ushman --filter "*.md"
-  acker-dacker ../ushman --include ../ushman-spector -f "*.md" -f "*.ts"
-  acker-dacker ../kodeguard --output=./kodeguard.zip
-`);
-};