@asrunjs/asrun 0.0.0-stage → 0.2.0

package/dist/ui/server/profiles.js

@@ -0,0 +1,195 @@
+import fs from 'node:fs';
+import { chromium } from '@playwright/test';
+import { isMap, isSeq, parseDocument } from 'yaml';
+import { listEnvs, listProfiles, loadProfiles, PROFILES_FILE } from '../../lib/profiles.js';
+import { authFile } from '../../lib/paths.js';
+import { checkSession } from '../../lib/session.js';
+import { withScheme } from '../shared/site-address.js';
+// Keyed by profile id.
+const verifications = new Map();
+const verifying = new Set();
+/** Only looks at file timestamps; the content of the session file is never read here. */
+function savedAt(profileId) {
+    const file = authFile(profileId);
+    return fs.existsSync(file) ? fs.statSync(file).mtime.toISOString() : null;
+}
+const toInfo = (profile) => {
+    const saved = savedAt(profile.id);
+    const verification = verifications.get(profile.id);
+    let status;
+    if (!saved)
+        status = 'missing';
+    else if (!verification)
+        status = 'unverified';
+    else
+        status = verification.status === 'missing' ? 'unverified' : verification.status;
+    return {
+        id: profile.id,
+        name: profile.name,
+        env: profile.env,
+        baseURL: profile.baseURL,
+        account: profile.account,
+        tags: profile.tags,
+        status,
+        verifying: verifying.has(profile.id),
+        savedAt: saved,
+        checkedAt: verification?.checkedAt ?? null,
+        error: verification?.error,
+    };
+};
+export function listProfileRows() {
+    return { profiles: listProfiles().map(toInfo), envs: listEnvs(), verifying: verifying.size > 0 };
+}
+/** Opens each saved session on the real site (read-only) and records whether it is still logged in. */
+export async function verifyProfiles(only) {
+    const profiles = listProfiles().filter((profile) => (!only?.ids || only.ids.includes(profile.id)) && (!only?.env || only.env === profile.env) && !verifying.has(profile.id));
+    const withSession = profiles.filter((profile) => savedAt(profile.id));
+    for (const profile of profiles) {
+        if (!savedAt(profile.id))
+            verifications.delete(profile.id);
+    }
+    if (withSession.length === 0)
+        return;
+    for (const profile of withSession)
+        verifying.add(profile.id);
+    let browser;
+    try {
+        browser = await chromium.launch();
+        await Promise.all(withSession.map(async (profile) => {
+            try {
+                const status = await checkSession(browser, profile);
+                verifications.set(profile.id, { status, checkedAt: new Date().toISOString() });
+            }
+            catch (error) {
+                verifications.set(profile.id, {
+                    status: 'error',
+                    checkedAt: new Date().toISOString(),
+                    error: error.message.split('\n')[0],
+                });
+            }
+            finally {
+                verifying.delete(profile.id);
+            }
+        }));
+    }
+    catch (error) {
+        for (const profile of withSession) {
+            verifications.set(profile.id, {
+                status: 'error',
+                checkedAt: new Date().toISOString(),
+                error: error.message.split('\n')[0],
+            });
+            verifying.delete(profile.id);
+        }
+    }
+    finally {
+        await browser?.close();
+    }
+}
+const PROFILE_ID = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const ENV_NAME = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+export class ProfileError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+function parseSiteAddress(text, label) {
+    let url;
+    try {
+        // A typed address without a scheme (`example.com`) is completed with https://.
+        url = new URL(withScheme(text));
+    }
+    catch {
+        throw new ProfileError(`${label} must be a full URL, e.g. https://www.example.com.`, 400);
+    }
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+        throw new ProfileError(`${label} must start with https:// (or http://).`, 400);
+    }
+    if (url.pathname !== '/' || url.search || url.hash || url.username || url.password) {
+        throw new ProfileError(`${label} must be only the site address, without a path, query or credentials.`, 400);
+    }
+    return url;
+}
+const normalTags = (tags) => [...new Set((tags ?? []).map((tag) => tag.trim()).filter(Boolean))];
+/**
+ * Appends one profile to profiles.yaml. The file is edited as a YAML document, so comments and the
+ * existing entries stay as they are.
+ */
+export function addProfile(request, file = PROFILES_FILE) {
+    const id = request.id.trim();
+    const name = request.name.trim();
+    const env = request.env.trim();
+    const account = request.account?.trim() || undefined;
+    const sessionCheckPath = request.sessionCheckPath?.trim() || undefined;
+    const tags = normalTags(request.tags);
+    if (!PROFILE_ID.test(id)) {
+        throw new ProfileError('Profile id must be lowercase letters and digits, separated by single dashes (e.g. "example-staging").', 400);
+    }
+    if (!name)
+        throw new ProfileError('Name is required.', 400);
+    if (!ENV_NAME.test(env)) {
+        throw new ProfileError('Environment must be lowercase letters and digits, separated by single dashes (e.g. "production", "staging").', 400);
+    }
+    if (env === 'production' && request.email === true) {
+        throw new ProfileError('email: true is not allowed. Tests never send email in production.', 400);
+    }
+    const baseURL = parseSiteAddress(request.baseURL, 'Base URL').origin;
+    if (sessionCheckPath && (!sessionCheckPath.startsWith('/') || /\s/.test(sessionCheckPath))) {
+        throw new ProfileError('Session check path must start with "/" and contain no spaces.', 400);
+    }
+    if (loadProfiles(file).some((profile) => profile.id === id)) {
+        throw new ProfileError(`Profile "${id}" already exists.`, 409);
+    }
+    const original = fs.readFileSync(file, 'utf8');
+    const doc = parseDocument(original, { merge: true });
+    if (doc.errors.length > 0) {
+        throw new ProfileError('profiles.yaml has syntax errors; fix it by hand first.', 400);
+    }
+    const profiles = doc.get('profiles');
+    if (!isSeq(profiles))
+        throw new ProfileError('profiles.yaml has no "profiles" list.', 400);
+    // `profiles: []` is a flow sequence; adding a map entry to it would render `[ { ... } ]`. Keep the file block-style.
+    profiles.flow = false;
+    const hadEntries = profiles.items.length > 0;
+    const entry = doc.createNode({
+        id,
+        name,
+        env,
+        baseURL,
+        ...(account && { account }),
+        ...(tags.length > 0 && { tags }),
+        ...(sessionCheckPath && { sessionCheckPath }),
+        // Never send email from a new profile until a human has checked that a mailbox is connected.
+        email: request.email === true ? true : false,
+    });
+    if (isMap(entry)) {
+        entry.spaceBefore = hadEntries;
+        entry.flow = false;
+    }
+    profiles.add(entry);
+    const temp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, doc.toString());
+    fs.renameSync(temp, file);
+    // Never leave a file behind that the test runner cannot load.
+    try {
+        loadProfiles(file);
+    }
+    catch (error) {
+        fs.writeFileSync(file, original);
+        throw new ProfileError(`Could not add the profile: ${error.message}`, 400);
+    }
+    return {
+        id,
+        name,
+        env,
+        baseURL,
+        account: account ?? null,
+        tags,
+        status: 'missing',
+        verifying: false,
+        savedAt: null,
+        checkedAt: null,
+    };
+}

