@asrunjs/asrun 0.0.0-stage → 0.2.0

package/dist/ui/server/cases.js

@@ -0,0 +1,170 @@
+import { execFile, spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { parse } from 'yaml';
+import { isValidCaseId } from '../../lib/case-id.js';
+import { assertValidNewId, CaseError, caseFilePath, deleteCase as deleteCaseFiles, getCaseImpact, renameCase as renameCaseFiles, specFilePath, } from '../../lib/case-ops.js';
+import { listCaseFileIds, parseCaseMeta } from '../../lib/cases.js';
+import { scriptArgs } from '../../lib/node-cli.js';
+import { ROOT } from '../../lib/paths.js';
+const MAX_BYTES = 1_000_000;
+export { CaseError, isValidCaseId };
+function fileFor(id) {
+    if (!isValidCaseId(id))
+        throw new CaseError(`Invalid case id "${id}".`, 400);
+    return caseFilePath(id);
+}
+function frontMatter(text) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
+    if (!match)
+        return {};
+    try {
+        const value = parse(match[1]);
+        return value && typeof value === 'object' ? value : {};
+    }
+    catch {
+        return {};
+    }
+}
+const asString = (value) => (typeof value === 'string' ? value : null);
+export const listCaseIds = listCaseFileIds;
+export function listCases() {
+    return listCaseIds().map((id) => {
+        const file = fileFor(id);
+        const text = fs.readFileSync(file, 'utf8');
+        const meta = frontMatter(text);
+        let parsed = null;
+        let problem = null;
+        try {
+            parsed = parseCaseMeta(id, text);
+        }
+        catch (error) {
+            problem = error.message;
+        }
+        return {
+            id,
+            title: asString(meta.title),
+            login: asString(meta.login),
+            suites: parsed?.suites ?? [],
+            writes: parsed?.writes ?? [],
+            writesNote: parsed?.writesNote ?? null,
+            envs: parsed?.envs ?? null,
+            problem,
+            group: id.includes('/') ? id.slice(0, id.indexOf('/')) : null,
+            hasSpec: fs.existsSync(specFilePath(id)),
+            updatedAt: fs.statSync(file).mtime.toISOString(),
+        };
+    });
+}
+export function readCase(id) {
+    const file = fileFor(id);
+    if (!fs.existsSync(file))
+        throw new CaseError(`Case "${id}" does not exist.`, 404);
+    return { id, content: fs.readFileSync(file, 'utf8'), mtimeMs: fs.statSync(file).mtimeMs };
+}
+/** The path comes from the case id only, never from the browser. */
+function existingSpecFile(id) {
+    if (!isValidCaseId(id))
+        throw new CaseError(`Invalid case id "${id}".`, 400);
+    const file = specFilePath(id);
+    if (!fs.existsSync(file))
+        throw new CaseError(`Case "${id}" has no spec yet.`, 404);
+    return file;
+}
+export function readSpec(id) {
+    const file = existingSpecFile(id);
+    const stat = fs.statSync(file);
+    if (stat.size > MAX_BYTES)
+        throw new CaseError('Spec file is too large to show.', 400);
+    return {
+        id,
+        file: path.relative(ROOT, file),
+        path: file,
+        content: fs.readFileSync(file, 'utf8'),
+        mtimeMs: stat.mtimeMs,
+    };
+}
+/** Writes only if the file is unchanged since the editor loaded it (an agent or an external editor may change it too). */
+export function writeSpec(id, content, expectedMtimeMs) {
+    const file = existingSpecFile(id);
+    if (Buffer.byteLength(content) > MAX_BYTES)
+        throw new CaseError('Spec file is too large.', 400);
+    if (fs.statSync(file).mtimeMs !== expectedMtimeMs) {
+        throw new CaseError('The file changed on disk since you opened it. Reload it (copy your edits first) to continue.', 409);
+    }
+    const temp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, content);
+    fs.renameSync(temp, file);
+    return readSpec(id);
+}
+/** The command that opens a file with the application the operating system has registered for it. */
+function openCommand(file) {
+    if (process.platform === 'darwin')
+        return { command: 'open', args: [file] };
+    if (process.platform === 'win32')
+        return { command: 'cmd', args: ['/c', 'start', '""', file] };
+    return { command: 'xdg-open', args: [file] };
+}
+/**
+ * Opens the spec of a case in the default application of the system. Resolves once the opener has handed the file over
+ * (or is still running after a moment, as `xdg-open` can be); rejects when there is no opener or it fails.
+ */
+export function openSpec(id) {
+    const { command, args } = openCommand(existingSpecFile(id));
+    return new Promise((resolve, reject) => {
+        const fail = (reason) => reject(new CaseError(`Could not open the spec: ${reason}`, 400));
+        const child = spawn(command, args, { detached: true, stdio: 'ignore' });
+        const timer = setTimeout(() => {
+            child.unref();
+            resolve();
+        }, 3000);
+        child.on('error', (error) => {
+            clearTimeout(timer);
+            fail(error.message);
+        });
+        child.on('exit', (code) => {
+            clearTimeout(timer);
+            if (code === 0)
+                resolve();
+            else
+                fail(`"${command}" exited with code ${code}.`);
+        });
+    });
+}
+/** Writes only if the file is unchanged since the editor loaded it (an agent may be editing it too). */
+export function writeCase(id, content, expectedMtimeMs) {
+    const file = fileFor(id);
+    if (!fs.existsSync(file))
+        throw new CaseError(`Case "${id}" does not exist.`, 404);
+    if (Buffer.byteLength(content) > MAX_BYTES)
+        throw new CaseError('Case file is too large.', 400);
+    if (fs.statSync(file).mtimeMs !== expectedMtimeMs) {
+        throw new CaseError('The file changed on disk since you opened it. Reload it (copy your edits first) to continue.', 409);
+    }
+    const temp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, content);
+    fs.renameSync(temp, file);
+    return readCase(id);
+}
+/** Reuses `pnpm case:new` so the template stays in one place. */
+export async function createCase(id) {
+    assertValidNewId(id);
+    if (fs.existsSync(fileFor(id)))
+        throw new CaseError(`Case "${id}" already exists.`, 409);
+    await promisify(execFile)(process.execPath, [...scriptArgs('new-case.ts'), id], {
+        cwd: ROOT,
+    });
+    return readCase(id);
+}
+export const caseImpact = (id) => {
+    fileFor(id);
+    if (!fs.existsSync(caseFilePath(id)))
+        throw new CaseError(`Case "${id}" does not exist.`, 404);
+    return getCaseImpact(id);
+};
+export const renameCase = (id, to) => {
+    renameCaseFiles(id, to);
+    return readCase(to);
+};
+export const deleteCase = (id) => deleteCaseFiles(id);

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

