@asrunjs/asrun 0.0.0-stage → 0.5.2

package/dist/lib/write-gate.d.ts

@@ -0,0 +1,41 @@
+import { type RunFilters } from './run-filters.js';
+/** Set by `pnpm asrun` once a human confirmed that cases may write test data in this (protected) environment. */
+export declare const ALLOW_WRITES_ENV = "ASRUN_ALLOW_WRITES";
+/** Every environment except staging needs an explicit permission before a case may write data. */
+export declare const isProtectedEnv: (env: string) => boolean;
+export interface WriteCase {
+    id: string;
+    note: string;
+    /** Profiles whose test data the case will write to in this run. */
+    profiles: string[];
+}
+/** The write cases of a run, split by whether the environment is one the case may write in. */
+export interface WriteCases {
+    /** The case lists this environment under `writes`: it writes here, after the confirmation in a protected one. */
+    writing: WriteCase[];
+    /** The case writes only in other environments: it is skipped here with a notice, not failed. */
+    skipped: WriteCase[];
+}
+/** Can a case run in this environment at all (`envs` in its front matter)? */
+export declare function caseRunsIn(caseId: string, env: string): boolean;
+/** One case of a run and the profiles it runs for. `skip` says why it is skipped in this environment, if it is. */
+export interface PlannedCase {
+    id: string;
+    profiles: string[];
+    writes: boolean;
+    skip: string | null;
+}
+/**
+ * Every case that a run with these filters would list, as Playwright itself reports it (`--list`), so project, grep
+ * and suite filters are applied exactly as in the real run. Async, so a slow list of tests never blocks the UI server.
+ * Rejects with a readable message when Playwright cannot list the tests (for example an invalid grep expression).
+ */
+export declare function planRun(filters: RunFilters): Promise<PlannedCase[]>;
+/**
+ * The cases that a run with these filters would execute and that write data, split into those that write in this
+ * environment and those that are skipped here. Asks Playwright itself
+ * (`--list`), so project, grep and suite filters are applied exactly as in the real run.
+ */
+export declare function findWriteCases(filters: RunFilters): WriteCases;
+export declare function describeWriteCases(env: string, cases: WriteCase[]): string;
+export declare function describeSkippedWriteCases(env: string, cases: WriteCase[]): string;

package/dist/lib/write-gate.js

