@push.rocks/smartlinuxrepo 0.0.0-stage → 1.0.0

package/dist_ts/debian/control.js

@@ -0,0 +1,137 @@
+import { LinuxRepoError, limitExceeded } from '../shared/errors.js';
+import { isValidUrl } from '../shared/url.js';
+import { fromByteString, goTrimSpace, toByteString } from './gostring.js';
+import { parseMailAddress } from './mailaddress.js';
+/**
+ * Gitea 28.2.0 `modules/packages/debian/metadata.go` patterns. In both Go and
+ * JS `+-.` and `+-~` inside a class are ranges (0x2B-0x2E and 0x2B-0x7E), so
+ * the name accepts `,` and the revision accepts almost all printable ASCII.
+ */
+const NAME_PATTERN = /^[a-z0-9][a-z0-9+-.]+$/;
+const VERSION_PATTERN = /^(?:(0|[1-9][0-9]*):)?[a-zA-Z0-9.+~]+(?:-[a-zA-Z0-9.+-~]+)?$/;
+/** Gitea's distribution and component rule (`metadata.go:67`, applied at upload). */
+export const DEBIAN_SYMBOL_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9.~+_-]*$/;
+/**
+ * A port of Gitea 28.2.0 `ParseControlFile` (`metadata.go:165-265`) over the
+ * bytes of the `control` entry. Lines are split as `bufio.ScanLines` does
+ * (`\n`, one trailing `\r` dropped); the first blank line after content ends
+ * the stanza. Every derived value is Gitea's: the raw stanza trimmed, the
+ * Maintainer name through `net/mail`, the Homepage only when Gitea's URL
+ * check accepts it, the Description with its continuation lines appended
+ * verbatim, and the Depends text split on `,` (`['']` when there is none).
+ *
+ * Gitea's scanner refuses lines over 64 KiB; the codec accepts lines up to
+ * `maxLineBytes` (`maxHeaderBytes`), which is at least that.
+ */
+export function parseDebianControlFile(bytesArg, maxLineBytesArg) {
+    const text = toByteString(bytesArg);
+    let name = '';
+    let version = '';
+    let architecture = '';
+    let maintainer = '';
+    let projectUrl = '';
+    let key = '';
+    let depends = '';
+    let control = '';
+    let description = '';
+    let offset = 0;
+    while (offset < text.length) {
+        const newline = text.indexOf('\n', offset);
+        const end = newline < 0 ? text.length : newline;
+        let line = text.slice(offset, end);
+        offset = newline < 0 ? text.length : newline + 1;
+        if (line.endsWith('\r')) {
+            line = line.slice(0, -1);
+        }
+        if (line.length > maxLineBytesArg) {
+            throw limitExceeded('maxHeaderBytes', maxLineBytesArg, 'Debian control line');
+        }
+        const trimmed = goTrimSpace(line);
+        if (trimmed === '') {
+            // one stanza only: the blank line after content ends it (metadata.go:182-191)
+            if (control.length === 0) {
+                continue;
+            }
+            break;
+        }
+        control += `${line}\n`;
+        if (line[0] === ' ' || line[0] === '\t') {
+            // a folded continuation line of the previous field
+            if (key === 'Description') {
+                description += line;
+            }
+            else if (key === 'Depends') {
+                depends += trimmed;
+            }
+            continue;
+        }
+        const colon = trimmed.indexOf(':');
+        if (colon < 0) {
+            // Gitea keeps the previous key here (metadata.go:207-210)
+            continue;
+        }
+        key = trimmed.slice(0, colon);
+        const value = goTrimSpace(trimmed.slice(colon + 1));
+        switch (key) {
+            case 'Package':
+                name = value;
+                break;
+            case 'Version':
+                version = value;
+                break;
+            case 'Architecture':
+                architecture = value;
+                break;
+            case 'Maintainer': {
+                const address = parseMailAddress(value);
+                maintainer = address === null || address.name === '' ? value : address.name;
+                break;
+            }
+            case 'Description':
+                description = value;
+                break;
+            case 'Depends':
+                // appended without a separator, as Gitea does for a repeated field
+                depends += value;
+                break;
+            case 'Homepage':
+                if (isValidUrl(fromByteString(value))) {
+                    projectUrl = value;
+                }
+                break;
+        }
+    }
+    if (name === '') {
+        throw new LinuxRepoError('missing-field', 'the control file has no Package field', { field: 'Package' });
+    }
+    if (!NAME_PATTERN.test(name)) {
+        throw new LinuxRepoError('invalid-field', 'the package name is invalid', { field: 'Package', value: fromByteString(name) });
+    }
+    if (version === '') {
+        throw new LinuxRepoError('missing-field', 'the control file has no Version field', { field: 'Version' });
+    }
+    if (!VERSION_PATTERN.test(version)) {
+        throw new LinuxRepoError('invalid-field', 'the package version is invalid', {
+            field: 'Version',
+            value: fromByteString(version),
+        });
+    }
+    if (architecture === '') {
+        throw new LinuxRepoError('missing-field', 'the control file has no Architecture field', {
+            field: 'Architecture',
+        });
+    }
+    return {
+        name,
+        version,
+        architecture: fromByteString(architecture),
+        metadata: {
+            control: fromByteString(goTrimSpace(control)),
+            maintainer: fromByteString(maintainer),
+            projectUrl: fromByteString(projectUrl),
+            description: fromByteString(description),
+            dependencies: depends.split(',').map((dependency) => fromByteString(goTrimSpace(dependency))),
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/debian/gostring.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Go string semantics for the Debian ports. A Go string is a byte sequence;
+ * here it is a "byte string": a JS string whose every code unit is one byte
+ * (0-255). The ported Gitea and Go code indexes, slices and compares bytes
+ * exactly as Go does, and only the finished values are decoded into Unicode
+ * with `fromByteString` (Go's JSON coercion of invalid UTF-8).
+ */
+export declare function toByteString(bytesArg: Uint8Array): string;
+export declare function byteStringToBytes(valueArg: string): Uint8Array;
+/** The byte string of a JS string's UTF-8 encoding. */
+export declare function utf8ByteString(valueArg: string): string;
+/** Decodes a byte string into Unicode, replacing every invalid byte with U+FFFD as Go's JSON encoder does. */
+export declare function fromByteString(valueArg: string): string;
+export declare const RUNE_ERROR = 65533;
+/**
+ * Go `utf8.DecodeRuneInString(s[i:])`: the rune at byte offset `i` and its
+ * width. The width is 0 at the end of the string; an invalid or truncated
+ * sequence is `RUNE_ERROR` with width 1.
+ */
+export declare function decodeRune(valueArg: string, indexArg: number): [number, number];
+/** Go `unicode.IsSpace`. */
+export declare function isGoSpace(runeArg: number): boolean;
+/** Go `strings.TrimSpace` on a byte string. */
+export declare function goTrimSpace(valueArg: string): string;
+/** Bytewise comparison of two JS strings by their UTF-8 encodings (Go `sort.Strings` order). */
+export declare function compareUtf8(aArg: string, bArg: string): number;

package/dist_ts/debian/gostring.js

@@ -0,0 +1,145 @@
+import { decodeGoUtf8, decodeLatin1 } from '../readers/text.js';
+/**
+ * Go string semantics for the Debian ports. A Go string is a byte sequence;
+ * here it is a "byte string": a JS string whose every code unit is one byte
+ * (0-255). The ported Gitea and Go code indexes, slices and compares bytes
+ * exactly as Go does, and only the finished values are decoded into Unicode
+ * with `fromByteString` (Go's JSON coercion of invalid UTF-8).
+ */
+export function toByteString(bytesArg) {
+    return decodeLatin1(bytesArg);
+}
+export function byteStringToBytes(valueArg) {
+    return Uint8Array.from(Buffer.from(valueArg, 'latin1'));
+}
+/** The byte string of a JS string's UTF-8 encoding. */
+export function utf8ByteString(valueArg) {
+    return Buffer.from(valueArg, 'utf8').toString('latin1');
+}
+/** Decodes a byte string into Unicode, replacing every invalid byte with U+FFFD as Go's JSON encoder does. */
+export function fromByteString(valueArg) {
+    return decodeGoUtf8(byteStringToBytes(valueArg));
+}
+export const RUNE_ERROR = 0xfffd;
+/**
+ * Go `utf8.DecodeRuneInString(s[i:])`: the rune at byte offset `i` and its
+ * width. The width is 0 at the end of the string; an invalid or truncated
+ * sequence is `RUNE_ERROR` with width 1.
+ */
+export function decodeRune(valueArg, indexArg) {
+    if (indexArg >= valueArg.length) {
+        return [RUNE_ERROR, 0];
+    }
+    const b0 = valueArg.charCodeAt(indexArg);
+    if (b0 < 0x80) {
+        return [b0, 1];
+    }
+    let need;
+    let rune;
+    let low = 0x80;
+    let high = 0xbf;
+    if (b0 >= 0xc2 && b0 <= 0xdf) {
+        need = 1;
+        rune = b0 & 0x1f;
+    }
+    else if (b0 >= 0xe0 && b0 <= 0xef) {
+        need = 2;
+        rune = b0 & 0x0f;
+        if (b0 === 0xe0) {
+            low = 0xa0;
+        }
+        else if (b0 === 0xed) {
+            high = 0x9f;
+        }
+    }
+    else if (b0 >= 0xf0 && b0 <= 0xf4) {
+        need = 3;
+        rune = b0 & 0x07;
+        if (b0 === 0xf0) {
+            low = 0x90;
+        }
+        else if (b0 === 0xf4) {
+            high = 0x8f;
+        }
+    }
+    else {
+        return [RUNE_ERROR, 1];
+    }
+    if (indexArg + need >= valueArg.length) {
+        return [RUNE_ERROR, 1];
+    }
+    for (let k = 1; k <= need; k++) {
+        const b = valueArg.charCodeAt(indexArg + k);
+        const min = k === 1 ? low : 0x80;
+        const max = k === 1 ? high : 0xbf;
+        if (b < min || b > max) {
+            return [RUNE_ERROR, 1];
+        }
+        rune = (rune << 6) | (b & 0x3f);
+    }
+    return [rune, need + 1];
+}
+/** Go `unicode.IsSpace`. */
+export function isGoSpace(runeArg) {
+    switch (runeArg) {
+        case 0x09:
+        case 0x0a:
+        case 0x0b:
+        case 0x0c:
+        case 0x0d:
+        case 0x20:
+        case 0x85:
+        case 0xa0:
+        case 0x1680:
+        case 0x2028:
+        case 0x2029:
+        case 0x202f:
+        case 0x205f:
+        case 0x3000:
+            return true;
+    }
+    return runeArg >= 0x2000 && runeArg <= 0x200a;
+}
+/** Go `strings.TrimSpace` on a byte string. */
+export function goTrimSpace(valueArg) {
+    let start = 0;
+    while (start < valueArg.length) {
+        const [rune, width] = decodeRune(valueArg, start);
+        if (!isGoSpace(rune)) {
+            break;
+        }
+        start += width;
+    }
+    let end = valueArg.length;
+    while (end > start) {
+        const [rune, width] = decodeLastRune(valueArg, start, end);
+        if (!isGoSpace(rune)) {
+            break;
+        }
+        end -= width;
+    }
+    return valueArg.slice(start, end);
+}
+/** Go `utf8.DecodeLastRuneInString(s[start:end])`. */
+function decodeLastRune(valueArg, startArg, endArg) {
+    const last = valueArg.charCodeAt(endArg - 1);
+    if (last < 0x80) {
+        return [last, 1];
+    }
+    // a rune is at most 4 bytes: find the start byte and check it decodes to exactly the tail
+    const lowest = Math.max(startArg, endArg - 4);
+    let begin = endArg - 1;
+    while (begin > lowest && (valueArg.charCodeAt(begin) & 0xc0) === 0x80) {
+        begin -= 1;
+    }
+    const [rune, width] = decodeRune(valueArg.slice(0, endArg), begin);
+    if (begin + width !== endArg) {
+        return [RUNE_ERROR, 1];
+    }
+    return [rune, width];
+}
+/** Bytewise comparison of two JS strings by their UTF-8 encodings (Go `sort.Strings` order). */
+export function compareUtf8(aArg, bArg) {
+    return Buffer.compare(Buffer.from(aArg, 'utf8'), Buffer.from(bArg, 'utf8'));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/debian/indexbuilder.d.ts

@@ -0,0 +1,47 @@
+import type { IDebianPackageRecord, ILinuxIndexFile } from '../shared/types.js';
+import type { IOpenPgpSigner } from '../signing/signers.js';
+export interface IDebianIndexEntry {
+    component: string;
+    record: IDebianPackageRecord;
+}
+/**
+ * Builds the index files of one Debian distribution as Gitea 28.2.0 does
+ * (`services/packages/debian/repository.go:147-397`):
+ *
+ * - per component and architecture with packages:
+ *   `dists/<dist>/<component>/binary-<arch>/Packages`, `.gz` and `.xz`,
+ *   each with `by-hash/{MD5Sum,SHA1,SHA256,SHA512}/<hex>` aliases;
+ * - `dists/<dist>/Release`, `Release.gpg` (armored detached signature) and
+ *   `InRelease` (cleartext-signed `Release`), all signed at `timestamp`.
+ *
+ * An `all` package is listed only under `binary-all`, as in Gitea. Stanzas are
+ * sorted by name, version, architecture and file name (bytewise; Gitea uses
+ * database order), and the Release file lists follow component, architecture
+ * and file order. The output is the complete set of files for the
+ * distribution; an empty entry set returns `[]`.
+ */
+export declare function buildDebianIndex(input: {
+    distribution: string;
+    entries: Array<{
+        component: string;
+        record: IDebianPackageRecord;
+    }>;
+    origin: string;
+    label: string;
+    signer: IOpenPgpSigner;
+    timestamp: Date;
+}): Promise<ILinuxIndexFile[]>;
+/**
+ * One `Packages` stanza, without the separating blank line: Gitea's trimmed
+ * control stanza without the six index-owned fields (`Filename`, `Size`,
+ * `MD5sum`, `SHA1`, `SHA256`, `SHA512`, matched case-insensitively, with their
+ * continuation lines), then those fields from the record
+ * (`repository.go:202-209`). A control file that sets them would point apt at
+ * other bytes; Gitea would write them twice. Internal: 1.0.0 exports no
+ * per-entry renderer.
+ */
+export declare function renderDebianPackagesStanza(input: {
+    distribution: string;
+    component: string;
+    record: IDebianPackageRecord;
+}): string;