@leera.io/qa-runner 1.0.0

package/dist/src/ci/client.js

@@ -0,0 +1,90 @@
+import { openAsBlob } from 'node:fs';
+import { ApiError } from '../client.js';
+export const CI_PATHS = {
+    runs: '/api/v1/qa/runner/runs',
+    status: '/api/v1/qa/runner/runs/status',
+    cancel: '/api/v1/qa/runner/runs/cancel',
+    builds: '/api/v1/qa/runner/builds',
+    finish: '/api/v1/qa/runner/builds/finish',
+    content: '/api/v1/qa/runner/builds/content',
+};
+/** CI-token calls: runs and build uploads (contracts §J). */
+export class CiClient {
+    base;
+    token;
+    fetchImpl;
+    constructor(baseUrl, token, fetchImpl = fetch) {
+        this.base = baseUrl.replace(/\/+$/, '');
+        this.token = token;
+        this.fetchImpl = fetchImpl;
+    }
+    async createRun(body) {
+        const run = await this.post(CI_PATHS.runs, body);
+        return { ...run, skipped: run.skipped ?? [], report_url: run.report_url ?? null };
+    }
+    runStatus(runId) {
+        return this.post(CI_PATHS.status, { run_id: runId });
+    }
+    async cancelRun(runId) {
+        const result = await this.post(CI_PATHS.cancel, { run_id: runId });
+        return result.cancelled ?? 0;
+    }
+    createBuild(body) {
+        return this.post(CI_PATHS.builds, body);
+    }
+    finishBuild(buildId) {
+        return this.post(CI_PATHS.finish, { build_id: buildId }, 5 * 60_000);
+    }
+    /** Sends the file through the server (for storage the CI machine cannot reach directly). */
+    async relayBuild(buildId, path, fileName, contentType) {
+        const form = new FormData();
+        form.append('file', await openAsBlob(path, { type: contentType }), fileName);
+        return this.request(`${CI_PATHS.content}?build_id=${buildId}`, { method: 'POST', body: form }, 60 * 60_000);
+    }
+    /** PUTs the file to the presigned upload URL with the headers the server asked for. */
+    async putPresigned(upload, path, contentType) {
+        const url = new URL(upload.url);
+        if (url.protocol !== 'https:' && url.protocol !== 'http:')
+            throw new Error(`refusing to upload to a ${url.protocol} URL`);
+        // Case-insensitive: the server's headers (signed into the URL) win over the guessed type.
+        const headers = new Headers({ 'content-type': contentType });
+        for (const [name, value] of Object.entries(upload.headers ?? {}))
+            headers.set(name, value);
+        const response = await this.fetchImpl(url, {
+            method: upload.method || 'PUT',
+            headers,
+            body: await openAsBlob(path, { type: contentType }),
+            signal: AbortSignal.timeout(60 * 60_000),
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`the upload URL answered HTTP ${response.status}${text ? `: ${text.slice(0, 200)}` : ''}`);
+        }
+    }
+    post(path, body, timeoutMs = 60_000) {
+        return this.request(path, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) }, timeoutMs);
+    }
+    async request(path, init, timeoutMs) {
+        const response = await this.fetchImpl(this.base + path, {
+            ...init,
+            headers: { ...init.headers, authorization: `Bearer ${this.token}` },
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        const text = await response.text();
+        let payload = null;
+        try {
+            payload = text ? JSON.parse(text) : null;
+        }
+        catch {
+            payload = null;
+        }
+        if (!response.ok) {
+            const message = payload?.message || payload?.error_message || `HTTP ${response.status}`;
+            throw new ApiError(message, response.status, payload);
+        }
+        const data = payload && typeof payload === 'object' && 'data' in payload ? payload.data : payload;
+        if (data === null || data === undefined)
+            throw new ApiError('the server returned no data', 502);
+        return data;
+    }
+}

package/dist/src/ci/env.js

@@ -0,0 +1,118 @@
+import { execFileSync } from 'node:child_process';
+import { basename } from 'node:path';
+export const defaultGit = (args) => {
+    try {
+        const out = execFileSync('git', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 5_000 }).trim();
+        return out || null;
+    }
+    catch {
+        return null;
+    }
+};
+function value(env, ...names) {
+    for (const name of names) {
+        const text = env[name]?.trim();
+        if (text)
+            return text;
+    }
+    return null;
+}
+function truthy(raw) {
+    return ['1', 'true', 'yes'].includes((raw ?? '').trim().toLowerCase());
+}
+/** Detects GitHub Actions, GitLab CI, Buildkite, CircleCI, a generic `CI=true` and falls back to git. */
+export function detectCi(env, git = defaultGit, now = Date.now) {
+    let info;
+    if (truthy(env.GITHUB_ACTIONS)) {
+        const server = value(env, 'GITHUB_SERVER_URL') ?? 'https://github.com';
+        const repository = value(env, 'GITHUB_REPOSITORY');
+        const runId = value(env, 'GITHUB_RUN_ID');
+        info = {
+            provider: 'github',
+            sha: value(env, 'GITHUB_SHA'),
+            // Pull request builds check out a merge ref; the head branch is what people recognise.
+            branch: value(env, 'GITHUB_HEAD_REF', 'GITHUB_REF_NAME'),
+            url: repository && runId ? `${server.replace(/\/+$/, '')}/${repository}/actions/runs/${runId}` : null,
+            repo: repository ? basename(repository) : null,
+            run: runId,
+            attempt: value(env, 'GITHUB_RUN_ATTEMPT'),
+        };
+    }
+    else if (truthy(env.GITLAB_CI)) {
+        info = {
+            provider: 'gitlab',
+            sha: value(env, 'CI_COMMIT_SHA'),
+            branch: value(env, 'CI_MERGE_REQUEST_SOURCE_BRANCH_NAME', 'CI_COMMIT_BRANCH', 'CI_COMMIT_REF_NAME'),
+            url: value(env, 'CI_JOB_URL', 'CI_PIPELINE_URL'),
+            repo: value(env, 'CI_PROJECT_NAME'),
+            run: value(env, 'CI_PIPELINE_ID'),
+            // A retried GitLab job gets a new job id.
+            attempt: value(env, 'CI_JOB_ID'),
+        };
+    }
+    else if (truthy(env.BUILDKITE)) {
+        const retries = Number.parseInt(env.BUILDKITE_RETRY_COUNT ?? '', 10);
+        info = {
+            provider: 'buildkite',
+            sha: value(env, 'BUILDKITE_COMMIT'),
+            branch: value(env, 'BUILDKITE_BRANCH'),
+            url: value(env, 'BUILDKITE_BUILD_URL'),
+            repo: value(env, 'BUILDKITE_PIPELINE_SLUG'),
+            run: value(env, 'BUILDKITE_BUILD_NUMBER'),
+            attempt: Number.isFinite(retries) ? String(retries + 1) : '1',
+        };
+    }
+    else if (truthy(env.CIRCLECI)) {
+        const node = Number.parseInt(env.CIRCLE_NODE_INDEX ?? '', 10);
+        info = {
+            provider: 'circleci',
+            sha: value(env, 'CIRCLE_SHA1'),
+            branch: value(env, 'CIRCLE_BRANCH'),
+            url: value(env, 'CIRCLE_BUILD_URL'),
+            repo: value(env, 'CIRCLE_PROJECT_REPONAME'),
+            run: value(env, 'CIRCLE_BUILD_NUM'),
+            attempt: Number.isFinite(node) ? String(node + 1) : '1',
+        };
+    }
+    else {
+        info = {
+            provider: truthy(env.CI) ? 'ci' : 'local',
+            sha: null,
+            branch: null,
+            url: null,
+            repo: null,
+            run: null,
+            attempt: null,
+        };
+    }
+    // Fill what the provider did not say from git.
+    if (!info.sha)
+        info.sha = git(['rev-parse', 'HEAD']);
+    if (!info.branch) {
+        const branch = git(['rev-parse', '--abbrev-ref', 'HEAD']);
+        info.branch = branch && branch !== 'HEAD' ? branch : null;
+    }
+    if (!info.repo) {
+        const top = git(['rev-parse', '--show-toplevel']);
+        info.repo = top ? basename(top) : null;
+    }
+    if (!info.run)
+        info.run = String(Math.floor(now() / 1000));
+    if (!info.attempt)
+        info.attempt = '1';
+    return info;
+}
+/** `ci-<repo>-<run>-<attempt>`, restricted to safe characters and the server's 100-character limit. */
+export function ciRunnerName(info) {
+    const part = (text, fallback) => (text ?? fallback)
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '') || fallback;
+    const suffix = `-${part(info.run, 'run')}-${part(info.attempt, '1')}`.slice(-60);
+    return `ci-${part(info.repo, 'repo').slice(0, 100 - 3 - suffix.length)}${suffix}`;
+}
+/** A readable default run name such as `CI main@1a2b3c4`. */
+export function defaultRunName(info, platform) {
+    const where = [info.branch, info.sha ? info.sha.slice(0, 7) : null].filter(Boolean).join('@');
+    return `CI ${platform}${where ? ` ${where}` : ''}`;
+}

