@sdods/cli 0.2.0

package/dist/commands/report.js

@@ -0,0 +1,255 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { execa } from 'execa';
+import pc from 'picocolors';
+import { runFiles } from '@sdods/contracts';
+import { SdodsError } from '@sdods/core';
+import { createContext } from '../context.js';
+import { json, ok, out, table } from '../ui.js';
+function artifactsRoot(rootDir) {
+    return resolve(rootDir, process.env.SDODS_ARTIFACTS_DIR ?? '.sdods/runs');
+}
+function latestRunId(root) {
+    if (!existsSync(root))
+        return null;
+    const dirs = readdirSync(root)
+        .map((name) => ({ name, dir: join(root, name) }))
+        .filter((d) => statSync(d.dir).isDirectory() &&
+        (existsSync(join(d.dir, runFiles.manifest)) ||
+            existsSync(join(d.dir, runFiles.messages)) ||
+            existsSync(join(d.dir, runFiles.results))))
+        .sort((a, b) => statSync(b.dir).mtimeMs - statSync(a.dir).mtimeMs);
+    return dirs[0]?.name ?? null;
+}
+function readJsonFile(file) {
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function openPath(p) {
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    await execa(cmd, [p], { shell: process.platform === 'win32' }).catch(() => undefined);
+}
+export function register(program) {
+    const report = program
+        .command('report')
+        .description('Open reports of a run, ingest results into the database, render dashboards')
+        .option('--last', 'use the most recent run')
+        .option('--run <id>', 'run id')
+        .option('--open', 'open the HTML report and dashboard')
+        .option('--html', 'open only the HTML report')
+        .option('--dashboard', 'open only the SDODS dashboard')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const root = artifactsRoot(ctx.rootDir);
+        const runId = opts.run ?? latestRunId(root);
+        if (!runId)
+            throw new SdodsError('RUN_FAILED', `No runs found under ${root}.`, {
+                hint: 'Run `sdods run -p <slug>` first.',
+                exitCode: 2,
+            });
+        const dir = join(root, runId);
+        const manifest = readJsonFile(join(dir, runFiles.manifest));
+        const summary = readJsonFile(join(dir, runFiles.summary));
+        const html = join(dir, runFiles.htmlReport, 'index.html');
+        const dashboard = join(dir, runFiles.dashboard, 'index.html');
+        const info = {
+            runId,
+            dir,
+            manifest,
+            summary,
+            reports: {
+                html: existsSync(html) ? html : null,
+                dashboard: existsSync(dashboard) ? dashboard : null,
+                messages: existsSync(join(dir, runFiles.messages)) ? join(dir, runFiles.messages) : null,
+            },
+        };
+        if (ctx.opts.json)
+            return json(info);
+        out(pc.bold(`Run ${runId}`) + pc.dim(`  ${dir}`));
+        if (manifest)
+            out(pc.dim(`project ${manifest.projectSlug} · env ${manifest.env} · ${manifest.startedAt}`));
+        if (summary?.totals) {
+            const t = summary.totals;
+            out(`${pc.green(`${t.passed ?? 0} passed`)}  ${pc.red(`${t.failed ?? 0} failed`)}  ${pc.yellow(`${t.flaky ?? 0} flaky`)}  ${pc.dim(`${t.skipped ?? 0} skipped`)}`);
+        }
+        table(Object.entries(info.reports).map(([k, v]) => ({
+            report: k,
+            path: v ?? pc.dim('(missing)'),
+        })));
+        if (opts.open || opts.html)
+            if (info.reports.html)
+                await openPath(info.reports.html);
+        if (opts.open || opts.dashboard)
+            if (info.reports.dashboard)
+                await openPath(info.reports.dashboard);
+    });
+    report
+        .command('ingest [files...]')
+        .description('Ingest cucumber messages NDJSON and runner JSON results into the database')
+        .requiredOption('--run-id <id>', 'run id (directory name under the artifacts root)')
+        .option('-p, --project <slug>', 'project slug when run.json is missing')
+        .option('--manifest <file>', 'explicit run.json path')
+        .option('--format <fmt>', 'auto|cucumber|runner-json (alias: pw-json)', 'auto')
+        .option('--artifacts-dir <dir>', 'artifacts root (default .sdods/runs)')
+        .option('--replace', 'delete previously ingested rows of this run first')
+        .option('-e, --env <name>', 'environment name when run.json is missing')
+        .option('--server <url>', 'upload to an SDODS server (POST /api/runs/:id/ingest) instead of writing to a local database')
+        .option('--token <token>', 'API token for --server (or SDODS_TOKEN)')
+        .action(async (files, opts, cmd) => {
+        const ctx = createContext(cmd);
+        const serverUrl = opts.server ?? process.env.SDODS_SERVER_URL;
+        if (serverUrl) {
+            // CI path: no DB credentials on the runner; the server ingests with a scoped token.
+            const token = opts.token ?? process.env.SDODS_TOKEN;
+            if (!token)
+                throw new SdodsError('AUTH_FAILED', '--server needs --token (or SDODS_TOKEN).', {
+                    exitCode: 2,
+                });
+            const { readFileSync, existsSync } = await import('node:fs');
+            const { basename } = await import('node:path');
+            const form = new FormData();
+            let count = 0;
+            for (const f of files) {
+                const abs = resolve(ctx.rootDir, f);
+                if (!existsSync(abs))
+                    continue;
+                form.append('files', new Blob([readFileSync(abs)]), basename(abs));
+                count++;
+            }
+            if (!count)
+                throw new SdodsError('CONFIG_INVALID', 'No existing files to upload.', { exitCode: 2 });
+            const url = `${serverUrl.replace(/\/$/, '')}/api/runs/${encodeURIComponent(opts.runId)}/ingest`;
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { authorization: `Bearer ${token}` },
+                body: form,
+            });
+            const body = (await res.json().catch(() => ({})));
+            if (!res.ok)
+                throw new SdodsError('RUN_FAILED', `Server ingest failed (${res.status}): ${JSON.stringify(body)}`, {
+                    exitCode: 1,
+                });
+            if (ctx.opts.json)
+                return json(body);
+            return ok(`Uploaded ${count} file(s) for run ${opts.runId} to ${serverUrl}`);
+        }
+        const m = await import('@sdods/db');
+        const adb = m.createDb();
+        try {
+            await m.migrateToLatest(adb);
+            const root = opts.artifactsDir
+                ? resolve(ctx.rootDir, opts.artifactsDir)
+                : artifactsRoot(ctx.rootDir);
+            const ndjson = [];
+            const runnerJson = [];
+            for (const f of files) {
+                const abs = resolve(ctx.rootDir, f);
+                const fmt = opts.format === 'auto'
+                    ? abs.endsWith('.ndjson')
+                        ? 'cucumber'
+                        : 'runner-json'
+                    : // `pw-json` is the pre-1.0 name, still accepted
+                        opts.format === 'pw-json'
+                            ? 'runner-json'
+                            : opts.format;
+                (fmt === 'cucumber' ? ndjson : runnerJson).push(abs);
+            }
+            const manifest = opts.manifest
+                ? readJsonFile(resolve(ctx.rootDir, opts.manifest))
+                : undefined;
+            const res = await m.ingestRun(adb, {
+                runId: opts.runId,
+                projectSlug: opts.project,
+                manifest,
+                ndjsonPaths: ndjson,
+                runnerJsonPaths: runnerJson,
+                artifactsRoot: root,
+                replace: Boolean(opts.replace),
+                env: opts.env,
+            });
+            if (ctx.opts.json)
+                return json(res);
+            ok(`Ingested run ${res.runId} (${res.projectSlug}): ${res.scenarios} scenario(s), ${res.attempts} attempt(s), ${res.steps} step(s), ${res.artifacts} artifact(s), ${res.healEvents} heal event(s)`);
+            const t = res.totals;
+            out(`${pc.green(`${t.passed} passed`)}  ${pc.red(`${t.failed} failed`)}  ${pc.yellow(`${t.flaky} flaky`)}  ${pc.dim(`${t.skipped} skipped`)}  → ${res.status}`);
+            if (res.filesSkipped.length)
+                out(pc.dim(`skipped (already ingested): ${res.filesSkipped.join(', ')}`));
+            if (res.parseErrors)
+                out(pc.yellow(`${res.parseErrors} unparsable line(s) skipped`));
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    report
+        .command('merge <dirs...>')
+        .description('Merge sharded run reports into one HTML report and JUnit file')
+        .option('--run <id>', 'run id to write the merged report into (default: latest)')
+        .option('--reporter <list>', 'reporters for the merged output', 'html,junit')
+        .action(async (dirs, opts, cmd) => {
+        const ctx = createContext(cmd);
+        const root = artifactsRoot(ctx.rootDir);
+        const runId = opts.run ?? latestRunId(root);
+        if (!runId) {
+            throw new SdodsError('CONFIG_NOT_FOUND', 'No run to merge into.', {
+                hint: 'Pass --run <id>, or run a suite first.',
+                exitCode: 2,
+            });
+        }
+        const runDir = join(root, runId);
+        const missing = dirs.filter((d) => !existsSync(resolve(ctx.rootDir, d)));
+        if (missing.length) {
+            throw new SdodsError('CONFIG_NOT_FOUND', `No such shard report directory: ${missing.join(', ')}`, {
+                hint: 'Each argument is a directory of shard reports downloaded from CI.',
+                exitCode: 2,
+            });
+        }
+        // Shard reports are produced by `sdods run --reporter blob --shard i/n`; merging them
+        // rebuilds one HTML report and JUnit file for the whole matrix.
+        const args = [
+            'playwright',
+            'merge-reports',
+            '--reporter',
+            opts.reporter,
+            ...dirs.map((d) => resolve(ctx.rootDir, d)),
+        ];
+        const res = await execa('npx', args, {
+            cwd: ctx.rootDir,
+            reject: false,
+            env: { ...process.env, PLAYWRIGHT_HTML_OUTPUT_DIR: join(runDir, runFiles.htmlReport) },
+        });
+        if (res.exitCode !== 0) {
+            throw new SdodsError('RUN_FAILED', `Merging shard reports failed (exit ${res.exitCode}).`, {
+                hint: res.stderr?.split('\n').slice(-3).join(' ') || undefined,
+            });
+        }
+        if (ctx.opts.json)
+            return json({ runId, merged: dirs.length, htmlReport: join(runDir, runFiles.htmlReport) });
+        ok(`Merged ${dirs.length} shard report dir(s) into ${join(runDir, runFiles.htmlReport)}`);
+    });
+    program
+        .command('show-report')
+        .description('Open the HTML report of a run')
+        .option('--run <id>', 'run id (default: latest)')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const root = artifactsRoot(ctx.rootDir);
+        const runId = opts.run ?? latestRunId(root);
+        if (!runId)
+            throw new SdodsError('RUN_FAILED', `No runs found under ${root}.`, { exitCode: 2 });
+        const html = join(root, runId, runFiles.htmlReport, 'index.html');
+        if (!existsSync(html))
+            throw new SdodsError('RUN_FAILED', `No HTML report at ${html}.`, { exitCode: 2 });
+        await execa('npx', ['playwright', 'show-report', join(root, runId, runFiles.htmlReport)], {
+            stdio: 'inherit',
+            cwd: ctx.rootDir,
+        });
+    });
+}
+//# sourceMappingURL=report.js.map

