@leera.io/qa-runner 1.0.0

package/dist/src/ci/summary.js

@@ -0,0 +1,126 @@
+/** CI exit codes (plan §7.1). */
+export const CiExit = {
+    ok: 0,
+    error: 1,
+    failed: 10,
+    blocked: 11,
+    timeout: 12,
+    cancelled: 13,
+    interrupted: 130,
+};
+/** Exit code for a finished (or abandoned) run. */
+export function exitCodeFor(status, ended) {
+    if (ended === 'interrupted')
+        return CiExit.interrupted;
+    if (ended === 'timeout')
+        return CiExit.timeout;
+    if (!status)
+        return CiExit.error;
+    if (status.status === 'cancelled')
+        return CiExit.cancelled;
+    if (status.items.failed > 0)
+        return CiExit.failed;
+    if (status.items.blocked > 0 || status.items.pending > 0)
+        return CiExit.blocked;
+    return CiExit.ok;
+}
+export function verdict(code) {
+    switch (code) {
+        case CiExit.ok:
+            return 'passed';
+        case CiExit.failed:
+            return 'failed';
+        case CiExit.blocked:
+            return 'blocked';
+        case CiExit.timeout:
+            return 'timed out';
+        case CiExit.cancelled:
+            return 'cancelled';
+        case CiExit.interrupted:
+            return 'interrupted';
+        default:
+            return 'error';
+    }
+}
+function counts(outcome) {
+    const items = outcome.status?.items;
+    if (!items)
+        return [];
+    return [
+        ['Total', items.total],
+        ['Passed', items.passed],
+        ['Failed', items.failed],
+        ['Blocked', items.blocked],
+        ['Skipped', items.skipped],
+        ['Pending', items.pending],
+    ];
+}
+function sortedItems(outcome) {
+    const order = { failed: 0, error: 1, blocked: 2, skipped: 3, passed: 4 };
+    return [...outcome.items].sort((a, b) => (order[a.result] ?? 5) - (order[b.result] ?? 5) || a.item_id - b.item_id);
+}
+function oneLine(text, max) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+/** The plain-text table printed at the end of `ci`. */
+export function formatSummary(outcome, code) {
+    const lines = [
+        '',
+        `Run #${outcome.runId} "${outcome.runName}" (${outcome.platform}): ${verdict(code)} in ${Math.round(outcome.elapsedSecs)}s`,
+    ];
+    const table = counts(outcome);
+    if (table.length > 0) {
+        lines.push(table.map(([label]) => label.padStart(8)).join(''));
+        lines.push(table.map(([, value]) => String(value).padStart(8)).join(''));
+    }
+    const items = sortedItems(outcome);
+    if (items.length > 0) {
+        lines.push('');
+        for (const item of items) {
+            const detail = item.failures[0] ?? (item.result !== 'passed' ? item.notes : '');
+            lines.push(`  ${item.result.padEnd(8)} ${oneLine(item.title, 70)}${detail ? ` — ${oneLine(detail, 100)}` : ''}`);
+        }
+    }
+    if (outcome.created.skipped.length > 0) {
+        lines.push('', `Not queued (${outcome.created.skipped.length}):`);
+        for (const skipped of outcome.created.skipped)
+            lines.push(`  ${oneLine(skipped.title, 70)} — ${oneLine(skipped.reason, 100)}`);
+    }
+    const report = outcome.status?.report_url ?? outcome.created.report_url;
+    if (report)
+        lines.push('', `Report: ${report}`);
+    return lines.join('\n');
+}
+function cell(text, max = 200) {
+    return oneLine(text, max).replace(/\|/g, '\\|');
+}
+const ICONS = { passed: '✅', failed: '❌', blocked: '⛔', skipped: '⏭️', error: '⚠️' };
+/** Markdown for `$GITHUB_STEP_SUMMARY`. */
+export function formatMarkdown(outcome, code) {
+    const report = outcome.status?.report_url ?? outcome.created.report_url;
+    const title = report ? `[${cell(outcome.runName)}](${report})` : cell(outcome.runName);
+    const lines = [`### QA run ${title}: ${verdict(code)}`, '', `Platform \`${outcome.platform}\` · run #${outcome.runId} · ${Math.round(outcome.elapsedSecs)}s`, ''];
+    const table = counts(outcome);
+    if (table.length > 0) {
+        lines.push(`| ${table.map(([label]) => label).join(' | ')} |`);
+        lines.push(`|${table.map(() => '---:').join('|')}|`);
+        lines.push(`| ${table.map(([, value]) => value).join(' | ')} |`, '');
+    }
+    const items = sortedItems(outcome);
+    if (items.length > 0) {
+        lines.push('| Result | Test | Notes |', '|---|---|---|');
+        for (const item of items) {
+            const detail = item.failures.length > 0 ? item.failures.join('; ') : item.result === 'passed' ? '' : item.notes;
+            lines.push(`| ${ICONS[item.result] ?? ''} ${item.result} | ${cell(item.title)} | ${cell(detail, 300)} |`);
+        }
+        lines.push('');
+    }
+    if (outcome.created.skipped.length > 0) {
+        lines.push('<details><summary>Not queued ('.concat(String(outcome.created.skipped.length), ')</summary>'), '');
+        for (const skipped of outcome.created.skipped)
+            lines.push(`- ${cell(skipped.title)}: ${cell(skipped.reason)}`);
+        lines.push('', '</details>', '');
+    }
+    return `${lines.join('\n')}\n`;
+}