@@ -0,0 +1,129 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { STAGING } from './profiles.js';
+import { caseWrites, caseWritesIn, readCaseMeta } from './cases.js';
+import { commandScript } from './node-cli.js';
+import { ROOT } from './paths.js';
+import { filterArgs } from './run-filters.js';
+import { caseIdFromFile } from './run-summary.js';
+/** Set by `pnpm asrun` once a human confirmed that cases may write test data in this (protected) environment. */
+export const ALLOW_WRITES_ENV = 'ASRUN_ALLOW_WRITES';
+/** Every environment except staging needs an explicit permission before a case may write data. */
+export const isProtectedEnv = (env) => env !== STAGING;
+/** Can a case run in this environment at all (`envs` in its front matter)? */
+export function caseRunsIn(caseId, env) {
+    const { envs } = readCaseMeta(caseId);
+    return envs === null || envs.includes(env);
+}
+const PLAYWRIGHT = commandScript('@playwright/test', 'playwright');
+const listArgs = (filters) => ['test', '--list', '--reporter=json', ...filterArgs(filters)];
+const listEnv = (env) => ({ ...process.env, ASRUN_ENV: env });
+/** The profiles that a `--list` report schedules for each case. Throws when Playwright reported a real error. */
+function profilesByCaseOf(stdout, stderr) {
+    let report;
+    try {
+        report = JSON.parse(stdout);
+    }
+    catch {
+        throw new Error(`Could not list the tests: ${(stderr || stdout).trim().slice(0, 400)}`);
+    }
+    // "No tests found" is an empty result, not a failure; anything else (an invalid expression, a broken spec) is.
+    const problem = (report.errors ?? []).find((error) => !/No tests found/.test(error.message ?? ''));
+    if (problem)
+        throw new Error(String(problem.message ?? 'Playwright could not list the tests.').trim().slice(0, 400));
+    const profilesByCase = new Map();
+    const visit = (suite) => {
+        for (const spec of suite.specs ?? []) {
+            const caseId = caseIdFromFile(spec.file);
+            for (const test of spec.tests ?? []) {
+                const profile = String(test.projectName);
+                if (!profilesByCase.has(caseId))
+                    profilesByCase.set(caseId, new Set());
+                profilesByCase.get(caseId).add(profile);
+            }
+        }
+        for (const child of suite.suites ?? [])
+            visit(child);
+    };
+    for (const suite of report.suites ?? [])
+        visit(suite);
+    return profilesByCase;
+}
+/**
+ * Every case that a run with these filters would list, as Playwright itself reports it (`--list`), so project, grep
+ * and suite filters are applied exactly as in the real run. Async, so a slow list of tests never blocks the UI server.
+ * Rejects with a readable message when Playwright cannot list the tests (for example an invalid grep expression).
+ */
+export async function planRun(filters) {
+    const { stdout, stderr } = await new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [PLAYWRIGHT, ...listArgs(filters)], { cwd: ROOT, env: listEnv(filters.env) });
+        let out = '';
+        let err = '';
+        child.stdout.on('data', (chunk) => (out += chunk));
+        child.stderr.on('data', (chunk) => (err += chunk));
+        child.on('error', reject);
+        // The exit code is not checked: "no tests found" exits with 1 but still prints a valid (empty) report.
+        child.on('close', () => resolve({ stdout: out, stderr: err }));
+    });
+    const planned = [];
+    for (const [id, profiles] of profilesByCaseOf(stdout, stderr)) {
+        let meta;
+        try {
+            meta = readCaseMeta(id);
+        }
+        catch {
+            continue; // seed.spec.ts and other specs without a case document
+        }
+        const skip = !caseRunsIn(id, filters.env)
+            ? `Limited to: ${meta.envs?.join(', ')}`
+            : caseWrites(meta) && !caseWritesIn(meta, filters.env)
+                ? `Writes data, no permission in ${filters.env.toUpperCase()}`
+                : null;
+        planned.push({ id, profiles: [...profiles].sort(), writes: caseWrites(meta), skip });
+    }
+    return planned.sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+ * The cases that a run with these filters would execute and that write data, split into those that write in this
+ * environment and those that are skipped here. Asks Playwright itself
+ * (`--list`), so project, grep and suite filters are applied exactly as in the real run.
+ */
+export function findWriteCases(filters) {
+    const env = filters.env;
+    const result = spawnSync(process.execPath, [PLAYWRIGHT, ...listArgs(filters)], {
+        cwd: ROOT,
+        encoding: 'utf8',
+        env: listEnv(env),
+        maxBuffer: 50_000_000,
+    });
+    const profilesByCase = profilesByCaseOf(result.stdout, result.stderr);
+    const writing = [];
+    const skipped = [];
+    for (const [id, profiles] of profilesByCase) {
+        let meta;
+        try {
+            meta = readCaseMeta(id);
+        }
+        catch {
+            continue; // seed.spec.ts and other specs without a case document
+        }
+        if (!caseWrites(meta) || !caseRunsIn(id, env))
+            continue;
+        (caseWritesIn(meta, env) ? writing : skipped).push({ id, note: meta.writesNote ?? '', profiles: [...profiles].sort() });
+    }
+    const byId = (a, b) => a.id.localeCompare(b.id);
+    return { writing: writing.sort(byId), skipped: skipped.sort(byId) };
+}
+export function describeWriteCases(env, cases) {
+    return [
+        `${cases.length} case(s) in this run write data in ${env.toUpperCase()}:`,
+        ...cases.flatMap((item) => [`  - ${item.id}  (profiles: ${item.profiles.join(', ')})`, `      ${item.note}`]),
+        'They only touch data of the test accounts. They never send email in production.',
+    ].join('\n');
+}
+export function describeSkippedWriteCases(env, cases) {
+    return [
+        `Skipped: ${cases.length} case(s) write data but have no permission to write in ${env.toUpperCase()}:`,
+        ...cases.map((item) => `  - ${item.id}`),
+        `To allow one, add "${env}" to "writes" in its front matter (and make sure it cleans up).`,
+    ].join('\n');
+}

package/dist/playwright.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@playwright/test").PlaywrightTestConfig<{}, {}>;
+export default _default;

