@asrunjs/asrun 0.0.0-stage → 0.5.2

package/dist/ui/shared/ai-commands.js

@@ -0,0 +1,177 @@
+export const AI_TOOLS = ['claude', 'opencode'];
+export const DEFAULT_AI_TOOL = 'claude';
+export const AI_TOOL_LABEL = { claude: 'Claude', opencode: 'OpenCode' };
+export const AI_COMMANDS = ['explore-case', 'gen-spec', 'heal-spec'];
+export const AI_COMMAND_LABEL = {
+    'explore-case': 'Explore case',
+    'gen-spec': 'Generate spec',
+    'heal-spec': 'Heal spec',
+};
+export const AI_COMMAND_WRITES = {
+    'explore-case': 'case',
+    'gen-spec': 'spec',
+    'heal-spec': 'files',
+};
+/**
+ * Every command opens real pages, so every command needs an environment and there is no default.
+ * Agents never write data in any of them: a person does those steps.
+ */
+export const AI_ENV_HINT = {
+    'explore-case': 'Where the agent explores. It only reads; with Attended on, you do the steps that write data.',
+    'gen-spec': 'Where the agent explores and verifies the spec.',
+    'heal-spec': 'Where the failing spec is diagnosed. Only the profiles that are logged in there are run.',
+};
+export const slashCommand = (command, caseId, options) => {
+    const { env, force, attended, profiles, hints, report } = options;
+    const heal = command === 'heal-spec';
+    return (`/${command} ${caseId} ${env}${force && command === 'gen-spec' ? ' --force' : ''}` +
+        `${attended && command === 'explore-case' ? ' --attended' : ''}` +
+        `${heal && profiles?.length ? ` --profiles ${profiles.join(',')}` : ''}` +
+        `${heal && report ? ` --report ${report}` : ''}` +
+        `${heal && hints ? ` --hints ${hints}` : ''}`);
+};
+/** The MCP tools of the Playwright server that agents explore with. */
+const PLAYWRIGHT_MCP = 'mcp__playwright-test__*';
+// Claude Code asks before using an MCP tool or running a command; a one-shot run cannot answer, so what the agent
+// needs is allowed up front. Edit rules are limited to the folders the command may change.
+function claudeAllowedTools(writes) {
+    // `node --import tsx` is the same check without tsx's CLI, which needs a local socket that Claude's sandbox refuses.
+    // The scripts sit in the framework folder (a submodule, so the path varies), hence the open prefix.
+    const nodeTsx = 'Bash(node --import tsx:*)';
+    const check = ['Bash(pnpm case:check:*)', nodeTsx];
+    const common = [PLAYWRIGHT_MCP, 'Bash(pnpm status:*)', 'Bash(pnpm pdf:render:*)', ...check];
+    if (writes === 'case')
+        return [...common, 'Edit(/cases/**)'];
+    if (writes === 'cases-new')
+        return [...check, 'Edit(/cases/**)'];
+    const spec = [
+        ...common,
+        'Edit(/cases/**)',
+        'Edit(/tests/**)',
+        'Bash(pnpm typecheck:*)',
+        'Bash(pnpm spec:lint:*)',
+        nodeTsx,
+        'Bash(pnpm baselines:review:*)',
+    ];
+    // Running specs is a separate process: only healing does it. `pnpm asrun` runs outside Claude's sandbox via
+    // `sandbox.excludedCommands` in .claude/settings.json, because tsx and the browser need local sockets and network.
+    // Healing reads the existing report first (`pnpm heal:evidence`) and reruns only when that is not enough.
+    return writes === 'spec' ? spec : [...spec, 'Bash(pnpm asrun:*)', 'Bash(pnpm heal:evidence:*)'];
+}
+// Never allowed in a one-shot run, whatever the command: AGENTS.md forbids agents to lift the write confirmation.
+const CLAUDE_DENIED_TOOLS = ['Bash(*--allow-writes*)', 'Bash(*ASRUN_ALLOW_WRITES*)'];
+/**
+ * Arguments that make the CLI print what it does as it goes (one JSON event per line) instead of the final answer only,
+ * so the job log shows which tool call is running. The server turns the events into log lines (`ai-stream.ts`).
+ */
+const STREAM_ARGS = {
+    claude: ['--output-format', 'stream-json', '--verbose'],
+    opencode: ['--format', 'json'],
+};
+function invocation(tool, prompt, writes, session, model, thinking) {
+    // OpenCode creates the session when the id does not exist yet, and continues it when it does.
+    // A model is named on every run: without one OpenCode falls back to its built-in free model, which has a daily
+    // usage limit, and nothing in the CLI's own state (the TUI's last-used model) applies to a one-shot run.
+    if (tool === 'opencode')
+        return {
+            file: 'opencode',
+            args: [
+                'run',
+                '--auto',
+                ...STREAM_ARGS.opencode,
+                ...(session ? ['-s', session.id] : []),
+                ...(model ? ['--model', model] : []),
+                // Without it OpenCode does not ask the model to think, so the reasoning it does would never reach the log.
+                // Claude Code has no such flag: it shows thinking when the model and its settings have it on.
+                ...(thinking ? ['--thinking'] : []),
+                prompt,
+            ],
+        };
+    return {
+        file: 'claude',
+        args: [
+            '-p',
+            prompt,
+            ...STREAM_ARGS.claude,
+            ...(session ? [session.resume ? '--resume' : '--session-id', session.id] : []),
+            // `acceptEdits` approves edits anywhere in the folder, which would void the narrow Edit rules below.
+            ...(writes === 'files' || writes === 'spec' ? ['--permission-mode', 'acceptEdits'] : []),
+            ...(model ? ['--model', model] : []),
+            '--allowedTools',
+            ...claudeAllowedTools(writes),
+            '--disallowedTools',
+            ...CLAUDE_DENIED_TOOLS,
+        ],
+    };
+}
+const commandLine = ({ file, args }) => [file, ...args.map((arg) => (/^[\w@=,.:/-]+$/.test(arg) ? arg : JSON.stringify(arg)))].join(' ');
+/**
+ * Said in every one-shot run: nobody is there to answer, so questions go into the case file and the last line
+ * is a result the UI can read. The skills define the details.
+ */
+const NON_INTERACTIVE = 'Non-interactive run: nobody can answer questions, so do not stop to ask. Write open questions into the case file ' +
+    'as the skill describes and end with the RESULT: line.';
+/**
+ * An attended exploration: nobody answers questions in the chat, but a person sits at the machine and works in the
+ * browser window, so the agent hands them the steps that write data and waits, as user-handoff.md describes.
+ */
+const ATTENDED = 'Attended run: a person is at the machine and the browser window is visible, so hand steps that write data or ' +
+    'need a choice to them and wait, as the skill describes. Start every handoff (also a second one in the same run) ' +
+    'with its own call that sets __handoffCfg, before the call that runs handoff-card.js, and never change those options ' +
+    'inside the call that runs the card: the web UI sees that a person is needed only from that call, so without it ' +
+    'there is no "Your turn" badge and no notification. Nobody can answer questions in the chat, so write open ' +
+    'questions into the case file as the skill describes and end with the RESULT: line.';
+/** The prompt of a one-shot run. `heal-spec` has no questions of its own, so it keeps the plain slash command. */
+export function headlessPrompt(command, caseId, options) {
+    const slash = slashCommand(command, caseId, options);
+    if (command === 'heal-spec')
+        return slash;
+    if (command === 'explore-case' && options.attended)
+        return `${slash} ${ATTENDED}`;
+    return `${slash} ${NON_INTERACTIVE}`;
+}
+/** Executable and arguments of the one-shot (non-interactive) run. */
+export function headlessInvocation(tool, command, caseId, options, session) {
+    return invocation(tool, headlessPrompt(command, caseId, options), AI_COMMAND_WRITES[command], session, options.model, options.thinking);
+}
+/** The one-shot command as it is typed in a shell. */
+export function headlessCommandLine(tool, command, caseId, options, session) {
+    return commandLine(headlessInvocation(tool, command, caseId, options, session));
+}
+/** Folder (relative to the AsRun root, git-ignored) where the clues typed into the Heal dialog are stored. */
+export const HINTS_DIR = '.tmp/hints';
+export const HINTS_MAX_CHARS = 8000;
+/** Folder (relative to the AsRun root, git-ignored) where the answers typed into the Continue box are stored. */
+export const REPLY_DIR = '.tmp/replies';
+export const REPLY_MAX_CHARS = 4000;
+export const USE_DEFAULTS_REPLY = 'Accept the suggestion of every open question: delete its TODO block and keep the sentence above it as confirmed text.';
+/**
+ * The next turn of a run that ended with `RESULT: needs-input`: the user's answers. They go into the case file, which
+ * stays the record of truth, and the task of the original command is finished. The answers come from a file
+ * (`.tmp/replies/…md`) rather than from the prompt, so a line break or a quote in them cannot break the command line.
+ */
+export function replyPrompt(command, replyFile) {
+    return (`The user answers your open questions (still nobody to ask, so do not stop to ask again). ` +
+        `Their answers are in ${replyFile}, relative to the project root: read that file first.\n` +
+        'Fold every answer into the case file as the skill describes: write the answer into the sentence above the ' +
+        'TODO block and remove the block, and keep a TODO block (with an empty Answer: line, emoji prefixes included) for what is still unknown. ' +
+        `Then finish the task of /${command} and end with the RESULT: line.`);
+}
+/** The next turn of an earlier run, in its session and with exactly the permissions of the first turn. */
+export function continueInvocation(tool, command, replyFile, sessionId, model, thinking) {
+    return invocation(tool, replyPrompt(command, replyFile), AI_COMMAND_WRITES[command], { id: sessionId, resume: true }, model, thinking);
+}
+export const continueCommandLine = (tool, command, replyFile, sessionId, model, thinking) => commandLine(continueInvocation(tool, command, replyFile, sessionId, model, thinking));
+/** Folder (relative to the AsRun root, git-ignored) where memos from the Cases page are stored. */
+export const MEMO_DIR = '.tmp/memos';
+export const MEMO_MAX_CHARS = 100_000;
+/** /make-case is interactive by design; a one-shot run cannot answer questions, so it must use the defaults. */
+export const makeCasePrompt = (memoPath) => `/make-case ${memoPath} ` +
+    'Non-interactive run: nobody can answer questions, so do not stop to ask. ' +
+    'Do not open a browser or explore pages. Write the suggested default of every gap as a normal sentence and put a ' +
+    'TODO block with an empty Answer: line under it, as open-questions.md describes (every marker starts with its emoji). ' +
+    'Never overwrite an existing case: choose a new id instead. ' +
+    'Put the cases of one area in a group folder (cases/<group>/<name>.md, id <group>/<name>), reusing an existing folder when it fits. ' +
+    'Write the cases, run pnpm case:check, and list the open questions in your final report.';
+export const makeCaseInvocation = (tool, memoPath, model, thinking) => invocation(tool, makeCasePrompt(memoPath), 'cases-new', undefined, model, thinking);
+export const makeCaseCommandLine = (tool, memoPath, model, thinking) => commandLine(makeCaseInvocation(tool, memoPath, model, thinking));