package/dist/src/cli/commands/builds.js

@@ -0,0 +1,104 @@
+import { parseArgs } from 'node:util';
+import { describeBuildFile, uploadBuild } from '../../ci/builds.js';
+import { CiClient } from '../../ci/client.js';
+import { detectCi } from '../../ci/env.js';
+import { ApiError } from '../../client.js';
+import { isPlatform } from '../../devices/types.js';
+import { ExitCode, ExitError, messageOf } from '../../errors.js';
+import { createLogger } from '../../log.js';
+import { printJson, usageError } from '../output.js';
+const usage = `Usage: leera-qa-runner builds upload PATH --platform PLATFORM [options]
+
+Uploads an app build with a CI token (RUNNER_URL, RUNNER_TOKEN) and prints its id, for
+\`leera-qa-runner ci --build-id\` or the workspace's environment settings.
+
+Options:
+  --project KEY|ID      Project (default: the CI token's project)
+  --platform NAME       android, ios, ... (required)
+  --version-name TEXT   Version name shown in the workspace
+  --build-number TEXT   Build number
+  --app-id ID           Package name or bundle id
+  --notes TEXT          Notes
+  --git-sha SHA         Commit the build came from (default: detected from the CI environment or git)
+  --git-branch NAME     Branch the build came from (likewise)
+  --relay               Send the file through the server instead of the direct upload URL
+  --json                Print the build as JSON
+`;
+export const command = {
+    summary: 'Upload an app build (CI token)',
+    usage,
+    async run(args, io) {
+        const [action, ...rest] = args;
+        if (action !== 'upload')
+            throw usageError(action ? `unknown builds action '${action}'` : 'missing action', usage);
+        const { values, positionals } = parseArgs({
+            args: rest,
+            strict: true,
+            allowPositionals: true,
+            options: {
+                project: { type: 'string' },
+                platform: { type: 'string' },
+                'version-name': { type: 'string' },
+                'build-number': { type: 'string' },
+                'app-id': { type: 'string' },
+                notes: { type: 'string' },
+                'git-sha': { type: 'string' },
+                'git-branch': { type: 'string' },
+                relay: { type: 'boolean' },
+                json: { type: 'boolean' },
+            },
+        });
+        if (positionals.length !== 1)
+            throw usageError('pass exactly one build file', usage);
+        const platform = values.platform;
+        if (!platform)
+            throw usageError('--platform is required', usage);
+        if (!isPlatform(platform) || platform === 'web')
+            throw usageError(`'${platform}' does not take app builds`, usage);
+        const url = io.env.RUNNER_URL?.trim() || io.env.LEERA_URL?.trim();
+        const token = io.env.RUNNER_TOKEN?.trim() || io.env.LEERA_RUNNER_TOKEN?.trim();
+        if (!url)
+            throw new ExitError(ExitCode.usage, 'RUNNER_URL is required');
+        if (!token)
+            throw new ExitError(ExitCode.usage, 'RUNNER_TOKEN is required (a CI token)');
+        const log = createLogger({ console: io.interactive ? 'pretty' : 'json', stdout: (line) => io.stderr(line) });
+        const explicitGit = values['git-sha'] !== undefined && values['git-branch'] !== undefined;
+        const ci = explicitGit ? null : detectCi(io.env);
+        const gitSha = values['git-sha'] ?? ci?.sha ?? undefined;
+        const gitBranch = values['git-branch'] ?? ci?.branch ?? undefined;
+        const file = await describeBuildFile(positionals[0]);
+        const project = values.project ?? io.env.RUNNER_PROJECT?.trim();
+        let build;
+        try {
+            build = await uploadBuild(new CiClient(url, token), {
+                file,
+                platform,
+                ...(project ? { project } : {}),
+                meta: {
+                    ...(values['version-name'] ? { version_name: values['version-name'] } : {}),
+                    ...(values['build-number'] ? { build_number: values['build-number'] } : {}),
+                    ...(values['app-id'] ? { app_id: values['app-id'] } : {}),
+                    ...(values.notes ? { notes: values.notes } : {}),
+                    ...(gitSha ? { git_sha: gitSha } : {}),
+                    ...(gitBranch ? { git_branch: gitBranch } : {}),
+                },
+                relay: values.relay ?? false,
+                log,
+            });
+        }
+        catch (error) {
+            if (error instanceof ApiError && (error.status === 401 || error.status === 403)) {
+                throw new ExitError(ExitCode.tokenRejected, `the server refused the token (${error.status} ${error.message})`);
+            }
+            if (error instanceof ApiError && error.status >= 400 && error.status < 500) {
+                throw new ExitError(ExitCode.usage, `the upload was refused: ${error.message}`);
+            }
+            throw new ExitError(ExitCode.error, `the upload failed: ${messageOf(error)}`);
+        }
+        if (values.json)
+            printJson(io, build);
+        else
+            io.stdout(String(build.id));
+        return ExitCode.ok;
+    },
+};