package/dist/playwright.config.js

@@ -0,0 +1,92 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { defineConfig, devices } from '@playwright/test';
+import { listProfiles } from './lib/profiles.js';
+import { authFile, isFrameworkRoot, REPORTS_DIR, ROOT, TEMPLATES_DIR, TMP_DIR } from './lib/paths.js';
+import { parseNotLoggedIn } from './lib/session.js';
+import { PRODUCT_NAME } from './ui/shared/product.js';
+const runId = process.env.ASRUN_RUN_ID ?? 'adhoc';
+// Set by `pnpm asrun --env <env>`. Without it (MCP exploration, `--list`) every profile is a project.
+const runEnv = process.env.ASRUN_ENV;
+const stepText = process.env.ASRUN_STEP_TEXT === '1';
+// Exploration through the MCP (and `--list`) has no environment. Nobody needs videos, traces or screenshots there,
+// and encoding a video of a long, busy session can stall the browser.
+const recording = runEnv !== undefined;
+const notLoggedIn = parseNotLoggedIn();
+const profiles = listProfiles();
+const selected = profiles.filter((profile) => !runEnv || profile.env === runEnv);
+if (profiles.length === 0) {
+    throw new Error(`No profiles in ${path.join(ROOT, 'profiles.yaml')}. Add one entry per environment (see ` +
+        `${path.join(TEMPLATES_DIR, 'profiles.yaml')}), then log in with "pnpm signin <profile-id>".` +
+        (isFrameworkRoot()
+            ? ' This looks like the framework folder itself: run the command in a project that uses the framework, or set ASRUN_ROOT.'
+            : ''));
+}
+if (runEnv !== undefined && selected.length === 0) {
+    throw new Error(`profiles.yaml has no profile with "env: ${runEnv}". Known environments: ${[...new Set(profiles.map((profile) => profile.env))].join(', ')}.`);
+}
+// Every path is absolute on purpose: a project that uses the framework re-exports this file from its own
+// `playwright.config.ts`, and Playwright resolves relative paths against the file that holds them (this one).
+// The compiled package has `summary-reporter.js`; the framework repository runs the `.ts` source.
+const summaryReporter = [path.join(import.meta.dirname, 'lib', 'summary-reporter.js'), path.join(import.meta.dirname, 'lib', 'summary-reporter.ts')].find((file) => fs.existsSync(file));
+export default defineConfig({
+    testDir: path.join(ROOT, 'tests'),
+    outputDir: path.join(TMP_DIR, 'results'),
+    timeout: 60_000,
+    expect: {
+        timeout: 10_000,
+        toHaveScreenshot: { maxDiffPixelRatio: 0.01, animations: 'disabled' },
+    },
+    retries: 1,
+    // Be gentle with the sites under test.
+    workers: 2,
+    metadata: {
+        environment: runEnv ? runEnv.toUpperCase() : 'not set',
+        runId,
+        workspace: ROOT,
+    },
+    reporter: [
+        ['list'],
+        [
+            'html',
+            {
+                outputFolder: path.join(REPORTS_DIR, runId, 'html'),
+                open: 'never',
+                title: runEnv ? `${PRODUCT_NAME} report - ${runEnv.toUpperCase()} - ${runId}` : `${PRODUCT_NAME} report - ${runId}`,
+            },
+        ],
+        [summaryReporter],
+    ],
+    use: {
+        // Project convention in uc-frontend: data-tn attributes.
+        testIdAttribute: 'data-tn',
+        // `pnpm asrun --step-text` overlays the current test.step() title on the video.
+        video: recording
+            ? {
+                mode: 'on',
+                size: { width: 1440, height: 900 },
+                ...(stepText && { show: { test: { level: 'step', position: 'top-left' } } }),
+            }
+            : 'off',
+        trace: recording ? 'on' : 'off',
+        screenshot: recording ? 'on' : 'off',
+        // Without these a locator that matches nothing (a dialog that never opened) waits for ever. In a test the 60 s
+        // test timeout ended it anyway; in an MCP exploration nothing did, and the agent hung.
+        actionTimeout: 15_000,
+        navigationTimeout: 30_000,
+        locale: 'en-US',
+        timezoneId: 'America/New_York',
+    },
+    // One project per profile. Baseline images are stored per project, so every environment keeps its own.
+    projects: selected.map((profile) => ({
+        name: profile.id,
+        // Retrying cannot fix a missing login.
+        ...(notLoggedIn.has(profile.id) && { retries: 0 }),
+        use: {
+            ...devices['Desktop Chrome'],
+            viewport: { width: 1440, height: 900 },
+            baseURL: profile.baseURL,
+            ...(fs.existsSync(authFile(profile.id)) && { storageState: authFile(profile.id) }),
+        },
+    })),
+});

