@asrunjs/asrun 0.2.0 → 0.5.2

package/dist/scripts/init.js

@@ -6,12 +6,14 @@ import { FRAMEWORK_ROOT, TEMPLATES_DIR } from '../lib/paths.js';
  * Creates the files a workspace needs. It is safe to run many times: it never overwrites a file the project owns, and
  * `--update` refreshes only the files generated from the framework templates.
  */
-const USAGE = `Usage: pnpm asrun init [--root <dir>] [--update] [--force <path>] [--no-env] [--install [spec]]
-
-  --root <dir>    the workspace to initialize (default: the current folder)
-  --update        refresh the generated files (playwright.config.ts, tests/seed.spec.ts, .claude/commands/*)
-  --force <path>  overwrite one file, e.g. --force playwright.config.ts (may be repeated)
-  --no-env        do not write .env (ASRUN_ROOT)
+const USAGE = `Usage: pnpm asrun init [--root <dir>] [--update] [--force <path>] [--no-env] [--install [spec]]
+
+  --root <dir>    the workspace to initialize (default: the current folder)
+  --update        refresh the generated files (playwright.config.ts, tests/seed.spec.ts, .claude/commands/*,
+                  .opencode/commands/*)
+  --force <path>  overwrite one file this tool writes, e.g. --force playwright.config.ts (may be repeated)
+  --reset-rules   allow --force on AGENTS.md, CLAUDE.md or .claude/skills/** (project-owned rules)
+  --no-env        do not write .env (ASRUN_ROOT)
   --install [spec]  also add the dependency (default "asrun"; e.g. --install github:wizcas/asrun#v0.1.0)`;
 /** Files `init` owns: `--update` rewrites exactly these, and a project never edits them. */
 export const GENERATED = [
@@ -21,12 +23,18 @@ export const GENERATED = [
     { file: '.claude/commands/explore-case.md', template: '.claude/commands/explore-case.md' },
     { file: '.claude/commands/gen-spec.md', template: '.claude/commands/gen-spec.md' },
     { file: '.claude/commands/heal-spec.md', template: '.claude/commands/heal-spec.md' },
+    // OpenCode does not read `.claude/commands` (only `.claude/skills`), so the same commands live here too.
+    { file: '.opencode/commands/make-case.md', template: '.claude/commands/make-case.md' },
+    { file: '.opencode/commands/explore-case.md', template: '.claude/commands/explore-case.md' },
+    { file: '.opencode/commands/gen-spec.md', template: '.claude/commands/gen-spec.md' },
+    { file: '.opencode/commands/heal-spec.md', template: '.claude/commands/heal-spec.md' },
 ];
 /** Files `init` creates once; after that the project owns them and may edit them freely. */
 const ONCE = [
     { file: 'AGENTS.md', template: 'AGENTS.md' },
     { file: 'CLAUDE.md', template: 'CLAUDE.md' },
     { file: '.mcp.json', template: '.mcp.json' },
+    { file: 'opencode.jsonc', template: 'opencode.jsonc' },
     { file: '.claude/settings.json', template: '.claude/settings.json' },
     { file: 'tsconfig.json', template: 'tsconfig.json' },
     { file: 'pnpm-workspace.yaml', template: 'pnpm-workspace.yaml' },
@@ -71,9 +79,22 @@ export function frameworkPath(root) {
 export function isInstalled(root) {
     return fs.existsSync(path.join(path.resolve(root, frameworkPath(root)), 'package.json'));
 }
-/** Fills the `{{framework}}` placeholder of a template. */
+/** Fills the `{{framework}}` and `{{playwright}}` placeholders of a template. */
 export function renderTemplate(name, root) {
-    return readTemplate(name).replaceAll('{{framework}}', frameworkPath(root));
+    return readTemplate(name)
+        .replaceAll('{{framework}}', frameworkPath(root))
+        .replaceAll('{{playwright}}', playwrightBin(root));
+}
+/**
+ * The Playwright CLI the MCP server runs. The workspace's own install is the normal place; a workspace that lives
+ * inside the framework repository (examples/demo) has no `node_modules` of its own, so it points at the framework's.
+ * Kept relative: the file is committed and must not name a machine.
+ */
+export function playwrightBin(root) {
+    if (fs.existsSync(path.join(root, 'node_modules', '.bin', 'playwright')))
+        return './node_modules/.bin/playwright';
+    const framework = frameworkPath(root);
+    return framework.startsWith('..') ? `${framework}/node_modules/.bin/playwright` : './node_modules/.bin/playwright';
 }
 export function frameworkVersion() {
     let version = '0.0.0';
@@ -183,7 +204,10 @@ export async function main(args) {
     const installAt = args.indexOf('--install');
     const install = installAt >= 0;
     const installSpec = install && args[installAt + 1] && !args[installAt + 1].startsWith('-') ? args[installAt + 1] : PACKAGE;
-    const forced = args.flatMap((arg, index) => (arg === '--force' && args[index + 1] ? [args[index + 1]] : []));
+    const forced = args
+        .flatMap((arg, index) => (arg === '--force' && args[index + 1] ? [args[index + 1]] : []))
+        .map((file) => file.split('\\').join('/'));
+    const resetRules = args.includes('--reset-rules');
     const skipEnv = args.includes('--no-env');
     if (path.resolve(root) === path.resolve(FRAMEWORK_ROOT)) {
         console.error('This folder is the framework itself, not a workspace. Run "pnpm asrun init" inside the project that uses ' +
@@ -195,6 +219,20 @@ export async function main(args) {
     const kept = [];
     const notes = [];
     const framework = frameworkPath(root);
+    // `--force` repairs a file this tool writes. A project's own rules are never overwritten by a framework update:
+    // `AGENTS.md`, `CLAUDE.md` and `.claude/skills/**` need `--reset-rules` on top.
+    const owned = [...GENERATED, ...ONCE].map((entry) => entry.file);
+    const projectRules = (file) => file === 'AGENTS.md' || file === 'CLAUDE.md' || file === '.claude/skills' || file.startsWith('.claude/skills/');
+    for (const file of forced) {
+        if (!owned.includes(file)) {
+            console.error(`--force ${file}: init only writes the files it owns (${owned.join(', ')}).`);
+            return 1;
+        }
+        if (projectRules(file) && !resetRules) {
+            console.error(`--force ${file}: this file belongs to the project. Add --reset-rules to replace it with the template.`);
+            return 1;
+        }
+    }
     const place = (entry, overwrite) => {
         const target = path.join(root, entry.file);
         if (fs.existsSync(target) && !overwrite) {
@@ -231,10 +269,20 @@ export async function main(args) {
             notes.push('pnpm-workspace.yaml lists "packages"; asrun is a dependency now, so that list can go.');
         }
     }
-    if (fs.existsSync(path.join(root, '.mcp.json'))) {
-        const mcp = fs.readFileSync(path.join(root, '.mcp.json'), 'utf8');
-        if (!mcp.includes('playwright-test'))
-            notes.push('Add the "playwright-test" MCP server to .mcp.json (see templates/.mcp.json).');
+    if (fs.existsSync(path.join(root, '.mcp.json')) && !fs.readFileSync(path.join(root, '.mcp.json'), 'utf8').includes('playwright-test')) {
+        notes.push('Add the "playwright-test" MCP server to .mcp.json (see templates/.mcp.json).');
+    }
+    if (fs.existsSync(path.join(root, 'opencode.jsonc')) && !fs.readFileSync(path.join(root, 'opencode.jsonc'), 'utf8').includes('playwright-test')) {
+        notes.push('Add the "playwright-test" MCP server to opencode.jsonc (see templates/opencode.jsonc).');
+    }
+    if (fs.existsSync(path.join(root, 'opencode.jsonc'))) {
+        const text = fs.readFileSync(path.join(root, 'opencode.jsonc'), 'utf8');
+        // A commented-out "model" (the template has one) does not set anything: only a real key counts.
+        const withoutComments = text.replace(/^\s*\/\/.*$/gm, '');
+        if (!/["']?model["']?\s*:/.test(withoutComments)) {
+            notes.push('opencode.jsonc sets no "model": a one-shot "opencode run" then uses OpenCode\'s built-in free model, which has a ' +
+                'daily usage limit. Pick a model in the AsRun web UI (top bar), or set "model" there.');
+        }
     }
     if (fs.existsSync(path.join(root, '.claude', 'settings.json'))) {
         const settings = fs.readFileSync(path.join(root, '.claude', 'settings.json'), 'utf8');

package/dist/scripts/lint-specs.js

@@ -128,8 +128,11 @@ function lint(file) {
     TARGET_REF.lastIndex = 0;
     return findings;
 }
+// A case id is written with `/` (`conduit/header-navigation`), while a path on Windows has `\`: without the
+// normalization this filter matched nothing and reported "0 spec(s)" for a spec that was right there.
+const casePath = (file) => file.replace(/\\/g, '/');
 const wanted = process.argv.slice(2).filter((arg) => !arg.startsWith('-'));
-const files = specFiles(TESTS_DIR).filter((file) => wanted.length === 0 || wanted.some((id) => file.endsWith(`${id}.spec.ts`)));
+const files = specFiles(TESTS_DIR).filter((file) => wanted.length === 0 || wanted.some((id) => casePath(file).endsWith(`${casePath(id)}.spec.ts`)));
 const findings = files.flatMap(lint);
 for (const f of findings)
     console.log(`${f.level.toUpperCase().padEnd(4)} ${f.file}:${f.line}  [${f.rule}] ${f.message}`);

package/dist/scripts/login.js

@@ -6,6 +6,7 @@ import { getProfile, listProfiles, profileLabel } from '../lib/profiles.js';
 import { parseCliTarget } from '../lib/cli.js';
 import { authFile } from '../lib/paths.js';
 import { checkSession } from '../lib/session.js';
+import { showLoginCard, showLoginCardSaved, waitForLoginCard } from '../lib/login-card.js';
 const parsed = parseCliTarget(process.argv.slice(2));
 if (!parsed.profileId || parsed.help) {
     console.log('Usage: pnpm signin <profile-id>\n\nProfiles:');
@@ -23,14 +24,41 @@ const file = authFile(profile.id);
 fs.mkdirSync(path.dirname(file), { recursive: true });
 const browser = await chromium.launch({ headless: false });
 const context = await browser.newContext({ viewport: null });
+// The card goes in before the first page, so it is there on the login page and again after every navigation.
+showLoginCard(context, `Log in as usual, including the 2FA code. When you can see the logged-in page, press "Done, save the session": ` +
+    `the session is saved and this window closes.`);
 const page = await context.newPage();
 await page.goto(new URL('/login/', profile.baseURL).href);
 console.log(`\nA browser window opened for "${profileLabel(profile)}" (${profile.baseURL}).`);
 console.log('1. Log in as usual, including the 2FA code.');
-console.log('2. Wait until you can see the logged-in page.');
+console.log('2. When you can see the logged-in page, press "Done, save the session" on the card in that window.');
+console.log('   The card sits in the bottom-left corner; drag it if it is in the way.');
 const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-await rl.question('3. Come back here and press Enter to save the session... ');
+const stopWaiting = new AbortController();
+const card = waitForLoginCard(context, page, stopWaiting.signal);
+const typed = rl
+    .question('   Or press Enter here (in the terminal, or the button on the job in the UI): ')
+    .then(() => 'enter');
+const answer = await Promise.race([
+    card.then((outcome) => ({ via: 'card', outcome })),
+    typed.then(() => ({ via: 'enter', outcome: 'done' })),
+]);
+stopWaiting.abort();
 rl.close();
+if (answer.via === 'card' && answer.outcome !== 'done') {
+    await browser.close().catch(() => { });
+    console.error(answer.outcome === 'cancel'
+        ? `\nNothing was saved: the login was cancelled on the card. Run \`pnpm signin ${profile.id}\` again when you are ready.`
+        : '\nNothing was saved: the browser window was closed before the session was saved. ' +
+            `Run \`pnpm signin ${profile.id}\` again.`);
+    process.exit(1);
+}
+if (answer.via === 'card') {
+    console.log('\nSaving the session from the card...');
+    // The person is still looking at the window: say that the session is safe before it disappears.
+    await showLoginCardSaved(context, 'Session saved. Closing this window...');
+    await new Promise((resolve) => setTimeout(resolve, 1200));
+}
 await context.storageState({ path: file });
 await browser.close();
 fs.chmodSync(file, 0o600);

package/dist/ui/server/actions.d.ts

@@ -24,6 +24,8 @@ export declare const startJobSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     env: z.ZodString;
     force: z.ZodOptional<z.ZodBoolean>;
     attended: z.ZodOptional<z.ZodBoolean>;
+    thinking: z.ZodOptional<z.ZodBoolean>;
+    model: z.ZodOptional<z.ZodString>;
     profiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
     hints: z.ZodOptional<z.ZodString>;
     report: z.ZodOptional<z.ZodString>;
@@ -38,6 +40,8 @@ export declare const startJobSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         opencode: "opencode";
     }>;
     memo: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    thinking: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>, z.ZodObject<{
     action: z.ZodLiteral<"run">;
     env: z.ZodString;

package/dist/ui/server/actions.js

@@ -12,8 +12,7 @@ import { jobs } from './jobs.js';
 import { verifyProfiles } from './profiles.js';
 import { isValidCaseId, listCaseIds } from './cases.js';
 import { snapshotDirPath, specFilePath } from '../../lib/case-ops.js';
-import { AI_COMMANDS, AI_COMMAND_WRITES, AI_TOOLS, continueCommandLine, continueInvocation, headlessCommandLine, headlessInvocation, HINTS_DIR, HINTS_MAX_CHARS, makeCaseCommandLine, makeCaseInvocation, MEMO_DIR, MEMO_MAX_CHARS, REPLY_MAX_CHARS, } from '../shared/ai-commands.js';
-const VISIT_PATH = '/app/home';
+import { AI_COMMANDS, AI_COMMAND_WRITES, AI_TOOLS, continueCommandLine, continueInvocation, headlessCommandLine, headlessInvocation, HINTS_DIR, HINTS_MAX_CHARS, makeCaseCommandLine, makeCaseInvocation, MEMO_DIR, MEMO_MAX_CHARS, REPLY_DIR, REPLY_MAX_CHARS, } from '../shared/ai-commands.js';
 const REPORTS_DIR = path.join(ROOT, 'reports');
 const REPORT_ID = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}(-[a-z0-9]+(-[a-z0-9]+)*)?$/;
 const newSessionId = (tool) => tool === 'claude' ? crypto.randomUUID() : `ses_${crypto.randomBytes(12).toString('hex')}`;
@@ -28,6 +27,8 @@ export const startJobSchema = z.discriminatedUnion('action', [
         env: z.string().min(1),
         force: z.boolean().optional(),
         attended: z.boolean().optional(),
+        thinking: z.boolean().optional(),
+        model: z.string().min(1).max(200).optional(),
         profiles: z.array(z.string().min(1)).optional(),
         hints: z.string().max(HINTS_MAX_CHARS).optional(),
         report: z.string().min(1).max(100).optional(),
@@ -41,6 +42,8 @@ export const startJobSchema = z.discriminatedUnion('action', [
         action: z.literal('make-cases'),
         tool: z.enum(AI_TOOLS),
         memo: z.string().max(MEMO_MAX_CHARS),
+        model: z.string().min(1).max(200).optional(),
+        thinking: z.boolean().optional(),
     }),
     z.object({
         action: z.literal('run'),
@@ -159,15 +162,17 @@ export function buildJobSpec(request) {
     }
     if (request.action === 'visit') {
         checkProfile(request.profile, request.env);
+        // Where a login lands is a profile setting (its own home page), not something the UI knows.
+        const startPath = knownProfiles.find((profile) => profile.id === request.profile)?.startPath ?? '';
         // Only reads the saved session when it starts, so it does not take the auth lock
         // (that would block test runs for as long as the window stays open).
         return {
             kind: 'visit',
             profile: request.profile,
             env: request.env,
-            command: `pnpm explore ${request.profile} ${VISIT_PATH}`,
+            command: ['pnpm explore', request.profile, startPath].filter(Boolean).join(' '),
             file: process.execPath,
-            args: [...scriptArgs('explore.ts'), request.profile, VISIT_PATH],
+            args: [...scriptArgs('explore.ts'), request.profile, ...(startPath ? [startPath] : [])],
             locks: [`visit:${request.profile}`],
             acceptsInput: false,
         };
@@ -175,14 +180,14 @@ export function buildJobSpec(request) {
     // An AI run on a case, a first turn or a continuation: the same permissions and locks either way.
     // Generating and healing write the spec and the case values and run the tests, so they must not overlap with a run.
     // Reviewing only edits the case file and looks at pages, so it takes just the case lock.
-    const aiSpec = (tool, command, caseId, env, sessionId, run) => ({
+    const aiSpec = (tool, command, caseId, env, sessionId, run, model, thinking) => ({
         kind: 'ai',
         env,
         ...run,
         locks: [`ai:${caseId}`, ...(AI_COMMAND_WRITES[command] === 'files' ? ['run', ...allLocks()] : [])],
         acceptsInput: false,
         stream: tool,
-        ai: { tool, command, caseId, env, sessionId },
+        ai: { tool, command, caseId, env, sessionId, ...(model && { model }), ...(thinking && { thinking }) },
     });
     if (request.action === 'ai') {
         if (!isValidCaseId(request.caseId) || !listCaseIds().includes(request.caseId)) {
@@ -225,6 +230,8 @@ export function buildJobSpec(request) {
         }
         const options = {
             env: request.env,
+            model: request.model,
+            thinking: request.thinking,
             force: request.force,
             attended: request.attended,
             // Naming every profile is the same as leaving it out: the agent then takes all that are logged in.
@@ -238,7 +245,7 @@ export function buildJobSpec(request) {
             command: headlessCommandLine(request.tool, request.command, request.caseId, options, session),
             file,
             args,
-        });
+        }, request.model, request.thinking);
     }
     if (request.action === 'continue') {
         const earlier = jobs.get(request.jobId);
@@ -253,13 +260,19 @@ export function buildJobSpec(request) {
         }
         if (!listCaseIds().includes(ai.caseId))
             throw new ActionError(`The case "${ai.caseId}" no longer exists.`);
-        const { file, args } = continueInvocation(ai.tool, ai.command, request.reply, ai.sessionId);
+        // The answers are stored as a file so the agent reads them verbatim; a line break or a quote in them cannot
+        // break the command line of the agent CLI.
+        const replyPath = `${REPLY_DIR}/${new Date().toISOString().replace(/[:.]/g, '-')}-${crypto.randomBytes(3).toString('hex')}.md`;
+        fs.mkdirSync(path.join(ROOT, REPLY_DIR), { recursive: true });
+        fs.writeFileSync(path.join(ROOT, replyPath), request.reply.trim() + '\n');
+        // The next turn keeps how the first one was told to run (model and reasoning), so the log stays the same.
+        const { file, args } = continueInvocation(ai.tool, ai.command, replyPath, ai.sessionId, ai.model, ai.thinking);
         return aiSpec(ai.tool, ai.command, ai.caseId, ai.env, ai.sessionId, {
-            command: continueCommandLine(ai.tool, ai.command, request.reply, ai.sessionId),
+            command: continueCommandLine(ai.tool, ai.command, replyPath, ai.sessionId, ai.model, ai.thinking),
             file,
             args,
             continuesJobId: earlier.info.id,
-        });
+        }, ai.model, ai.thinking);
     }
     if (request.action === 'make-cases') {
         if (request.memo.trim() === '')
@@ -268,10 +281,10 @@ export function buildJobSpec(request) {
         const memoPath = `${MEMO_DIR}/${new Date().toISOString().replace(/[:.]/g, '-')}-${crypto.randomBytes(3).toString('hex')}.md`;
         fs.mkdirSync(path.join(ROOT, MEMO_DIR), { recursive: true });
         fs.writeFileSync(path.join(ROOT, memoPath), request.memo);
-        const { file, args } = makeCaseInvocation(request.tool, memoPath);
+        const { file, args } = makeCaseInvocation(request.tool, memoPath, request.model, request.thinking);
         return {
             kind: 'ai',
-            command: makeCaseCommandLine(request.tool, memoPath),
+            command: makeCaseCommandLine(request.tool, memoPath, request.model, request.thinking),
             file,
             args,
             locks: ['ai:make-cases'],

package/dist/ui/server/ai-models.d.ts

@@ -0,0 +1,3 @@
+import type { AiTool } from '../shared/ai-commands.js';
+import type { AiModelsResponse } from '../shared/types.js';
+export declare function listAiModels(tool: AiTool, refresh?: boolean): Promise<AiModelsResponse>;