@@ -0,0 +1,5 @@
+import type { Context } from 'hono';
+/** Resolves `relative` under `base`; returns null if the result escapes `base` (also via symlinks). */
+export declare function resolveInside(base: string, relative: string): string | null;
+/** Serves a file with HTTP Range support, which videos need for seeking. */
+export declare function sendFile(c: Context, file: string): Response | Promise<Response>;

package/dist/ui/server/files.js

@@ -0,0 +1,67 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Readable } from 'node:stream';
+const MIME = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.mjs': 'text/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.webmanifest': 'application/manifest+json',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webm': 'video/webm',
+    '.mp4': 'video/mp4',
+    '.zip': 'application/zip',
+    '.ttf': 'font/ttf',
+    '.woff2': 'font/woff2',
+    '.txt': 'text/plain; charset=utf-8',
+    '.md': 'text/markdown; charset=utf-8',
+};
+/** Resolves `relative` under `base`; returns null if the result escapes `base` (also via symlinks). */
+export function resolveInside(base, relative) {
+    const realBase = fs.realpathSync(base);
+    const target = path.resolve(realBase, '.' + path.sep + relative);
+    let real;
+    try {
+        real = fs.realpathSync(target);
+    }
+    catch {
+        return null;
+    }
+    return real === realBase || real.startsWith(realBase + path.sep) ? real : null;
+}
+/** Serves a file with HTTP Range support, which videos need for seeking. */
+export function sendFile(c, file) {
+    const stat = fs.statSync(file, { throwIfNoEntry: false });
+    if (!stat?.isFile())
+        return c.notFound();
+    const headers = {
+        'Content-Type': MIME[path.extname(file).toLowerCase()] ?? 'application/octet-stream',
+        'Accept-Ranges': 'bytes',
+        'Cache-Control': 'no-cache',
+    };
+    const range = /^bytes=(\d*)-(\d*)$/.exec(c.req.header('range') ?? '');
+    if (range && (range[1] || range[2])) {
+        const size = stat.size;
+        const start = range[1] ? Number(range[1]) : Math.max(0, size - Number(range[2]));
+        const end = range[1] && range[2] ? Math.min(Number(range[2]), size - 1) : size - 1;
+        if (start > end || start >= size) {
+            return new Response(null, { status: 416, headers: { 'Content-Range': `bytes */${size}` } });
+        }
+        return new Response(Readable.toWeb(fs.createReadStream(file, { start, end })), {
+            status: 206,
+            headers: {
+                ...headers,
+                'Content-Range': `bytes ${start}-${end}/${size}`,
+                'Content-Length': String(end - start + 1),
+            },
+        });
+    }
+    return new Response(Readable.toWeb(fs.createReadStream(file)), {
+        status: 200,
+        headers: { ...headers, 'Content-Length': String(stat.size) },
+    });
+}

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

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