package/dist/src/ci/junit.js

@@ -0,0 +1,79 @@
+export function xmlEscape(text) {
+    return (text
+        // Characters XML 1.0 does not allow at all.
+        // biome-ignore lint/suspicious/noControlCharactersInRegex: stripping control characters is the point
+        .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\uFFFE\uFFFF]/g, '')
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;'));
+}
+/**
+ * JUnit XML: one testcase per item this runner executed (failed → `<failure>`, error →
+ * `<error>`, blocked/skipped → `<skipped>`) plus one skipped testcase per item the server did
+ * not queue. Items executed elsewhere only appear in the suite properties' counts.
+ */
+export function formatJunit(outcome) {
+    const suite = outcome.runName;
+    const classname = `leera.${outcome.platform}`;
+    const cases = [];
+    let failures = 0;
+    let errors = 0;
+    let skipped = 0;
+    let time = 0;
+    for (const item of [...outcome.items].sort((a, b) => a.item_id - b.item_id)) {
+        time += item.elapsed_secs;
+        const open = `    <testcase name="${xmlEscape(item.title)}" classname="${xmlEscape(classname)}" time="${item.elapsed_secs.toFixed(3)}">`;
+        const message = item.failures[0] ?? item.notes;
+        const body = [item.failures.join('\n'), item.notes].filter(Boolean).join('\n\n');
+        switch (item.result) {
+            case 'passed':
+                cases.push(`${open}</testcase>`);
+                break;
+            case 'failed':
+                failures++;
+                cases.push(`${open}\n      <failure message="${xmlEscape(message)}" type="failed">${xmlEscape(body)}</failure>\n    </testcase>`);
+                break;
+            case 'error':
+                errors++;
+                cases.push(`${open}\n      <error message="${xmlEscape(message)}" type="error">${xmlEscape(body)}</error>\n    </testcase>`);
+                break;
+            default:
+                skipped++;
+                cases.push(`${open}\n      <skipped message="${xmlEscape(`${item.result}: ${message}`)}"/>\n    </testcase>`);
+        }
+    }
+    for (const item of outcome.created.skipped) {
+        skipped++;
+        cases.push(`    <testcase name="${xmlEscape(item.title)}" classname="${xmlEscape(classname)}" time="0">\n      <skipped message="${xmlEscape(`not queued: ${item.reason}`)}"/>\n    </testcase>`);
+    }
+    const properties = [
+        ['run_id', String(outcome.runId)],
+        ['platform', outcome.platform],
+    ];
+    const report = outcome.status?.report_url ?? outcome.created.report_url;
+    if (report)
+        properties.push(['report_url', report]);
+    if (outcome.status) {
+        properties.push(['status', outcome.status.status]);
+        for (const [key, value] of Object.entries(outcome.status.items))
+            properties.push([`items.${key}`, String(value)]);
+    }
+    if (outcome.ended)
+        properties.push(['ended', outcome.ended]);
+    const tests = cases.length;
+    const attrs = `name="${xmlEscape(suite)}" tests="${tests}" failures="${failures}" errors="${errors}" skipped="${skipped}" time="${time.toFixed(3)}"`;
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        `<testsuites ${attrs}>`,
+        `  <testsuite ${attrs}>`,
+        '    <properties>',
+        ...properties.map(([name, value]) => `      <property name="${xmlEscape(name)}" value="${xmlEscape(value)}"/>`),
+        '    </properties>',
+        ...cases,
+        '  </testsuite>',
+        '</testsuites>',
+        '',
+    ].join('\n');
+}