package/dist/ui/shared/case-id.d.ts

@@ -0,0 +1 @@
+export * from '../../lib/case-id.js';

package/dist/ui/shared/case-id.js

@@ -0,0 +1 @@
+export * from '../../lib/case-id.js';

package/dist/ui/shared/jobs.d.ts

@@ -0,0 +1,6 @@
+import type { JobInfo } from './types.js';
+/**
+ * The run that took over the answers of a `needs-input` run. A continuation that failed or was cancelled does not
+ * count: the questions are still open, so the earlier run can be continued again.
+ */
+export declare function findContinuation(jobs: readonly JobInfo[], jobId: string): JobInfo | undefined;

package/dist/ui/shared/jobs.js

@@ -0,0 +1,7 @@
+/**
+ * The run that took over the answers of a `needs-input` run. A continuation that failed or was cancelled does not
+ * count: the questions are still open, so the earlier run can be continued again.
+ */
+export function findContinuation(jobs, jobId) {
+    return jobs.find((job) => job.continuesJobId === jobId && (job.status === 'running' || job.status === 'succeeded'));
+}

package/dist/ui/shared/product.d.ts

@@ -0,0 +1,3 @@
+/** The product name shown to people. The command, the package and the environment variables stay lowercase:
+ * `asrun`, `@asrunjs/asrun`, `ASRUN_ROOT`. */
+export declare const PRODUCT_NAME = "AsRun";

