@push.rocks/smartlinuxrepo 0.0.0-stage → 1.0.0

package/dist_ts/readers/text.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Decodes bytes as Go maps them to text: valid UTF-8 unchanged (a leading BOM
+ * is kept), and every byte of an invalid sequence replaced by one U+FFFD, as
+ * Go's `utf8.DecodeRune` reports invalid input with width 1. The WHATWG
+ * decoder differs for truncated multi-byte sequences (one U+FFFD for the
+ * maximal subpart).
+ *
+ * Gitea 28.2.0 stores package metadata with `encoding/json/v2`, which refuses
+ * invalid UTF-8 (`modules/json/jsonv2.go:22-29`,
+ * `services/packages/packages.go:166`), so 28.2.0 rejects such a package.
+ * Packages stored under older Gitea are still served, so the codec
+ * deliberately accepts more than 28.2.0 to keep them importable.
+ */
+export declare function decodeGoUtf8(bytesArg: Uint8Array): string;
+/** ASCII/Latin-1 view of header bytes (magic values, numeric fields). */
+export declare function decodeLatin1(bytesArg: Uint8Array): string;

package/dist_ts/readers/text.js

@@ -0,0 +1,96 @@
+const strictUtf8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+/**
+ * Decodes bytes as Go maps them to text: valid UTF-8 unchanged (a leading BOM
+ * is kept), and every byte of an invalid sequence replaced by one U+FFFD, as
+ * Go's `utf8.DecodeRune` reports invalid input with width 1. The WHATWG
+ * decoder differs for truncated multi-byte sequences (one U+FFFD for the
+ * maximal subpart).
+ *
+ * Gitea 28.2.0 stores package metadata with `encoding/json/v2`, which refuses
+ * invalid UTF-8 (`modules/json/jsonv2.go:22-29`,
+ * `services/packages/packages.go:166`), so 28.2.0 rejects such a package.
+ * Packages stored under older Gitea are still served, so the codec
+ * deliberately accepts more than 28.2.0 to keep them importable.
+ */
+export function decodeGoUtf8(bytesArg) {
+    try {
+        return strictUtf8.decode(bytesArg);
+    }
+    catch {
+        return decodeGoUtf8Slow(bytesArg);
+    }
+}
+function decodeGoUtf8Slow(bytesArg) {
+    const parts = [];
+    let i = 0;
+    while (i < bytesArg.length) {
+        const b0 = bytesArg[i];
+        if (b0 < 0x80) {
+            parts.push(String.fromCharCode(b0));
+            i += 1;
+            continue;
+        }
+        let need;
+        let codePoint;
+        let low = 0x80;
+        let high = 0xbf;
+        if (b0 >= 0xc2 && b0 <= 0xdf) {
+            need = 1;
+            codePoint = b0 & 0x1f;
+        }
+        else if (b0 >= 0xe0 && b0 <= 0xef) {
+            need = 2;
+            codePoint = b0 & 0x0f;
+            if (b0 === 0xe0) {
+                low = 0xa0;
+            }
+            else if (b0 === 0xed) {
+                high = 0x9f;
+            }
+        }
+        else if (b0 >= 0xf0 && b0 <= 0xf4) {
+            need = 3;
+            codePoint = b0 & 0x07;
+            if (b0 === 0xf0) {
+                low = 0x90;
+            }
+            else if (b0 === 0xf4) {
+                high = 0x8f;
+            }
+        }
+        else {
+            parts.push('\uFFFD');
+            i += 1;
+            continue;
+        }
+        let valid = i + need < bytesArg.length;
+        for (let k = 1; valid && k <= need; k++) {
+            const b = bytesArg[i + k];
+            const min = k === 1 ? low : 0x80;
+            const max = k === 1 ? high : 0xbf;
+            if (b < min || b > max) {
+                valid = false;
+            }
+            else {
+                codePoint = (codePoint << 6) | (b & 0x3f);
+            }
+        }
+        if (!valid) {
+            parts.push('\uFFFD');
+            i += 1;
+            continue;
+        }
+        parts.push(String.fromCodePoint(codePoint));
+        i += need + 1;
+    }
+    return parts.join('');
+}
+/** ASCII/Latin-1 view of header bytes (magic values, numeric fields). */
+export function decodeLatin1(bytesArg) {
+    let text = '';
+    for (let i = 0; i < bytesArg.length; i++) {
+        text += String.fromCharCode(bytesArg[i]);
+    }
+    return text;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/rpm/builder.d.ts

@@ -0,0 +1,28 @@
+import type { ILinuxIndexFile, IRpmPackageRecord, IRpmUpdate } from '../shared/types.js';
+import type { IOpenPgpSigner } from '../signing/signers.js';
+/**
+ * Builds the repodata of one RPM repository group, as Gitea 28.2.0's
+ * `BuildSpecificRepositoryFiles` does (`services/packages/rpm/repository.go:136-309`):
+ * `primary`, `filelists` and `other` (gzip), `updateinfo` only when there are
+ * updates, then `repomd.xml` and its armored detached signature
+ * `repomd.xml.asc`. Paths are relative to the RPM root: `<group>/repodata/…`,
+ * or `repodata/…` for the empty group. `repodataNaming` has no default:
+ * `'plain'` is Gitea's `repodata/<type>.xml.gz`, `'content-addressed'` is
+ * createrepo_c's default `repodata/<sha256 of the .gz>-<type>.xml.gz`
+ * (`--unique-md-filenames`, `src/cmd_parser.c:37`, `src/repomd.c:576-636`).
+ *
+ * Packages are sorted by name, version, architecture and file name; updates
+ * are combined as `combineRpmUpdates` describes. Every `repomd.xml` timestamp
+ * is `timestamp` in whole seconds. An empty entry set returns `[]` (Gitea
+ * deletes the repodata of a group without packages). An entry whose
+ * architecture fails `isIndexableArchitecture`, or whose name or version is not
+ * a path segment, is `invalid-input`, as are two entries with the same file.
+ */
+export declare function buildRpmIndex(input: {
+    group: string;
+    entries: IRpmPackageRecord[];
+    updates: IRpmUpdate[];
+    repodataNaming: 'plain' | 'content-addressed';
+    signer: IOpenPgpSigner;
+    timestamp: Date;
+}): Promise<ILinuxIndexFile[]>;

package/dist_ts/rpm/builder.js

@@ -0,0 +1,208 @@
+import * as plugins from '../plugins.js';
+import { isIndexableArchitecture } from '../shared/architecture.js';
+import { LinuxRepoError } from '../shared/errors.js';
+import { assertTimestamp, isPathSegment } from '../shared/validation.js';
+import { createDetachedArmoredSignature } from '../signing/openpgpframing.js';
+import { renderFilelists, renderOther, renderPrimary, renderRepomd, rpmPackageLocation } from './repodata.js';
+import { assertRpmUpdates, combineRpmUpdates, renderUpdateInfo } from './updates.js';
+import { compareCodePoints } from './xml.js';
+/**
+ * Builds the repodata of one RPM repository group, as Gitea 28.2.0's
+ * `BuildSpecificRepositoryFiles` does (`services/packages/rpm/repository.go:136-309`):
+ * `primary`, `filelists` and `other` (gzip), `updateinfo` only when there are
+ * updates, then `repomd.xml` and its armored detached signature
+ * `repomd.xml.asc`. Paths are relative to the RPM root: `<group>/repodata/…`,
+ * or `repodata/…` for the empty group. `repodataNaming` has no default:
+ * `'plain'` is Gitea's `repodata/<type>.xml.gz`, `'content-addressed'` is
+ * createrepo_c's default `repodata/<sha256 of the .gz>-<type>.xml.gz`
+ * (`--unique-md-filenames`, `src/cmd_parser.c:37`, `src/repomd.c:576-636`).
+ *
+ * Packages are sorted by name, version, architecture and file name; updates
+ * are combined as `combineRpmUpdates` describes. Every `repomd.xml` timestamp
+ * is `timestamp` in whole seconds. An empty entry set returns `[]` (Gitea
+ * deletes the repodata of a group without packages). An entry whose
+ * architecture fails `isIndexableArchitecture`, or whose name or version is not
+ * a path segment, is `invalid-input`, as are two entries with the same file.
+ */
+export async function buildRpmIndex(input) {
+    if (input === null || typeof input !== 'object') {
+        throw new LinuxRepoError('invalid-input', 'input must be an object', { field: 'input' });
+    }
+    const prefix = groupPrefix(input.group);
+    if (input.repodataNaming !== 'plain' && input.repodataNaming !== 'content-addressed') {
+        throw new LinuxRepoError('invalid-input', "repodataNaming must be 'plain' or 'content-addressed'", {
+            field: 'repodataNaming',
+        });
+    }
+    if (input.signer === null ||
+        typeof input.signer !== 'object' ||
+        typeof input.signer.signBinary !== 'function' ||
+        typeof input.signer.signText !== 'function') {
+        throw new LinuxRepoError('invalid-input', 'signer must implement IOpenPgpSigner', { field: 'signer' });
+    }
+    assertTimestamp(input.timestamp);
+    assertRpmRecords(input.entries);
+    assertRpmUpdates(input.updates, 'updates');
+    if (input.entries.length === 0) {
+        return [];
+    }
+    const entries = [...input.entries].sort((a, b) => compareCodePoints(a.name, b.name) ||
+        compareCodePoints(a.version, b.version) ||
+        compareCodePoints(a.architecture, b.architecture) ||
+        compareCodePoints(a.fileName, b.fileName));
+    const seconds = Math.floor(input.timestamp.getTime() / 1000);
+    const documents = [
+        ['primary', renderPrimary(entries)],
+        ['filelists', renderFilelists(entries)],
+        ['other', renderOther(entries)],
+    ];
+    const updates = combineRpmUpdates(input.updates);
+    if (updates.length > 0) {
+        documents.push(['updateinfo', renderUpdateInfo(updates)]);
+    }
+    const files = [];
+    const data = [];
+    for (const [type, xml] of documents) {
+        const open = new TextEncoder().encode(xml);
+        const gzipped = gzip(open);
+        const checksum = sha256(gzipped);
+        const name = input.repodataNaming === 'plain' ? `${type}.xml.gz` : `${checksum}-${type}.xml.gz`;
+        files.push(indexFile(`${prefix}repodata/${name}`, gzipped, checksum, 'application/gzip', 'content'));
+        data.push({
+            type,
+            checksum,
+            openChecksum: sha256(open),
+            href: `repodata/${name}`,
+            timestamp: seconds,
+            size: gzipped.length,
+            openSize: open.length,
+        });
+    }
+    const repomd = new TextEncoder().encode(renderRepomd(data));
+    const signature = new TextEncoder().encode(await createDetachedArmoredSignature({ data: repomd, signer: input.signer, timestamp: input.timestamp }));
+    files.push(indexFile(`${prefix}repodata/repomd.xml`, repomd, sha256(repomd), 'application/xml', 'pointer'));
+    files.push(indexFile(`${prefix}repodata/repomd.xml.asc`, signature, sha256(signature), 'application/pgp-signature', 'pointer'));
+    return files;
+}
+/** `''` for the root group, else `<group>/`; a group is `/`-separated path segments. */
+function groupPrefix(groupArg) {
+    if (typeof groupArg !== 'string') {
+        throw new LinuxRepoError('invalid-input', 'group must be a string', { field: 'group' });
+    }
+    if (groupArg === '') {
+        return '';
+    }
+    for (const segment of groupArg.split('/')) {
+        if (!isPathSegment(segment)) {
+            throw new LinuxRepoError('invalid-input', 'group must be "/"-separated non-empty segments other than "." and ".."', {
+                field: 'group',
+            });
+        }
+    }
+    return `${groupArg}/`;
+}
+function indexFile(pathArg, bytesArg, sha256Arg, mediaTypeArg, stageArg) {
+    return { path: pathArg, bytes: bytesArg, sha256: sha256Arg, mediaType: mediaTypeArg, stage: stageArg, aliases: [] };
+}
+function gzip(bytesArg) {
+    const compressed = plugins.zlib.gzipSync(bytesArg);
+    return new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength);
+}
+function sha256(bytesArg) {
+    return plugins.crypto.createHash('sha256').update(bytesArg).digest('hex');
+}
+/**
+ * Checks the record fields the renderers read and the layout rules: an
+ * indexable architecture, a name and version that are path segments, and no
+ * two entries with the same package location.
+ */
+function assertRpmRecords(entriesArg) {
+    if (!Array.isArray(entriesArg)) {
+        throw new LinuxRepoError('invalid-input', 'entries must be an array of RPM package records', { field: 'entries' });
+    }
+    const locations = new Set();
+    entriesArg.forEach((entry, i) => {
+        const at = `entries[${i}]`;
+        const record = entry;
+        const fail = (whatArg) => {
+            throw new LinuxRepoError('invalid-input', `${at} ${whatArg}`, { field: at });
+        };
+        if (record === null || typeof record !== 'object' || record.format !== 'rpm') {
+            fail('must be an RPM package record');
+        }
+        for (const key of ['name', 'version', 'architecture', 'fileName']) {
+            if (typeof record[key] !== 'string') {
+                fail(`.${key} must be a string`);
+            }
+        }
+        if (!isIndexableArchitecture(record.architecture)) {
+            fail(`(${record.fileName}) has an architecture that cannot name an index path: ${JSON.stringify(record.architecture)}`);
+        }
+        if (!isPathSegment(record.name) || !isPathSegment(record.version)) {
+            fail(`(${record.fileName}) has a name or version that cannot name a package path`);
+        }
+        const digests = record.digests;
+        if (digests === null || typeof digests !== 'object' || typeof digests.sha256 !== 'string' || !isCount(digests.size)) {
+            fail('.digests must hold sha256 and size');
+        }
+        const metadata = record.metadata;
+        if (metadata === null || typeof metadata !== 'object') {
+            fail('.metadata must be an object');
+        }
+        for (const key of [
+            'epoch',
+            'upstreamVersion',
+            'release',
+            'summary',
+            'description',
+            'license',
+            'projectUrl',
+            'vendor',
+            'group',
+            'packager',
+            'sourceRpm',
+            'buildHost',
+        ]) {
+            if (typeof metadata[key] !== 'string') {
+                fail(`.metadata.${key} must be a string`);
+            }
+        }
+        for (const key of ['buildTime', 'fileTime', 'installedSize', 'archiveSize']) {
+            if (!isCount(metadata[key])) {
+                fail(`.metadata.${key} must be a non-negative safe integer`);
+            }
+        }
+        for (const key of ['provides', 'requires', 'conflicts', 'obsoletes']) {
+            const list = metadata[key];
+            if (!Array.isArray(list) ||
+                !list.every((dependency) => dependency !== null &&
+                    typeof dependency === 'object' &&
+                    ['name', 'flags', 'epoch', 'version', 'release'].every((field) => typeof dependency[field] === 'string'))) {
+                fail(`.metadata.${key} must be a list of dependencies`);
+            }
+        }
+        const files = metadata.files;
+        if (!Array.isArray(files) ||
+            !files.every((file) => file !== null && typeof file === 'object' && typeof file.path === 'string' && typeof file.type === 'string' && typeof file.isExecutable === 'boolean')) {
+            fail('.metadata.files must be a list of files');
+        }
+        const changelogs = metadata.changelogs;
+        if (!Array.isArray(changelogs) ||
+            !changelogs.every((changelog) => changelog !== null &&
+                typeof changelog === 'object' &&
+                typeof changelog.author === 'string' &&
+                typeof changelog.text === 'string' &&
+                isCount(changelog.date))) {
+            fail('.metadata.changelogs must be a list of changelog entries');
+        }
+        const location = rpmPackageLocation(record);
+        if (locations.has(location)) {
+            fail(`duplicates the file ${record.fileName}`);
+        }
+        locations.add(location);
+    });
+}
+function isCount(valueArg) {
+    return typeof valueArg === 'number' && Number.isSafeInteger(valueArg) && valueArg >= 0;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"builder.js","sourceRoot":"","sources":["../../ts/rpm/builder.ts"],"names":[],"mappings":"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"}

