@push.rocks/smartlinuxrepo 0.0.0-stage → 1.0.0

package/ts/arch/vercmp.ts

@@ -0,0 +1,188 @@
+/**
+ * pacman's version comparison: libalpm `alpm_pkg_vercmp` with `parseEVR` and
+ * `rpmvercmp` (`lib/libalpm/version.c`, read from pacman 6.0.2 and checked
+ * against pacman's `vercmp` tool in the Docker gate). Gitea 28.2.0 uses a
+ * simplified comparator (`services/packages/arch/vercmp.go`) that splits on
+ * `.` only and can pick what pacman sees as a downgrade; the codec follows
+ * alpm. Characters are classified as in the C locale.
+ *
+ * Returns 1 when `a` is newer, -1 when `b` is newer, 0 when pacman treats
+ * them as the same version.
+ */
+export function compareArchVersions(aArg: string, bArg: string): -1 | 0 | 1 {
+  if (aArg === bArg) {
+    return 0;
+  }
+  const a = parseEvr(toBytes(aArg));
+  const b = parseEvr(toBytes(bArg));
+  let result = rpmvercmp(a.epoch, b.epoch);
+  if (result === 0) {
+    result = rpmvercmp(a.version, b.version);
+    if (result === 0 && a.release !== null && b.release !== null) {
+      result = rpmvercmp(a.release, b.release);
+    }
+  }
+  return result;
+}
+
+interface IEvr {
+  epoch: Uint8Array;
+  version: Uint8Array;
+  release: Uint8Array | null;
+}
+
+const ZERO = Uint8Array.of(0x30);
+
+function toBytes(valueArg: string): Uint8Array {
+  const bytes = new TextEncoder().encode(valueArg);
+  // a C string ends at the first NUL
+  const nul = bytes.indexOf(0);
+  return nul < 0 ? bytes : bytes.subarray(0, nul);
+}
+
+/** `parseEVR`: `[epoch:]version[-release]`; the release starts after the last `-`. */
+function parseEvr(evrArg: Uint8Array): IEvr {
+  let s = 0;
+  while (s < evrArg.length && isDigit(evrArg[s])) {
+    s++;
+  }
+  // strrchr(s, '-') searches from the epoch terminator on
+  let dash = -1;
+  for (let i = evrArg.length - 1; i >= s; i--) {
+    if (evrArg[i] === 0x2d) {
+      dash = i;
+      break;
+    }
+  }
+  let epoch: Uint8Array;
+  let versionStart: number;
+  if (s < evrArg.length && evrArg[s] === 0x3a) {
+    epoch = s === 0 ? ZERO : evrArg.subarray(0, s);
+    versionStart = s + 1;
+  } else {
+    epoch = ZERO;
+    versionStart = 0;
+  }
+  if (dash >= 0) {
+    return { epoch, version: evrArg.subarray(versionStart, dash), release: evrArg.subarray(dash + 1) };
+  }
+  return { epoch, version: evrArg.subarray(versionStart), release: null };
+}
+
+/** `rpmvercmp` over two C strings. */
+function rpmvercmp(aArg: Uint8Array, bArg: Uint8Array): -1 | 0 | 1 {
+  if (compareBytes(aArg, 0, aArg.length, bArg, 0, bArg.length) === 0) {
+    return 0;
+  }
+  const at = (bytesArg: Uint8Array, indexArg: number): number => (indexArg < bytesArg.length ? bytesArg[indexArg] : 0);
+  let one = 0;
+  let two = 0;
+  let ptr1 = 0;
+  let ptr2 = 0;
+  while (at(aArg, one) !== 0 && at(bArg, two) !== 0) {
+    while (at(aArg, one) !== 0 && !isAlnum(at(aArg, one))) {
+      one++;
+    }
+    while (at(bArg, two) !== 0 && !isAlnum(at(bArg, two))) {
+      two++;
+    }
+    if (!(at(aArg, one) !== 0 && at(bArg, two) !== 0)) {
+      break;
+    }
+    // separator runs of different length decide
+    if (one - ptr1 !== two - ptr2) {
+      return one - ptr1 < two - ptr2 ? -1 : 1;
+    }
+    ptr1 = one;
+    ptr2 = two;
+    let isNum: boolean;
+    if (isDigit(at(aArg, ptr1))) {
+      while (at(aArg, ptr1) !== 0 && isDigit(at(aArg, ptr1))) {
+        ptr1++;
+      }
+      while (at(bArg, ptr2) !== 0 && isDigit(at(bArg, ptr2))) {
+        ptr2++;
+      }
+      isNum = true;
+    } else {
+      while (at(aArg, ptr1) !== 0 && isAlpha(at(aArg, ptr1))) {
+        ptr1++;
+      }
+      while (at(bArg, ptr2) !== 0 && isAlpha(at(bArg, ptr2))) {
+        ptr2++;
+      }
+      isNum = false;
+    }
+    if (one === ptr1) {
+      return -1;
+    }
+    // numeric segments are newer than alpha segments
+    if (two === ptr2) {
+      return isNum ? 1 : -1;
+    }
+    let segment1 = one;
+    let segment2 = two;
+    if (isNum) {
+      while (at(aArg, segment1) === 0x30 && segment1 < ptr1) {
+        segment1++;
+      }
+      while (at(bArg, segment2) === 0x30 && segment2 < ptr2) {
+        segment2++;
+      }
+      if (ptr1 - segment1 > ptr2 - segment2) {
+        return 1;
+      }
+      if (ptr2 - segment2 > ptr1 - segment1) {
+        return -1;
+      }
+    }
+    const rc = compareBytes(aArg, segment1, ptr1, bArg, segment2, ptr2);
+    if (rc !== 0) {
+      return rc;
+    }
+    one = ptr1;
+    two = ptr2;
+  }
+  if (at(aArg, one) === 0 && at(bArg, two) === 0) {
+    return 0;
+  }
+  // a remaining alpha string never beats an empty one
+  if ((at(aArg, one) === 0 && !isAlpha(at(bArg, two))) || isAlpha(at(aArg, one))) {
+    return -1;
+  }
+  return 1;
+}
+
+/** `strcmp` over two byte ranges. */
+function compareBytes(
+  aArg: Uint8Array,
+  aStartArg: number,
+  aEndArg: number,
+  bArg: Uint8Array,
+  bStartArg: number,
+  bEndArg: number,
+): -1 | 0 | 1 {
+  const length = Math.min(aEndArg - aStartArg, bEndArg - bStartArg);
+  for (let i = 0; i < length; i++) {
+    const x = aArg[aStartArg + i];
+    const y = bArg[bStartArg + i];
+    if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  const aLength = aEndArg - aStartArg;
+  const bLength = bEndArg - bStartArg;
+  return aLength === bLength ? 0 : aLength < bLength ? -1 : 1;
+}
+
+function isDigit(byteArg: number): boolean {
+  return byteArg >= 0x30 && byteArg <= 0x39;
+}
+
+function isAlpha(byteArg: number): boolean {
+  return (byteArg >= 0x41 && byteArg <= 0x5a) || (byteArg >= 0x61 && byteArg <= 0x7a);
+}
+
+function isAlnum(byteArg: number): boolean {
+  return isDigit(byteArg) || isAlpha(byteArg);
+}

package/ts/debian/control.ts

@@ -0,0 +1,150 @@
+import { LinuxRepoError, limitExceeded } from '../shared/errors.js';
+import { isValidUrl } from '../shared/url.js';
+import type { IDebianPackageMetadata } from '../shared/types.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.~+_-]*$/;
+
+export interface IDebianControl {
+  name: string;
+  version: string;
+  architecture: string;
+  metadata: IDebianPackageMetadata;
+}
+
+/**
+ * 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: Uint8Array, maxLineBytesArg: number): IDebianControl {
+  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))),
+    },
+  };
+}

package/ts/debian/gostring.ts

@@ -0,0 +1,150 @@
+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: Uint8Array): string {
+  return decodeLatin1(bytesArg);
+}
+
+export function byteStringToBytes(valueArg: string): Uint8Array {
+  return Uint8Array.from(Buffer.from(valueArg, 'latin1'));
+}
+
+/** The byte string of a JS string's UTF-8 encoding. */
+export function utf8ByteString(valueArg: string): string {
+  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: string): string {
+  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: string, indexArg: number): [number, number] {
+  if (indexArg >= valueArg.length) {
+    return [RUNE_ERROR, 0];
+  }
+  const b0 = valueArg.charCodeAt(indexArg);
+  if (b0 < 0x80) {
+    return [b0, 1];
+  }
+  let need: number;
+  let rune: number;
+  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: number): boolean {
+  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: string): string {
+  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: string, startArg: number, endArg: number): [number, number] {
+  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: string, bArg: string): number {
+  return Buffer.compare(Buffer.from(aArg, 'utf8'), Buffer.from(bArg, 'utf8'));
+}