package/dist/src/cli/commands/ci.js

@@ -0,0 +1,167 @@
+import { parseArgs } from 'node:util';
+import { DEFAULT_TIMEOUT_MINUTES, runCi, VIDEO_MODES } from '../../ci/run.js';
+import { splitList } from '../../config.js';
+import { formatDoctor, runDoctor } from '../../doctor.js';
+import { shutdownEmulatorsBootedHere } from '../../devices/android/emulator.js';
+import { stopSharedAppiumServer } from '../../drivers/android-appium.js';
+import { createRegistry } from '../../drivers/registry.js';
+import { BrowserPool } from '../../drivers/web-playwright.js';
+import { homePaths } from '../../home.js';
+import { createLogger } from '../../log.js';
+import { usageError } from '../output.js';
+import { installBrowsers } from './setup.js';
+const usage = `Usage: leera-qa-runner ci --environment ENV --platform PLATFORM [options]
+
+Creates a test run for this commit, runs its jobs on this machine as an ephemeral runner,
+waits for the verdict and exits with it. Reads RUNNER_URL and RUNNER_TOKEN (a CI token).
+
+Options:
+  --project KEY|ID      Project (default: the CI token's project)
+  --plan NAME|ID        Test plan (default: every active test case with a script for the platform)
+  --environment SLUG|ID Test environment (required)
+  --platform NAME       web, android, ios, electron, tauri, windows or macos (required)
+  --build PATH          App build to test; stays on this runner unless --upload-build
+  --upload-build        Upload --build to the workspace first (other runners can use it)
+  --build-id N          Test an uploaded build
+  --version-name TEXT   Build version name (with --upload-build, or to pick an uploaded build)
+  --build-number TEXT   Build number (likewise)
+  --name TEXT           Test run name (default: "CI <platform> <branch>@<sha>")
+  --video MODE          off, on_failure (default) or always
+  --timeout MINUTES     Cancel the run after this long (default ${DEFAULT_TIMEOUT_MINUTES})
+  --junit PATH          Write a JUnit XML report
+  --labels a,b          Use exactly these runner labels
+  --concurrency N       Browser jobs at once (default 1)
+  --skip-doctor         Do not check the machine first
+
+Exit codes: 0 passed · 1 error · 2 usage · 3 token refused · 4 machine not ready ·
+5 runner too old · 10 failed · 11 blocked · 12 timed out · 13 cancelled · 130 interrupted
+`;
+function positive(raw, name) {
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value <= 0)
+        throw usageError(`${name} must be a positive whole number`, usage);
+    return value;
+}
+export function parseCiFlags(args, env = {}) {
+    const { values } = parseArgs({
+        args,
+        strict: true,
+        allowPositionals: false,
+        options: {
+            project: { type: 'string' },
+            plan: { type: 'string' },
+            environment: { type: 'string' },
+            platform: { type: 'string' },
+            build: { type: 'string' },
+            'upload-build': { type: 'boolean' },
+            'build-id': { type: 'string' },
+            'version-name': { type: 'string' },
+            'build-number': { type: 'string' },
+            name: { type: 'string' },
+            video: { type: 'string' },
+            timeout: { type: 'string' },
+            junit: { type: 'string' },
+            labels: { type: 'string' },
+            concurrency: { type: 'string' },
+            'skip-doctor': { type: 'boolean' },
+        },
+    });
+    const environment = values.environment ?? env.RUNNER_ENVIRONMENT?.trim();
+    const platform = values.platform ?? env.RUNNER_PLATFORM?.trim();
+    if (!environment)
+        throw usageError('--environment is required', usage);
+    if (!platform)
+        throw usageError('--platform is required', usage);
+    const flags = { environment, platform };
+    const project = values.project ?? env.RUNNER_PROJECT?.trim();
+    if (project)
+        flags.project = project;
+    if (values.plan !== undefined)
+        flags.plan = values.plan;
+    if (values.build !== undefined)
+        flags.build = values.build;
+    if (values['upload-build'])
+        flags.uploadBuild = true;
+    if (values['build-id'] !== undefined)
+        flags.buildId = positive(values['build-id'], '--build-id');
+    if (values['version-name'] !== undefined)
+        flags.versionName = values['version-name'];
+    if (values['build-number'] !== undefined)
+        flags.buildNumber = values['build-number'];
+    if (values.name !== undefined)
+        flags.name = values.name;
+    if (values.video !== undefined) {
+        if (!VIDEO_MODES.includes(values.video))
+            throw usageError(`--video must be one of ${VIDEO_MODES.join(', ')}`, usage);
+        flags.video = values.video;
+    }
+    if (values.timeout !== undefined)
+        flags.timeoutMinutes = positive(values.timeout, '--timeout');
+    if (values.junit !== undefined)
+        flags.junit = values.junit;
+    if (values.labels !== undefined)
+        flags.labels = splitList(values.labels);
+    if (values.concurrency !== undefined)
+        flags.concurrency = positive(values.concurrency, '--concurrency');
+    if (values['skip-doctor'])
+        flags.skipDoctor = true;
+    return flags;
+}
+export const command = {
+    summary: 'Run this commit\'s tests in CI and exit with the verdict',
+    usage,
+    async run(args, io) {
+        const flags = parseCiFlags(args, io.env);
+        const paths = homePaths(io.env);
+        // CI logs are read by people: readable lines, not JSON.
+        const log = createLogger({ console: 'pretty' });
+        const registry = createRegistry();
+        const shared = { browsers: new BrowserPool({ headless: true }) };
+        const interrupt = new AbortController();
+        let signals = 0;
+        const onSignal = () => {
+            signals++;
+            if (signals > 1) {
+                log.warn('interrupted twice, exiting now');
+                process.exit(130);
+            }
+            log.warn('interrupted: cancelling the run');
+            interrupt.abort();
+        };
+        process.on('SIGINT', onSignal);
+        process.on('SIGTERM', onSignal);
+        try {
+            return await runCi(flags, {
+                env: io.env,
+                log,
+                print: (text) => io.stdout(text),
+                registry,
+                shared,
+                paths,
+                interrupt: interrupt.signal,
+                doctor: async (platform) => {
+                    // CI machines start clean: create the home and install Chromium when missing.
+                    const report = await runDoctor({
+                        env: io.env,
+                        paths,
+                        registry,
+                        platform,
+                        fix: true,
+                        installBrowsers: async () => (await installBrowsers(io, paths)) === 0,
+                    });
+                    return { ok: report.ok, text: formatDoctor(report) };
+                },
+            });
+        }
+        finally {
+            process.off('SIGINT', onSignal);
+            process.off('SIGTERM', onSignal);
+            await shared.browsers.close();
+            await stopSharedAppiumServer();
+            // An ephemeral runner owns the emulators it booted (iOS simulators are shut down when their lease ends).
+            const stopped = await shutdownEmulatorsBootedHere();
+            if (stopped.length > 0)
+                log.info('emulators shut down', { serials: stopped });
+        }
+    },
+};