package/dist/ui/server/index.js

@@ -0,0 +1,33 @@
+import { serve } from '@hono/node-server';
+import { createApp } from './app.js';
+import { verifyProfiles } from './profiles.js';
+import { jobs } from './jobs.js';
+import { startFileWatcher } from './watch-files.js';
+const port = Number(process.env.ASRUN_UI_PORT ?? 4173);
+const app = createApp({ port });
+const server = serve({ fetch: app.fetch, port, hostname: '127.0.0.1' }, () => {
+    const devOrigin = process.env.ASRUN_UI_DEV_ORIGIN;
+    if (devOrigin) {
+        console.log(`asrun API (dev, no UI here): http://127.0.0.1:${port}`);
+        console.log(`asrun UI: ${devOrigin}`);
+    }
+    else {
+        console.log(`asrun UI: http://127.0.0.1:${port}`);
+    }
+    startFileWatcher();
+    void verifyProfiles();
+});
+server.on('error', (error) => {
+    if (error.code === 'EADDRINUSE') {
+        console.error(`Port ${port} is already in use. Is the UI already running? Or set ASRUN_UI_PORT.`);
+        process.exit(1);
+    }
+    throw error;
+});
+const shutdown = () => {
+    jobs.killAll();
+    server.close();
+    setTimeout(() => process.exit(0), 300).unref();
+};
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

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

