@foss.global/forgefixtures 0.2.0

package/dist_ts/classes.containerlifecycle.js

@@ -0,0 +1,383 @@
+import * as plugins from './plugins.js';
+import { defaultMaxLifetimeMs, defaultPullTimeoutMs } from './constants.js';
+import { ForgeFixtureCertificateAuthority } from './classes.certificateauthority.js';
+import { ForgeFixtureHttpClient } from './classes.httpclient.js';
+import { createForgeFixtureDockerHost, reapStaleForgeFixtures } from './classes.reaper.js';
+import { ForgeFixtureTlsTerminator } from './classes.tlsterminator.js';
+import { createForgeFixtureOwner, forgeFixtureOwnerLabels } from './ownership.js';
+const maxPortAttempts = 5;
+/** Asks the kernel for a currently free loopback port. The caller must tolerate losing a race for it. */
+const reserveLoopbackPort = async () => {
+    const server = plugins.net.createServer();
+    await new Promise((resolveArg, rejectArg) => {
+        server.once('error', rejectArg);
+        server.listen({ host: '127.0.0.1', port: 0, exclusive: true }, () => resolveArg());
+    });
+    const address = server.address();
+    await new Promise((resolveArg) => server.close(() => resolveArg()));
+    if (address === null || typeof address === 'string')
+        throw new Error('The loopback port probe has no TCP address.');
+    return address.port;
+};
+const isPortConflict = (errorArg) => errorArg instanceof Error && /address already in use|port is already allocated/.test(errorArg.message);
+/** Raised by lifecycle steps that observe a stop request. */
+export class ForgeFixtureStoppedError extends Error {
+    constructor(kindArg, optionsArg) {
+        super(`The ${kindArg} fixture was stopped.`, optionsArg);
+        this.name = 'ForgeFixtureStoppedError';
+    }
+}
+/**
+ * Owns one fixture's Docker resources, local CA, TLS terminator and scoped
+ * HTTPS client. Every resource carries ownership labels, so resources left by a
+ * crashed process are removed by the next lifecycle's reaper run.
+ */
+export class ForgeFixtureContainerLifecycle {
+    #kind;
+    #options;
+    #state = 'idle';
+    #dockerHost;
+    #owner;
+    #terminator;
+    #http;
+    #endpoint;
+    #container;
+    #network;
+    #volumes = [];
+    #lastReapReport;
+    #stopController = new AbortController();
+    /** The prepare or container start currently running; `stop()` waits for it before cleaning up. */
+    #inflight;
+    /** Serialises cleanup runs so concurrent stops never remove the same resource twice. */
+    #cleanupQueue = Promise.resolve();
+    constructor(kindArg, optionsArg, startupTimeoutMsArg) {
+        this.#kind = kindArg;
+        this.#options = {
+            ...(optionsArg.dockerSocketPath === undefined ? {} : { dockerSocketPath: optionsArg.dockerSocketPath }),
+            maxLifetimeMs: optionsArg.maxLifetimeMs ?? defaultMaxLifetimeMs,
+            pullTimeoutMs: optionsArg.pullTimeoutMs ?? defaultPullTimeoutMs,
+            startupTimeoutMs: optionsArg.startupTimeoutMs ?? startupTimeoutMsArg,
+        };
+        for (const [name, value] of Object.entries(this.#options)) {
+            if (name !== 'dockerSocketPath' && (!Number.isSafeInteger(value) || value < 1)) {
+                throw new TypeError(`${name} must be a positive integer.`);
+            }
+        }
+    }
+    get state() {
+        return this.#state;
+    }
+    get startupTimeoutMs() {
+        return this.#options.startupTimeoutMs;
+    }
+    get lifecycleId() {
+        return this.#require(this.#owner, 'lifecycle owner').lifecycleId;
+    }
+    get endpoint() {
+        return this.#require(this.#endpoint, 'endpoint');
+    }
+    get http() {
+        return this.#require(this.#http, 'HTTPS client');
+    }
+    get dockerHost() {
+        return this.#require(this.#dockerHost, 'Docker host');
+    }
+    /** Aborted once `stop()` or `requestStop()` was called. */
+    get stopSignal() {
+        return this.#stopController.signal;
+    }
+    /** Throws {@link ForgeFixtureStoppedError} once a stop was requested. */
+    assertNotStopping() {
+        if (this.#stopController.signal.aborted)
+            throw new ForgeFixtureStoppedError(this.#kind);
+    }
+    /**
+     * Once a stop was requested, any failure it provoked (an aborted pull, a
+     * refused request) is reported as {@link ForgeFixtureStoppedError} with the
+     * original failure as its cause.
+     */
+    stopAwareError(errorArg) {
+        if (!this.#stopController.signal.aborted || errorArg instanceof ForgeFixtureStoppedError)
+            return errorArg;
+        return new ForgeFixtureStoppedError(this.#kind, { cause: errorArg });
+    }
+    /**
+     * Marks the lifecycle as stopping without waiting. Running steps observe it
+     * at their next checkpoint, an image pull is cancelled, and the lifecycle can
+     * no longer be prepared or started.
+     */
+    requestStop() {
+        if (!this.#stopController.signal.aborted)
+            this.#stopController.abort(new ForgeFixtureStoppedError(this.#kind));
+    }
+    /** Report of the reaper run that preceded this lifecycle. */
+    get lastReapReport() {
+        return this.#lastReapReport;
+    }
+    /**
+     * Reaps stale fixtures, creates ownership, CA and TLS terminator. The
+     * returned endpoint is final: its port is bound before the forge starts.
+     */
+    async prepare() {
+        this.assertNotStopping();
+        if (this.#state !== 'idle')
+            throw new Error(`Cannot prepare a ${this.#state} lifecycle.`);
+        this.#state = 'preparing';
+        return this.#track(this.#prepare());
+    }
+    async #prepare() {
+        try {
+            this.#dockerHost = createForgeFixtureDockerHost(this.#options.dockerSocketPath);
+            this.#lastReapReport = await reapStaleForgeFixtures(this.#dockerHost);
+            this.assertNotStopping();
+            this.#owner = await createForgeFixtureOwner(this.#kind, this.#options.maxLifetimeMs);
+            const authority = await ForgeFixtureCertificateAuthority.create(this.#owner.lifecycleId, this.#options.maxLifetimeMs + 24 * 60 * 60 * 1000);
+            const certificate = await authority.issueServerCertificate({ ipAddresses: ['127.0.0.1'], dnsNames: ['localhost'] });
+            this.assertNotStopping();
+            this.#terminator = new ForgeFixtureTlsTerminator(certificate);
+            const port = await this.#terminator.listen();
+            this.assertNotStopping();
+            this.#endpoint = { baseUrl: `https://127.0.0.1:${port}`, caCertificatePem: authority.certificatePem };
+            this.#http = new ForgeFixtureHttpClient({ baseUrl: this.#endpoint.baseUrl, caCertificatePem: authority.certificatePem });
+            this.#state = 'prepared';
+            return this.#endpoint;
+        }
+        catch (error) {
+            const reported = this.stopAwareError(error);
+            await this.#failAndCleanup(reported);
+            throw reported;
+        }
+    }
+    /** Pulls the pinned image, creates the owned network and container, starts it and wires the terminator. */
+    async startContainer(specArg) {
+        this.assertNotStopping();
+        if (this.#state !== 'prepared')
+            throw new Error(`Cannot start a container in a ${this.#state} lifecycle.`);
+        this.#state = 'starting';
+        return this.#track(this.#startContainer(specArg));
+    }
+    async #startContainer(specArg) {
+        const dockerHost = this.dockerHost;
+        const owner = this.#require(this.#owner, 'lifecycle owner');
+        const labels = forgeFixtureOwnerLabels(owner);
+        const name = `forgefixtures-${owner.kind}-${owner.lifecycleId}`;
+        try {
+            const image = await dockerHost.pullImage({
+                reference: specArg.image.repoDigest,
+                expectedRepoDigest: specArg.image.repoDigest,
+                signal: AbortSignal.any([AbortSignal.timeout(this.#options.pullTimeoutMs), this.#stopController.signal]),
+            });
+            this.assertNotStopping();
+            this.#network = await dockerHost.createNetwork({ Name: name, Driver: 'bridge', Labels: labels });
+            this.assertNotStopping();
+            for (const volume of specArg.volumes ?? []) {
+                if (!/^[a-z][a-z0-9-]{0,30}$/.test(volume.purpose))
+                    throw new TypeError(`Volume purpose "${volume.purpose}" is malformed.`);
+                this.#volumes.push(await dockerHost.createVolume({ name: `${name}-${volume.purpose}`, labels }));
+                this.assertNotStopping();
+            }
+            // The host port is chosen here rather than by Docker: a rootless daemon allocates
+            // "ephemeral" ports inside its own namespace, blind to host listeners, and then
+            // fails to bind them on the host. A conflict recreates the container on a new port.
+            for (let attempt = 1;; attempt++) {
+                const hostPort = await reserveLoopbackPort();
+                this.#container = await dockerHost.createContainer({
+                    name,
+                    imageId: image.Id,
+                    imageReference: specArg.image.repoDigest,
+                    user: specArg.user,
+                    ...(specArg.allowRootOnRootless ? { allowRootOnRootless: true } : {}),
+                    command: specArg.command,
+                    env: specArg.env,
+                    labels,
+                    stopTimeout: specArg.stopTimeoutSeconds,
+                    memoryBytes: specArg.memoryBytes,
+                    memorySwapBytes: specArg.memoryBytes,
+                    nanoCpus: specArg.nanoCpus,
+                    pidsLimit: specArg.pidsLimit,
+                    ...(specArg.shmSizeBytes === undefined ? {} : { shmSize: specArg.shmSizeBytes }),
+                    ...(specArg.tmpfsMounts === undefined ? {} : { tmpfsMounts: specArg.tmpfsMounts }),
+                    ...(specArg.healthcheck === undefined ? {} : { healthcheck: specArg.healthcheck }),
+                    namedVolumeMounts: (specArg.volumes ?? []).map((volumeArg, indexArg) => ({
+                        source: this.#volumes[indexArg].Name, target: volumeArg.target,
+                    })),
+                    networkEndpoints: [{ networkId: this.#network.Id }],
+                    portBindings: [{ containerPort: specArg.httpPort, hostPort, hostIp: '127.0.0.1', protocol: 'tcp' }],
+                });
+                this.assertNotStopping();
+                try {
+                    await this.#container.start();
+                    break;
+                }
+                catch (error) {
+                    if (attempt >= maxPortAttempts || !isPortConflict(error))
+                        throw error;
+                    await this.#container.remove({ force: true, removeAnonymousVolumes: true });
+                    this.#container = undefined;
+                }
+            }
+            this.assertNotStopping();
+            const publishedPort = await this.#publishedPort(this.#container, specArg.httpPort);
+            this.assertNotStopping();
+            this.#require(this.#terminator, 'TLS terminator').setUpstreamPort(publishedPort);
+            this.#state = 'running';
+        }
+        catch (error) {
+            const reported = this.stopAwareError(error);
+            await this.#failAndCleanup(reported);
+            throw reported;
+        }
+    }
+    /** Runs argv in the container as its configured user. Never logs stdin or output. */
+    async exec(commandArg, optionsArg = {}) {
+        if (this.#state !== 'running')
+            throw new Error(`Cannot exec in a ${this.#state} lifecycle.`);
+        return this.#require(this.#container, 'container').exec(commandArg, optionsArg);
+    }
+    /** Fails with the container's exit state and recent logs when it stopped running. */
+    async assertContainerRunning() {
+        const container = this.#require(this.#container, 'container');
+        const state = await container.inspectState();
+        if (state.Running)
+            return;
+        const logs = await container.logs({ tail: 40 });
+        throw new Error(`The ${this.#kind} fixture container is ${state.Status} (exit ${state.ExitCode}, OOM ${state.OOMKilled}). Last logs:\n${logs}`);
+    }
+    /** Docker's view of the container healthcheck (`none` without a healthcheck). */
+    async containerHealth() {
+        const inspection = await this.#require(this.#container, 'container').inspect();
+        const state = inspection.State;
+        const health = typeof state === 'object' && state !== null ? Reflect.get(state, 'Health') : undefined;
+        if (health === undefined || health === null)
+            return 'none';
+        const status = typeof health === 'object' ? Reflect.get(health, 'Status') : undefined;
+        if (status === 'starting' || status === 'healthy' || status === 'unhealthy')
+            return status;
+        throw new Error('Docker reported a malformed container health status.');
+    }
+    /** Recent container logs, for diagnostics after a failed readiness wait. */
+    async logsTail(linesArg) {
+        return this.#require(this.#container, 'container').logs({ tail: linesArg });
+    }
+    /**
+     * Requests a stop, waits for a running prepare or container start to observe
+     * it, then removes every owned resource in dependency order, including those
+     * that step created. Idempotent. When a removal fails, the remaining
+     * resources stay recorded and a later call retries them; the failures are
+     * thrown together.
+     */
+    async stop() {
+        this.requestStop();
+        const inflight = this.#inflight;
+        if (inflight)
+            await inflight.catch(() => undefined);
+        await this.#cleanup();
+    }
+    async #track(operationArg) {
+        this.#inflight = operationArg;
+        try {
+            return await operationArg;
+        }
+        finally {
+            if (this.#inflight === operationArg)
+                this.#inflight = undefined;
+        }
+    }
+    #cleanup() {
+        const run = this.#cleanupQueue.catch(() => undefined).then(() => this.#removeResources());
+        this.#cleanupQueue = run;
+        return run;
+    }
+    async #removeResources() {
+        if (!this.#hasResources()) {
+            this.#http = undefined;
+            this.#endpoint = undefined;
+            this.#state = 'stopped';
+            return;
+        }
+        this.#state = 'stopping';
+        const failures = [];
+        const attempt = async (operationArg) => {
+            try {
+                await operationArg();
+            }
+            catch (error) {
+                failures.push(error);
+            }
+        };
+        this.#http?.close();
+        this.#http = undefined;
+        await attempt(async () => {
+            await this.#terminator?.close();
+            this.#terminator = undefined;
+        });
+        await attempt(async () => {
+            await this.#container?.remove({ force: true, removeAnonymousVolumes: true });
+            this.#container = undefined;
+        });
+        await attempt(async () => {
+            if (this.#container)
+                return;
+            await this.#network?.remove();
+            this.#network = undefined;
+        });
+        while (this.#volumes.length > 0 && !this.#container) {
+            const volume = this.#volumes[0];
+            try {
+                await volume.remove({ force: true });
+                this.#volumes.shift();
+            }
+            catch (error) {
+                failures.push(error);
+                break;
+            }
+        }
+        if (!this.#hasResources()) {
+            await attempt(async () => {
+                await this.#dockerHost?.stop();
+                this.#dockerHost = undefined;
+            });
+        }
+        this.#endpoint = undefined;
+        this.#state = this.#hasResources() ? 'stopping' : 'stopped';
+        if (failures.length > 0) {
+            throw new AggregateError(failures, `The ${this.#kind} fixture ${this.#owner?.lifecycleId ?? ''} did not clean up completely.`);
+        }
+    }
+    #hasResources() {
+        return this.#terminator !== undefined || this.#container !== undefined
+            || this.#network !== undefined || this.#volumes.length > 0 || this.#dockerHost !== undefined;
+    }
+    async #failAndCleanup(errorArg) {
+        try {
+            await this.#cleanup();
+        }
+        catch (cleanupError) {
+            throw new AggregateError([errorArg, cleanupError], `The ${this.#kind} fixture failed to start and to clean up.`);
+        }
+    }
+    async #publishedPort(containerArg, containerPortArg) {
+        const inspection = await containerArg.inspect();
+        const settings = inspection.NetworkSettings;
+        const ports = typeof settings === 'object' && settings !== null ? Reflect.get(settings, 'Ports') : undefined;
+        const bindings = typeof ports === 'object' && ports !== null ? Reflect.get(ports, `${containerPortArg}/tcp`) : undefined;
+        if (Array.isArray(bindings)) {
+            for (const binding of bindings) {
+                if (typeof binding !== 'object' || binding === null)
+                    continue;
+                const hostIp = Reflect.get(binding, 'HostIp');
+                const hostPort = Reflect.get(binding, 'HostPort');
+                if (hostIp === '127.0.0.1' && typeof hostPort === 'string' && /^[0-9]{1,5}$/.test(hostPort)) {
+                    return Number(hostPort);
+                }
+            }
+        }
+        throw new Error(`Docker did not publish container port ${containerPortArg} on 127.0.0.1.`);
+    }
+    #require(valueArg, nameArg) {
+        if (valueArg === undefined)
+            throw new Error(`The ${this.#kind} fixture has no ${nameArg} in state ${this.#state}.`);
+        return valueArg;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.containerlifecycle.js","sourceRoot":"","sources":["../ts/classes.containerlifecycle.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.giteafixture.d.ts

@@ -0,0 +1,41 @@
+import type { ForgeFixtureHttpClient } from './classes.httpclient.js';
+import type { IForgeFixtureLifecycleOptions, IForgeFixtureReapReport, IGiteaFixtureRuntime } from './interfaces.js';
+export interface IGiteaFixtureOptions extends IForgeFixtureLifecycleOptions {
+    /** Container memory limit; swap is disabled. Defaults to 512 MiB. */
+    memoryBytes?: number;
+    /** CPU limit in billionths of a CPU. Defaults to 2 CPUs. */
+    nanoCpus?: number;
+}
+export interface IGiteaAccessTokenRequest {
+    username: string;
+    /** Unique per user. */
+    tokenName: string;
+    /** Gitea scopes such as `all`, `public-only` or `read:repository`. */
+    scopes: string[];
+}
+/**
+ * A disposable Gitea instance from the pinned rootless image, served over
+ * verified loopback TLS, with SQLite and all data in one owned named volume.
+ */
+export declare class GiteaFixture {
+    #private;
+    constructor(optionsArg?: IGiteaFixtureOptions);
+    get runtime(): IGiteaFixtureRuntime;
+    /** HTTPS client scoped to this fixture's origin and CA. */
+    get http(): ForgeFixtureHttpClient;
+    /** Report of the stale-fixture reaper run that preceded this start. */
+    get reapReport(): IForgeFixtureReapReport | undefined;
+    /**
+     * Starts the fixture and returns once Gitea answers with the pinned version
+     * and an admin token exists. A fixture starts at most once.
+     */
+    start(): Promise<IGiteaFixtureRuntime>;
+    /** Creates an access token through Gitea's supported admin CLI. The token is returned, never logged. */
+    createAccessToken(requestArg: IGiteaAccessTokenRequest): Promise<string>;
+    /**
+     * Removes every resource of this fixture. A start in progress is cancelled at
+     * its next checkpoint and awaited first, so nothing it created survives.
+     * Idempotent; retries incomplete cleanup.
+     */
+    stop(): Promise<void>;
+}

package/dist_ts/classes.giteafixture.js

@@ -0,0 +1,182 @@
+import * as plugins from './plugins.js';
+import { giteaFixtureImage } from './constants.js';
+import { ForgeFixtureContainerLifecycle } from './classes.containerlifecycle.js';
+const httpPort = 3000;
+const dataDirectory = '/var/lib/gitea';
+/** The configuration lives in the owned data volume, whose directories belong to the Gitea user. */
+const appIni = `${dataDirectory}/conf/app.ini`;
+const giteaBinary = '/usr/local/bin/gitea';
+const adminUsername = 'forgeadmin';
+const usernamePattern = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,38}$/;
+const scopePattern = /^(all|public-only|(read|write):[a-z]+)$/;
+const tokenPattern = /^[0-9a-f]{40}$/;
+const execTimeoutMs = 60_000;
+const sleep = (msArg) => new Promise((resolveArg) => setTimeout(resolveArg, msArg));
+/**
+ * A disposable Gitea instance from the pinned rootless image, served over
+ * verified loopback TLS, with SQLite and all data in one owned named volume.
+ */
+export class GiteaFixture {
+    #options;
+    #lifecycle;
+    #runtime;
+    #starting;
+    constructor(optionsArg = {}) {
+        this.#options = { ...optionsArg };
+        this.#lifecycle = new ForgeFixtureContainerLifecycle('gitea', optionsArg, 120_000);
+    }
+    get runtime() {
+        if (!this.#runtime)
+            throw new Error('The Gitea fixture is not running.');
+        return this.#runtime;
+    }
+    /** HTTPS client scoped to this fixture's origin and CA. */
+    get http() {
+        return this.#lifecycle.http;
+    }
+    /** Report of the stale-fixture reaper run that preceded this start. */
+    get reapReport() {
+        return this.#lifecycle.lastReapReport;
+    }
+    /**
+     * Starts the fixture and returns once Gitea answers with the pinned version
+     * and an admin token exists. A fixture starts at most once.
+     */
+    start() {
+        if (this.#starting)
+            return Promise.reject(new Error('The Gitea fixture was already started.'));
+        this.#starting = this.#start();
+        return this.#starting;
+    }
+    async #start() {
+        const endpoint = await this.#lifecycle.prepare();
+        try {
+            await this.#lifecycle.startContainer({
+                image: giteaFixtureImage,
+                user: '1000:1000',
+                command: [giteaBinary, '--config', appIni, 'web'],
+                env: {
+                    GITEA_APP_INI: appIni,
+                    GITEA__security__INSTALL_LOCK: 'true',
+                    GITEA__security__SECRET_KEY: plugins.crypto.randomBytes(32).toString('hex'),
+                    GITEA__server__ROOT_URL: `${endpoint.baseUrl}/`,
+                    GITEA__server__DOMAIN: '127.0.0.1',
+                    GITEA__server__SSH_DOMAIN: '127.0.0.1',
+                    GITEA__server__HTTP_PORT: String(httpPort),
+                    GITEA__server__LFS_START_SERVER: 'true',
+                    GITEA__server__OFFLINE_MODE: 'true',
+                    GITEA__service__DISABLE_REGISTRATION: 'true',
+                    GITEA__database__DB_TYPE: 'sqlite3',
+                    GITEA__log__LEVEL: 'Warn',
+                },
+                httpPort,
+                // Git hooks live in the data directory and must be executable, so it is an owned
+                // named volume (Docker mounts tmpfs noexec). It is removed with the lifecycle.
+                volumes: [{ purpose: 'data', target: dataDirectory }],
+                // Declared image volume, unused because the configuration lives in the data volume;
+                // mounted so Docker creates no anonymous volume for it.
+                tmpfsMounts: [{ target: '/etc/gitea', sizeBytes: 1024 * 1024 }],
+                memoryBytes: this.#options.memoryBytes ?? 512 * 1024 * 1024,
+                nanoCpus: this.#options.nanoCpus ?? 2_000_000_000,
+                pidsLimit: 512,
+                stopTimeoutSeconds: 10,
+            });
+            await this.#waitForHealth(Date.now() + this.#lifecycle.startupTimeoutMs);
+            const version = await this.#readVersion();
+            this.#lifecycle.assertNotStopping();
+            if (version !== giteaFixtureImage.version) {
+                throw new Error(`Gitea reports version ${version}; the pinned image is ${giteaFixtureImage.version}.`);
+            }
+            await this.#giteaCli([
+                'admin', 'user', 'create', '--username', adminUsername, '--email', `${adminUsername}@example.com`,
+                '--random-password', '--admin', '--must-change-password=false',
+            ], 'create the fixture administrator');
+            const token = await this.createAccessToken({ username: adminUsername, tokenName: 'forgefixtures-admin', scopes: ['all'] });
+            this.#lifecycle.assertNotStopping();
+            this.#runtime = {
+                kind: 'gitea',
+                lifecycleId: this.#lifecycle.lifecycleId,
+                baseUrl: endpoint.baseUrl,
+                caCertificatePem: endpoint.caCertificatePem,
+                version,
+                image: giteaFixtureImage,
+                admin: { username: adminUsername, token },
+            };
+            return this.#runtime;
+        }
+        catch (error) {
+            const reported = this.#lifecycle.stopAwareError(error);
+            try {
+                await this.#lifecycle.stop();
+            }
+            catch (cleanupError) {
+                throw new AggregateError([reported, cleanupError], 'The Gitea fixture failed to start and to clean up.');
+            }
+            throw reported;
+        }
+    }
+    /** Creates an access token through Gitea's supported admin CLI. The token is returned, never logged. */
+    async createAccessToken(requestArg) {
+        if (!usernamePattern.test(requestArg.username) || !/^[A-Za-z0-9_.-]{1,64}$/.test(requestArg.tokenName)
+            || requestArg.scopes.length === 0 || !requestArg.scopes.every((scopeArg) => scopePattern.test(scopeArg))) {
+            throw new TypeError('The access token request is malformed.');
+        }
+        const stdout = await this.#giteaCli([
+            'admin', 'user', 'generate-access-token', '--username', requestArg.username,
+            '--token-name', requestArg.tokenName, '--scopes', requestArg.scopes.join(','), '--raw',
+        ], `create an access token for ${requestArg.username}`);
+        const token = stdout.trim();
+        if (!tokenPattern.test(token))
+            throw new Error('Gitea returned an access token in an unexpected format.');
+        return token;
+    }
+    /**
+     * Removes every resource of this fixture. A start in progress is cancelled at
+     * its next checkpoint and awaited first, so nothing it created survives.
+     * Idempotent; retries incomplete cleanup.
+     */
+    async stop() {
+        this.#runtime = undefined;
+        this.#lifecycle.requestStop();
+        const starting = this.#starting;
+        if (starting)
+            await starting.catch(() => undefined);
+        await this.#lifecycle.stop();
+    }
+    async #waitForHealth(deadlineArg) {
+        let lastFailure = 'no attempt';
+        while (Date.now() < deadlineArg) {
+            this.#lifecycle.assertNotStopping();
+            await this.#lifecycle.assertContainerRunning();
+            try {
+                const response = await this.#lifecycle.http.request({
+                    method: 'GET', url: '/api/healthz', expectedStatus: [200, 503], timeoutMs: 5_000,
+                });
+                if (response.status === 200)
+                    return;
+                lastFailure = `status ${response.status}`;
+            }
+            catch (error) {
+                lastFailure = error instanceof Error ? error.message : String(error);
+            }
+            await sleep(500);
+        }
+        throw new Error(`Gitea did not become healthy within ${this.#lifecycle.startupTimeoutMs} ms (${lastFailure}). Last logs:\n${await this.#lifecycle.logsTail(40)}`);
+    }
+    async #readVersion() {
+        const body = await this.#lifecycle.http.requestJson({ method: 'GET', url: '/api/v1/version', expectedStatus: [200] });
+        const version = typeof body === 'object' && body !== null ? Reflect.get(body, 'version') : undefined;
+        if (typeof version !== 'string')
+            throw new Error('Gitea answered /api/v1/version without a version.');
+        return version;
+    }
+    /** Runs the Gitea CLI as the Gitea user. Output is returned but never included in errors. */
+    async #giteaCli(argsArg, purposeArg) {
+        const result = await this.#lifecycle.exec([giteaBinary, '--config', appIni, ...argsArg], { timeoutMs: execTimeoutMs });
+        if (result.exitCode !== 0) {
+            throw new Error(`Gitea CLI failed to ${purposeArg} (exit ${result.exitCode}): ${result.stderr.slice(0, 1024)}`);
+        }
+        return result.stdout;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.giteafixture.js","sourceRoot":"","sources":["../ts/classes.giteafixture.ts"],"names":[],"mappings":"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"}