package/dist/src/ci/run.js

@@ -0,0 +1,320 @@
+import { appendFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { buildCapabilities, detect, hostInfo } from '../capabilities.js';
+import { ApiError, RunnerClient } from '../client.js';
+import { registerLocalBuild, unregisterLocalBuild } from '../builds/install.js';
+import { resolveConfig } from '../config.js';
+import { DeviceManager } from '../devices/manager.js';
+import { BROWSER_DEVICE_ID, isPlatform } from '../devices/types.js';
+import { ExitCode, ExitError, messageOf } from '../errors.js';
+import { Runner } from '../runner.js';
+import { RUNNER_VERSION } from '../version.js';
+import { describeBuildFile, projectSelector, uploadBuild } from './builds.js';
+import { CiClient } from './client.js';
+import { ciRunnerName, defaultRunName, detectCi } from './env.js';
+import { formatJunit } from './junit.js';
+import { CiExit, exitCodeFor, formatMarkdown, formatSummary } from './summary.js';
+export const STATUS_POLL_MS = 10_000;
+export const DEFAULT_TIMEOUT_MINUTES = 60;
+export const VIDEO_MODES = ['off', 'on_failure', 'always'];
+function sleep(ms) {
+    let timer;
+    let resolveFn = () => undefined;
+    const promise = new Promise((resolve) => {
+        resolveFn = resolve;
+        timer = setTimeout(resolve, ms);
+    });
+    return {
+        promise,
+        cancel: () => {
+            clearTimeout(timer);
+            resolveFn();
+        },
+    };
+}
+function numeric(text) {
+    return text !== undefined && /^\d+$/.test(text) ? Number(text) : undefined;
+}
+/** Maps HTTP refusals to the CLI's exit codes. */
+function apiExit(error, what) {
+    if (error instanceof ApiError) {
+        if (error.status === 401 || error.status === 403) {
+            throw new ExitError(ExitCode.tokenRejected, `${what}: the server refused the token (${error.status} ${error.message}); use a CI token of the project`);
+        }
+        if (error.status === 426)
+            throw new ExitError(ExitCode.versionRefused, error.message);
+        if (error.status === 400 || error.status === 404 || error.status === 422) {
+            throw new ExitError(ExitCode.usage, `${what}: ${error.message}`);
+        }
+    }
+    throw new ExitError(ExitCode.error, `${what}: ${messageOf(error)}`);
+}
+/**
+ * `leera-qa-runner ci` (plan §8): doctor → CI facts → build → register an ephemeral runner →
+ * `POST /runs` → run the jobs bound to that run while polling `/runs/status` → summary,
+ * `$GITHUB_STEP_SUMMARY`, JUnit → exit code.
+ *
+ * Registration order: the runner registers once without `run_id` (the server needs its id to
+ * pin jobs of a local build), creates the run with that `runner_id`, then registers again with
+ * `run_id` — registration is idempotent on the runner name — before claiming with `run_id`.
+ */
+export async function runCi(flags, deps) {
+    const { env, log } = deps;
+    const started = (deps.now ?? Date.now)();
+    const elapsed = () => ((deps.now ?? Date.now)() - started) / 1000;
+    if (!isPlatform(flags.platform) || !deps.registry.has(flags.platform)) {
+        throw new ExitError(ExitCode.usage, `this runner version cannot run '${flags.platform}' jobs (supported: ${[...deps.registry.keys()].join(', ')})`);
+    }
+    const platform = flags.platform;
+    if (flags.build && flags.buildId !== undefined)
+        throw new ExitError(ExitCode.usage, 'pass either --build or --build-id, not both');
+    if (flags.uploadBuild && !flags.build)
+        throw new ExitError(ExitCode.usage, '--upload-build needs --build PATH');
+    if (flags.build && platform === 'web')
+        throw new ExitError(ExitCode.usage, 'web runs do not take a build');
+    if (flags.uploadBuild && !flags.project) {
+        // The server can fall back to the token's project; say so only in the log.
+        log.debug('no --project: the build is uploaded to the CI token project');
+    }
+    if (!flags.skipDoctor && deps.doctor) {
+        const report = await deps.doctor(platform);
+        if (!report.ok) {
+            deps.print(report.text);
+            throw new ExitError(ExitCode.environmentNotReady, `this machine is not ready to run ${platform} jobs (see the checks above)`);
+        }
+    }
+    const ci = detectCi(env, deps.git, deps.now);
+    const runnerName = ciRunnerName(ci);
+    const host = deps.host ?? hostInfo();
+    const detection = await detect(deps.registry, host);
+    const config = {
+        ...resolveConfig({
+            flags: {
+                name: runnerName,
+                ...(flags.labels ? { labels: flags.labels } : {}),
+                ...(flags.concurrency ? { concurrency: flags.concurrency } : {}),
+            },
+            env: { ...env, RUNNER_NAME: undefined, RUNNER_RUN_ID: undefined, RUNNER_ONCE: undefined },
+            file: null,
+            detectedLabels: detection.labels,
+        }),
+        once: false,
+    };
+    const client = new RunnerClient(config.url, config.token);
+    const ciClient = new CiClient(config.url, config.token, deps.fetchImpl);
+    log.info('ci', { provider: ci.provider, sha: ci.sha, branch: ci.branch, runner: runnerName, platform });
+    // The build under test.
+    let buildId = flags.buildId ?? null;
+    let local = null;
+    if (flags.build) {
+        const file = await describeBuildFile(flags.build);
+        if (flags.uploadBuild) {
+            let build;
+            try {
+                build = await uploadBuild(ciClient, {
+                    file,
+                    platform,
+                    ...(flags.project ? { project: flags.project } : {}),
+                    meta: {
+                        ...(flags.versionName ? { version_name: flags.versionName } : {}),
+                        ...(flags.buildNumber ? { build_number: flags.buildNumber } : {}),
+                        ...(ci.sha ? { git_sha: ci.sha } : {}),
+                        ...(ci.branch ? { git_branch: ci.branch } : {}),
+                    },
+                    log,
+                });
+            }
+            catch (error) {
+                apiExit(error, 'the build upload failed');
+            }
+            buildId = build.id;
+            log.info('build uploaded', { build_id: build.id, status: build.status });
+        }
+        else {
+            local = file;
+        }
+    }
+    const devices = new DeviceManager(detection.devices, (device) => device.id === BROWSER_DEVICE_ID ? config.concurrency.web : 1);
+    const baseRegistration = {
+        name: runnerName,
+        labels: config.labels,
+        version: RUNNER_VERSION,
+        os: host.os,
+        arch: host.arch,
+        hostname: host.hostname,
+        ephemeral: true,
+        capabilities: buildCapabilities(devices.capabilityDevices(), host),
+    };
+    let runnerId;
+    try {
+        runnerId = (await client.register(baseRegistration)).runner_id;
+    }
+    catch (error) {
+        apiExit(error, 'registering the runner failed');
+    }
+    const project = projectSelector(flags.project);
+    const planId = numeric(flags.plan);
+    const environmentId = numeric(flags.environment);
+    const runName = flags.name ?? defaultRunName(ci, platform);
+    const body = {
+        ...project,
+        ...(flags.plan === undefined ? { plan_id: null } : planId !== undefined ? { plan_id: planId } : { plan_name: flags.plan }),
+        ...(environmentId !== undefined ? { environment_id: environmentId } : { environment_slug: flags.environment }),
+        platform,
+        build_id: buildId,
+        build: buildId === null && !local && (flags.versionName || flags.buildNumber)
+            ? { version_name: flags.versionName ?? null, build_number: flags.buildNumber ?? null }
+            : null,
+        name: runName,
+        runner_id: runnerId,
+        git: { sha: ci.sha, branch: ci.branch },
+        ci: { provider: ci.provider, url: ci.url },
+        video: flags.video ?? 'on_failure',
+        local_build: local ? { file_name: local.file_name, sha256: local.sha256, size_bytes: local.size_bytes } : null,
+    };
+    let created;
+    try {
+        created = await ciClient.createRun(body);
+    }
+    catch (error) {
+        apiExit(error, 'creating the test run failed');
+    }
+    const runId = created.run_id;
+    log.info('run created', { run_id: runId, queued: created.queued, skipped: created.skipped.length, report_url: created.report_url });
+    const items = new Map();
+    const outcome = (status, ended) => ({
+        runId,
+        runName,
+        platform,
+        created,
+        status,
+        items: [...items.values()],
+        ...(ended ? { ended } : {}),
+        elapsedSecs: elapsed(),
+    });
+    if (created.queued === 0) {
+        const status = await ciClient.runStatus(runId).catch(() => null);
+        finish(flags, deps, outcome(status), CiExit.error);
+        throw new ExitError(ExitCode.error, `nothing was queued: no test case of run #${runId} has a ${platform} script`);
+    }
+    if (local)
+        registerLocalBuild(local.sha256, local.path);
+    const runner = new Runner({ ...config, runId }, {
+        client,
+        registry: deps.registry,
+        devices,
+        host,
+        shared: deps.shared,
+        log,
+        version: RUNNER_VERSION,
+        ephemeral: true,
+        ...(deps.paths ? { paths: deps.paths } : {}),
+        onJobFinished: (event) => {
+            if (event.result === 'cancelled')
+                return;
+            const previous = items.get(event.item_id);
+            // A job error is retried by the server; a later result for the item replaces it.
+            if (previous && previous.attempt > event.attempt)
+                return;
+            items.set(event.item_id, {
+                item_id: event.item_id,
+                title: event.title,
+                result: event.result,
+                notes: event.notes,
+                failures: event.failures,
+                elapsed_secs: event.elapsed_secs,
+                attempt: event.attempt,
+            });
+        },
+    });
+    let runnerError = null;
+    let runnerDone = false;
+    const running = runner.run().then(() => {
+        runnerDone = true;
+    }, (error) => {
+        runnerDone = true;
+        runnerError = error;
+    });
+    const deadline = started + (flags.timeoutMinutes ?? DEFAULT_TIMEOUT_MINUTES) * 60_000;
+    const pollMs = deps.pollMs ?? STATUS_POLL_MS;
+    let status = null;
+    let ended;
+    try {
+        while (true) {
+            if (deps.interrupt?.aborted) {
+                ended = 'interrupted';
+                break;
+            }
+            if (runnerError)
+                break;
+            try {
+                status = await ciClient.runStatus(runId);
+                if (status.done)
+                    break;
+            }
+            catch (error) {
+                if (error instanceof ApiError && (error.status === 401 || error.status === 403))
+                    apiExit(error, 'reading the run status failed');
+                log.warn('run status failed', { run_id: runId, error: messageOf(error) });
+            }
+            if ((deps.now ?? Date.now)() >= deadline) {
+                ended = 'timeout';
+                break;
+            }
+            const wait = sleep(Math.min(pollMs, Math.max(0, deadline - (deps.now ?? Date.now)())));
+            const onAbort = () => wait.cancel();
+            deps.interrupt?.addEventListener('abort', onAbort, { once: true });
+            // The runner loop only ends early on a fatal error (token refused, …): stop waiting then.
+            if (!runnerDone)
+                void running.then(() => wait.cancel());
+            await wait.promise;
+            deps.interrupt?.removeEventListener('abort', onAbort);
+        }
+        if (ended || runnerError) {
+            const why = ended === 'timeout' ? 'timed out' : ended === 'interrupted' ? 'was interrupted' : 'failed';
+            log.warn(`the CI command ${why}; cancelling the run`, { run_id: runId });
+            try {
+                const cancelled = await ciClient.cancelRun(runId);
+                log.info('run cancelled', { run_id: runId, jobs: cancelled });
+            }
+            catch (error) {
+                log.error('could not cancel the run', { run_id: runId, error: messageOf(error) });
+            }
+        }
+    }
+    finally {
+        runner.stop();
+        await running;
+        if (local)
+            unregisterLocalBuild(local.sha256);
+    }
+    if (runnerError)
+        throw runnerError;
+    if (ended)
+        status = (await ciClient.runStatus(runId).catch(() => null)) ?? status;
+    const code = exitCodeFor(status, ended);
+    finish(flags, deps, outcome(status, ended), code);
+    return code;
+}
+/** Prints the summary and writes `$GITHUB_STEP_SUMMARY` and `--junit`. */
+function finish(flags, deps, outcome, code) {
+    deps.print(formatSummary(outcome, code));
+    const stepSummary = deps.env.GITHUB_STEP_SUMMARY?.trim();
+    if (stepSummary) {
+        try {
+            appendFileSync(stepSummary, formatMarkdown(outcome, code));
+        }
+        catch (error) {
+            deps.log.warn('could not write the step summary', { path: stepSummary, error: messageOf(error) });
+        }
+    }
+    if (flags.junit) {
+        try {
+            mkdirSync(dirname(flags.junit), { recursive: true });
+            writeFileSync(flags.junit, formatJunit(outcome));
+        }
+        catch (error) {
+            deps.log.error('could not write the JUnit report', { path: flags.junit, error: messageOf(error) });
+        }
+    }
+}