@@ -0,0 +1,74 @@
+import { type ChildProcess } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import type { JobChunk, JobInfo, JobKind } from '../shared/types.js';
+import type { AiCommand, AiTool } from '../shared/ai-commands.js';
+import { AiStreamFormatter } from './ai-stream.js';
+export declare class JobConflictError extends Error {
+}
+export interface JobSpec {
+    kind: JobKind;
+    profile?: string;
+    env?: string;
+    /** Shown to the user. */
+    command: string;
+    /** Executable and arguments, spawned without a shell. */
+    file: string;
+    args: string[];
+    /** Jobs holding the same lock cannot run at the same time. */
+    locks: string[];
+    acceptsInput: boolean;
+    /** The agent CLI whose JSON event stream on stdout is turned into readable log lines. */
+    stream?: AiTool;
+    /** Set for a test run that overwrites the baselines of these cases. */
+    baselineCases?: string[];
+    /** Set for a test run: the report folder it writes. */
+    reportId?: string;
+    /** Set for the AI run of a command on a case: what a later turn of its conversation needs. */
+    ai?: {
+        tool: AiTool;
+        command: AiCommand;
+        caseId: string;
+        env: string;
+        sessionId: string;
+    };
+    /** The job whose conversation this one continues. */
+    continuesJobId?: string;
+    /** Runs synchronously right before the final status is published. */
+    onFinish?: (job: JobInfo) => void;
+}
+interface JobRecord {
+    info: JobInfo;
+    spec: JobSpec;
+    chunks: JobChunk[];
+    bufferedChars: number;
+    nextSeq: number;
+    emitter: EventEmitter;
+    child: ChildProcess | null;
+    cancelRequested: boolean;
+    logStream: fs.WriteStream;
+    formatter: AiStreamFormatter | null;
+    heartbeat: NodeJS.Timeout | null;
+}
+declare class JobManager {
+    private jobs;
+    /** Emits `job` with a JobInfo on every status change of any job. */
+    readonly events: EventEmitter<[never]>;
+    constructor();
+    list(): JobInfo[];
+    get(id: string): JobRecord | undefined;
+    start(spec: JobSpec): JobInfo;
+    write(id: string, text: string): boolean;
+    cancel(id: string): boolean;
+    /** Stops everything; called when the server shuts down. */
+    killAll(): void;
+    /** Publishes a change of "waiting for the person" (a handoff card) like any other status change. */
+    private syncAwaiting;
+    private signalGroup;
+    private push;
+    private finish;
+    private pruneFinished;
+    private pruneOldLogs;
+}
+export declare const jobs: JobManager;
+export {};

package/dist/ui/server/jobs.js

