@push.rocks/smartlinuxrepo 0.0.0-stage → 0.1.0

package/dist_ts/readers/bytesource.js

@@ -0,0 +1,154 @@
+import * as plugins from '../plugins.js';
+import { LinuxRepoError, limitExceeded } from '../shared/errors.js';
+import { takeFront } from './bytes.js';
+/**
+ * The digest tee: pulls the caller's package bytes once, counts them against
+ * `maxPackageBytes`, and feeds every byte exactly once into MD5, SHA-1,
+ * SHA-256 and SHA-512 at the moment it is pulled.
+ *
+ * - It pulls with `next()` only. It never calls `return()` or `throw()` on the
+ *   caller's iterator, so a web `ReadableStream` is never cancelled.
+ * - An error from the caller's iterator propagates unchanged. After any error
+ *   the source stops pulling for good.
+ * - `drain()` reads the rest of the input so the digests cover the whole file;
+ *   `digests()` is available only after the input has ended.
+ */
+export class PackageByteSource {
+    source;
+    maxPackageBytes;
+    iterator = null;
+    pushedBack = [];
+    hashes = {
+        md5: plugins.crypto.createHash('md5'),
+        sha1: plugins.crypto.createHash('sha1'),
+        sha256: plugins.crypto.createHash('sha256'),
+        sha512: plugins.crypto.createHash('sha512'),
+    };
+    pulledBytes = 0;
+    deliveredBytes = 0;
+    ended = false;
+    failure = undefined;
+    failed = false;
+    finalDigests = null;
+    constructor(sourceArg, maxPackageBytesArg) {
+        if (sourceArg === null ||
+            typeof sourceArg !== 'object' ||
+            typeof sourceArg[Symbol.asyncIterator] !== 'function') {
+            throw new LinuxRepoError('invalid-input', 'source must be an AsyncIterable<Uint8Array>', {
+                field: 'source',
+            });
+        }
+        this.source = sourceArg;
+        this.maxPackageBytes = maxPackageBytesArg;
+    }
+    /** Offset of the next byte `read` returns, counted from the start of the file. */
+    get position() {
+        return this.deliveredBytes;
+    }
+    /** Bytes pulled from the caller so far. */
+    get pulled() {
+        return this.pulledBytes;
+    }
+    async read(maxArg) {
+        const pushed = this.pushedBack.pop();
+        if (pushed !== undefined) {
+            const chunk = takeFront(pushed, maxArg, this.pushedBack);
+            this.deliveredBytes += chunk.length;
+            return chunk;
+        }
+        const pulled = await this.pull();
+        if (pulled === null) {
+            return null;
+        }
+        const chunk = takeFront(pulled, maxArg, this.pushedBack);
+        this.deliveredBytes += chunk.length;
+        return chunk;
+    }
+    unread(bytesArg) {
+        if (bytesArg.length === 0) {
+            return;
+        }
+        this.pushedBack.push(bytesArg);
+        this.deliveredBytes -= bytesArg.length;
+    }
+    /** Reads and discards the rest of the input. */
+    async drain() {
+        this.deliveredBytes += this.pushedBack.reduce((sum, chunk) => sum + chunk.length, 0);
+        this.pushedBack.length = 0;
+        while ((await this.pull()) !== null) {
+            // every pulled chunk is hashed and counted inside pull()
+        }
+        this.deliveredBytes = this.pulledBytes;
+    }
+    /** Size and digests of the whole input; only after the input has ended. */
+    digests() {
+        if (!this.ended || this.failed) {
+            throw new Error('PackageByteSource.digests() called before the input ended');
+        }
+        if (this.finalDigests === null) {
+            this.finalDigests = {
+                size: this.pulledBytes,
+                md5: this.hashes.md5.digest('hex'),
+                sha1: this.hashes.sha1.digest('hex'),
+                sha256: this.hashes.sha256.digest('hex'),
+                sha512: this.hashes.sha512.digest('hex'),
+            };
+        }
+        return { ...this.finalDigests };
+    }
+    async pull() {
+        if (this.failed) {
+            throw this.failure;
+        }
+        if (this.ended) {
+            return null;
+        }
+        try {
+            this.iterator ??= this.source[Symbol.asyncIterator]();
+            for (;;) {
+                let result;
+                try {
+                    result = await this.iterator.next();
+                }
+                catch (error) {
+                    // the caller's error, unchanged
+                    this.fail(error);
+                    throw error;
+                }
+                if (result.done) {
+                    this.ended = true;
+                    return null;
+                }
+                const value = result.value;
+                if (!(value instanceof Uint8Array)) {
+                    throw new LinuxRepoError('invalid-input', 'source yielded a chunk that is not a Uint8Array', {
+                        field: 'source',
+                    });
+                }
+                if (value.length === 0) {
+                    continue;
+                }
+                if (this.pulledBytes + value.length > this.maxPackageBytes) {
+                    throw limitExceeded('maxPackageBytes', this.maxPackageBytes, 'package input');
+                }
+                this.pulledBytes += value.length;
+                this.hashes.md5.update(value);
+                this.hashes.sha1.update(value);
+                this.hashes.sha256.update(value);
+                this.hashes.sha512.update(value);
+                return value;
+            }
+        }
+        catch (error) {
+            this.fail(error);
+            throw error;
+        }
+    }
+    fail(errorArg) {
+        if (!this.failed) {
+            this.failed = true;
+            this.failure = errorArg;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/readers/decompress.d.ts

@@ -0,0 +1,43 @@
+import type { ILinuxPackageLimits } from '../shared/limits.js';
+import { type IByteReader } from './bytes.js';
+/** The stream compressions the readers decode. */
+export type TLinuxCompression = 'none' | 'gzip' | 'xz' | 'zstd';
+export interface IDecompressOptions {
+    /** Bound on the decompressed bytes delivered. */
+    maxOutputBytes: number;
+    outputLimit: keyof ILinuxPackageLimits;
+}
+/**
+ * A reader over the decompressed bytes of an inner reader. Pulling is lazy
+ * and bounded: decompressed output past `maxOutputBytes` fails with
+ * `limit-exceeded` and stops the decoder. `close()` releases the decoder and
+ * must be called (see `withDecompressingReader`).
+ *
+ * - gzip (multi-member) and zstd come from `node:zlib`, xz from
+ *   `@napi-rs/lzma` `xz.decompressStream` (64 KiB chunks, cancellable).
+ * - An error from the inner reader (the caller's source, or a codec limit on
+ *   it) propagates unchanged.
+ * - A compressed stream that ends early is `truncated`; corrupt data is
+ *   `malformed-archive` with the decoder error as `cause`.
+ * - The decoder reads the inner reader ahead and never hands bytes back, so
+ *   the compressed stream must run to the end of the inner reader (a whole
+ *   package, or a `LimitedReader` over one archive member).
+ * - Opening a zstd decoder on a Node.js without nodejs/node#64593 throws a
+ *   plain `Error` (see `isZstdDecodingSafe`): a server fault, not a verdict
+ *   on the package.
+ */
+export interface IDecompressingReader extends IByteReader {
+    readonly outputBytes: number;
+    close(): Promise<void>;
+}
+export declare function openDecompressingReader(inputArg: IByteReader, compressionArg: TLinuxCompression, optionsArg: IDecompressOptions): IDecompressingReader;
+/**
+ * True when Node.js `versionArg` (a `process.versions.node` string) carries
+ * nodejs/node#64593, so node:zlib reports a zstd frame that ends early as
+ * `Z_BUF_ERROR` instead of returning a prefix: 24.x from 24.20.0, 26.x from
+ * 26.6.0, and every major from 27 on. Anything else, including all of 22.x,
+ * 23.x and 25.x, is false.
+ */
+export declare function isZstdDecodingSafe(versionArg: string): boolean;
+/** Runs `bodyArg` with a decompressing reader and always closes it. */
+export declare function withDecompressingReader<T>(inputArg: IByteReader, compressionArg: TLinuxCompression, optionsArg: IDecompressOptions, bodyArg: (readerArg: IDecompressingReader) => Promise<T>): Promise<T>;

package/dist_ts/readers/decompress.js

@@ -0,0 +1,269 @@
+import * as plugins from '../plugins.js';
+import { LinuxRepoError, limitExceeded, truncated } from '../shared/errors.js';
+import { READ_CHUNK_BYTES, takeFront } from './bytes.js';
+export function openDecompressingReader(inputArg, compressionArg, optionsArg) {
+    let source;
+    switch (compressionArg) {
+        case 'none':
+            source = new PassThroughSource(inputArg);
+            break;
+        case 'gzip':
+            source = new ZlibSource(inputArg, 'gzip');
+            break;
+        case 'zstd':
+            if (!isZstdDecodingSafe(process.versions.node)) {
+                throw new Error(`zstd decoding needs Node.js ${ZSTD_NODE_FLOOR} (nodejs/node#64593 reports a zstd frame that ends early); ` +
+                    `this process runs Node.js ${process.versions.node}`);
+            }
+            source = new ZlibSource(inputArg, 'zstd');
+            break;
+        case 'xz':
+            source = new XzSource(inputArg);
+            break;
+        default:
+            throw new LinuxRepoError('unsupported-compression', `unknown compression "${String(compressionArg)}"`, {
+                field: 'compression',
+            });
+    }
+    return new BoundedOutputReader(source, optionsArg);
+}
+/** The Node.js releases whose node:zlib reports a truncated zstd frame. */
+const ZSTD_NODE_FLOOR = '^24.20.0 || >=26.6.0';
+/**
+ * True when Node.js `versionArg` (a `process.versions.node` string) carries
+ * nodejs/node#64593, so node:zlib reports a zstd frame that ends early as
+ * `Z_BUF_ERROR` instead of returning a prefix: 24.x from 24.20.0, 26.x from
+ * 26.6.0, and every major from 27 on. Anything else, including all of 22.x,
+ * 23.x and 25.x, is false.
+ */
+export function isZstdDecodingSafe(versionArg) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:$|[-+])/.exec(versionArg);
+    if (match === null) {
+        return false;
+    }
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    if (major === 24) {
+        return minor >= 20;
+    }
+    if (major === 26) {
+        return minor >= 6;
+    }
+    return major >= 27;
+}
+/** Runs `bodyArg` with a decompressing reader and always closes it. */
+export async function withDecompressingReader(inputArg, compressionArg, optionsArg, bodyArg) {
+    const reader = openDecompressingReader(inputArg, compressionArg, optionsArg);
+    try {
+        return await bodyArg(reader);
+    }
+    finally {
+        await reader.close();
+    }
+}
+class BoundedOutputReader {
+    source;
+    options;
+    delivered = 0;
+    pushedBack = [];
+    closed = false;
+    constructor(source, options) {
+        this.source = source;
+        this.options = options;
+    }
+    get outputBytes() {
+        return this.delivered;
+    }
+    async read(maxArg) {
+        const pushed = this.pushedBack.pop();
+        if (pushed !== undefined) {
+            return takeFront(pushed, maxArg, this.pushedBack);
+        }
+        if (this.closed) {
+            return null;
+        }
+        const chunk = await this.source.next();
+        if (chunk === null) {
+            return null;
+        }
+        this.delivered += chunk.length;
+        if (this.delivered > this.options.maxOutputBytes) {
+            await this.close();
+            throw limitExceeded(this.options.outputLimit, this.options.maxOutputBytes, 'decompressed data');
+        }
+        return takeFront(chunk, maxArg, this.pushedBack);
+    }
+    unread(bytesArg) {
+        if (bytesArg.length > 0) {
+            this.pushedBack.push(bytesArg);
+        }
+    }
+    async close() {
+        this.pushedBack.length = 0;
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        await this.source.close();
+    }
+}
+class PassThroughSource {
+    input;
+    constructor(input) {
+        this.input = input;
+    }
+    next() {
+        return this.input.read(READ_CHUNK_BYTES);
+    }
+    async close() { }
+}
+/** gzip (multi-member, like Go's default) and zstd through `node:zlib`, with stream backpressure. */
+class ZlibSource {
+    kind;
+    feeder;
+    decoder;
+    iterator;
+    inputFailed = false;
+    inputError = undefined;
+    finished = false;
+    constructor(inputArg, kindArg) {
+        this.kind = kindArg;
+        const pump = async function* () {
+            for (;;) {
+                let chunk;
+                try {
+                    chunk = await inputArg.read(READ_CHUNK_BYTES);
+                }
+                catch (error) {
+                    this.inputFailed = true;
+                    this.inputError = error;
+                    throw error;
+                }
+                if (chunk === null) {
+                    return;
+                }
+                yield chunk;
+            }
+        };
+        this.feeder = plugins.stream.Readable.from(pump.call(this), { objectMode: false });
+        this.decoder = kindArg === 'gzip' ? plugins.zlib.createGunzip() : plugins.zlib.createZstdDecompress();
+        // errors surface through the iterator below; the callback only completes the pipeline
+        plugins.stream.pipeline(this.feeder, this.decoder, () => { });
+        this.iterator = this.decoder[Symbol.asyncIterator]();
+    }
+    async next() {
+        if (this.finished) {
+            return null;
+        }
+        try {
+            const result = await this.iterator.next();
+            if (result.done) {
+                this.finished = true;
+                return null;
+            }
+            return result.value;
+        }
+        catch (error) {
+            this.finished = true;
+            if (this.inputFailed) {
+                throw this.inputError;
+            }
+            throw mapZlibError(error, this.kind);
+        }
+    }
+    async close() {
+        this.finished = true;
+        this.feeder.destroy();
+        this.decoder.destroy();
+    }
+}
+function mapZlibError(errorArg, kindArg) {
+    const code = errorArg?.code;
+    // gunzip, and zstd on the Node.js floor, report an input that ended inside the stream as Z_BUF_ERROR
+    if (code === 'Z_BUF_ERROR') {
+        const error = truncated(`${kindArg} stream`);
+        return new LinuxRepoError(error.code, error.message, error.detail, { cause: errorArg });
+    }
+    return new LinuxRepoError('malformed-archive', `corrupt ${kindArg} data`, { field: `${kindArg} stream` }, {
+        cause: errorArg,
+    });
+}
+/**
+ * xz through `@napi-rs/lzma` `xz.decompressStream`, the one bounded decoder of
+ * that package (its class API buffers whole outputs). The input is a
+ * pull-based web stream that never reads ahead; cancelling the output stops it.
+ */
+class XzSource {
+    reader;
+    inputFailed = false;
+    inputError = undefined;
+    inputEnded = false;
+    finished = false;
+    stopped = false;
+    constructor(inputArg) {
+        const input = new ReadableStream({
+            pull: async (controller) => {
+                if (this.stopped) {
+                    controller.close();
+                    return;
+                }
+                let chunk;
+                try {
+                    chunk = await inputArg.read(READ_CHUNK_BYTES);
+                }
+                catch (error) {
+                    this.inputFailed = true;
+                    this.inputError = error;
+                    controller.error(error);
+                    return;
+                }
+                if (chunk === null) {
+                    this.inputEnded = true;
+                    controller.close();
+                }
+                else {
+                    controller.enqueue(chunk);
+                }
+            },
+            cancel: () => {
+                this.stopped = true;
+            },
+        }, { highWaterMark: 0 });
+        this.reader = plugins.lzma.xz.decompressStream(input).getReader();
+    }
+    async next() {
+        if (this.finished) {
+            return null;
+        }
+        try {
+            const result = await this.reader.read();
+            if (result.done) {
+                this.finished = true;
+                return null;
+            }
+            return result.value;
+        }
+        catch (error) {
+            this.finished = true;
+            if (this.inputFailed) {
+                throw this.inputError;
+            }
+            // @napi-rs/lzma 1.5.3 reports a decoder that ran out of input as Rust's
+            // read_exact error; with the input at its end that is a truncated stream
+            const message = error instanceof Error ? error.message : '';
+            if (this.inputEnded && message.includes('failed to fill whole buffer')) {
+                const base = truncated('xz stream');
+                throw new LinuxRepoError(base.code, base.message, base.detail, { cause: error });
+            }
+            throw new LinuxRepoError('malformed-archive', 'corrupt xz data', { field: 'xz stream' }, { cause: error });
+        }
+    }
+    async close() {
+        this.stopped = true;
+        if (!this.finished) {
+            this.finished = true;
+            await this.reader.cancel();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decompress.js","sourceRoot":"","sources":["../../ts/readers/decompress.ts"],"names":[],"mappings":"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"}

package/dist_ts/readers/gzipmember.d.ts

@@ -0,0 +1,32 @@
+import type { ILinuxPackageLimits } from '../shared/limits.js';
+import { type IByteReader } from './bytes.js';
+export interface IGzipMemberOptions {
+    /** Bound on the member's own bytes (header, deflate data and trailer). */
+    maxMemberBytes: number;
+    memberLimit: keyof ILinuxPackageLimits;
+    /** Bound on the member's decompressed bytes. */
+    maxOutputBytes: number;
+    outputLimit: keyof ILinuxPackageLimits;
+    /** Bound on the header's FNAME and FCOMMENT strings. */
+    maxHeaderBytes: number;
+}
+export interface IGzipMember {
+    /** The decompressed member. */
+    output: Uint8Array;
+    /** The member's own byte count: header, deflate data and trailer. */
+    memberBytes: number;
+    /** Lowercase hex SHA-1 of exactly the member's bytes. */
+    memberSha1: string;
+}
+/**
+ * Reads exactly one gzip member (RFC 1952) from `inputArg` and leaves the
+ * reader positioned at the first byte after it, so concatenated members (an
+ * apk v2 package) can be read one at a time with their exact boundaries.
+ *
+ * The header is parsed here; the deflate data is inflated with
+ * `zlib.createInflateRaw()`, whose `bytesWritten` counts only the bytes the
+ * deflate stream consumed, and the bytes past the stream's end are pushed back
+ * with `unread`. The trailer's CRC-32 and ISIZE are checked. Returns `null`
+ * when the input ends exactly where a member would start.
+ */
+export declare function readGzipMember(inputArg: IByteReader, optionsArg: IGzipMemberOptions): Promise<IGzipMember | null>;