@push.rocks/smartlinuxrepo 0.0.0-stage → 0.1.0

package/dist_ts/alpine/reader.js

@@ -0,0 +1,89 @@
+import { LinuxRepoError, truncated } from '../shared/errors.js';
+import { resolveLinuxPackageLimits } from '../shared/limits.js';
+import { BufferReader, readUpTo } from '../readers/bytes.js';
+import { PackageByteSource } from '../readers/bytesource.js';
+import { readGzipMember } from '../readers/gzipmember.js';
+import { readTarEntryData, TarReader } from '../readers/tar.js';
+import { parseAlpinePackageInfo } from './pkginfo.js';
+const PKGINFO = '.PKGINFO';
+/**
+ * Reads an apk v2 package (concatenated gzip members: usually the signature,
+ * the control segment holding `.PKGINFO`, and the data) into a record, as
+ * Gitea 28.2.0's `ParsePackage` does (`modules/packages/alpine/metadata.go:77-134`):
+ * - gzip members are read one at a time; the first member whose tar holds an
+ *   entry named exactly `.PKGINFO` is the control segment. Unsigned packages
+ *   (no signature member) are accepted;
+ * - `digests.controlSha1` is the SHA-1 of exactly that member's bytes (the
+ *   APKINDEX `C:` value is `Q1` plus its base64);
+ * - the rest of the input is hashed, never decompressed;
+ * - the record's `fileName` is Gitea's `{name}-{version}.apk`.
+ *
+ * Each member read before the control segment is buffered and bounded by
+ * `maxMetadataBytes` (member bytes) and `maxDecompressedMetadataBytes` (its
+ * tar). An apk v3 (ADB) package is `unsupported-package-format`, as Gitea
+ * refuses it too. On failure the reader stops pulling and returns no record.
+ */
+export async function readAlpinePackage(sourceArg, limitsArg) {
+    const limits = resolveLinuxPackageLimits(limitsArg);
+    const input = new PackageByteSource(sourceArg, limits.maxPackageBytes);
+    const head = await readUpTo(input, 3);
+    if (head.length === 0) {
+        throw truncated('apk package');
+    }
+    if (head.length === 3 && head[0] === 0x41 && head[1] === 0x44 && head[2] === 0x42) {
+        throw new LinuxRepoError('unsupported-package-format', 'apk v3 (ADB) packages are not supported', {
+            field: 'apk package',
+        });
+    }
+    input.unread(head);
+    for (;;) {
+        const member = await readGzipMember(input, {
+            maxMemberBytes: limits.maxMetadataBytes,
+            memberLimit: 'maxMetadataBytes',
+            maxOutputBytes: limits.maxDecompressedMetadataBytes,
+            outputLimit: 'maxDecompressedMetadataBytes',
+            maxHeaderBytes: limits.maxHeaderBytes,
+        });
+        if (member === null) {
+            throw new LinuxRepoError('missing-field', 'the package has no .PKGINFO', { field: PKGINFO });
+        }
+        const tar = new TarReader(new BufferReader(member.output), {
+            maxEntries: limits.maxEntries,
+            maxHeaderBytes: limits.maxHeaderBytes,
+        });
+        for (let entry = await tar.next(); entry !== null; entry = await tar.next()) {
+            if (entry.name !== PKGINFO) {
+                continue;
+            }
+            // Gitea stops at the first .PKGINFO and ignores the rest of the member's tar
+            const pkginfo = await readTarEntryData(entry, limits.maxDecompressedMetadataBytes, 'maxDecompressedMetadataBytes');
+            const info = parseAlpinePackageInfo(pkginfo, limits);
+            await input.drain();
+            const digests = input.digests();
+            return {
+                format: 'alpine',
+                name: info.name,
+                version: info.version,
+                architecture: info.architecture,
+                fileName: `${info.name}-${info.version}.apk`,
+                digests: { ...digests, controlSha1: member.memberSha1 },
+                metadata: {
+                    description: info.description,
+                    license: info.license,
+                    projectUrl: info.projectUrl,
+                    maintainer: info.maintainer,
+                    packager: info.packager,
+                    buildDate: info.buildDate,
+                    installedSize: info.installedSize,
+                    origin: info.origin,
+                    commit: info.commit,
+                    installIf: info.installIf,
+                    provides: info.provides,
+                    dependencies: info.dependencies,
+                    providerPriority: info.providerPriority,
+                },
+            };
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/arch/builder.d.ts

@@ -0,0 +1,41 @@
+import type { IArchPackageRecord, ILinuxIndexFile } from '../shared/types.js';
+import { type IOpenPgpSigner } from '../signing/signers.js';
+/** One package of an Arch repository index. */
+export interface IArchIndexEntry {
+    record: IArchPackageRecord;
+    /**
+     * The package's detached signature (the `.sig` file's bytes) as stored at
+     * upload time; written as `%PGPSIG%`. Without it the entry has no
+     * `%PGPSIG%` and pacman fetches `<file>.sig`. The builder never signs a package.
+     */
+    packageSignature?: Uint8Array;
+}
+/**
+ * Builds the Arch index files of one repository: for every architecture that
+ * has packages, the gzip tar `packages.db` and its detached signature, as
+ * Gitea 28.2.0 `buildPackagesIndex` builds them.
+ *
+ * - `any` packages also go into every other architecture's index.
+ * - Each index lists one version per package (Gitea's identity: the
+ *   lower-cased name), the newest by pacman's version comparison; versions
+ *   that compare equal are ordered by architecture (the index's own before
+ *   `any`), then bytewise by version and file name, so input order never decides.
+ * - Entries are written sorted bytewise by `<name>-<version>`, each as
+ *   `<name>-<version>/files` then `<name>-<version>/desc`.
+ * - Only the index is signed (binary detached signature over the gzip bytes).
+ *
+ * Paths are `<repository>/<architecture>/packages.db` and `packages.db.sig`
+ * (no repository prefix when `repository` is `''`), without aliases: the
+ * request names Gitea maps onto them (`<repo>.db`, `.files`, the `any`
+ * fallback) are the consumer's route, documented in the readme.
+ */
+export declare function buildArchIndex(inputArg: {
+    repository: string;
+    entries: IArchIndexEntry[];
+    signer: IOpenPgpSigner;
+    timestamp: Date;
+}): Promise<ILinuxIndexFile[]>;
+/** The `desc` member of one entry (`repository.go:353-379`). */
+export declare function renderArchDesc(entryArg: IArchIndexEntry): string;
+/** The `files` member of one entry (`repository.go:346-350`). */
+export declare function renderArchFiles(recordArg: IArchPackageRecord): string;

package/dist_ts/arch/builder.js

@@ -0,0 +1,234 @@
+import * as plugins from '../plugins.js';
+import { isIndexableArchitecture } from '../shared/architecture.js';
+import { LinuxRepoError } from '../shared/errors.js';
+import { assertBytes, assertSegmentName, assertTimestamp, hasControlCharacter } from '../shared/validation.js';
+import { createDetachedBinarySignature } from '../signing/openpgpframing.js';
+import { singleChunk } from '../signing/signers.js';
+import { writeGoTar } from '../writers/gotar.js';
+import { ARCH_NAME_PATTERN, ARCH_VERSION_PATTERN } from './reader.js';
+import { compareArchVersions } from './vercmp.js';
+/** Gitea's stored name of the index archive (`services/packages/arch/repository.go:37`). */
+const INDEX_ARCHIVE_NAME = 'packages.db';
+const ANY_ARCHITECTURE = 'any';
+/** `int64(os.ModePerm)` (`repository.go:393`). */
+const ENTRY_MODE = 0o777;
+/**
+ * Builds the Arch index files of one repository: for every architecture that
+ * has packages, the gzip tar `packages.db` and its detached signature, as
+ * Gitea 28.2.0 `buildPackagesIndex` builds them.
+ *
+ * - `any` packages also go into every other architecture's index.
+ * - Each index lists one version per package (Gitea's identity: the
+ *   lower-cased name), the newest by pacman's version comparison; versions
+ *   that compare equal are ordered by architecture (the index's own before
+ *   `any`), then bytewise by version and file name, so input order never decides.
+ * - Entries are written sorted bytewise by `<name>-<version>`, each as
+ *   `<name>-<version>/files` then `<name>-<version>/desc`.
+ * - Only the index is signed (binary detached signature over the gzip bytes).
+ *
+ * Paths are `<repository>/<architecture>/packages.db` and `packages.db.sig`
+ * (no repository prefix when `repository` is `''`), without aliases: the
+ * request names Gitea maps onto them (`<repo>.db`, `.files`, the `any`
+ * fallback) are the consumer's route, documented in the readme.
+ */
+export async function buildArchIndex(inputArg) {
+    if (inputArg === null || typeof inputArg !== 'object') {
+        throw new LinuxRepoError('invalid-input', 'input must be an object', { field: 'input' });
+    }
+    assertRepository(inputArg.repository);
+    assertTimestamp(inputArg.timestamp);
+    if (inputArg.signer === null || typeof inputArg.signer !== 'object' || typeof inputArg.signer.signBinary !== 'function') {
+        throw new LinuxRepoError('invalid-input', 'signer must be an IOpenPgpSigner', { field: 'signer' });
+    }
+    if (!Array.isArray(inputArg.entries)) {
+        throw new LinuxRepoError('invalid-input', 'entries must be an array', { field: 'entries' });
+    }
+    const fileNames = new Set();
+    for (const entry of inputArg.entries) {
+        assertEntry(entry);
+        if (fileNames.has(entry.record.fileName)) {
+            throw new LinuxRepoError('invalid-input', `duplicate package file ${entry.record.fileName}`, {
+                field: 'entries',
+                value: entry.record.fileName,
+            });
+        }
+        fileNames.add(entry.record.fileName);
+    }
+    if (inputArg.entries.length === 0) {
+        return [];
+    }
+    const architectures = [...new Set(inputArg.entries.map((entry) => entry.record.architecture))].sort(compareText);
+    const files = [];
+    for (const architecture of architectures) {
+        const candidates = inputArg.entries.filter((entry) => entry.record.architecture === architecture ||
+            (architecture !== ANY_ARCHITECTURE && entry.record.architecture === ANY_ARCHITECTURE));
+        const selected = selectLatest(candidates, architecture);
+        const tarFiles = selected.flatMap((entry) => {
+            const directory = `${entry.record.name}-${entry.record.version}`;
+            return [
+                { name: `${directory}/files`, mode: ENTRY_MODE, data: encodeText(renderArchFiles(entry.record)) },
+                { name: `${directory}/desc`, mode: ENTRY_MODE, data: encodeText(renderArchDesc(entry)) },
+            ];
+        });
+        const archive = toUint8Array(plugins.zlib.gzipSync(writeGoTar(tarFiles)));
+        const signature = await createDetachedBinarySignature({
+            data: singleChunk(archive),
+            signer: inputArg.signer,
+            timestamp: inputArg.timestamp,
+        });
+        const directory = inputArg.repository === '' ? architecture : `${inputArg.repository}/${architecture}`;
+        files.push(indexFile(`${directory}/${INDEX_ARCHIVE_NAME}`, archive, 'application/gzip'), indexFile(`${directory}/${INDEX_ARCHIVE_NAME}.sig`, signature, 'application/pgp-signature'));
+    }
+    return files.sort((a, b) => compareText(a.path, b.path));
+}
+/** The `desc` member of one entry (`repository.go:353-379`). */
+export function renderArchDesc(entryArg) {
+    const record = entryArg.record;
+    const metadata = record.metadata;
+    const signature = entryArg.packageSignature === undefined ? '' : toBuffer(entryArg.packageSignature).toString('base64');
+    return renderFields([
+        ['FILENAME', record.fileName],
+        ['MD5SUM', record.digests.md5],
+        ['SHA256SUM', record.digests.sha256],
+        ['PGPSIG', signature],
+        ['CSIZE', String(record.digests.size)],
+        ['ISIZE', String(metadata.installedSize)],
+        ['NAME', record.name],
+        ['BASE', metadata.base],
+        ['ARCH', record.architecture],
+        ['VERSION', record.version],
+        ['DESC', metadata.description],
+        ['URL', metadata.projectUrl],
+        ['LICENSE', joinFields(metadata.licenses)],
+        ['GROUPS', joinFields(metadata.groups)],
+        ['BUILDDATE', String(metadata.buildDate)],
+        ['PACKAGER', metadata.packager],
+        ['PROVIDES', joinFields(metadata.provides)],
+        ['REPLACES', joinFields(metadata.replaces)],
+        ['CONFLICTS', joinFields(metadata.conflicts)],
+        ['DEPENDS', joinFields(metadata.depends)],
+        ['OPTDEPENDS', joinFields(metadata.optDepends)],
+        ['MAKEDEPENDS', joinFields(metadata.makeDepends)],
+        ['CHECKDEPENDS', joinFields(metadata.checkDepends)],
+    ]);
+}
+/** The `files` member of one entry (`repository.go:346-350`). */
+export function renderArchFiles(recordArg) {
+    return renderFields([['FILES', joinFields(recordArg.metadata.files)]]);
+}
+/** `writeFields`: `%KEY%\nvalue\n\n` per non-empty value. */
+function renderFields(fieldsArg) {
+    let text = '';
+    for (const [key, value] of fieldsArg) {
+        if (value !== '') {
+            text += `%${key}%\n${value}\n\n`;
+        }
+    }
+    return text;
+}
+/** `joinFields`: LF-joined, dropping values that contain CR or LF (they would forge index lines). */
+function joinFields(valuesArg) {
+    return valuesArg.filter((value) => !/[\n\r]/.test(value)).join('\n');
+}
+function selectLatest(entriesArg, architectureArg) {
+    const latest = new Map();
+    for (const entry of entriesArg) {
+        const key = entry.record.name.toLowerCase();
+        const current = latest.get(key);
+        if (current === undefined || isPreferred(entry, current, architectureArg)) {
+            latest.set(key, entry);
+        }
+    }
+    return [...latest.values()].sort((a, b) => compareText(`${a.record.name}-${a.record.version}`, `${b.record.name}-${b.record.version}`));
+}
+/** True when `candidateArg` wins over `currentArg`: newer by alpm, then the tie order. */
+function isPreferred(candidateArg, currentArg, architectureArg) {
+    const byVersion = compareArchVersions(candidateArg.record.version, currentArg.record.version);
+    if (byVersion !== 0) {
+        return byVersion > 0;
+    }
+    const ownArchitecture = (entryArg) => (entryArg.record.architecture === architectureArg ? 0 : 1);
+    const byArchitecture = ownArchitecture(candidateArg) - ownArchitecture(currentArg);
+    if (byArchitecture !== 0) {
+        return byArchitecture < 0;
+    }
+    const byVersionText = compareText(candidateArg.record.version, currentArg.record.version);
+    if (byVersionText !== 0) {
+        return byVersionText < 0;
+    }
+    return compareText(candidateArg.record.fileName, currentArg.record.fileName) < 0;
+}
+function indexFile(pathArg, bytesArg, mediaTypeArg) {
+    return {
+        path: pathArg,
+        bytes: bytesArg,
+        sha256: plugins.crypto.createHash('sha256').update(bytesArg).digest('hex'),
+        mediaType: mediaTypeArg,
+        stage: 'pointer',
+        aliases: [],
+    };
+}
+/** `''`, or `/`-separated segments that are non-empty, not `.` or `..`, and free of control characters. */
+function assertRepository(valueArg) {
+    if (typeof valueArg !== 'string') {
+        throw new LinuxRepoError('invalid-input', 'repository must be a string', { field: 'repository' });
+    }
+    if (valueArg === '') {
+        return;
+    }
+    for (const segment of valueArg.split('/')) {
+        if (segment === '' || segment === '.' || segment === '..' || hasControlCharacter(segment)) {
+            throw new LinuxRepoError('invalid-input', 'repository segments must be non-empty, not "." or "..", and free of control characters', { field: 'repository' });
+        }
+    }
+}
+/**
+ * The record values that become index paths and lines must be what the
+ * reader produces: Gitea's name and version patterns, an indexable
+ * architecture, a file name that is one path segment.
+ */
+function assertEntry(entryArg) {
+    if (entryArg === null || typeof entryArg !== 'object') {
+        throw new LinuxRepoError('invalid-input', 'each entry must be an object', { field: 'entries' });
+    }
+    const entry = entryArg;
+    const record = entry.record;
+    if (record === null || typeof record !== 'object' || record.format !== 'arch') {
+        throw new LinuxRepoError('invalid-input', 'each entry needs an Arch package record', { field: 'entries' });
+    }
+    if (typeof record.fileName !== 'string') {
+        throw new LinuxRepoError('invalid-input', 'record.fileName must be a string', { field: 'record.fileName' });
+    }
+    if (typeof record.name !== 'string' || !ARCH_NAME_PATTERN.test(record.name)) {
+        throw new LinuxRepoError('invalid-input', `package ${record.fileName} has an invalid name`, {
+            field: 'record.name',
+            value: record.fileName,
+        });
+    }
+    if (typeof record.version !== 'string' || !ARCH_VERSION_PATTERN.test(record.version)) {
+        throw new LinuxRepoError('invalid-input', `package ${record.fileName} has an invalid version`, {
+            field: 'record.version',
+            value: record.fileName,
+        });
+    }
+    if (!isIndexableArchitecture(record.architecture)) {
+        throw new LinuxRepoError('invalid-input', `package ${record.fileName} has an architecture that cannot name an index path`, { field: 'record.architecture', value: record.fileName });
+    }
+    assertSegmentName(record.fileName, 'record.fileName');
+    if (entry.packageSignature !== undefined) {
+        assertBytes(entry.packageSignature, 'packageSignature');
+    }
+}
+function compareText(aArg, bArg) {
+    return Buffer.compare(Buffer.from(aArg, 'utf8'), Buffer.from(bArg, 'utf8'));
+}
+function encodeText(textArg) {
+    return new TextEncoder().encode(textArg);
+}
+function toBuffer(bytesArg) {
+    return Buffer.from(bytesArg.buffer, bytesArg.byteOffset, bytesArg.byteLength);
+}
+function toUint8Array(bufferArg) {
+    return new Uint8Array(bufferArg.buffer, bufferArg.byteOffset, bufferArg.byteLength);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"builder.js","sourceRoot":"","sources":["../../ts/arch/builder.ts"],"names":[],"mappings":"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"}

package/dist_ts/arch/reader.d.ts

@@ -0,0 +1,16 @@
+import { type ILinuxPackageLimits } from '../shared/limits.js';
+import type { IArchPackageRecord } from '../shared/types.js';
+/** Gitea `namePattern` (`modules/packages/arch/metadata.go:47`). */
+export declare const ARCH_NAME_PATTERN: RegExp;
+/** Gitea `versionPattern` (`metadata.go:49`); Go's `\d` and `\w` are ASCII, as in a JS RegExp without `u`. */
+export declare const ARCH_VERSION_PATTERN: RegExp;
+/**
+ * Reads an Arch package (`.pkg.tar.zst`, `.xz` or `.gz`, chosen by magic as
+ * Gitea 28.2.0 does) into a record: `.PKGINFO` metadata and the file list,
+ * derived exactly as Gitea's `arch.ParsePackage`, plus the size and digests of
+ * the whole file. The whole payload is decompressed (bounded by
+ * `maxPayloadBytes`) because the file list needs every tar entry, and to the
+ * end of the compressed stream, so a cut or corrupt container is refused
+ * even where it lies past the tar end marker (Go stops reading there).
+ */
+export declare function readArchPackage(sourceArg: AsyncIterable<Uint8Array>, limitsArg?: Partial<ILinuxPackageLimits>): Promise<IArchPackageRecord>;