@@ -0,0 +1,263 @@
+import { spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
+import { ROOT } from '../../lib/paths.js';
+import { AiStreamFormatter } from './ai-stream.js';
+const LOG_DIR = path.join(ROOT, '.tmp', 'ui-jobs');
+const MAX_BUFFERED_CHARS = 4_000_000;
+const MAX_FINISHED_JOBS = 30;
+const LOG_RETENTION_MS = 7 * 24 * 3600 * 1000;
+const KILL_GRACE_MS = 5000;
+// An agent that has said nothing for this long gets a "still waiting for <tool call>" line in its log.
+const QUIET_MS = 45_000;
+const HEARTBEAT_MS = 15_000;
+export class JobConflictError extends Error {
+}
+const ANSI = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
+/** The last `RESULT: ready|needs-input` line of what the agent printed (markdown emphasis around it is fine). */
+function parseResultState(record) {
+    const text = record.chunks
+        .filter((chunk) => chunk.stream !== 'system')
+        .map((chunk) => chunk.data)
+        .join('')
+        .replace(ANSI, '');
+    const matches = [...text.matchAll(/^[\s*`>_-]*RESULT:\s*(ready|needs-input)\b/gm)];
+    return matches.at(-1)?.[1] ?? null;
+}
+class JobManager {
+    jobs = new Map();
+    /** Emits `job` with a JobInfo on every status change of any job. */
+    events = new EventEmitter();
+    constructor() {
+        this.events.setMaxListeners(0);
+        this.pruneOldLogs();
+    }
+    list() {
+        return [...this.jobs.values()].map((record) => record.info).reverse();
+    }
+    get(id) {
+        return this.jobs.get(id);
+    }
+    start(spec) {
+        for (const record of this.jobs.values()) {
+            if (record.info.status !== 'running')
+                continue;
+            const clash = record.spec.locks.find((lock) => spec.locks.includes(lock));
+            if (clash) {
+                throw new JobConflictError(`Cannot start: "${record.info.command}" is already running (${clash}). Wait for it to finish or cancel it.`);
+            }
+        }
+        const id = crypto.randomBytes(6).toString('hex');
+        fs.mkdirSync(LOG_DIR, { recursive: true });
+        const record = {
+            info: {
+                id,
+                kind: spec.kind,
+                profile: spec.profile,
+                env: spec.env,
+                command: spec.command,
+                status: 'running',
+                exitCode: null,
+                signal: null,
+                startedAt: new Date().toISOString(),
+                endedAt: null,
+                acceptsInput: spec.acceptsInput,
+                ...(spec.baselineCases && { baselineCases: spec.baselineCases }),
+                ...(spec.reportId && { reportId: spec.reportId }),
+                ...(spec.ai && {
+                    caseId: spec.ai.caseId,
+                    aiCommand: spec.ai.command,
+                    sessionId: spec.ai.sessionId,
+                    resultState: null,
+                }),
+                ...(spec.continuesJobId && { continuesJobId: spec.continuesJobId }),
+            },
+            spec,
+            chunks: [],
+            bufferedChars: 0,
+            nextSeq: 0,
+            emitter: new EventEmitter(),
+            child: null,
+            cancelRequested: false,
+            logStream: fs.createWriteStream(path.join(LOG_DIR, `${id}.log`)),
+            formatter: spec.stream ? new AiStreamFormatter(spec.stream) : null,
+            heartbeat: null,
+        };
+        record.emitter.setMaxListeners(0);
+        this.jobs.set(id, record);
+        this.push(record, 'system', `$ ${spec.command}\n`);
+        let child;
+        try {
+            child = spawn(spec.file, spec.args, {
+                cwd: ROOT,
+                detached: true,
+                stdio: [spec.acceptsInput ? 'pipe' : 'ignore', 'pipe', 'pipe'],
+                env: { ...process.env, FORCE_COLOR: '1', NO_COLOR: undefined },
+            });
+        }
+        catch (error) {
+            this.finish(record, null, null, `Failed to start: ${error.message}`);
+            return record.info;
+        }
+        record.child = child;
+        for (const stream of ['stdout', 'stderr']) {
+            const decoder = new StringDecoder('utf8');
+            const formatted = stream === 'stdout' ? record.formatter : null;
+            const emit = (text) => {
+                const out = formatted ? formatted.feed(text) : text;
+                if (out)
+                    this.push(record, stream, out);
+                this.syncAwaiting(record);
+            };
+            child[stream]?.on('data', (buffer) => {
+                const text = decoder.write(buffer);
+                if (text)
+                    emit(text);
+            });
+            child[stream]?.on('end', () => {
+                const rest = decoder.end();
+                if (rest)
+                    emit(rest);
+                const tail = formatted?.end();
+                if (tail)
+                    this.push(record, stream, tail);
+            });
+        }
+        if (record.formatter) {
+            const formatter = record.formatter;
+            record.heartbeat = setInterval(() => {
+                const line = formatter.waiting(QUIET_MS);
+                if (line)
+                    this.push(record, 'system', line);
+            }, HEARTBEAT_MS);
+            record.heartbeat.unref();
+        }
+        child.stdin?.on('error', () => { });
+        let finished = false;
+        child.on('error', (error) => {
+            if (finished)
+                return;
+            finished = true;
+            this.finish(record, null, null, `Failed to start: ${error.message}`);
+        });
+        child.on('close', (code, signal) => {
+            if (finished)
+                return;
+            finished = true;
+            this.finish(record, code, signal);
+        });
+        this.events.emit('job', record.info);
+        return record.info;
+    }
+    write(id, text) {
+        const record = this.jobs.get(id);
+        if (!record || record.info.status !== 'running' || !record.info.acceptsInput)
+            return false;
+        return record.child?.stdin?.write(text) ?? false;
+    }
+    cancel(id) {
+        const record = this.jobs.get(id);
+        const pid = record?.child?.pid;
+        if (!record || record.info.status !== 'running' || !pid)
+            return false;
+        record.cancelRequested = true;
+        this.signalGroup(pid, 'SIGTERM');
+        setTimeout(() => {
+            if (record.info.status === 'running')
+                this.signalGroup(pid, 'SIGKILL');
+        }, KILL_GRACE_MS).unref();
+        return true;
+    }
+    /** Stops everything; called when the server shuts down. */
+    killAll() {
+        for (const record of this.jobs.values()) {
+            const pid = record.child?.pid;
+            if (record.info.status === 'running' && pid)
+                this.signalGroup(pid, 'SIGTERM');
+        }
+    }
+    /** Publishes a change of "waiting for the person" (a handoff card) like any other status change. */
+    syncAwaiting(record) {
+        const { info } = record;
+        if (info.status !== 'running' || !record.formatter)
+            return;
+        const now = record.formatter.awaiting;
+        const before = info.awaitingUser ?? null;
+        if (!now && !before)
+            return;
+        if (now && before && before.since === new Date(now.since).toISOString())
+            return;
+        info.awaitingUser = now ? { message: now.message, since: new Date(now.since).toISOString() } : null;
+        this.events.emit('job', info);
+    }
+    signalGroup(pid, signal) {
+        try {
+            process.kill(-pid, signal);
+        }
+        catch {
+            // Already gone.
+        }
+    }
+    push(record, stream, data) {
+        const chunk = { seq: record.nextSeq++, stream, data };
+        record.chunks.push(chunk);
+        record.bufferedChars += data.length;
+        while (record.bufferedChars > MAX_BUFFERED_CHARS && record.chunks.length > 1) {
+            record.bufferedChars -= record.chunks.shift().data.length;
+        }
+        record.logStream.write(stream === 'stderr' ? `[stderr] ${data}` : data);
+        record.emitter.emit('chunk', chunk);
+    }
+    finish(record, code, signal, note) {
+        const { info } = record;
+        if (record.heartbeat)
+            clearInterval(record.heartbeat);
+        info.awaitingUser = null;
+        info.exitCode = code;
+        info.signal = signal;
+        info.endedAt = new Date().toISOString();
+        info.status = record.cancelRequested
+            ? 'cancelled'
+            : code === 0
+                ? 'succeeded'
+                : 'failed';
+        const summary = note ??
+            (info.status === 'cancelled'
+                ? '[cancelled]'
+                : signal
+                    ? `[process killed by ${signal}]`
+                    : `[process exited with code ${code}]`);
+        if (record.spec.ai && info.status === 'succeeded')
+            info.resultState = parseResultState(record);
+        this.push(record, 'system', `\n${summary}\n`);
+        record.logStream.end();
+        try {
+            record.spec.onFinish?.(info);
+        }
+        catch (error) {
+            console.error('onFinish failed:', error);
+        }
+        record.emitter.emit('status', info);
+        this.events.emit('job', info);
+        this.pruneFinished();
+    }
+    pruneFinished() {
+        const finished = [...this.jobs.values()].filter((record) => record.info.status !== 'running');
+        for (const record of finished.slice(0, Math.max(0, finished.length - MAX_FINISHED_JOBS))) {
+            this.jobs.delete(record.info.id);
+        }
+    }
+    pruneOldLogs() {
+        if (!fs.existsSync(LOG_DIR))
+            return;
+        for (const name of fs.readdirSync(LOG_DIR)) {
+            const file = path.join(LOG_DIR, name);
+            if (Date.now() - fs.statSync(file).mtimeMs > LOG_RETENTION_MS)
+                fs.rmSync(file, { force: true });
+        }
+    }
+}
+export const jobs = new JobManager();

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

@@ -0,0 +1,16 @@
+import type { AddProfileRequest, ProfileInfo, ProfilesResponse } from '../shared/types.js';
+export declare function listProfileRows(): ProfilesResponse;
+/** Opens each saved session on the real site (read-only) and records whether it is still logged in. */
+export declare function verifyProfiles(only?: {
+    ids?: string[];
+    env?: string;
+}): Promise<void>;
+export declare class ProfileError extends Error {
+    readonly status: 400 | 409;
+    constructor(message: string, status: 400 | 409);
+}
+/**
+ * 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 declare function addProfile(request: AddProfileRequest, file?: string): ProfileInfo;