package/dist/src/cli/commands/config.js

@@ -0,0 +1,83 @@
+import { parseArgs } from 'node:util';
+import { CONFIG_KEYS, checkKey, getConfigValue, loadFileConfig, saveFileConfig, setConfigValue, unsetConfigValue, } from '../../config.js';
+import { ExitCode } from '../../errors.js';
+import { homePaths, writeTokenFile } from '../../home.js';
+import { printJson, usageError } from '../output.js';
+import { readToken } from './connect.js';
+const usage = `Usage: leera-qa-runner config <get|set|unset|list|path|set-token> ...
+
+  config get KEY              Print one value
+  config set KEY VALUE        Store a value
+  config unset KEY            Remove a value
+  config list [--json]        Print the stored configuration (the token is never printed)
+  config path                 Print where the configuration lives
+  config set-token [--token-stdin]
+                              Replace the runner token (prompted without echo)
+
+Keys:
+${Object.entries(CONFIG_KEYS)
+    .map(([key, { help }]) => `  ${key.padEnd(25)} ${help}`)
+    .join('\n')}
+  env.NAME                  Environment variable applied when the service starts
+
+Environment variables (RUNNER_*) and flags override stored values.
+`;
+export const command = {
+    summary: 'Read or change the stored configuration',
+    usage,
+    async run(args, io) {
+        const { values, positionals } = parseArgs({
+            args,
+            strict: true,
+            allowPositionals: true,
+            options: { json: { type: 'boolean' }, 'token-stdin': { type: 'boolean' } },
+        });
+        const [action, key, ...rest] = positionals;
+        const paths = homePaths(io.env);
+        const { file, token } = loadFileConfig(paths);
+        const config = file ?? {};
+        switch (action) {
+            case 'get': {
+                if (!key || rest.length > 0)
+                    throw usageError('config get needs one KEY', usage);
+                checkKey(key);
+                const value = getConfigValue(config, key);
+                if (value === undefined)
+                    return ExitCode.error;
+                io.stdout(Array.isArray(value) ? value.join(',') : typeof value === 'object' ? JSON.stringify(value) : String(value));
+                return ExitCode.ok;
+            }
+            case 'set': {
+                if (!key || rest.length !== 1)
+                    throw usageError('config set needs KEY and VALUE', usage);
+                saveFileConfig(paths, setConfigValue(config, key, rest[0]));
+                return ExitCode.ok;
+            }
+            case 'unset': {
+                if (!key || rest.length > 0)
+                    throw usageError('config unset needs one KEY', usage);
+                saveFileConfig(paths, unsetConfigValue(config, key));
+                return ExitCode.ok;
+            }
+            case 'list': {
+                const shown = { ...config, token: token ? 'stored' : 'not set' };
+                if (values.json)
+                    printJson(io, shown);
+                else
+                    io.stdout(JSON.stringify(shown, null, 2));
+                return ExitCode.ok;
+            }
+            case 'path':
+                io.stdout(paths.config);
+                return ExitCode.ok;
+            case 'set-token': {
+                const next = await readToken(io, values['token-stdin'] ?? false);
+                writeTokenFile(paths, next);
+                io.stdout(`Saved the token to ${paths.token}.`);
+                return ExitCode.ok;
+            }
+            default:
+                throw usageError(action ? `unknown config action '${action}'` : 'say what to do', usage);
+        }
+    },
+};