package/dist/ui/shared/product.js

@@ -0,0 +1,3 @@
+/** The product name shown to people. The command, the package and the environment variables stay lowercase:
+ * `asrun`, `@asrunjs/asrun`, `ASRUN_ROOT`. */
+export const PRODUCT_NAME = 'AsRun';

package/dist/ui/shared/run-filters.d.ts

@@ -0,0 +1 @@
+export { casePattern } from '../../lib/run-filters.js';

package/dist/ui/shared/run-filters.js

@@ -0,0 +1 @@
+export { casePattern } from '../../lib/run-filters.js';

package/dist/ui/shared/site-address.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Completes a site address without a URL scheme: `example.com` becomes `https://example.com`.
+ * Anything that already starts with a scheme (`https://`, `http://`, `ftp://`, ...) is left alone,
+ * so the caller still decides whether the scheme is allowed.
+ */
+export declare function withScheme(value: string): string;

package/dist/ui/shared/site-address.js

@@ -0,0 +1,11 @@
+/** `https://`, `http://` and any other scheme the user typed: kept exactly as given. */
+const HAS_SCHEME = /^[a-z][a-z0-9+.-]*:\/\//i;
+/**
+ * Completes a site address without a URL scheme: `example.com` becomes `https://example.com`.
+ * Anything that already starts with a scheme (`https://`, `http://`, `ftp://`, ...) is left alone,
+ * so the caller still decides whether the scheme is allowed.
+ */
+export function withScheme(value) {
+    const text = value.trim();
+    return HAS_SCHEME.test(text) ? text : `https://${text}`;
+}