package/dist/ui/server/watch-files.d.ts

@@ -0,0 +1,4 @@
+import { EventEmitter } from 'node:events';
+/** Emits `files` when a case file or a spec changes on disk, whoever changed it (the UI, an agent, an editor). */
+export declare const fileEvents: EventEmitter<[never]>;
+export declare function startFileWatcher(): void;

package/dist/ui/server/watch-files.js

@@ -0,0 +1,36 @@
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import { CASES_DIR, TESTS_DIR } from '../../lib/paths.js';
+const DEBOUNCE_MS = 200;
+/** Emits `files` when a case file or a spec changes on disk, whoever changed it (the UI, an agent, an editor). */
+export const fileEvents = new EventEmitter();
+fileEvents.setMaxListeners(0);
+export function startFileWatcher() {
+    const pending = { cases: false, specs: false };
+    let timer = null;
+    const schedule = (kind) => {
+        pending[kind] = true;
+        timer ??= setTimeout(() => {
+            timer = null;
+            const change = { ...pending };
+            pending.cases = false;
+            pending.specs = false;
+            fileEvents.emit('files', change);
+        }, DEBOUNCE_MS);
+    };
+    const watch = (dir, kind, suffix) => {
+        try {
+            const watcher = fs.watch(dir, { recursive: true }, (_event, filename) => {
+                if (filename && filename.toString().endsWith(suffix))
+                    schedule(kind);
+            });
+            watcher.on('error', () => watcher.close());
+            watcher.unref();
+        }
+        catch {
+            // The folder does not exist (yet) or cannot be watched; the pages still refresh when the window gets focus.
+        }
+    };
+    watch(CASES_DIR, 'cases', '.md');
+    watch(TESTS_DIR, 'specs', '.spec.ts');
+}

package/dist/ui/shared/ai-commands.d.ts

