@mingchuno/agent-workflows 0.1.0 → 0.2.0

package/dist/src/tui/log.js

@@ -0,0 +1,90 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from "ink";
+import { useState } from "react";
+import { HelpDialog } from "./dialogs.js";
+import { cells, colorFor } from "./format.js";
+import { presentLogLine } from "./log-file.js";
+import { matchIndex } from "./text.js";
+import { useLogController } from "./use-log-controller.js";
+const horizontalPanColumns = 20;
+export function LogViewer({ sources, initial, columns, rows, onBack, }) {
+    const [index, setIndex] = useState(initial);
+    const source = sources[index] ?? sources[0];
+    if (!source)
+        return _jsx(Text, { children: "No logs recorded. Esc back" });
+    return (_jsx(LogScreen, { source: source, columns: columns, rows: rows, onBack: onBack, onNext: () => setIndex((value) => (value + 1) % sources.length), multiple: sources.length > 1 }, source.path));
+}
+function Highlight({ text, query }) {
+    const at = query ? matchIndex(text, query) : -1;
+    if (at < 0)
+        return _jsx(Text, { children: text });
+    return (_jsxs(Text, { children: [text.slice(0, at), _jsx(Text, { inverse: true, bold: true, children: text.slice(at, at + query.length) }), text.slice(at + query.length)] }));
+}
+function LogScreen({ source, columns, rows, onBack, onNext, multiple, }) {
+    const log = useLogController(source.path, columns, rows);
+    const { height, following, horizontal, raw, lines, total, message, editing, draft, query, searching, position, } = log;
+    const [help, setHelp] = useState(false);
+    useInput((input, key) => {
+        if (key.ctrl || key.meta || key.eventType === "release")
+            return;
+        if (help)
+            return;
+        if (key.escape) {
+            if (!log.dismissSearch())
+                onBack();
+            return;
+        }
+        if (editing) {
+            if (key.return)
+                log.applySearch();
+            else if (key.backspace || key.delete)
+                log.eraseDraft();
+            else if (!key.ctrl &&
+                !key.meta &&
+                !key.upArrow &&
+                !key.downArrow &&
+                !key.leftArrow &&
+                !key.rightArrow &&
+                !key.tab)
+                log.appendDraft(input);
+            return;
+        }
+        if (input === "/")
+            log.beginSearch();
+        else if (input === "n" || input === "N")
+            log.repeatSearch(input === "n" ? 1 : -1);
+        else if (input === "f")
+            log.follow();
+        else if (input === "R")
+            log.toggleRaw();
+        else if (key.tab && multiple)
+            onNext();
+        else if (input === "?")
+            setHelp(true);
+        else if (key.upArrow || input === "k")
+            log.scroll(-1);
+        else if (key.downArrow || input === "j")
+            log.scroll(1);
+        else if (key.pageUp)
+            log.scroll(-height);
+        else if (key.pageDown || input === " ")
+            log.scroll(height);
+        else if (key.home || input === "g")
+            log.firstPage();
+        else if (key.end || input === "G")
+            log.lastPage();
+        else if (key.leftArrow)
+            log.pan(-horizontalPanColumns);
+        else if (key.rightArrow)
+            log.pan(horizontalPanColumns);
+    });
+    if (help)
+        return (_jsx(HelpDialog, { columns: columns, rows: rows, initialPage: 2, onClose: () => setHelp(false) }));
+    return (_jsxs(Box, { width: columns, height: rows, flexDirection: "column", children: [_jsx(Text, { bold: true, color: colorFor("running"), wrap: "truncate", children: cells(`Logs · ${source.label}`, columns) }), _jsx(Text, { wrap: "truncate", children: cells(source.path, columns) }), _jsxs(Text, { children: [following ? "LIVE FOLLOW" : "SCROLLING", " \u00B7 ", raw ? "Raw" : "Readable", " \u00B7 lines ", total ? position + 1 : 0, "\u2013", Math.min(total, position + height), "/", total, searching ? " · Searching…" : ""] }), _jsx(Box, { height: height, flexDirection: "column", overflow: "hidden", children: lines.map((line, index) => (_jsx(Text, { wrap: "truncate", children: _jsx(Highlight, { text: cells(presentLogLine(line, raw), columns, horizontal), query: query }) }, `${position + index}`))) }), _jsx(Text, { wrap: "truncate", children: cells(editing
+                    ? `/${draft}▏`
+                    : query
+                        ? `Search: ${query}${message ? ` · ${message}` : ""}`
+                        : message, columns) }), _jsx(Text, { color: colorFor("running"), wrap: "truncate", children: editing
+                    ? "Enter search · Esc cancel"
+                    : `/ search · n/N match · f follow · R ${raw ? "readable" : "raw"} · ${multiple ? "Tab log · " : ""}Esc back · ? help` }), _jsx(Text, { dimColor: true, wrap: "truncate", children: cells("↑↓ scroll · PgUp/PgDn page · ←→ pan · workflow continues in background", columns) })] }));
+}