package/dist/src/cli/commands/connect.js

@@ -0,0 +1,70 @@
+import { parseArgs } from 'node:util';
+import { loadFileConfig, parseConfigValue, saveFileConfig, TOKEN_PREFIX } from '../../config.js';
+import { formatDoctor, runDoctor } from '../../doctor.js';
+import { createRegistry } from '../../drivers/registry.js';
+import { ExitCode } from '../../errors.js';
+import { homePaths, writeTokenFile } from '../../home.js';
+import { promptHidden, readStdin, usageError } from '../output.js';
+const usage = `Usage: leera-qa-runner connect --url <server> [--token-stdin] [--name <name>]
+
+Saves the server URL and a runner token, then checks the machine with \`doctor\`.
+The token is prompted for without echo, or read from stdin with --token-stdin.
+
+Options:
+  --url URL           The workspace server, e.g. https://app.example.com
+  --token-stdin       Read the token from stdin (for scripts)
+  --name NAME         Runner name shown in the workspace (default: host name)
+  --skip-doctor       Do not run the checks afterwards
+`;
+/** Reads a token from stdin or a hidden prompt and checks its shape. */
+export async function readToken(io, fromStdin) {
+    let token;
+    if (fromStdin)
+        token = (await readStdin(io.stdin)).trim();
+    else if (io.interactive)
+        token = (await promptHidden(io, 'Runner token: ')).trim();
+    else
+        throw usageError('no terminal to prompt for the token; pipe it and pass --token-stdin');
+    if (!token)
+        throw usageError('no token given');
+    if (!token.startsWith(TOKEN_PREFIX))
+        throw usageError(`that is not a runner pool token (${TOKEN_PREFIX}...)`);
+    return token;
+}
+export const command = {
+    summary: 'Save the server URL and token, then run doctor',
+    usage,
+    async run(args, io) {
+        const { values } = parseArgs({
+            args,
+            strict: true,
+            options: {
+                url: { type: 'string' },
+                'token-stdin': { type: 'boolean' },
+                name: { type: 'string' },
+                'skip-doctor': { type: 'boolean' },
+            },
+        });
+        const paths = homePaths(io.env);
+        const { file } = loadFileConfig(paths);
+        const rawUrl = values.url ?? file?.url;
+        if (!rawUrl)
+            throw usageError('--url is required', usage);
+        const url = parseConfigValue('url', rawUrl);
+        const token = await readToken(io, values['token-stdin'] ?? false);
+        const next = { ...(file ?? {}), url };
+        if (values.name !== undefined)
+            next.name = values.name.trim();
+        saveFileConfig(paths, next);
+        writeTokenFile(paths, token);
+        io.stdout(`Saved the server URL to ${paths.config} and the token to ${paths.token}.`);
+        if (!values['skip-doctor']) {
+            const report = await runDoctor({ env: io.env, paths, registry: createRegistry() });
+            io.stdout('');
+            io.stdout(formatDoctor(report));
+        }
+        io.stdout('');
+        io.stdout('Next: run `leera-qa-runner service install` to run in the background, or `leera-qa-runner start` to run in this terminal.');
+        return ExitCode.ok;
+    },
+};