@@ -0,0 +1,78 @@
+export declare const AI_TOOLS: readonly ['claude', 'opencode'];
+export type AiTool = (typeof AI_TOOLS)[number];
+export declare const DEFAULT_AI_TOOL: AiTool;
+export declare const AI_TOOL_LABEL: Record<AiTool, string>;
+export declare const AI_COMMANDS: readonly ['explore-case', 'gen-spec', 'heal-spec'];
+export type AiCommand = (typeof AI_COMMANDS)[number];
+export declare const AI_COMMAND_LABEL: Record<AiCommand, string>;
+/**
+ * What a one-shot run of a command may change, so the permissions can be as narrow as possible.
+ * `case`: only cases/*.md. `spec`: also the spec, but it never runs the tests.
+ * `files`: also snapshots, and it runs the tests.
+ */
+export type AiWrites = 'case' | 'spec' | 'files';
+export declare const AI_COMMAND_WRITES: Record<AiCommand, AiWrites>;
+/**
+ * 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 declare const AI_ENV_HINT: Record<AiCommand, string>;
+/** What a run of a command on a case may be told besides the case id. */
+export interface AiRunOptions {
+    /** The environment to explore. There is no default. */
+    env: string;
+    /** `gen-spec` only: regenerate and overwrite an existing spec instead of leaving it alone. */
+    force?: boolean;
+    /** `explore-case` only: a person is at the machine, so steps that write data are handed to them in the browser. */
+    attended?: boolean;
+    /** `heal-spec` only: the profiles to heal. Omitted = every profile that is logged in in `env`. */
+    profiles?: string[];
+    /** `heal-spec` only: file (relative to the project root) with the user's description and clues. */
+    hints?: string;
+    /** `heal-spec` only: the report (folder name under reports/) to read first instead of the newest one. */
+    report?: string;
+}
+export declare const slashCommand: (command: AiCommand, caseId: string, options: AiRunOptions) => string;
+/**
+ * The conversation of a one-shot run. The server picks the id, so a later turn can resume it: the first turn
+ * creates the session, every following one (`resume`) continues it with the same permissions.
+ */
+export interface AiSession {
+    id: string;
+    resume: boolean;
+}
+/** The prompt of a one-shot run. `heal-spec` has no questions of its own, so it keeps the plain slash command. */
+export declare function headlessPrompt(command: AiCommand, caseId: string, options: AiRunOptions): string;
+/** Executable and arguments of the one-shot (non-interactive) run. */
+export declare function headlessInvocation(tool: AiTool, command: AiCommand, caseId: string, options: AiRunOptions, session?: AiSession): {
+    file: string;
+    args: string[];
+};
+/** The one-shot command as it is typed in a shell. */
+export declare function headlessCommandLine(tool: AiTool, command: AiCommand, caseId: string, options: AiRunOptions, session?: AiSession): string;
+/** Folder (relative to the AsRun root, git-ignored) where the clues typed into the Heal dialog are stored. */
+export declare const HINTS_DIR = ".tmp/hints";
+export declare const HINTS_MAX_CHARS = 8000;
+export declare const REPLY_MAX_CHARS = 4000;
+export declare 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.
+ */
+export declare function replyPrompt(command: AiCommand, reply: string): string;
+/** The next turn of an earlier run, in its session and with exactly the permissions of the first turn. */
+export declare function continueInvocation(tool: AiTool, command: AiCommand, reply: string, sessionId: string): {
+    file: string;
+    args: string[];
+};
+export declare const continueCommandLine: (tool: AiTool, command: AiCommand, reply: string, sessionId: string) => string;
+/** Folder (relative to the AsRun root, git-ignored) where memos from the Cases page are stored. */
+export declare const MEMO_DIR = ".tmp/memos";
+export declare const MEMO_MAX_CHARS = 100000;
+/** /make-case is interactive by design; a one-shot run cannot answer questions, so it must use the defaults. */
+export declare const makeCasePrompt: (memoPath: string) => string;
+export declare const makeCaseInvocation: (tool: AiTool, memoPath: string) => {
+    file: string;
+    args: string[];
+};
+export declare const makeCaseCommandLine: (tool: AiTool, memoPath: string) => string;

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

@@ -0,0 +1,154 @@
+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) {
+    // OpenCode creates the session when the id does not exist yet, and continues it when it does.
+    if (tool === 'opencode')
+        return { file: 'opencode', args: ['run', '--auto', ...STREAM_ARGS.opencode, ...(session ? ['-s', session.id] : []), 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'] : []),
+            '--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. 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);
+}
+/** 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;
+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.
+ */
+export function replyPrompt(command, reply) {
+    return (`The user answers your open questions (still nobody to ask, so do not stop to ask again):\n${reply.trim()}\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, reply, sessionId) {
+    return invocation(tool, replyPrompt(command, reply), AI_COMMAND_WRITES[command], { id: sessionId, resume: true });
+}
+export const continueCommandLine = (tool, command, reply, sessionId) => commandLine(continueInvocation(tool, command, reply, sessionId));
+/** 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) => invocation(tool, makeCasePrompt(memoPath), 'cases-new');
+export const makeCaseCommandLine = (tool, memoPath) => commandLine(makeCaseInvocation(tool, memoPath));

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}`;
+}