package/dist/commands/run.d.ts

@@ -0,0 +1,41 @@
+import type { Command } from 'commander';
+export interface RunFlags {
+    project?: string;
+    env?: string;
+    tags?: string;
+    layer: string[];
+    browser: string[];
+    module: string[];
+    process?: string;
+    headed?: boolean;
+    workers?: number;
+    shard?: string;
+    retries?: number;
+    grep?: string;
+    feature?: string;
+    scenario?: string;
+    runId?: string;
+    artifactsDir?: string;
+    lint: boolean;
+    ingest?: boolean;
+    allure?: boolean;
+    harUpdate?: boolean;
+    harReplay?: boolean;
+    strict?: boolean;
+    updateSnapshots?: boolean;
+    ui?: boolean;
+    debug?: boolean;
+    list?: boolean;
+    repeatEach?: number;
+    failOnFlaky?: boolean;
+    maxFailures?: number;
+    timeout?: number;
+    reporter: string[];
+    projectMatrix?: boolean;
+    device?: string;
+    reporterMode?: string;
+    trigger?: string;
+}
+export declare function register(program: Command): void;
+export declare function runCommand(flags: RunFlags, cmd: Command): Promise<number>;
+//# sourceMappingURL=run.d.ts.map

package/dist/commands/run.js