package/dist_ts/rpm/header.d.ts

@@ -0,0 +1,138 @@
+import { type IByteReader } from '../readers/bytes.js';
+import type { ILinuxPackageLimits } from '../shared/limits.js';
+/**
+ * RPM lead and header structures, read the way go-rpmutils v0.4.0 (Gitea
+ * 28.2.0's pin, `go.mod:85`) reads them (`header.go:75-146`,
+ * `rpmutils.go:97-136`), so that a package Gitea accepts is accepted and one
+ * Gitea refuses (or panics on) is refused:
+ * - an index entry of a fixed-size type covers `offset .. offset + size*count`;
+ *   any other type is a run of `count` NUL-terminated strings; an entry that
+ *   does not fit the data is `malformed-header`;
+ * - a later entry with the same tag replaces an earlier one;
+ * - the main header's SHA-256 (signature tag 273), else SHA-1 (269), is
+ *   checked as lowercase hex (`digest-mismatch`).
+ */
+export declare const RPM_LEAD_BYTES = 96;
+/** Header data types. */
+export declare const RPM_TYPE: {
+    readonly null: 0;
+    readonly char: 1;
+    readonly int8: 2;
+    readonly int16: 3;
+    readonly int32: 4;
+    readonly int64: 5;
+    readonly string: 6;
+    readonly bin: 7;
+    readonly stringArray: 8;
+    readonly i18nString: 9;
+};
+/** Signature header tags. */
+export declare const RPM_SIGNATURE_TAG: {
+    readonly headerSignatures: 62;
+    readonly dsa: 267;
+    readonly rsa: 268;
+    readonly sha1: 269;
+    readonly longArchiveSize: 271;
+    readonly sha256: 273;
+    readonly size: 1000;
+    readonly pgp: 1002;
+    readonly md5: 1004;
+    readonly gpg: 1005;
+    readonly payloadSize: 1007;
+    readonly reservedSpace: 1008;
+};
+/** One index entry with the byte range of its contents in the header data. */
+export interface IRpmHeaderEntry {
+    tag: number;
+    type: number;
+    count: number;
+    start: number;
+    end: number;
+}
+/** The value of an integer tag as go-rpmutils `getInts` reads it. */
+export interface IRpmIntegers {
+    /** Element width in bytes: 1, 2, 4 or 8. */
+    width: 1 | 2 | 4 | 8;
+    values: bigint[];
+}
+/**
+ * A parsed header: its exact bytes, as read, and its index entries. The index
+ * stays in the header bytes; only the end of each entry's contents is kept
+ * beside it (4 bytes per entry), and finding the end of a string entry may
+ * build a NUL directory of about 3% of the data (`NulIndex`), so a header
+ * costs little more than its own bytes: reading a 64 MiB header peaks at
+ * about 1.33x its bytes with 4.19M entries and 1.12x with data of all NULs
+ * (Node 24.20.0). `IRpmHeaderEntry` objects are made only for the entries
+ * asked for.
+ */
+export declare class RpmHeader {
+    /** The header bytes as read: intro, index and data (with the padding of a signature header). */
+    readonly bytes: Uint8Array;
+    readonly data: Uint8Array;
+    /** Number of index entries. */
+    readonly entryCount: number;
+    private readonly view;
+    private readonly ends;
+    private readonly lookup;
+    private readonly maxEntries;
+    constructor(bytesArg: Uint8Array, endsArg: Uint32Array, dataStartArg: number, maxEntriesArg: number);
+    /** The tag of index entry `indexArg`. */
+    tagAt(indexArg: number): number;
+    /** Index entry `indexArg`. */
+    entryAt(indexArg: number): IRpmHeaderEntry;
+    /** The effective entry for a tag (the last one in the index), or `null`. */
+    entry(tagArg: number): IRpmHeaderEntry | null;
+    /** The index positions of every effective entry (the last one per tag), in ascending tag order. */
+    effectiveIndexes(): Uint32Array;
+    contents(entryArg: IRpmHeaderEntry): Uint8Array;
+    /**
+     * go-rpmutils `GetStrings` on the raw bytes: `null` when the tag is absent
+     * or not a string type. A negative count (a Go slice panic) is
+     * `malformed-header`; more values than `maxEntries` is `limit-exceeded`.
+     */
+    strings(tagArg: number): Uint8Array[] | null;
+    /** go-rpmutils `getInts`: `null` when the tag is absent or not an integer type. */
+    integers(tagArg: number): IRpmIntegers | null;
+    /** go-rpmutils `GetUint32s`: `null` when absent, not an integer type, or 64-bit. */
+    uint32s(tagArg: number): number[] | null;
+    /** go-rpmutils `GetUint64s`: `null` when absent or not an integer type. */
+    uint64s(tagArg: number): bigint[] | null;
+    /** go-rpmutils `GetBytes`: `null` when absent or not binary. */
+    binary(tagArg: number): Uint8Array | null;
+    private assertCount;
+}
+/** The lead, both headers and their offsets, as read from the start of a package. */
+export interface IRpmPackageHeaders {
+    lead: Uint8Array;
+    /** Lead bytes 6-7 equal 1 (go-rpmutils `rpmutils.go:131`). */
+    isSource: boolean;
+    signature: RpmHeader;
+    main: RpmHeader;
+    /** Offset of the main header: 96 plus the signature header with its padding. */
+    mainStart: number;
+}
+/**
+ * Reads the lead, the signature header and the main header from `readerArg`
+ * and checks the main header digest. The signature header plus the main
+ * header count against `maxMetadataBytes`. The reader is left at the payload.
+ */
+export declare function readRpmHeaders(readerArg: IByteReader, limitsArg: Readonly<ILinuxPackageLimits>): Promise<IRpmPackageHeaders>;
+/** An entry written by `writeSignatureHeader` that does not come from the source header. */
+export interface IRpmNewEntry {
+    tag: number;
+    type: number;
+    count: number;
+    contents: Uint8Array;
+}
+/**
+ * Serializes a signature header as go-rpmutils `WriteTo(…, 62)` does
+ * (`writeheader.go:66-123`): entries below tag 64 are dropped, the rest are
+ * written in ascending tag order with INT16/32/64 data aligned, the region
+ * tag 62 comes first in the index with its 16-byte trailer as the last data
+ * item, and the whole header is padded to 8 bytes.
+ *
+ * The entries are the effective entries of `sourceArg` whose tags are not in
+ * `removedArg`, copied without an object per entry, and `addedArg`, whose
+ * tags must be in `removedArg`.
+ */
+export declare function writeSignatureHeader(sourceArg: RpmHeader, removedArg: ReadonlySet<number>, addedArg: IRpmNewEntry[]): Uint8Array;