package/dist/src/tui/monitor.d.ts

@@ -0,0 +1,8 @@
+import { type MonitorSource } from "./data.js";
+export declare function Monitor({ source, size, }: {
+    source: MonitorSource;
+    size?: {
+        columns: number;
+        rows: number;
+    };
+}): import("react").JSX.Element;

package/dist/src/tui/monitor.js

@@ -0,0 +1,222 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useApp, useInput, useWindowSize } from "ink";
+import { useEffect, useState } from "react";
+import { actionAvailability } from "./actions.js";
+import { minimumTerminalSize } from "./constants.js";
+import { useMonitorData } from "./data.js";
+import { ConfirmDialog, HelpDialog } from "./dialogs.js";
+import { cells, colorFor, wrapLines } from "./format.js";
+import { monitorLayout } from "./layout.js";
+import { LogViewer } from "./log.js";
+import { detailLines, Lines, RunList, summaryLines } from "./views.js";
+const focuses = ["runs", "summary", "sessions"];
+const statusRefreshIntervalMs = 1_000;
+const actionDescriptions = {
+    stop: "Cancel this run and wait for its active local work to stop.",
+    retry: "Create a new run and branch; execute the workflow again.",
+    recover: "Continue the failed publication step using completed work.",
+};
+export function Monitor({ source, size, }) {
+    const window = useWindowSize();
+    const { columns, rows } = size ?? window;
+    const { exit } = useApp();
+    const [selection, setSelection] = useState({});
+    const data = useMonitorData(source, selection);
+    const { projects, project, projectRuns, run, sessions, events } = data;
+    const [focus, setFocus] = useState("runs");
+    const [screen, setScreen] = useState("dashboard");
+    const [sessionId, setSessionId] = useState();
+    const [stepSequence, setStepSequence] = useState();
+    const [offset, setOffset] = useState(0);
+    const [helpOpen, setHelpOpen] = useState(false);
+    const [confirmation, setConfirmation] = useState();
+    const [logs, setLogs] = useState();
+    const [now, setNow] = useState(Date.now());
+    const layout = monitorLayout(columns, rows);
+    const { wide, height, paneWidth, summaryWidth } = layout;
+    const session = sessions.find((item) => item.id === sessionId) ?? sessions[0];
+    const event = events.find((item) => item.sequence === stepSequence) ?? events.at(-1);
+    useEffect(() => {
+        const timer = setInterval(() => setNow(Date.now()), statusRefreshIntervalMs);
+        return () => clearInterval(timer);
+    }, []);
+    useEffect(() => {
+        // Pin default selections by identity before incoming rows can reorder them.
+        setSelection((current) => current.projectId === project?.id && current.runId === run?.id
+            ? current
+            : { projectId: project?.id, runId: run?.id });
+    }, [project?.id, run?.id]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: reset navigation when the selected run identity changes.
+    useEffect(() => {
+        setSessionId(undefined);
+        setStepSequence(undefined);
+        setOffset(0);
+        setConfirmation(undefined);
+    }, [run?.id]);
+    const selectProject = (delta) => {
+        const index = projects.findIndex((item) => item.id === project?.id);
+        const next = projects[Math.max(0, Math.min(projects.length - 1, index + delta))];
+        setSelection({ projectId: next?.id });
+        setFocus("runs");
+        setOffset(0);
+    };
+    const openAgentLog = () => {
+        if (!sessions.length)
+            return;
+        setLogs({
+            sources: sessions.map((item) => ({
+                path: item.log,
+                label: `${item.step} · invocation ${item.attempt}`,
+            })),
+            initial: Math.max(0, sessions.findIndex((item) => item.id === session?.id)),
+        });
+    };
+    const { recoveryReason, available } = actionAvailability({
+        run,
+        project,
+        projectRuns,
+        pending: Boolean(data.pending),
+    });
+    useInput((input, key) => {
+        if (key.ctrl || key.meta || key.eventType === "release")
+            return;
+        const terminalIsLargeEnough = columns >= minimumTerminalSize.columns &&
+            rows >= minimumTerminalSize.rows;
+        if (logs && terminalIsLargeEnough)
+            return;
+        if (terminalIsLargeEnough && (confirmation || helpOpen))
+            return;
+        if (input === "q") {
+            exit();
+            return;
+        }
+        if (!terminalIsLargeEnough)
+            return;
+        if (key.escape) {
+            setScreen("dashboard");
+            setFocus("runs");
+            setOffset(0);
+            return;
+        }
+        if (input === "?") {
+            setHelpOpen(true);
+            return;
+        }
+        if (key.tab && screen === "dashboard") {
+            setFocus(focuses[(focuses.indexOf(focus) + (key.shift ? 2 : 1)) % 3]);
+            setOffset(0);
+        }
+        if (input === "a") {
+            setScreen("dashboard");
+            setFocus("sessions");
+        }
+        if (key.leftArrow && screen === "dashboard")
+            selectProject(-1);
+        if (key.rightArrow && screen === "dashboard")
+            selectProject(1);
+        if (key.return && run) {
+            setScreen("details");
+            setOffset(0);
+        }
+        if (input === "l")
+            openAgentLog();
+        if (input === "v" && run?.validation?.length)
+            setLogs({
+                sources: run.validation.map((item) => ({
+                    path: item.log,
+                    label: `${item.command} · exit ${item.exitCode}`,
+                })),
+                initial: 0,
+            });
+        if (input === "[" || input === "]") {
+            const index = events.findIndex((item) => item.sequence === event?.sequence);
+            setStepSequence(events[Math.max(0, Math.min(events.length - 1, index + (input === "]" ? 1 : -1)))]?.sequence);
+        }
+        if (key.end)
+            setStepSequence(undefined);
+        if (key.upArrow || key.downArrow || key.pageUp || key.pageDown) {
+            const delta = key.upArrow || key.pageUp ? -1 : 1;
+            if (screen === "details" || focus === "summary") {
+                const lines = run
+                    ? screen === "details"
+                        ? detailLines(run, sessions, now, recoveryReason)
+                        : summaryLines(run, now, event)
+                    : [];
+                const viewport = screen === "details" ? layout.details : layout.summary;
+                setOffset((value) => Math.max(0, Math.min(wrapLines(lines, viewport.width).length - viewport.height, value +
+                    delta *
+                        (key.pageUp || key.pageDown ? layout.details.height : 1))));
+            }
+            else if (focus === "sessions") {
+                const index = sessions.findIndex((item) => item.id === session?.id);
+                setSessionId(sessions[Math.max(0, Math.min(sessions.length - 1, index + delta))]
+                    ?.id);
+            }
+            else {
+                const index = projectRuns.findIndex((item) => item.id === run?.id);
+                setSelection({
+                    projectId: project?.id,
+                    runId: projectRuns[Math.max(0, Math.min(projectRuns.length - 1, index + delta))]?.id,
+                });
+            }
+        }
+        if (input === "p" && project && !data.pending)
+            void data.action(project.paused ? "resume" : "pause", project.id);
+        const kind = input === "s"
+            ? "stop"
+            : input === "r"
+                ? "retry"
+                : input === "c"
+                    ? "recover"
+                    : undefined;
+        if (kind && run && available[kind])
+            setConfirmation({
+                kind,
+                runId: run.id,
+                title: `#${run.issue.number} ${run.issue.title}`,
+            });
+    });
+    if (columns < minimumTerminalSize.columns || rows < minimumTerminalSize.rows)
+        return (_jsx(Box, { width: columns, height: rows, flexDirection: "column", children: _jsx(Text, { children: cells(`Resize terminal to at least ${minimumTerminalSize.columns}×${minimumTerminalSize.rows}. q closes monitor.`, columns) }) }));
+    if (helpOpen)
+        return (_jsx(HelpDialog, { columns: columns, rows: rows, onClose: () => setHelpOpen(false) }));
+    if (confirmation)
+        return (_jsx(ConfirmDialog, { columns: columns, rows: rows, title: `Confirm ${confirmation.kind}`, subject: confirmation.title, description: actionDescriptions[confirmation.kind], available: run?.id === confirmation.runId && available[confirmation.kind], onCancel: () => setConfirmation(undefined), onConfirm: () => {
+                void data.action(confirmation.kind, confirmation.runId);
+                setConfirmation(undefined);
+            } }));
+    if (logs)
+        return (_jsx(LogViewer, { ...logs, columns: columns, rows: rows, onBack: () => setLogs(undefined) }));
+    const status = `${data.connection}${data.lastUpdated ? ` · refreshed ${Math.max(0, Math.floor((now - data.lastUpdated) / statusRefreshIntervalMs))}s ago` : ""}`;
+    const sessionIndex = Math.max(0, sessions.findIndex((item) => item.id === session?.id));
+    const sessionLines = sessions.length
+        ? sessions
+            .slice(Math.max(0, sessionIndex - 1), sessionIndex + 3)
+            .map((item) => `${item.id === session?.id ? ">" : " "} ${item.step} · invocation ${item.attempt} · ${item.outcome}`)
+        : ["No agent sessions recorded"];
+    const controls = [
+        sessions.length ? "l log" : "",
+        run?.validation?.length ? "v validation" : "",
+        project ? (project.paused ? "p resume" : "p pause") : "",
+        available.stop ? "s stop" : "",
+        available.retry ? "r retry" : "",
+        available.recover ? "c recover" : "",
+        "? help",
+        "q close",
+    ]
+        .filter(Boolean)
+        .join(" · ");
+    return (_jsxs(Box, { width: columns, height: rows, flexDirection: "column", children: [_jsx(Text, { bold: true, color: colorFor("running"), wrap: "truncate", children: cells(`Agent Workflows · ${screen === "dashboard" ? "Monitor" : "Run details"}`, columns) }), _jsx(Text, { wrap: "truncate", children: cells(project
+                    ? `${project.id} · intake ${project.paused ? "paused" : "enabled"} · ${projectRuns.filter((item) => item.outcome === "queued").length} queued${project.blocked ? ` · BLOCKED: ${project.blocked}` : ""}`
+                    : "No projects registered. Start the runner to populate this view.", columns) }), _jsx(Box, { height: height, flexDirection: "row", overflow: "hidden", children: screen === "details" ? (_jsxs(Box, { borderStyle: "round", width: columns, height: height, paddingX: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Details \u00B7 \u2191\u2193 scroll \u00B7 Esc back" }), _jsx(Lines, { lines: run
+                                ? detailLines(run, sessions, now, recoveryReason)
+                                : ["Run no longer available"], width: layout.details.width, height: layout.details.height, offset: offset })] })) : (_jsxs(_Fragment, { children: [(wide || focus === "runs") && (_jsxs(Box, { width: paneWidth, height: height, borderStyle: "round", borderColor: focus === "runs" ? colorFor("running") : undefined, flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { bold: true, children: [focus === "runs" ? "> " : "", "Runs \u00B7 ", projectRuns.length] }), _jsx(RunList, { runs: projectRuns, selected: run?.id, width: layout.runs.width, height: layout.runs.height, now: now })] })), (wide || focus !== "runs") && (_jsxs(Box, { width: summaryWidth, height: height, flexDirection: "column", children: [(wide || focus === "summary") && (_jsxs(Box, { width: summaryWidth, height: layout.summaryPanelHeight, borderStyle: "round", borderColor: focus === "summary" ? colorFor("running") : undefined, paddingX: 1, flexDirection: "column", children: [_jsxs(Text, { bold: true, children: [focus === "summary" ? "> " : "", "Summary \u00B7 Enter details"] }), _jsx(Lines, { lines: run
+                                                ? summaryLines(run, now, event)
+                                                : ["Select a run to inspect progress"], width: layout.summary.width, height: layout.summary.height, offset: offset })] })), (wide || focus === "sessions") && (_jsxs(Box, { width: summaryWidth, height: layout.sessionsPanelHeight, borderStyle: "round", borderColor: focus === "sessions" ? colorFor("running") : undefined, paddingX: 1, flexDirection: "column", children: [_jsxs(Text, { bold: true, children: [focus === "sessions" ? "> " : "", "Agent sessions \u00B7", " ", sessions.length, " \u00B7 l log"] }), _jsx(Lines, { lines: sessionLines, width: layout.sessions.width, height: layout.sessions.height })] }))] }))] })) }), _jsx(Text, { wrap: "truncate", color: data.connection.startsWith("Connection error")
+                    ? colorFor("failed")
+                    : undefined, children: cells(data.message || status, columns) }), _jsx(Text, { dimColor: true, wrap: "truncate", children: cells(data.message
+                    ? status
+                    : "Runner liveness unverified · closing monitor leaves workflows running", columns) }), _jsx(Text, { color: colorFor("running"), wrap: "truncate", children: cells(screen === "dashboard"
+                    ? "Tab pane · ↑↓ select/scroll · ←→ project · Enter details"
+                    : "↑↓ scroll · PgUp/PgDn page · Esc back", columns) }), _jsx(Text, { wrap: "truncate", children: cells(controls, columns) })] }));
+}