package/dist/ui/shared/types.d.ts

@@ -0,0 +1,371 @@
+import type { ResultStatus } from '../../lib/run-summary.js';
+import type { AiCommand, AiTool } from './ai-commands.js';
+export type JobStatus = 'running' | 'succeeded' | 'failed' | 'cancelled';
+export type JobKind = 'signin' | 'visit' | 'run' | 'ai';
+/** What changed on disk: case files (`cases/**`) and/or specs (`tests/**`). */
+export interface FilesChange {
+    cases: boolean;
+    specs: boolean;
+}
+export interface JobInfo {
+    id: string;
+    kind: JobKind;
+    /** Set for `signin` and `visit` jobs. */
+    profile?: string;
+    /** Environment of the job (`signin`, `visit` and `run`). */
+    env?: string;
+    /** Human-readable command, e.g. `pnpm signin example-staging`. */
+    command: string;
+    status: JobStatus;
+    exitCode: number | null;
+    signal: string | null;
+    startedAt: string;
+    endedAt: string | null;
+    /** The process reads stdin (used by `signin`, which waits for Enter). */
+    acceptsInput: boolean;
+    /** Set for a test run that overwrote the screenshot baselines of these cases. */
+    baselineCases?: string[];
+    /** Set for a test run: the folder under reports/ it writes (it may only exist once the run has produced one). */
+    reportId?: string;
+    /** Set for the one-shot runs of an AI command on a case. */
+    caseId?: string;
+    /** Set for the one-shot runs of an AI command on a case: which command ran. */
+    aiCommand?: AiCommand;
+    /** The conversation of an AI run; a later job can resume it. */
+    sessionId?: string;
+    /** The model the AI run was started with; omitted = the CLI's own choice. */
+    aiModel?: string;
+    /** What the agent said in its last `RESULT:` line; null when it did not say or the run did not succeed. */
+    resultState?: ResultState | null;
+    /** The earlier job whose conversation this job continues. */
+    continuesJobId?: string;
+    /** An AI run that has handed a step to the person in the browser window and waits for them to press Done. */
+    awaitingUser?: AwaitingUserInfo | null;
+}
+export interface AwaitingUserInfo {
+    /** What the person is asked to do, as the agent wrote it on the card; null when unknown. */
+    message: string | null;
+    since: string;
+}
+/** `needs-input`: the agent wrote open questions into the case file and cannot go on without answers. */
+export type ResultState = 'ready' | 'needs-input';
+/**
+ * How one block of an AI job's log is presented. Absent for the plain output of every other job, which stays raw.
+ * `markdown`: what the agent said; `reasoning`: what it was thinking (not a result); `tool`: one call, started or
+ * finished; `result`: the first lines of a call's output; `error` / `hint`: what failed and what to do about it;
+ * `meta`: anything else a person should read (the waiting line, noise the CLI printed).
+ */
+export type JobChunkKind = 'tool' | 'result' | 'reasoning' | 'markdown' | 'error' | 'hint' | 'meta';
+/** A tool call of an AI job, so the log can color its name, its outcome and the time it took. */
+export interface JobChunkTool {
+    name: string;
+    /** What the call is about (the file, the command, the intent); empty when the CLI gave nothing telling. */
+    detail: string;
+    ok: boolean;
+    /** Still running: Claude reports the start of a call, OpenCode only its end. */
+    pending?: boolean;
+    /** How long it ran, as a person reads it (`0.4 s`); absent when the CLI did not report a start time. */
+    took?: string;
+}
+export interface JobChunk {
+    seq: number;
+    stream: 'stdout' | 'stderr' | 'system';
+    data: string;
+    /** Set for the blocks of an AI job (see `JobChunkKind`); absent for a plain command's output. */
+    kind?: JobChunkKind;
+    /** When the block was produced, for AI jobs: shown as its own styled timestamp, not as part of the text. */
+    at?: string;
+    tool?: JobChunkTool;
+}
+export type StartJobRequest = {
+    action: 'signin';
+    profile: string;
+    env: string;
+} | {
+    action: 'visit';
+    profile: string;
+    env: string;
+} | {
+    action: 'ai';
+    tool: AiTool;
+    command: AiCommand;
+    caseId: string;
+    env: string;
+    force?: boolean;
+    attended?: boolean;
+    /**
+     * Show the agent's reasoning in the log (`--thinking` for OpenCode; Claude shows it when its model has it on).
+     * Off by default: it costs tokens and time.
+     */
+    thinking?: boolean;
+    /**
+     * The model to run the agent with (as the CLI names it). Omitted = the CLI's own choice, which for OpenCode is
+     * its built-in free model. `heal-spec` keeps the model of the run it continues.
+     */
+    model?: string;
+    /** `heal-spec` only: the profiles to heal; omitted = every profile that is logged in. */
+    profiles?: string[];
+    /** `heal-spec` only: what the user knows (optional). The server stores it as a file for the agent. */
+    hints?: string;
+    /** `heal-spec` only: the report to read first (folder name under reports/); omitted = the newest one. */
+    report?: string;
+} | {
+    action: 'continue';
+    jobId: string;
+    reply: string;
+} | {
+    action: 'make-cases';
+    tool: AiTool;
+    memo: string;
+    model?: string;
+    thinking?: boolean;
+} | {
+    action: 'run';
+    env: string;
+    profiles?: string[];
+    /** Only the profiles that carry one of these tags. */
+    tags?: string[];
+    suites?: string[];
+    grep?: string;
+    stepText?: boolean;
+    /** Leave out the cases that write data. */
+    readOnly?: boolean;
+    /** Cases (ids) whose screenshot baselines are overwritten with what the page shows now (`--update-baselines`). */
+    updateBaselines?: string[];
+    /** The environment the user confirmed write cases for. Must equal `env`; checked again on the server. */
+    confirmWritesIn?: string;
+};
+/** A case that writes data and would run, as listed in the confirmation. */
+export interface WriteCaseInfo {
+    id: string;
+    note: string;
+    profiles: string[];
+}
+export interface RunPreviewRequest {
+    env: string;
+    profiles?: string[];
+    tags?: string[];
+    suites?: string[];
+    grep?: string;
+    readOnly?: boolean;
+}
+export interface RunPreview {
+    env: string;
+    /** True when the environment is protected and the run includes write cases: the user must confirm. */
+    needsConfirmation: boolean;
+    writeCases: WriteCaseInfo[];
+    /** Cases that write only in other environments; they are skipped in this run. */
+    skippedWriteCases: WriteCaseInfo[];
+}
+export interface PlannedCaseInfo {
+    id: string;
+    profiles: string[];
+    writes: boolean;
+    /** Why the case is skipped in this environment; null when it runs. */
+    skip: string | null;
+    /** How many baseline images the case has on disk (all profiles and environments). */
+    baselineCount: number;
+}
+/** One screenshot baseline, with what it must show (from the target card of the case). */
+export interface BaselineItem {
+    caseId: string;
+    file: string;
+    profile: string | null;
+    env: string | null;
+    /** New or modified in git. */
+    changed: boolean;
+    mtimeMs: number;
+    targetId: string | null;
+    card: {
+        id: string;
+        name: string;
+        what: string | null;
+        where: string | null;
+        not: string | null;
+        pages: string | null;
+        region: string | null;
+    } | null;
+    problem: string | null;
+}
+/** The cases a run with the chosen filters would list. */
+export interface RunPlan {
+    env: string;
+    /** Playwright could not list the tests (for example an invalid search expression). */
+    error: string | null;
+    /** Cases that run (skipped ones not counted). */
+    totalCases: number;
+    /** Case x profile combinations that run. */
+    totalTests: number;
+    cases: PlannedCaseInfo[];
+}
+export type ProfileStatus = 'missing' | 'unverified' | 'ok' | 'expired' | 'error';
+/** One profile: a row of the Profiles page. */
+export interface SessionCheckInfo {
+    /** Where a visitor without a valid session is sent: a path on the site (`/login`) or a full URL (single sign-on). */
+    loggedOutUrl: string;
+    /** A selector that only exists while signed in; null when the profile does not name one. */
+    loggedInSelector: string | null;
+    /** A selector that proves the visitor is signed out, e.g. the password field of a login form. */
+    loggedOutSelector: string | null;
+    /** How long to wait for one of those signals, in milliseconds. */
+    timeoutMs: number;
+}
+export interface ProfileInfo {
+    id: string;
+    name: string;
+    env: string;
+    baseURL: string;
+    account: string | null;
+    tags: string[];
+    /** The page "Visit" opens after a login, e.g. `/app/home`; empty = the site root. */
+    startPath: string;
+    /** A page only a signed-in visitor sees; `/account/` unless set in profiles.yaml. */
+    sessionCheckPath: string;
+    /** How that page shows a missing login. */
+    sessionCheck: SessionCheckInfo;
+    /** Tests may send real email in this environment. Always false for production. */
+    email: boolean;
+    status: ProfileStatus;
+    verifying: boolean;
+    /** When the session file was last written. */
+    savedAt: string | null;
+    checkedAt: string | null;
+    error?: string;
+}
+export interface AddProfileRequest {
+    id: string;
+    name: string;
+    /** The environment this profile points at, e.g. `production`, `staging`. */
+    env: string;
+    baseURL: string;
+    /** A label for humans (a mailbox or username). Never a password. */
+    account?: string;
+    tags?: string[];
+    /** The page "Visit" opens after a login. Defaults to the site root. */
+    startPath?: string;
+    /** Page that redirects to /login when logged out. Defaults to /account/. */
+    sessionCheckPath?: string;
+    /** How that page shows a missing login. Omitted keys keep their default. */
+    sessionCheck?: Partial<SessionCheckInfo>;
+    /** Only for environments other than production. Defaults to false. */
+    email?: boolean;
+}
+/** Changes to one existing profile. The id itself cannot change: commands, session files and baselines use it. */
+export interface EditProfileRequest {
+    name: string;
+    /** The environment this profile points at, e.g. `production`, `staging`. */
+    env: string;
+    baseURL: string;
+    /** A label for humans (a mailbox or username). Never a password. */
+    account?: string;
+    tags?: string[];
+    /** The page "Visit" opens after a login. Defaults to the site root. */
+    startPath?: string;
+    /** Page that redirects to /login when logged out. Defaults to /account/. */
+    sessionCheckPath?: string;
+    /** How that page shows a missing login. Omitted keys keep their default. */
+    sessionCheck?: Partial<SessionCheckInfo>;
+    /** Only for environments other than production. Defaults to false. */
+    email?: boolean;
+}
+export interface EditProfileResult {
+    profile: ProfileInfo;
+    /**
+     * True when the site address changed: the saved login belonged to the old site, was deleted, and the
+     * profile has to log in again.
+     */
+    sessionCleared: boolean;
+}
+export interface ProfilesResponse {
+    profiles: ProfileInfo[];
+    /** Every environment used in profiles.yaml, `production` first. */
+    envs: string[];
+    verifying: boolean;
+}
+export interface CaseSummary {
+    /** Path below `cases/` without `.md`, e.g. `documents/landing-page`. */
+    id: string;
+    /** The folder of the case (`documents`), `null` for a case directly in `cases/`. */
+    group: string | null;
+    title: string | null;
+    login: string | null;
+    suites: string[];
+    /** Environments the case may write in; empty = read-only. */
+    writes: string[];
+    writesNote: string | null;
+    /** Environments the case may run in; null = all. */
+    envs: string[] | null;
+    /** Set when the front matter is invalid; the case is still listed so it can be fixed. */
+    problem: string | null;
+    hasSpec: boolean;
+    updatedAt: string;
+}
+export interface CaseDetail {
+    id: string;
+    content: string;
+    mtimeMs: number;
+}
+/** The spec of a case. */
+export interface SpecDetail {
+    id: string;
+    /** Path relative to the project root, for display. */
+    file: string;
+    /** Absolute path, to paste into a terminal. */
+    path: string;
+    content: string;
+    mtimeMs: number;
+}
+export interface ReportInfo {
+    /** Folder name under reports/. */
+    id: string;
+    /** Environment the run targeted; null for runs from before environments existed (those were production). */
+    env: string | null;
+    createdAt: string;
+    isLatest: boolean;
+    /** Pass/fail counts; null for runs from before summaries existed. */
+    counts: Record<ResultStatus, number> | null;
+}
+export type { ParsedError, ResultStatus, RunSettings, RunSummary, TestRunResult } from '../../lib/run-summary.js';
+export interface InfoResponse {
+    root: string;
+    envs: string[];
+    suites: string[];
+    caseIds: string[];
+}
+/** Everything that belongs to one case. Shown before a delete or rename, and returned by them. */
+export interface CaseImpact {
+    id: string;
+    caseFile: string;
+    specFile: string | null;
+    snapshotDir: string | null;
+    snapshotCount: number;
+}
+/** One model an AI CLI can be run with, as the CLI itself names it. */
+export interface AiModelOption {
+    /** Exactly what `--model` takes: `provider/model` or `provider/model#variant` (OpenCode), an alias or an id (Claude). */
+    id: string;
+    label: string;
+    /** Where the row comes from: a provider id, or `alias` / `settings` / `gateway` for a Claude CLI. */
+    group: string;
+    /** A second line: what the model is, or what an alias resolves to. */
+    detail?: string;
+}
+/** The models one AI CLI offers on this machine, read from the CLI itself or from its configuration. */
+export interface AiModelsResponse {
+    tool: AiTool;
+    models: AiModelOption[];
+    /**
+     * What the CLI would run when asrun passes no `--model`; null when it cannot be known (OpenCode picks a built-in
+     * free model, which is not stored anywhere).
+     */
+    clientDefault: string | null;
+    /**
+     * What to preselect while the user has not chosen: the CLI's default (Claude), or the model the CLI's own last
+     * session used (OpenCode). Null when neither is known.
+     */
+    suggested: string | null;
+    /** Parts of the list that could not be read, in the words of the CLI: shown above the list, never fatal. */
+    notes: string[];
+    /** Set when there is no list at all (the CLI is not installed, or its answer could not be read). */
+    error: string | null;
+}

package/dist/ui/shared/types.js

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