package/dist/src/cli/commands/doctor.js

@@ -0,0 +1,57 @@
+import { parseArgs } from 'node:util';
+import { formatDoctor, runDoctor } from '../../doctor.js';
+import { isPlatform } from '../../devices/types.js';
+import { createRegistry } from '../../drivers/registry.js';
+import { ExitCode } from '../../errors.js';
+import { homePaths } from '../../home.js';
+import { printJson, usageError } from '../output.js';
+import { installBrowsers } from './setup.js';
+const usage = `Usage: leera-qa-runner doctor [--json] [--fix] [--platform web|android|ios|electron|tauri]
+
+Checks that this machine can run jobs: Node.js, the runner home, the server URL and
+token, and each platform's tools. Exits 4 when something needs fixing.
+
+Options:
+  --json              Print the report as JSON
+  --fix               Fix what can be fixed safely (permissions, installing Chromium)
+  --platform NAME     Only check one platform
+`;
+export const command = {
+    summary: 'Check that this machine is ready to run jobs',
+    usage,
+    async run(args, io) {
+        const { values } = parseArgs({
+            args,
+            strict: true,
+            options: {
+                json: { type: 'boolean' },
+                fix: { type: 'boolean' },
+                platform: { type: 'string' },
+                offline: { type: 'boolean' },
+            },
+        });
+        const registry = createRegistry();
+        let platform;
+        if (values.platform !== undefined) {
+            if (!isPlatform(values.platform) || !registry.has(values.platform)) {
+                throw usageError(`this runner version cannot run '${values.platform}' jobs (supported: ${[...registry.keys()].join(', ')})`);
+            }
+            platform = values.platform;
+        }
+        const paths = homePaths(io.env);
+        const report = await runDoctor({
+            env: io.env,
+            paths,
+            registry,
+            fix: values.fix ?? false,
+            offline: values.offline ?? false,
+            ...(platform ? { platform } : {}),
+            installBrowsers: async () => (await installBrowsers(io, paths)) === 0,
+        });
+        if (values.json)
+            printJson(io, report);
+        else
+            io.stdout(formatDoctor(report));
+        return report.ok ? ExitCode.ok : ExitCode.environmentNotReady;
+    },
+};