package/dist/src/tui/text.d.ts

@@ -0,0 +1,3 @@
+export declare function terminalText(text: string): string;
+/** Literal smart-case match, returning a UTF-16 offset for string slicing. */
+export declare function matchIndex(text: string, query: string): number;

package/dist/src/tui/text.js

@@ -0,0 +1,10 @@
+import { stripVTControlCharacters } from "node:util";
+export function terminalText(text) {
+    return stripVTControlCharacters(text).replace(
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: remove control bytes from untrusted terminal output.
+    /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, "");
+}
+/** Literal smart-case match, returning a UTF-16 offset for string slicing. */
+export function matchIndex(text, query) {
+    return (query === query.toLowerCase() ? text.toLowerCase() : text).indexOf(query);
+}

package/dist/src/tui/use-log-controller.d.ts

@@ -0,0 +1,27 @@
+/** Owned by one keyed log screen; unmount cancels polling and search. */
+export declare function useLogController(path: string, columns: number, rows: number): {
+    height: number;
+    following: boolean;
+    horizontal: number;
+    raw: boolean;
+    lines: string[];
+    total: number;
+    message: string;
+    editing: boolean;
+    draft: string;
+    query: string;
+    searching: boolean;
+    position: number;
+    scroll: (delta: number) => void;
+    dismissSearch(): boolean;
+    beginSearch(): void;
+    applySearch(): void;
+    repeatSearch(direction: 1 | -1): void;
+    eraseDraft(): void;
+    appendDraft(input: string): void;
+    follow(): void;
+    toggleRaw(): void;
+    firstPage(): void;
+    lastPage(): void;
+    pan(delta: number): void;
+};