@@ -0,0 +1,369 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join, relative, resolve as resolvePath } from 'node:path';
+import { execa } from 'execa';
+import pc from 'picocolors';
+import { newRunId, runFiles, } from '@sdods/contracts';
+import { SdodsError, CLI_OVERRIDES_ENV, VERSION, formatFindings, lintProject, listGeneratedProjects, moduleByName, moduleDir, normalizeTagExpr, serializeCliOverrides, } from '@sdods/core';
+import { createContext } from '../context.js';
+import { collect, json, out, parseIntFlag, warn } from '../ui.js';
+function addRunOptions(cmd) {
+    return cmd
+        .option('-p, --project <slug>', 'project slug (default: the only project, else required)')
+        .option('-e, --env <name>', 'environment name')
+        .option('-t, --tags <expr>', 'Cucumber tag expression, e.g. "@smoke and not @mock" (comma list = OR)')
+        .option('-l, --layer <layer>', 'ui | api | hybrid | recorded (repeatable)', collect, [])
+        .option('-b, --browser <name>', 'chromium | firefox | webkit | mobile-chrome | mobile-safari (repeatable)', collect, [])
+        .option('-m, --module <name>', 'restrict to a module (repeatable)', collect, [])
+        .option('--process <name>', 'run a named process (recipe) from the project or workspace')
+        .option('--project-matrix', 'run every browser declared in the project yaml')
+        .option('--device <name>', 'device name for mobile emulation, e.g. "iPhone 15"')
+        .option('--headed', 'run headed')
+        .option('-w, --workers <n>', 'parallel workers', parseIntFlag('workers'))
+        .option('--shard <i/n>', 'shard, e.g. 1/3')
+        .option('--retries <n>', 'retries per test', parseIntFlag('retries'))
+        .option('--grep <pattern>', 'filter tests by title (regular expression)')
+        .option('--feature <path>', 'only this feature file (relative to features/)')
+        .option('--scenario <name>', 'only scenarios whose title contains this text')
+        .option('--run-id <id>', 'run id (default: uuid v7)')
+        .option('--artifacts-dir <dir>', 'artifacts root (default: .sdods/runs)')
+        .option('--no-lint', 'skip feature lint before running')
+        .option('--ingest', 'ingest results into the database after the run')
+        .option('--no-ingest', 'do not ingest even when a database is configured')
+        .option('--allure', 'also produce allure-results')
+        .option('--har-update', 'record/refresh HAR files for @har scenarios')
+        .option('--har-replay', 'replay HAR files for @har scenarios')
+        .option('--strict', 'with --har-replay: abort on any request not in the HAR (offline)')
+        .option('--update-snapshots', 'update visual baselines')
+        .option('--ui', 'interactive UI mode')
+        .option('--debug', 'step debugger')
+        .option('--list', 'list the run targets and tests that would run')
+        .option('--repeat-each <n>', 'repeat each test n times', parseIntFlag('repeat-each'))
+        .option('--fail-on-flaky', 'exit 1 when any test is flaky')
+        .option('--max-failures <n>', 'stop after n failures', parseIntFlag('max-failures'))
+        .option('--timeout <ms>', 'per-test timeout override', parseIntFlag('timeout'))
+        .option('--reporter <name>', 'reporter override (repeatable, name=outputFile)', collect, [])
+        .option('--reporter-mode <mode>', 'default | server | quiet')
+        .option('--trigger <kind>', 'cli | ui | ci | agent | mcp | schedule', 'cli');
+}
+export function register(program) {
+    const run = addRunOptions(program
+        .command('run')
+        .description('Generate BDD specs and run them for a project (alias: test)'));
+    run.action(async (flags, cmd) => {
+        process.exitCode = await runCommand(flags, cmd);
+    });
+    const test = addRunOptions(program.command('test').description('Alias of run'));
+    test.action(async (flags, cmd) => {
+        process.exitCode = await runCommand(flags, cmd);
+    });
+}
+export async function runCommand(flags, cmd) {
+    const ctx = createContext(cmd);
+    const entry = ctx.registry.pick(flags.project);
+    const projectCfg = entry.config;
+    // process → defaults for flags not given explicitly
+    const proc = flags.process ? ctx.registry.processOf(entry.slug, flags.process) : undefined;
+    const envName = flags.env ?? proc?.env;
+    const tags = normalizeTagExpr(flags.tags ?? proc?.tags);
+    const layers = (flags.layer.length ? flags.layer : (proc?.layers ?? []));
+    const browsers = (flags.projectMatrix
+        ? projectCfg.browsers
+        : flags.browser.length
+            ? flags.browser
+            : (proc?.browsers ?? []));
+    const modules = flags.module.length ? flags.module : (proc?.modules ?? []);
+    const retries = flags.retries ?? proc?.retries;
+    const harMode = flags.harUpdate ? 'update' : flags.harReplay ? 'replay' : proc?.harMode;
+    // Recording writes each HAR file when its context closes, so parallel workers sharing a
+    // `@har:<name>` fixture overwrite one another and the file ends up missing entries.
+    // Recording is a one-off authoring step, so serialise it instead of losing requests.
+    const workers = harMode === 'update' ? 1 : (flags.workers ?? proc?.workers);
+    if (harMode === 'update' && (flags.workers ?? proc?.workers ?? 0) > 1) {
+        warn('Recording HAR fixtures runs with a single worker so shared files keep every request.');
+    }
+    const failOnFlaky = flags.failOnFlaky ?? proc?.failOnFlaky ?? false;
+    for (const l of layers) {
+        if (!projectCfg.layers.includes(l)) {
+            throw new SdodsError('CONFIG_INVALID', `Layer "${l}" is not enabled for project ${entry.slug} (layers: ${projectCfg.layers.join(', ')}).`, { exitCode: 2 });
+        }
+    }
+    for (const b of browsers) {
+        if (!projectCfg.browsers.includes(b)) {
+            throw new SdodsError('CONFIG_INVALID', `Browser "${b}" is not enabled for project ${entry.slug} (browsers: ${projectCfg.browsers.join(', ')}).`, { exitCode: 2 });
+        }
+    }
+    for (const m of modules)
+        moduleByName(projectCfg, m);
+    const runId = flags.runId ?? newRunId();
+    const cli = {
+        env: envName,
+        headed: flags.headed,
+        workers,
+        shard: flags.shard,
+        retries,
+        runId,
+        artifactsDir: flags.artifactsDir,
+        harMode: harMode,
+        offline: flags.strict && harMode === 'replay' ? true : undefined,
+        updateSnapshots: flags.updateSnapshots,
+    };
+    const cfg = ctx.registry.resolve(entry.slug, envName, cli);
+    const runDir = cfg.runtime.runDir;
+    mkdirSync(runDir, { recursive: true });
+    const manifest = {
+        runId,
+        projectSlug: entry.slug,
+        env: cfg.env.name,
+        tagsExpr: tags,
+        layers: layers.length ? layers : projectCfg.layers,
+        browsers: browsers.length ? browsers : projectCfg.browsers,
+        suiteTag: tags && /^@[a-z]+$/.test(tags) ? tags : undefined,
+        trigger: flags.trigger ?? 'cli',
+        git: await gitInfo(ctx.rootDir),
+        ci: process.env.GITHUB_ACTIONS
+            ? {
+                provider: 'github',
+                runId: process.env.GITHUB_RUN_ID,
+                url: `${process.env.GITHUB_SERVER_URL}/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`,
+            }
+            : undefined,
+        startedAt: new Date().toISOString(),
+        command: process.argv.slice(2).join(' '),
+        shardIndex: cfg.runtime.shard?.current,
+        shardTotal: cfg.runtime.shard?.total,
+        process: proc?.name,
+        modules: modules.length ? modules : undefined,
+        sdodsVersion: VERSION,
+    };
+    const writeManifest = () => writeFileSync(join(runDir, runFiles.manifest), JSON.stringify(manifest, null, 2));
+    writeManifest();
+    if (flags.lint !== false) {
+        const result = await lintProject({ project: cfg.project });
+        if (result.errors.length) {
+            process.stderr.write(formatFindings(result) + '\n');
+            throw new SdodsError('LINT_FAILED', `${result.errors.length} lint error(s) in project ${entry.slug}. Fix them or pass --no-lint.`, { exitCode: 3 });
+        }
+        if (result.warnings.length && ctx.opts.verbose)
+            process.stderr.write(formatFindings(result) + '\n');
+    }
+    const selection = {
+        project: entry.slug,
+        env: cfg.env.name,
+        layers: layers.length ? layers : undefined,
+        browsers: browsers.length ? browsers : undefined,
+        tags,
+        runId,
+        allure: flags.allure,
+        reporters: flags.reporter.length ? flags.reporter : undefined,
+        reporterMode: flags.reporterMode ??
+            (ctx.opts.quiet ? 'quiet' : 'default'),
+    };
+    const childEnv = {
+        ...process.env,
+        SDODS_ROOT: ctx.rootDir,
+        SDODS_PROJECT: entry.slug,
+        SDODS_ENV: cfg.env.name,
+        SDODS_TAGS: tags ?? '',
+        SDODS_LAYERS: selection.layers?.join(',') ?? '',
+        SDODS_BROWSERS: selection.browsers?.join(',') ?? '',
+        SDODS_RUN_ID: runId,
+        SDODS_ALLURE: flags.allure ? '1' : '',
+        SDODS_REPORTERS: selection.reporters?.join(',') ?? '',
+        SDODS_REPORTER_MODE: selection.reporterMode ?? 'default',
+        SDODS_PROCESS: proc?.name ?? '',
+        SDODS_MODULES: modules.join(','),
+        [CLI_OVERRIDES_ENV]: serializeCliOverrides(cli),
+        FORCE_COLOR: ctx.opts.color === false ? '0' : (process.env.FORCE_COLOR ?? '1'),
+    };
+    if (flags.updateSnapshots)
+        childEnv.SDODS_UPDATE_SNAPSHOTS = '1';
+    if (harMode)
+        childEnv.SDODS_HAR_MODE = harMode;
+    if (flags.strict && harMode === 'replay')
+        childEnv.SDODS_OFFLINE = '1';
+    const configPath = join(ctx.rootDir, 'sdods.runner.config.ts');
+    if (!existsSync(configPath)) {
+        throw new SdodsError('CONFIG_NOT_FOUND', `No runner config at ${configPath}.`, {
+            hint: 'Run `sdods init` or copy the template from the SDODS repo.',
+        });
+    }
+    const runnerProjects = listGeneratedProjects(ctx.registry, selection);
+    if (!runnerProjects.length) {
+        throw new SdodsError('CONFIG_INVALID', 'The selection produced no run targets.', {
+            hint: 'Check --layer / --browser against the project yaml.',
+            exitCode: 2,
+        });
+    }
+    // Recorded specs are plain runner tests: no Gherkin to generate.
+    const recordedOnly = runnerProjects.every((p) => p.layer === 'recorded');
+    if (!recordedOnly) {
+        const gen = await execa('npx', ['bddgen', '-c', configPath], {
+            cwd: ctx.rootDir,
+            env: childEnv,
+            stdio: ctx.opts.quiet ? 'pipe' : 'inherit',
+            reject: false,
+        });
+        if (gen.exitCode !== 0) {
+            if (ctx.opts.quiet && gen.stderr)
+                process.stderr.write(gen.stderr + '\n');
+            throw new SdodsError('RUN_FAILED', 'bddgen failed to generate specs.', {
+                hint: 'Run `sdods lint -p <slug> --undefined-steps` to find undefined steps.',
+                exitCode: 2,
+            });
+        }
+    }
+    const args = ['playwright', 'test', '-c', configPath, '--pass-with-no-tests'];
+    for (const p of runnerProjects)
+        args.push('--project', p.name);
+    if (flags.headed)
+        args.push('--headed');
+    if (workers)
+        args.push('--workers', String(workers));
+    if (flags.shard)
+        args.push('--shard', flags.shard);
+    if (retries !== undefined)
+        args.push('--retries', String(retries));
+    if (flags.grep)
+        args.push('--grep', flags.grep);
+    if (flags.scenario)
+        args.push('--grep', escapeRe(flags.scenario));
+    if (flags.repeatEach)
+        args.push('--repeat-each', String(flags.repeatEach));
+    if (flags.maxFailures)
+        args.push('--max-failures', String(flags.maxFailures));
+    if (flags.timeout)
+        args.push('--timeout', String(flags.timeout));
+    if (flags.updateSnapshots)
+        args.push('--update-snapshots');
+    if (failOnFlaky)
+        args.push('--fail-on-flaky-tests');
+    if (flags.ui)
+        args.push('--ui');
+    if (flags.debug)
+        args.push('--debug');
+    if (flags.list)
+        args.push('--list');
+    // module / feature restriction → generated spec path filters (features/<dir>/x.feature → .sdods/generated/<slug>/<layer>/<dir>/x.feature.spec.js)
+    const filters = [];
+    for (const m of modules) {
+        const rel = relative(join(cfg.project.root, 'features'), moduleDir(cfg.project.root, moduleByName(projectCfg, m))).replace(/\\/g, '/');
+        filters.push(`\\.sdods/generated/${escapeRe(runId)}/${escapeRe(entry.slug)}/[^/]+/${escapeRe(rel)}/`);
+    }
+    if (flags.feature)
+        filters.push(escapeRe(flags.feature.replace(/^features\//, '').replace(/\.feature$/, '')) +
+            '\\.feature\\.spec');
+    // positional filters must precede `--project` (variadic in the runner CLI)
+    args.splice(4, 0, ...filters);
+    if (flags.list) {
+        out(pc.bold('Run targets:'));
+        for (const p of runnerProjects)
+            out(`  ${p.name}`);
+        const listed = await execa('npx', args, {
+            cwd: ctx.rootDir,
+            env: childEnv,
+            stdio: 'inherit',
+            reject: false,
+        });
+        rmSync(join(ctx.rootDir, '.sdods', 'generated', runId), { recursive: true, force: true });
+        rmSync(runDir, { recursive: true, force: true });
+        return listed.exitCode ?? 0;
+    }
+    out(pc.dim(`run ${runId} · project ${entry.slug} · env ${cfg.env.name}${tags ? ` · tags ${tags}` : ''}${proc ? ` · process ${proc.name}` : ''}${modules.length ? ` · modules ${modules.join(',')}` : ''}`));
+    out(pc.dim(`projects: ${runnerProjects.map((p) => p.name).join(', ')}`));
+    const started = Date.now();
+    const child = execa('npx', args, {
+        cwd: ctx.rootDir,
+        env: childEnv,
+        stdio: 'inherit',
+        reject: false,
+    });
+    const onSignal = () => child.kill('SIGTERM');
+    process.once('SIGINT', onSignal);
+    process.once('SIGTERM', onSignal);
+    const result = await child;
+    process.off('SIGINT', onSignal);
+    process.off('SIGTERM', onSignal);
+    const exitCode = result.signal === 'SIGINT' || result.signal === 'SIGTERM' ? 130 : (result.exitCode ?? 1);
+    rmSync(join(ctx.rootDir, '.sdods', 'generated', runId), { recursive: true, force: true });
+    manifest.finishedAt = new Date().toISOString();
+    manifest.exitCode = exitCode;
+    writeManifest();
+    const summary = readSummary(runDir, runId, exitCode, Date.now() - started);
+    if (summary)
+        writeFileSync(join(runDir, runFiles.summary), JSON.stringify(summary, null, 2));
+    const dbConfigured = process.env.DB_DRIVER === 'postgres'
+        ? Boolean(process.env.DATABASE_URL)
+        : existsSync(resolvePath(ctx.rootDir, process.env.SQLITE_PATH ?? '.sdods/sdods.db'));
+    if (flags.ingest === true || (flags.ingest !== false && dbConfigured)) {
+        try {
+            const dbModule = '@sdods/db';
+            const mod = (await import(dbModule));
+            const adb = await mod.openDb();
+            try {
+                await mod.ingestRun(adb, { artifactsRoot: cfg.runtime.artifactsDir, runId });
+                manifest.ingestedAt = new Date().toISOString();
+                writeManifest();
+                out(pc.dim(`ingested run ${runId} into the ${process.env.DB_DRIVER ?? 'sqlite'} database`));
+            }
+            finally {
+                await adb.close();
+            }
+        }
+        catch (e) {
+            warn(`ingest skipped: ${e.message}`);
+        }
+    }
+    if (summary && summary.totals.total === 0)
+        warn(`No scenarios matched the selection${tags ? ` (tags: ${tags})` : ''}.`);
+    if (ctx.opts.json) {
+        json({ runId, runDir, exitCode, summary, manifest });
+    }
+    else {
+        const t = summary?.totals;
+        out('');
+        out(`${exitCode === 0 ? pc.green('✔ passed') : exitCode === 130 ? pc.yellow('■ cancelled') : pc.red('✖ failed')}  ${t ? `${t.passed} passed, ${t.failed} failed, ${t.skipped} skipped, ${t.flaky} flaky` : ''}  ${pc.dim(`(${Math.round((Date.now() - started) / 1000)}s)`)}`);
+        out(pc.dim(`artifacts:   ${runDir}`));
+        out(pc.dim(`html report: ${join(runDir, runFiles.htmlReport, 'index.html')}`));
+        out(pc.dim(`dashboard:   ${join(runDir, runFiles.dashboard, 'index.html')}`));
+    }
+    return exitCode;
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+async function gitInfo(cwd) {
+    try {
+        const sha = (await execa('git', ['rev-parse', 'HEAD'], { cwd })).stdout.trim();
+        const branch = (await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd })).stdout.trim();
+        const dirty = (await execa('git', ['status', '--porcelain'], { cwd })).stdout.trim().length > 0;
+        return { sha, branch, dirty };
+    }
+    catch {
+        return undefined;
+    }
+}
+function readSummary(runDir, runId, exitCode, durationMs) {
+    const metrics = join(runDir, runFiles.dashboard, 'metrics.json');
+    if (!existsSync(metrics))
+        return undefined;
+    try {
+        const m = JSON.parse(readFileSync(metrics, 'utf8'));
+        return {
+            runId,
+            status: exitCode === 0 ? 'passed' : exitCode === 130 ? 'cancelled' : 'failed',
+            totals: { ...m.summary, durationMs },
+            byProject: m.byProject,
+            failed: m.failed ?? [],
+            flaky: m.flaky ?? [],
+            reportPaths: {
+                html: join(runDir, runFiles.htmlReport, 'index.html'),
+                dashboard: join(runDir, runFiles.dashboard, 'index.html'),
+                messages: join(runDir, runFiles.messages),
+            },
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=run.js.map

package/dist/commands/schedule.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function register(program: Command): void;
+//# sourceMappingURL=schedule.d.ts.map