package/dist/scripts/build.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/build.js

@@ -0,0 +1,21 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { COPIED_SCRIPTS } from '../lib/build-artifacts.js';
+import { commandScript } from '../lib/node-cli.js';
+import { FRAMEWORK_ROOT } from '../lib/paths.js';
+// Compiles the framework to `dist/`: JavaScript and type declarations that Node and Playwright can load from a
+// node_modules folder (Node refuses to strip types there). The plain `.mjs` tools are copied as they are.
+const tsc = commandScript('typescript', 'tsc');
+const result = spawnSync(process.execPath, [tsc, '-p', path.join(FRAMEWORK_ROOT, 'tsconfig.build.json')], {
+    cwd: FRAMEWORK_ROOT,
+    stdio: 'inherit',
+});
+if ((result.status ?? 1) !== 0)
+    process.exit(result.status ?? 1);
+for (const file of COPIED_SCRIPTS) {
+    const from = path.join(FRAMEWORK_ROOT, 'scripts', file);
+    const to = path.join(FRAMEWORK_ROOT, 'dist', 'scripts', file);
+    fs.mkdirSync(path.dirname(to), { recursive: true });
+    fs.copyFileSync(from, to);
+}

package/dist/scripts/check-cases.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/check-cases.js

@@ -0,0 +1,149 @@
+import fs from 'node:fs';
+import { CASES_DIR } from '../lib/paths.js';
+import { listCaseFileIds, readCaseMeta } from '../lib/cases.js';
+import { parseCaseDocument } from '../lib/case-doc.js';
+import path from 'node:path';
+import { ROOT } from '../lib/paths.js';
+import { checksNeedingTarget, parseTargets, readCaseText, REQUIRED_FIELDS, targetRefsIn } from '../lib/targets.js';
+import { parseCaseValues } from '../lib/values.js';
+/** Step numbers of the lines marked `[input]` or `[writes]` in "## Steps" (a person does them), and the numbers that have a `- Recipe:` line under them (or an old "## Inputs" line). */
+function inputSteps(id) {
+    const doc = parseCaseDocument(fs.readFileSync(path.join(CASES_DIR, `${id}.md`), 'utf8'));
+    const marked = doc.steps
+        .filter((step) => step.tags.includes('input') || step.tags.includes('writes'))
+        .map((step) => step.number);
+    const recorded = [
+        ...doc.steps.flatMap((step) => step.recipes.map(() => step.number)),
+        ...doc.inputs.map((input) => input.step).filter((step) => step !== null),
+    ];
+    return { marked, recorded };
+}
+/**
+ * Warnings about the question blocks and the recipe lines of a case: a block nobody can answer, an answer that is not
+ * the last line (so the agent cannot tell what it belongs to), a question with no text to keep, a nesting that Markdown
+ * will not render inside its step, and a recipe under a step that is not tagged (all `warn`: old cases keep working).
+ */
+function questionProblems(id) {
+    const doc = parseCaseDocument(fs.readFileSync(path.join(CASES_DIR, `${id}.md`), 'utf8'));
+    const warnings = [];
+    for (const question of doc.questions) {
+        if (!question.hasAnswerLine) {
+            warnings.push(`the question on line ${question.line} has no "✍️ Answer:" line; add one so it can be answered in place`);
+        }
+        else if (question.answerLine !== question.lastLine) {
+            warnings.push(`the "✍️ Answer:" line of the question on line ${question.line} is not the last line of its block`);
+        }
+        if (!question.parent) {
+            warnings.push(`the question on line ${question.line} has no text above it: accepting it would delete a claim nobody sees`);
+            continue;
+        }
+        const step = doc.steps.find((candidate) => candidate.line === question.parent?.line);
+        if (step && question.indent < 4) {
+            warnings.push(`the question on line ${question.line} is indented by ${question.indent} space(s) under step ${step.number}; 4 renders it inside the step`);
+        }
+    }
+    for (const step of doc.steps) {
+        if (step.recipes.length === 0)
+            continue;
+        if (!step.tags.includes('input') && !step.tags.includes('writes')) {
+            warnings.push(`step ${step.number} has a "- Recipe:" line but is not tagged [input] or [writes]`);
+        }
+    }
+    for (const input of doc.inputs) {
+        if (input.step === null)
+            continue;
+        const step = doc.steps.find((candidate) => candidate.number === input.step);
+        if (!step) {
+            warnings.push(`"## Inputs" line ${input.line} (old format) belongs to step ${input.step}, which this case does not have`);
+        }
+        else if (!step.tags.includes('input') && !step.tags.includes('writes')) {
+            warnings.push(`"## Inputs" line ${input.line} (old format) belongs to step ${input.step}, which is not tagged [input] or [writes]`);
+        }
+    }
+    return warnings;
+}
+/**
+ * Warnings for the old layout. `## Data` and `## Inputs` are deprecated: the one-sentence summary belongs in
+ * `writes-note`, the cleanup in steps, and a person's recipe under its step. Cases keep working, so this never fails.
+ */
+function formatProblems(id) {
+    const doc = parseCaseDocument(fs.readFileSync(path.join(CASES_DIR, `${id}.md`), 'utf8'));
+    const warnings = [];
+    if (doc.sections.some((section) => section.name === 'Data')) {
+        warnings.push('has a "## Data" section, which is no longer part of the case format: move it into "writes-note", the delete steps or "## Notes"');
+    }
+    if (doc.inputs.length > 0) {
+        warnings.push('uses the old "## Inputs" section: move each line under its step as "- Recipe (phase): ..."');
+    }
+    return warnings;
+}
+/** Problems with the target cards (`## Targets`) of a case: `fail` stops, `warn` is what `/explore-case` still has to settle. */
+function targetProblems(id) {
+    const text = readCaseText(id);
+    const cards = parseTargets(text);
+    const fail = [];
+    const warn = [];
+    const known = new Set(cards.map((card) => card.id));
+    for (const card of cards) {
+        const missing = REQUIRED_FIELDS.filter((field) => !card.fields[field]);
+        if (missing.length > 0 && !card.blocking)
+            fail.push(`target ${card.id} "${card.name}" has no ${missing.map((field) => `"${field}"`).join(', ')}`);
+        for (const [label, file] of Object.entries(card.references)) {
+            if (/^none\b/i.test(file))
+                continue;
+            // References live in .explore/ (git-ignored, they show logged-in pages), so a fresh checkout has none: a warning.
+            if (!file.startsWith('.explore/'))
+                fail.push(`target ${card.id}: the reference image for ${label} must be saved under .explore/targets/<case-id>/ (got ${file})`);
+            else if (!fs.existsSync(path.join(ROOT, file)))
+                warn.push(`target ${card.id}: the reference image for ${label} is not on this machine: ${file}`);
+        }
+        if (Object.keys(card.references).length === 0 && !card.blocking) {
+            warn.push(`target ${card.id} "${card.name}" has no "Reference <profile-id>:" line (a highlighted screenshot of what the check looks at, or "none: <reason>")`);
+        }
+    }
+    const body = text.replace(/^## Targets\s*$[\s\S]*?(?=^## |(?![\s\S]))/m, '').replace(/^## Source\s*$[\s\S]*?(?=^## |(?![\s\S]))/m, '');
+    for (const ref of targetRefsIn(body))
+        if (!known.has(ref))
+            fail.push(`a check refers to [${ref}] but "## Targets" has no card ${ref}`);
+    for (const check of checksNeedingTarget(text)) {
+        warn.push(`"${check.section}" has a check on an image, file or logo without a target card ([T<n>]): ${check.line.slice(0, 90)}`);
+    }
+    try {
+        const values = parseCaseValues(text, `cases/${id}.md`);
+        if (Object.keys(values).length === 0) {
+            warn.push('has no "## Values" block; a spec that asserts expected values cannot run for any profile');
+        }
+    }
+    catch (error) {
+        fail.push(error.message);
+    }
+    return { fail, warn };
+}
+const ids = process.argv.slice(2).length > 0 ? process.argv.slice(2) : listCaseFileIds();
+let problems = 0;
+for (const id of ids) {
+    try {
+        const meta = readCaseMeta(id);
+        console.log(`ok   ${id}  suites=[${meta.suites.join(', ')}]  writes=[${meta.writes.join(', ')}]` +
+            `${meta.envs ? `  envs=[${meta.envs.join(', ')}]` : ''}`);
+        const targets = targetProblems(id);
+        for (const message of targets.warn)
+            console.log(`warn ${id}: ${message}`);
+        for (const message of targets.fail)
+            throw new Error(message);
+        const { marked, recorded } = inputSteps(id);
+        const missing = marked.filter((step) => !recorded.includes(step));
+        if (missing.length > 0) {
+            console.log(`warn ${id}: step ${missing.join(', ')} is marked [input] or [writes] but has no "- Recipe:" line under it (run /explore-case --attended)`);
+        }
+        for (const message of formatProblems(id))
+            console.log(`warn ${id}: ${message}`);
+        for (const message of questionProblems(id))
+            console.log(`warn ${id}: ${message}`);
+    }
+    catch (error) {
+        problems++;
+        console.error(`FAIL ${id}: ${error.message}`);
+    }
+}
+process.exit(problems > 0 ? 1 : 0);

package/dist/scripts/cleanup.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/cleanup.js

@@ -0,0 +1,25 @@
+import { listEnvs } from '../lib/profiles.js';
+import { describeLeftovers, findLeftovers, forgetLedgers } from '../lib/records.js';
+const args = process.argv.slice(2);
+const envArg = args.find((arg) => arg.startsWith('--env='))?.slice('--env='.length) ?? args[args.indexOf('--env') + 1];
+const forget = args.includes('--forget');
+if (!envArg || !listEnvs().includes(envArg)) {
+    console.error('Usage: pnpm cleanup --env <env> [--forget]\n' +
+        `  --env is required (${listEnvs().join(' | ')}); there is no default.\n` +
+        '  Lists test data that cases created and could not remove (from .tmp/records).\n' +
+        '  Delete it by hand in the product, then run with --forget to clear the list.');
+    process.exit(1);
+}
+const leftovers = findLeftovers({ env: envArg });
+if (leftovers.length === 0) {
+    console.log(`No test data left behind in ${envArg.toUpperCase()}.`);
+    process.exit(0);
+}
+console.log(`Test data left behind in ${envArg.toUpperCase()} (named "[asrun] ..."):\n${describeLeftovers(leftovers)}`);
+if (forget) {
+    console.log(`\nForgot ${forgetLedgers(envArg)} ledger file(s). Only do this after the data is deleted.`);
+}
+else {
+    console.log('\nDelete these by hand in the product, then run: pnpm cleanup --env ' + envArg + ' --forget');
+    process.exit(1);
+}

package/dist/scripts/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/cli.js

@@ -0,0 +1,28 @@
+// `pnpm asrun <command>`: a thin dispatcher so every subcommand keeps one entry point.
+// Anything that is not a subcommand is passed to the run command unchanged.
+const [command, ...rest] = process.argv.slice(2);
+async function main() {
+    if (command === 'init') {
+        const { main: init } = await import('./init.js');
+        process.exitCode = await init(rest);
+        return;
+    }
+    if (command === 'doctor') {
+        const { main: doctor } = await import('./doctor.js');
+        process.exitCode = await doctor(rest);
+        return;
+    }
+    if (command === 'help' || command === '--help-init') {
+        console.log(USAGE);
+        return;
+    }
+    await import('./run.js');
+}
+const USAGE = `Usage: pnpm asrun [init|doctor] [options]
+
+  (no subcommand)  Run the tests of one environment. See "pnpm asrun --help".
+  init             Create the files a workspace needs (never overwrites; --update refreshes generated files,
+                   --root <dir> targets another folder, --force <path> overwrites one file).
+  doctor           Check the workspace: profiles, tsconfig alias, generated files, skill overrides.`;
+await main();
+export {};

package/dist/scripts/doctor.d.ts

@@ -0,0 +1 @@
+export declare function main(args: string[]): Promise<number>;