package/dist/src/tui/use-log-controller.js

@@ -0,0 +1,192 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import stringWidth from "string-width";
+import { screenChromeRows, tuiRefreshIntervalMs } from "./constants.js";
+import { LogFile, presentLogLine } from "./log-file.js";
+import { matchIndex, terminalText } from "./text.js";
+/** Owned by one keyed log screen; unmount cancels polling and search. */
+export function useLogController(path, columns, rows) {
+    const file = useMemo(() => new LogFile(path), [path]);
+    const height = Math.max(1, rows - screenChromeRows);
+    const [following, setFollowing] = useState(true);
+    const [top, setTop] = useState(0);
+    const [horizontal, setHorizontal] = useState(0);
+    const [raw, setRaw] = useState(false);
+    const [lines, setLines] = useState([]);
+    const [total, setTotal] = useState(0);
+    const [message, setMessage] = useState("Loading log…");
+    const [editing, setEditing] = useState(false);
+    const [draft, setDraft] = useState("");
+    const [query, setQuery] = useState("");
+    const [searching, setSearching] = useState(false);
+    const searchController = useRef(undefined);
+    const position = useRef(0);
+    useEffect(() => () => searchController.current?.abort(), []);
+    useEffect(() => {
+        const controller = new AbortController();
+        let busy = false;
+        const update = async () => {
+            if (busy)
+                return;
+            busy = true;
+            try {
+                await file.refresh(controller.signal);
+                const nextTop = following
+                    ? Math.max(0, file.count - height)
+                    : Math.min(top, Math.max(0, file.count - 1));
+                const page = await file.page(nextTop, height, controller.signal);
+                if (controller.signal.aborted)
+                    return;
+                position.current = nextTop;
+                if (!following && nextTop !== top)
+                    setTop(nextTop);
+                setTotal(file.count);
+                setLines(page);
+                setMessage((current) => !file.count
+                    ? "No output yet; waiting for log data"
+                    : /^(Loading log|Log unavailable|No output yet)/.test(current)
+                        ? ""
+                        : current);
+            }
+            catch (error) {
+                if (!controller.signal.aborted) {
+                    setLines([]);
+                    setMessage(`Log unavailable: ${String(error)}`);
+                }
+            }
+            finally {
+                busy = false;
+            }
+        };
+        void update();
+        const timer = setInterval(() => void update(), tuiRefreshIntervalMs);
+        return () => {
+            controller.abort();
+            clearInterval(timer);
+        };
+    }, [file, following, top, height]);
+    const search = async (value, direction, first = false) => {
+        if (!value)
+            return;
+        searchController.current?.abort();
+        const controller = new AbortController();
+        searchController.current = controller;
+        setFollowing(false);
+        setQuery(value);
+        setSearching(true);
+        try {
+            const match = await file.search({
+                query: value,
+                from: first ? position.current - 1 : position.current,
+                direction,
+                raw,
+                signal: controller.signal,
+            });
+            if (controller.signal.aborted)
+                return;
+            if (match === undefined)
+                setMessage(`No matches: ${value}`);
+            else {
+                position.current = match;
+                setTop(match);
+                const [line] = await file.page(match, 1, controller.signal);
+                if (controller.signal.aborted)
+                    return;
+                const text = presentLogLine(line ?? "", raw);
+                const at = matchIndex(text, value);
+                setHorizontal(stringWidth(text.slice(0, at + value.length)) > columns
+                    ? Math.max(0, stringWidth(text.slice(0, at)) - 8)
+                    : 0);
+                setMessage(`Match on line ${match + 1} (wraps at file boundary)`);
+            }
+        }
+        catch (error) {
+            if (!controller.signal.aborted)
+                setMessage(`Search failed: ${String(error)}`);
+        }
+        finally {
+            if (!controller.signal.aborted)
+                setSearching(false);
+        }
+    };
+    const scroll = (delta) => {
+        setFollowing(false);
+        const next = Math.max(0, Math.min(Math.max(0, total - 1), position.current + delta));
+        position.current = next;
+        setTop(next);
+    };
+    const cancelSearch = () => {
+        searchController.current?.abort();
+        setSearching(false);
+    };
+    return {
+        height,
+        following,
+        horizontal,
+        raw,
+        lines,
+        total,
+        message,
+        editing,
+        draft,
+        query,
+        searching,
+        position: position.current,
+        scroll,
+        dismissSearch() {
+            cancelSearch();
+            if (!editing && !query)
+                return false;
+            setEditing(false);
+            setQuery("");
+            setDraft("");
+            return true;
+        },
+        beginSearch() {
+            setFollowing(false);
+            setTop(position.current);
+            setDraft("");
+            setEditing(true);
+        },
+        applySearch() {
+            setEditing(false);
+            void search(draft, 1, true);
+        },
+        repeatSearch(direction) {
+            void search(query, direction);
+        },
+        eraseDraft() {
+            setDraft((value) => Array.from(value).slice(0, -1).join(""));
+        },
+        appendDraft(input) {
+            setDraft((value) => value +
+                terminalText(input)
+                    .replaceAll("\n", "")
+                    .replaceAll("\r", "")
+                    .replaceAll("\t", ""));
+        },
+        follow() {
+            cancelSearch();
+            setQuery("");
+            setFollowing(true);
+            setHorizontal(0);
+        },
+        toggleRaw() {
+            cancelSearch();
+            setRaw(!raw);
+            setQuery("");
+        },
+        firstPage() {
+            setFollowing(false);
+            position.current = 0;
+            setTop(0);
+        },
+        lastPage() {
+            setFollowing(false);
+            position.current = Math.max(0, total - height);
+            setTop(position.current);
+        },
+        pan(delta) {
+            setHorizontal((value) => Math.max(0, value + delta));
+        },
+    };
+}

package/dist/src/tui/views.d.ts

@@ -0,0 +1,17 @@
+import type { RunRecord } from "../domain.js";
+import type { EventRecord, InvocationRecord } from "../store.js";
+export declare function summaryLines(run: RunRecord, now: number, event?: EventRecord): string[];
+export declare function detailLines(run: RunRecord, sessions: InvocationRecord[], now: number, recoveryReason?: string | undefined): string[];
+export declare function Lines({ lines, width, height, offset, }: {
+    lines: string[];
+    width: number;
+    height: number;
+    offset?: number;
+}): import("react").JSX.Element;
+export declare function RunList({ runs, selected, width, height, now, }: {
+    runs: RunRecord[];
+    selected?: string;
+    width: number;
+    height: number;
+    now: number;
+}): import("react").JSX.Element;