@push.rocks/smartlinuxrepo 0.0.0-stage → 1.0.0

package/dist_ts/arch/reader.js

@@ -0,0 +1,271 @@
+import { LinuxRepoError, limitExceeded } from '../shared/errors.js';
+import { goPathBase, goPathClean } from '../shared/gopath.js';
+import { resolveLinuxPackageLimits } from '../shared/limits.js';
+import { isValidUrl } from '../shared/url.js';
+import { readUpTo, skipToEnd } from '../readers/bytes.js';
+import { PackageByteSource } from '../readers/bytesource.js';
+import { withDecompressingReader } from '../readers/decompress.js';
+import { readTarEntryData, TarReader } from '../readers/tar.js';
+import { decodeGoUtf8 } from '../readers/text.js';
+import { goParseInt64, goTrimSpace } from '../shared/gostrings.js';
+/** Gitea `namePattern` (`modules/packages/arch/metadata.go:47`). */
+export const ARCH_NAME_PATTERN = /^[a-zA-Z0-9@._+-]+$/;
+/** Gitea `versionPattern` (`metadata.go:49`); Go's `\d` and `\w` are ASCII, as in a JS RegExp without `u`. */
+export const ARCH_VERSION_PATTERN = /^(?:\d:)?[\w.+~]+(?:-[-\w.+~]+)?$/;
+const MAGIC_BYTES = 10;
+const GO_C_ISDIR = 0o40000;
+/**
+ * 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 async function readArchPackage(sourceArg, limitsArg) {
+    const limits = resolveLinuxPackageLimits(limitsArg);
+    const source = new PackageByteSource(sourceArg, limits.maxPackageBytes);
+    const magic = await readUpTo(source, MAGIC_BYTES);
+    source.unread(magic);
+    const container = detectContainer(magic);
+    if (container === null) {
+        throw new LinuxRepoError('unsupported-compression', 'not a zst, xz or gz compressed Arch package', {
+            field: 'compression',
+        });
+    }
+    const walked = await withDecompressingReader(source, container.decoder, { maxOutputBytes: limits.maxPayloadBytes, outputLimit: 'maxPayloadBytes' }, async (payloadArg) => {
+        const result = await walkPayload(new TarReader(payloadArg, { maxEntries: limits.maxEntries, maxHeaderBytes: limits.maxHeaderBytes }), limits);
+        // Go stops at the tar end marker; the codec decodes the rest of the
+        // stream as well, so a package cut or corrupted after the marker fails
+        // loudly instead of being stored and signed
+        await skipToEnd(payloadArg);
+        return result;
+    });
+    if (walked.info === null) {
+        throw new LinuxRepoError('missing-field', '.PKGINFO file is missing', { field: '.PKGINFO' });
+    }
+    await source.drain();
+    const info = walked.info;
+    return {
+        format: 'arch',
+        name: info.name,
+        version: info.version,
+        architecture: info.architecture,
+        fileName: `${info.name}-${info.version}-${info.architecture}.pkg.tar.${container.extension}`,
+        digests: source.digests(),
+        metadata: {
+            compression: container.extension,
+            ...info.metadata,
+            files: walked.files,
+        },
+    };
+}
+function detectContainer(magicArg) {
+    const startsWith = (bytesArg) => bytesArg.every((byte, index) => magicArg[index] === byte);
+    if (startsWith([0x28, 0xb5, 0x2f, 0xfd])) {
+        return { extension: 'zst', decoder: 'zstd' };
+    }
+    if (startsWith([0xfd, 0x37, 0x7a, 0x58, 0x5a])) {
+        return { extension: 'xz', decoder: 'xz' };
+    }
+    if (startsWith([0x1f, 0x8b])) {
+        return { extension: 'gz', decoder: 'gzip' };
+    }
+    return null;
+}
+/**
+ * Gitea's tar walk (`metadata.go:135-163`): regular entries only; a regular
+ * entry whose base name is `.PKGINFO` is parsed (a later one replaces an
+ * earlier one); every other regular entry whose base name does not start with
+ * `.` and whose name holds no CR or LF joins the file list, in archive order.
+ */
+async function walkPayload(tarArg, limitsArg) {
+    let info = null;
+    const files = [];
+    let fileBytes = 0;
+    for (;;) {
+        const entry = await tarArg.next();
+        if (entry === null) {
+            break;
+        }
+        if (entry.typeflag !== '0') {
+            continue;
+        }
+        const base = fileInfoName(entry);
+        if (base === '.PKGINFO') {
+            const data = await readTarEntryData(entry, limitsArg.maxDecompressedMetadataBytes, 'maxDecompressedMetadataBytes');
+            info = parsePackageInfo(data, limitsArg);
+        }
+        else if (!base.startsWith('.')) {
+            if (/[\n\r]/.test(entry.name)) {
+                continue;
+            }
+            // Gitea's BoundedFileList: entry count and total name bytes
+            const nameBytes = Buffer.byteLength(entry.name, 'utf8');
+            if (files.length >= limitsArg.maxEntries) {
+                throw limitExceeded('maxEntries', limitsArg.maxEntries, 'Arch file list');
+            }
+            if (fileBytes + nameBytes > limitsArg.maxFileListBytes) {
+                throw limitExceeded('maxFileListBytes', limitsArg.maxFileListBytes, 'Arch file list');
+            }
+            fileBytes += nameBytes;
+            files.push(entry.name);
+        }
+    }
+    return { info, files };
+}
+/** Go `tar.Header.FileInfo().Name()` for a regular entry: `path.Base`, after `path.Clean` when the mode marks a directory. */
+function fileInfoName(entryArg) {
+    const typeBits = (Number(BigInt.asUintN(32, entryArg.mode)) & ~0o7777) >>> 0;
+    if (typeBits === GO_C_ISDIR) {
+        return goPathBase(goPathClean(entryArg.name));
+    }
+    return goPathBase(entryArg.name);
+}
+const MULTI_VALUE_KEYS = {
+    license: 'licenses',
+    provides: 'provides',
+    depend: 'depends',
+    replaces: 'replaces',
+    optdepend: 'optDepends',
+    makedepend: 'makeDepends',
+    checkdepend: 'checkDepends',
+    conflict: 'conflicts',
+    backup: 'backup',
+    group: 'groups',
+    xdata: 'xdata',
+};
+/**
+ * Gitea's `ParsePackageInfo` (`metadata.go:178-267`): lines as Go's
+ * `bufio.ScanLines` splits them (a trailing CR dropped), `#` lines and lines
+ * without `=` skipped, key and value `strings.TrimSpace`d, single values last
+ * one wins, `builddate` and `size` parsed as int64 (an unparsable value
+ * refuses the package), then the name, version and architecture checks and
+ * the URL check. Lines are bounded by `maxHeaderBytes` (Gitea: 64 KiB) and
+ * each multi-valued key by `maxEntries`.
+ */
+function parsePackageInfo(dataArg, limitsArg) {
+    const info = {
+        name: '',
+        version: '',
+        architecture: '',
+        metadata: {
+            base: '',
+            description: '',
+            projectUrl: '',
+            licenses: [],
+            installedSize: 0,
+            buildDate: 0,
+            packager: '',
+            groups: [],
+            provides: [],
+            replaces: [],
+            depends: [],
+            optDepends: [],
+            makeDepends: [],
+            checkDepends: [],
+            conflicts: [],
+            xdata: [],
+            backup: [],
+        },
+    };
+    for (const rawLine of splitLines(dataArg, limitsArg.maxHeaderBytes)) {
+        const line = decodeGoUtf8(rawLine);
+        if (line.startsWith('#')) {
+            continue;
+        }
+        const equals = line.indexOf('=');
+        if (equals < 0) {
+            continue;
+        }
+        const key = goTrimSpace(line.slice(0, equals));
+        const value = goTrimSpace(line.slice(equals + 1));
+        switch (key) {
+            case 'pkgname':
+                info.name = value;
+                break;
+            case 'pkgbase':
+                info.metadata.base = value;
+                break;
+            case 'pkgver':
+                info.version = value;
+                break;
+            case 'pkgdesc':
+                info.metadata.description = value;
+                break;
+            case 'url':
+                info.metadata.projectUrl = value;
+                break;
+            case 'packager':
+                info.metadata.packager = value;
+                break;
+            case 'arch':
+                info.architecture = value;
+                break;
+            case 'builddate':
+                info.metadata.buildDate = parseInteger(value, 'builddate');
+                break;
+            case 'size':
+                info.metadata.installedSize = parseInteger(value, 'size');
+                break;
+            default:
+                if (Object.hasOwn(MULTI_VALUE_KEYS, key)) {
+                    const list = info.metadata[MULTI_VALUE_KEYS[key]];
+                    if (list.length >= limitsArg.maxEntries) {
+                        throw limitExceeded('maxEntries', limitsArg.maxEntries, `.PKGINFO ${key} values`);
+                    }
+                    list.push(value);
+                }
+        }
+    }
+    if (!ARCH_NAME_PATTERN.test(info.name)) {
+        throw new LinuxRepoError('invalid-field', 'package name is invalid', { field: 'pkgname' });
+    }
+    if (!ARCH_VERSION_PATTERN.test(info.version)) {
+        throw new LinuxRepoError('invalid-field', 'package version is invalid', { field: 'pkgver' });
+    }
+    if (info.architecture === '') {
+        throw new LinuxRepoError('invalid-field', 'package architecture is invalid', { field: 'arch' });
+    }
+    if (!isValidUrl(info.metadata.projectUrl)) {
+        info.metadata.projectUrl = '';
+    }
+    return info;
+}
+/** int64 as Go parses it; values outside the safe integer range cannot live in a JSON record. */
+function parseInteger(valueArg, fieldArg) {
+    const value = goParseInt64(valueArg);
+    if (value === null) {
+        throw new LinuxRepoError('invalid-field', `.PKGINFO ${fieldArg} is not an integer`, { field: fieldArg });
+    }
+    if (value > BigInt(Number.MAX_SAFE_INTEGER) || value < BigInt(Number.MIN_SAFE_INTEGER)) {
+        throw new LinuxRepoError('invalid-field', `.PKGINFO ${fieldArg} is outside the safe integer range`, {
+            field: fieldArg,
+        });
+    }
+    return Number(value);
+}
+/** Go `bufio.ScanLines`: split at LF, drop one trailing CR, keep a final unterminated line when non-empty. */
+function splitLines(dataArg, maxLineBytesArg) {
+    const lines = [];
+    let start = 0;
+    while (start < dataArg.length) {
+        let end = dataArg.indexOf(0x0a, start);
+        const terminated = end >= 0;
+        if (!terminated) {
+            end = dataArg.length;
+        }
+        if (end - start > maxLineBytesArg) {
+            throw limitExceeded('maxHeaderBytes', maxLineBytesArg, '.PKGINFO line');
+        }
+        let line = dataArg.subarray(start, end);
+        if (line.length > 0 && line[line.length - 1] === 0x0d) {
+            line = line.subarray(0, line.length - 1);
+        }
+        lines.push(line);
+        start = terminated ? end + 1 : end;
+    }
+    return lines;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reader.js","sourceRoot":"","sources":["../../ts/arch/reader.ts"],"names":[],"mappings":"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"}

package/dist_ts/arch/signer.d.ts

@@ -0,0 +1,21 @@
+import { type ILinuxPackageLimits } from '../shared/limits.js';
+import type { IOpenPgpSigner } from '../signing/signers.js';
+/**
+ * Signs an Arch package at upload time, as Gitea 28.2.0 signs every upload
+ * (`routers/api/packages/arch/arch.go:83`, `openpgp.DetachSign`): returns the
+ * `.sig` file, one binary detached signature packet over the package bytes.
+ * The package streams to the signer once, counted against `maxPackageBytes`
+ * of `limits` (pass the limits the package was read with); the codec keeps no
+ * copy, but the built-in OpenPGP signer still holds it in memory: openpgp.js
+ * buffers the whole document when detach-signing a stream.
+ * A failure of the package stream (the limit, or the caller's source error
+ * unchanged) wins over whatever the signer made of it. Pass the result as the index
+ * entry's `packageSignature`. Imported packages keep their stored signature
+ * and are never re-signed.
+ */
+export declare function signArchPackage(inputArg: {
+    source: AsyncIterable<Uint8Array>;
+    signer: IOpenPgpSigner;
+    timestamp: Date;
+    limits?: Partial<ILinuxPackageLimits>;
+}): Promise<Uint8Array>;

package/dist_ts/arch/signer.js

@@ -0,0 +1,66 @@
+import { LinuxRepoError } from '../shared/errors.js';
+import { resolveLinuxPackageLimits } from '../shared/limits.js';
+import { assertTimestamp } from '../shared/validation.js';
+import { READ_CHUNK_BYTES } from '../readers/bytes.js';
+import { PackageByteSource } from '../readers/bytesource.js';
+import { createDetachedBinarySignature } from '../signing/openpgpframing.js';
+/**
+ * Signs an Arch package at upload time, as Gitea 28.2.0 signs every upload
+ * (`routers/api/packages/arch/arch.go:83`, `openpgp.DetachSign`): returns the
+ * `.sig` file, one binary detached signature packet over the package bytes.
+ * The package streams to the signer once, counted against `maxPackageBytes`
+ * of `limits` (pass the limits the package was read with); the codec keeps no
+ * copy, but the built-in OpenPGP signer still holds it in memory: openpgp.js
+ * buffers the whole document when detach-signing a stream.
+ * A failure of the package stream (the limit, or the caller's source error
+ * unchanged) wins over whatever the signer made of it. Pass the result as the index
+ * entry's `packageSignature`. Imported packages keep their stored signature
+ * and are never re-signed.
+ */
+export async function signArchPackage(inputArg) {
+    if (inputArg === null || typeof inputArg !== 'object') {
+        throw new LinuxRepoError('invalid-input', 'input must be an object', { field: 'input' });
+    }
+    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' });
+    }
+    const limits = resolveLinuxPackageLimits(inputArg.limits);
+    const source = new PackageByteSource(inputArg.source, limits.maxPackageBytes);
+    let ended = false;
+    let failure;
+    const chunks = async function* () {
+        for (;;) {
+            let chunk;
+            try {
+                chunk = await source.read(READ_CHUNK_BYTES);
+            }
+            catch (error) {
+                failure = { error };
+                throw error;
+            }
+            if (chunk === null) {
+                ended = true;
+                return;
+            }
+            yield chunk;
+        }
+    };
+    let packet;
+    try {
+        packet = await createDetachedBinarySignature({ data: chunks(), signer: inputArg.signer, timestamp: inputArg.timestamp });
+    }
+    catch (error) {
+        throw failure !== undefined ? failure.error : error;
+    }
+    if (failure !== undefined) {
+        throw failure.error;
+    }
+    if (!ended) {
+        throw new LinuxRepoError('signing-failed', 'the signer returned before reading the whole package', {
+            field: 'signer',
+        });
+    }
+    return packet;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/arch/vercmp.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 declare function compareArchVersions(aArg: string, bArg: string): -1 | 0 | 1;

package/dist_ts/arch/vercmp.js

@@ -0,0 +1,170 @@
+/**
+ * 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, bArg) {
+    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;
+}
+const ZERO = Uint8Array.of(0x30);
+function toBytes(valueArg) {
+    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) {
+    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;
+    let versionStart;
+    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, bArg) {
+    if (compareBytes(aArg, 0, aArg.length, bArg, 0, bArg.length) === 0) {
+        return 0;
+    }
+    const at = (bytesArg, indexArg) => (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;
+        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, aStartArg, aEndArg, bArg, bStartArg, bEndArg) {
+    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) {
+    return byteArg >= 0x30 && byteArg <= 0x39;
+}
+function isAlpha(byteArg) {
+    return (byteArg >= 0x41 && byteArg <= 0x5a) || (byteArg >= 0x61 && byteArg <= 0x7a);
+}
+function isAlnum(byteArg) {
+    return isDigit(byteArg) || isAlpha(byteArg);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vercmp.js","sourceRoot":"","sources":["../../ts/arch/vercmp.ts"],"names":[],"mappings":"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"}

package/dist_ts/debian/control.d.ts

@@ -0,0 +1,22 @@
+import type { IDebianPackageMetadata } from '../shared/types.js';
+/** Gitea's distribution and component rule (`metadata.go:67`, applied at upload). */
+export declare const DEBIAN_SYMBOL_PATTERN: RegExp;
+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 declare function parseDebianControlFile(bytesArg: Uint8Array, maxLineBytesArg: number): IDebianControl;