@voidlabs.gg/voidshift 0.0.0-stage → 0.4.1

package/dist/tui/palette.js

@@ -0,0 +1,269 @@
+// The command palette. ":" opens a filterable list of every vsf command line,
+// built from the umbrella usage table and each added tool's help output, plus
+// picks that fill in real card names ("agents retry ENG-1407"). Enter runs the
+// command through the action runner; commands that need a terminal are marked
+// and handed the real terminal instead.
+import React, { useEffect, useMemo, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { needsTerminal } from "./actions.js";
+import { editText, Panel } from "./widgets.js";
+import { theme } from "./theme.js";
+import { useData } from "./data.js";
+const h = React.createElement;
+// Splits "agents retry 'ENG 1'" into words. Quotes group words.
+export function splitCommand(text) {
+    const out = [];
+    let cur = '';
+    let quote = null;
+    let any = false;
+    for (const ch of text) {
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            else
+                cur += ch;
+        }
+        else if (ch === '"' || ch === "'") {
+            quote = ch;
+            any = true;
+        }
+        else if (/\s/.test(ch)) {
+            if (cur || any)
+                out.push(cur);
+            cur = '';
+            any = false;
+        }
+        else
+            cur += ch;
+    }
+    if (cur || any)
+        out.push(cur);
+    return out;
+}
+const isPlaceholder = (word) => word.startsWith('[') || word.startsWith('<') || word.startsWith('-') || word.includes('|') || (/[A-Z]/.test(word) && word === word.toUpperCase());
+// Builds an entry from a command signature such as "agents run [CARD] [--from STEP]".
+export function makeEntry(text, desc, dynamic = false) {
+    const words = text.trim().split(/\s+/);
+    const at = words.findIndex(isPlaceholder);
+    const prefixWords = at === -1 ? words : words.slice(0, at);
+    const rest = at === -1 ? '' : words.slice(at).join(' ');
+    // Runnable as the prefix when everything after it is optional.
+    const runnable = rest.replace(/\[[^\]]*\]/g, '').trim() === '';
+    return { text: text.trim(), desc, prefix: prefixWords.join(' '), runnable: dynamic || runnable, dynamic };
+}
+// Pulls command lines out of a tool's captured help. Three shapes exist:
+// "Usage: vsf awake on [..]", "  status  Description", and
+// "  status [--json]\n      Description".
+export function parseHelpLines(tool, text) {
+    const lines = text.split('\n');
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const full = new RegExp(`^\\s*(?:Usage:\\s*)?vsf ${tool} (.+)$`).exec(line);
+        if (full) {
+            const [sig, desc] = full[1].trim().split(/\s{2,}/);
+            if (!sig.startsWith('<'))
+                out.push(makeEntry(`${tool} ${sig}`, desc));
+            continue;
+        }
+        if (/^ {2}\S/.test(line)) {
+            const [sig, desc] = line.trim().split(/\s{2,}/);
+            let d = desc;
+            const next = lines[i + 1];
+            if (!d && next && /^ {4,}\S/.test(next))
+                d = next.trim();
+            if (sig && !sig.startsWith('<') && !sig.startsWith('vsf '))
+                out.push(makeEntry(`${tool} ${sig}`, d));
+        }
+    }
+    return out;
+}
+// Command lines from the umbrella usage table (commands/help.ts).
+export function parseUsages(usages) {
+    const out = [];
+    for (const usage of Object.values(usages)) {
+        const lines = usage.split('\n');
+        const hits = [];
+        for (const line of lines) {
+            const m = /^\s*(?:Usage:\s*)?vsf (.+)$/.exec(line);
+            if (!m)
+                continue;
+            const [sig, desc] = m[1].trim().split(/\s{2,}/);
+            hits.push({ sig: sig, desc });
+        }
+        // One-line usages describe themselves on the next paragraph.
+        const prose = lines.find((l, i) => i > 0 && l.trim() && !/^\s*(Usage:\s*)?vsf /.test(l) && !/^\s{2,}/.test(l));
+        for (const hit of hits)
+            out.push(makeEntry(hit.sig, hit.desc ?? (hits.length === 1 ? prose : undefined)));
+    }
+    return out;
+}
+// Picks that fill in card names from live data.
+export function dynamicEntries(state) {
+    const out = [];
+    const seen = new Set();
+    const add = (text, desc) => {
+        if (!seen.has(text)) {
+            seen.add(text);
+            out.push(makeEntry(text, desc, true));
+        }
+    };
+    const nameOf = (id) => state.steps?.steps.find((s) => s.id === id)?.name ?? id.replace(/^vs-/, '');
+    for (const p of state.agents?.parked ?? [])
+        add(`agents retry ${p.card}`, 'queue the parked card again');
+    for (const c of state.agents?.interrupted ?? [])
+        add(`agents retry ${c}`, 'queue the interrupted card again');
+    const live = state.agents?.current?.card;
+    if (live)
+        add(`agents cancel ${live}`, 'stop the card being worked on');
+    const cards = new Set();
+    for (const r of state.runs) {
+        if (cards.size >= 6 && !cards.has(r.card))
+            continue;
+        cards.add(r.card);
+        const rec = r.record;
+        if (!rec)
+            continue;
+        if (!seen.has(`agents show ${r.card}`))
+            add(`agents show ${r.card}`, 'steps, outcome and labels of the latest run');
+        if (rec.outcome === 'cancelled')
+            add(`agents retry ${r.card}`, 'queue the cancelled card again');
+        const last = rec.steps[rec.steps.length - 1];
+        if (last && (rec.outcome === 'parked' || rec.outcome === 'cancelled'))
+            add(`agents run ${r.card} --from ${nameOf(last.step)}`, 'run again from that step');
+    }
+    return out;
+}
+const norm = (s) => s.toLowerCase().trim().replace(/\s+/g, ' ');
+// Entries matching what was typed, best first. Every typed word has to appear
+// in the command (or, failing that, its description).
+export function filterPalette(entries, query) {
+    const q = norm(query.replace(/^:/, ''));
+    if (!q)
+        return entries;
+    const words = q.split(' ');
+    const scored = [];
+    entries.forEach((e, i) => {
+        const text = norm(e.text);
+        if (text.startsWith(q))
+            scored.push({ e, score: 0, i });
+        else if (words.every((w) => text.includes(w)))
+            scored.push({ e, score: 1, i });
+        else if (words.every((w) => norm(`${e.text} ${e.desc ?? ''}`).includes(w)))
+            scored.push({ e, score: 2, i });
+    });
+    return scored.sort((a, b) => a.score - b.score || a.i - b.i).map((s) => s.e);
+}
+// What Tab puts in the input for an entry.
+export function completion(entry) {
+    return entry.dynamic ? entry.text : entry.prefix + ' ';
+}
+export function onEnter(entry, query) {
+    const typed = splitCommand(query.replace(/^:/, ''));
+    if (!entry)
+        return typed.length ? { run: typed } : { none: true };
+    if (entry.dynamic)
+        return { run: splitCommand(entry.text) };
+    const prefix = splitCommand(entry.prefix);
+    // Words typed after the command's own: they are the card, name or flags.
+    if (norm(query).startsWith(norm(entry.prefix)) && typed.length > prefix.length)
+        return { run: typed };
+    if (entry.runnable)
+        return { run: prefix };
+    // A command that needs a card or a name: complete it, the user types the rest.
+    return { fill: completion(entry) };
+}
+const terminalNote = (e) => (needsTerminal(splitCommand(e.dynamic ? e.text : e.prefix)) ? 'opens in the terminal' : '');
+const MAX_ROWS = 8;
+export function Palette(props) {
+    const data = useData();
+    const [query, setQuery] = useState('');
+    const [cursor, setCursor] = useState(0);
+    const [sel, setSel] = useState(0);
+    const [toolEntries, setToolEntries] = useState([]);
+    const [result, setResult] = useState(null);
+    const tools = data.state.tools.join(',');
+    useEffect(() => {
+        let live = true;
+        void Promise.all(data.state.tools.map(async (t) => parseHelpLines(t, await data.help(t)))).then((all) => {
+            if (live)
+                setToolEntries(all.flat());
+        });
+        return () => {
+            live = false;
+        };
+    }, [tools]);
+    const all = useMemo(() => {
+        const seen = new Set();
+        return [...dynamicEntries(data.state), ...props.umbrella, ...toolEntries].filter((e) => !seen.has(e.text) && !!seen.add(e.text));
+    }, [data.state.agents, data.state.runs, data.state.steps, props.umbrella, toolEntries]);
+    const matches = useMemo(() => filterPalette(all, query), [all, query]);
+    const index = Math.min(sel, Math.max(0, matches.length - 1));
+    const entry = matches[index];
+    const typed = splitCommand(query);
+    useInput((input, key) => {
+        if (result) {
+            if (key.escape || key.return || input === 'q')
+                props.onClose();
+            return;
+        }
+        if (key.escape)
+            return props.onClose();
+        if (key.upArrow)
+            return setSel(Math.max(0, index - 1));
+        if (key.downArrow)
+            return setSel(Math.min(matches.length - 1, index + 1));
+        if (key.tab) {
+            if (entry) {
+                const v = completion(entry);
+                setQuery(v);
+                setCursor(v.length);
+                setSel(0);
+            }
+            return;
+        }
+        if (key.return) {
+            const act = onEnter(entry, query);
+            if ('fill' in act) {
+                setQuery(act.fill);
+                setCursor(act.fill.length);
+                setSel(0);
+            }
+            else if ('run' in act) {
+                const args = act.run;
+                if (needsTerminal(args)) {
+                    props.onClose();
+                    props.onTerminal(args);
+                }
+                else {
+                    setResult({ args, code: null, output: '' });
+                    void props.onRun(args).then((r) => setResult({ args, code: r.code, output: r.output }));
+                }
+            }
+            return;
+        }
+        const r = editText(query, cursor, input, key);
+        setCursor(r.cursor);
+        if (r.value !== query) {
+            setQuery(r.value);
+            setSel(0);
+        }
+    });
+    if (result) {
+        const lines = result.output ? result.output.split('\n') : [];
+        const shown = lines.slice(-14);
+        return h(Panel, { title: ': command', focused: true }, h(Text, { color: theme.accent }, `vsf ${result.args.join(' ')}`), h(Text, null, ' '), result.code === null ? h(Text, { color: theme.dim }, 'Running...') : null, ...shown.map((l, i) => h(Text, { key: i, wrap: 'truncate-end' }, l || ' ')), lines.length > shown.length ? h(Text, { color: theme.dim }, `(${lines.length - shown.length} earlier lines hidden)`) : null, result.code !== null
+            ? h(Text, { color: result.code === 0 ? theme.green : theme.red }, result.code === 0 ? (lines.length ? ' ' : 'Done.') : `Exited with code ${result.code}.`)
+            : null, h(Text, { color: theme.dim }, 'esc or enter closes'));
+    }
+    const at = Math.min(cursor, query.length);
+    const start = Math.max(0, Math.min(index - MAX_ROWS + 1, matches.length - MAX_ROWS));
+    const visible = matches.slice(start, start + MAX_ROWS);
+    const width = Math.max(...visible.map((e) => e.text.length), 20);
+    return h(Panel, { title: ': command', focused: true }, h(Text, null, h(Text, { color: theme.dim }, ':'), h(Text, null, query.slice(0, at)), h(Text, { inverse: true }, query[at] ?? ' '), h(Text, null, query.slice(at + 1))), h(Text, null, ' '), ...visible.map((e, i) => {
+        const on = start + i === index;
+        return h(Text, { key: e.text, wrap: 'truncate-end', backgroundColor: on ? theme.selected : undefined, bold: on }, `${on ? '▶ ' : '  '}${e.text.padEnd(Math.min(width, 44))}  `, h(Text, { color: theme.dim, bold: false }, [e.desc, terminalNote(e)].filter(Boolean).join(' · ')));
+    }), matches.length === 0 && typed.length
+        ? h(Text, { backgroundColor: theme.selected, bold: true }, `▶ ${query.trim()}`, h(Text, { color: theme.dim, bold: false }, needsTerminal(typed) ? '  run as typed, opens in the terminal' : '  run as typed'))
+        : null, matches.length > visible.length ? h(Text, { color: theme.dim }, `  ${matches.length - visible.length} more, keep typing`) : null, h(Box, { marginTop: 1 }, h(Text, { color: theme.dim }, 'Every vsf command is here, with the same flags. Picks fill in card and workflow names.')));
+}

package/dist/tui/run.d.ts

@@ -0,0 +1 @@
+export declare function runDashboard(): Promise<number>;

package/dist/tui/run.js

@@ -0,0 +1,20 @@
+// Opens the dashboard. Loaded with a dynamic import only when it is needed, so
+// plain commands never load React or Ink.
+import React from 'react';
+import { render } from 'ink';
+import { App } from "./app.js";
+export async function runDashboard() {
+    const instance = render(React.createElement(App), {
+        alternateScreen: true,
+        exitOnCtrlC: true,
+        // Anything a tool prints through console is routed above the UI, not into it.
+        patchConsole: true,
+    });
+    try {
+        await instance.waitUntilExit();
+        return 0;
+    }
+    finally {
+        instance.cleanup();
+    }
+}

package/dist/tui/screens/agents.d.ts

@@ -0,0 +1,6 @@
+import { type Screen } from '../screens.ts';
+export declare function nextTab(index: number, count: number, input: string, key: {
+    leftArrow?: boolean;
+    rightArrow?: boolean;
+}): number | null;
+export declare const agentsScreen: Screen;

package/dist/tui/screens/agents.js

@@ -0,0 +1,44 @@
+// The agents shell: a tab bar (Runs, Workflows, Projects, Homes, Settings) over
+// the screens with those ids. Left and right or 1 to 5 switch tabs. The Runs
+// tab is built in runs.ts; the others are rendered by id from the registry.
+import React from 'react';
+import { Box, useInput } from 'ink';
+import { useScreen } from "../context.js";
+import { AGENT_TABS, ScreenHost, activeTab, screens } from "../screens.js";
+import { SubTabs } from "../widgets.js";
+import { tabLock } from "./runs.js";
+const h = React.createElement;
+const TAB_HINT = { key: '←→', label: 'tab' };
+const BACK = { key: 'esc', label: 'back' };
+// The tab a key leads to, or null. `index` is the current tab.
+export function nextTab(index, count, input, key) {
+    if (key.rightArrow)
+        return (index + 1) % count;
+    if (key.leftArrow)
+        return (index + count - 1) % count;
+    const n = Number(input);
+    return /^[1-9]$/.test(input) && n <= count ? n - 1 : null;
+}
+function AgentsShell(props) {
+    const ctx = useScreen();
+    const tab = activeTab(props.params);
+    useInput((input, key) => {
+        if (tabLock.on)
+            return;
+        const to = nextTab(AGENT_TABS.indexOf(tab), AGENT_TABS.length, input, key);
+        const next = to === null ? undefined : AGENT_TABS[to];
+        if (next && next.id !== tab.id)
+            ctx.nav.replace('agents', { ...props.params, tab: next.id });
+    }, { isActive: !ctx.modalOpen && !ctx.capturing });
+    return h(Box, { flexDirection: 'column' }, h(SubTabs, { tabs: AGENT_TABS.map((t) => ({ id: t.id, label: t.label })), active: tab.id }), h(Box, { height: 1 }), h(ScreenHost, { key: tab.id, id: tab.id, params: { ...props.params, ...tab.params }, extraHints: [TAB_HINT] }));
+}
+export const agentsScreen = {
+    id: 'agents',
+    title: (p) => ['Agents', activeTab(p).label],
+    component: AgentsShell,
+    hints: (p) => {
+        const tab = activeTab(p);
+        const inner = screens[tab.id];
+        return [...(inner ? inner.hints({ params: { ...p, ...tab.params } }) : [BACK]), TAB_HINT];
+    },
+};

package/dist/tui/screens/awake.d.ts

@@ -0,0 +1,23 @@
+import { type AwakeStatus } from '../data.ts';
+import { type Line } from '../widgets.ts';
+import type { Screen } from '../screens.ts';
+export type AwakeFull = AwakeStatus & {
+    heat?: boolean;
+    revertOnReboot?: boolean;
+};
+export declare const logFile: (dir?: string) => string;
+export declare function readTail(path: string, maxBytes?: number): string;
+export declare function statusLines(a: AwakeFull): Line[];
+export interface OnForm {
+    mode: 'until' | 'for';
+    value: string;
+    battery: string;
+}
+export declare const emptyForm: () => OnForm;
+export declare function onArgs(f: OnForm): {
+    args: string[];
+} | {
+    error: string;
+};
+export declare function formSummary(f: OnForm): string;
+export declare const awakeScreen: Screen;

package/dist/tui/screens/awake.js

@@ -0,0 +1,209 @@
+// Awake: the full status, the last lines of the watchdog log, and the three
+// things you do with it (turn on, turn off, read the whole log). Each action
+// runs the real command: vsf awake on / off.
+import React, { useEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+import { existsSync, readFileSync, statSync, openSync, readSync, closeSync } from 'node:fs';
+import { join } from 'node:path';
+import { configDir } from "../../config.js";
+import { useData } from "../data.js";
+import { useBackGuard, useEquivalent, useHints, useKeys, useScreen } from "../context.js";
+import { clock, minutesText } from "../format.js";
+import { theme } from "../theme.js";
+import { Lines, Panel, Select, seg, TextInput } from "../widgets.js";
+import { scrollBy, tailLines } from "./list-window.js";
+const h = React.createElement;
+export const logFile = (dir = configDir()) => join(dir, 'awake', 'watchdog.log');
+// The tail of a file without reading all of a huge log.
+export function readTail(path, maxBytes = 256 * 1024) {
+    try {
+        if (!existsSync(path))
+            return '';
+        const size = statSync(path).size;
+        const start = Math.max(0, size - maxBytes);
+        const fd = openSync(path, 'r');
+        try {
+            const buf = Buffer.alloc(size - start);
+            readSync(fd, buf, 0, buf.length, start);
+            return buf.toString('utf8');
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        return '';
+    }
+}
+// ---- the status block -----------------------------------------------------
+export function statusLines(a) {
+    const label = (t) => seg(t.padEnd(12), theme.dim);
+    const power = a.power.onBattery ? `on battery, ${a.power.percent ?? '?'}%` : 'on power adapter';
+    const lines = [];
+    if (a.on)
+        lines.push([seg('● ', theme.green), seg(`On since ${a.since ? clock(new Date(a.since)) : '?'}, the lid can close`, undefined, { bold: true })]);
+    else if (a.sleepDisabledByOther)
+        lines.push([seg('● ', theme.yellow), seg('Sleep is off, but not by VoidShift')]);
+    else
+        lines.push([seg('○ ', theme.dim), seg('Off. The Mac sleeps normally.')]);
+    lines.push([]);
+    if (a.on) {
+        lines.push([label('Until'), seg(a.until ? `${clock(new Date(a.until))}${a.minutesLeft !== null ? ` (${minutesText(a.minutesLeft)} left)` : ''}` : 'no end time')]);
+    }
+    lines.push([label('Battery'), seg(`floor ${a.batteryFloor}%, `), a.floorApplies ? seg('applies now (on battery)') : seg('does not apply while on power', theme.dim)]);
+    lines.push([label('Power'), seg(power)]);
+    lines.push([label('Watchdog'), a.watchdog ? seg('ok, checks every minute', theme.green) : seg('not loaded, guardrails will not act. vsf setup awake', theme.yellow)]);
+    if (a.lastReason)
+        lines.push([label('Last ended'), seg(a.lastReason)]);
+    lines.push([
+        label('Guardrails'),
+        seg(`heat stop ${a.heat === false ? 'off' : 'on'}`, a.heat === false ? theme.yellow : undefined),
+        seg(' · '),
+        seg(`turn off after reboot ${a.revertOnReboot === false ? 'off' : 'on'}`, a.revertOnReboot === false ? theme.yellow : undefined),
+    ]);
+    return lines;
+}
+export const emptyForm = () => ({ mode: 'until', value: '', battery: '' });
+// The vsf awake on arguments, or what is wrong with the form.
+export function onArgs(f) {
+    const args = ['awake', 'on'];
+    const value = f.value.trim();
+    if (value)
+        args.push(f.mode === 'until' ? '--until' : '--for', value);
+    const battery = f.battery.trim();
+    if (battery) {
+        if (!/^\d+$/.test(battery) || Number(battery) < 5 || Number(battery) > 95)
+            return { error: 'Battery takes a whole percentage from 5 to 95.' };
+        args.push('--battery', battery);
+    }
+    return { args };
+}
+// A short plain-English line of what the form will do.
+export function formSummary(f) {
+    const value = f.value.trim();
+    const when = !value ? 'with the default time limit' : f.mode === 'until' ? `until ${value}` : `for ${value}`;
+    return `Keep the Mac awake ${when}${f.battery.trim() ? `, stopping at ${f.battery.trim()}% battery` : ''}.`;
+}
+const FIELDS = ['mode', 'value', 'battery'];
+function OnFormView(props) {
+    const ctx = useScreen();
+    const { form, setForm } = props;
+    const [field, setField] = useState(0);
+    const [error, setError] = useState('');
+    const parsed = onArgs(form);
+    const submit = async () => {
+        if ('error' in parsed) {
+            setError(parsed.error);
+            return;
+        }
+        const result = await ctx.actions.run({
+            args: parsed.args,
+            title: 'Turn awake on?',
+            body: `${formSummary(form)} The lid can close and the Mac keeps running. The watchdog turns it off at the limit.`,
+            confirmLabel: 'Turn on',
+            cancelLabel: 'Not now',
+        });
+        if (result && result.code === 0)
+            props.onClose();
+    };
+    useKeys((input, key) => {
+        if (key.escape)
+            props.onClose();
+        else if (key.tab)
+            setField((i) => (i + (key.shift ? FIELDS.length - 1 : 1)) % FIELDS.length);
+        else if (key.ctrl && input === 's')
+            void submit();
+    }, { whileCapturing: true });
+    const row = (i, name, node, note) => h(Box, { key: name, flexDirection: 'row' }, h(Text, { color: field === i ? theme.accent : theme.dim }, name.padEnd(15)), h(Box, { minWidth: 18 }, node), note ? h(Text, { color: theme.dim }, `  ${note}`) : null);
+    return h(Panel, { title: 'Turn awake on', focused: true }, row(0, 'Stop', h(Select, { focus: field === 0, value: form.mode, onChange: (v) => setForm({ ...form, mode: v === 'for' ? 'for' : 'until' }), options: [{ value: 'until', label: 'At a time' }, { value: 'for', label: 'After a while' }] })), row(1, form.mode === 'until' ? 'Until' : 'For', h(TextInput, { focus: field === 1, value: form.value, onChange: (v) => setForm({ ...form, value: v }), placeholder: form.mode === 'until' ? '7am or 19:30' : '6h or 90m', onSubmit: () => void submit() }), 'leave empty for the default'), row(2, 'Battery floor', h(TextInput, { focus: field === 2, value: form.battery, onChange: (v) => setForm({ ...form, battery: v }), placeholder: '20', onSubmit: () => void submit() }), '5 to 95, stops here when on battery'), h(Box, { marginTop: 1 }, h(Text, { color: error ? theme.red : theme.dim }, error || formSummary(form))));
+}
+// ---- the screen -----------------------------------------------------------
+function Awake() {
+    const ctx = useScreen();
+    const { state } = useData();
+    const [mode, setMode] = useState('main');
+    const [log, setLog] = useState('');
+    const [offset, setOffset] = useState(0);
+    const [form, setForm] = useState(emptyForm());
+    const a = state.awake;
+    // Refreshed live: read the log again every second and after each poll.
+    useEffect(() => {
+        const read = () => setLog(readTail(logFile()));
+        read();
+        const t = setInterval(read, 1000);
+        return () => clearInterval(t);
+    }, []);
+    const size = Math.max(5, ctx.rows - 8);
+    const maxOffset = Math.max(0, tailLines(log, 100000).length - size);
+    useBackGuard(() => {
+        if (mode === 'main')
+            return false;
+        setMode('main');
+        return true;
+    });
+    useHints(mode === 'form'
+        ? [{ key: 'tab', label: 'next field' }, { key: 'enter', label: 'turn on' }, { key: 'esc', label: 'cancel' }]
+        : mode === 'log'
+            ? [{ key: '↑↓', label: 'scroll' }, { key: 'G', label: 'latest' }, { key: 'l', label: 'close log' }, { key: 'esc', label: 'back' }]
+            : [{ key: 'o', label: 'turn on' }, { key: 'f', label: 'turn off' }, { key: 'l', label: 'full log' }, { key: 'esc', label: 'back' }]);
+    const formArgs = onArgs(form);
+    useEquivalent(mode === 'main' ? ['awake', 'status'] : mode === 'form' ? ('args' in formArgs ? formArgs.args : ['awake', 'on']) : null);
+    useKeys((input, key) => {
+        if (mode === 'form')
+            return;
+        if (mode === 'log') {
+            const total = tailLines(log, 100000).length;
+            if (key.upArrow)
+                setOffset((o) => scrollBy(o, 1, maxOffset));
+            else if (key.downArrow)
+                setOffset((o) => scrollBy(o, -1, maxOffset));
+            else if (key.pageUp)
+                setOffset((o) => scrollBy(o, size - 1, maxOffset));
+            else if (key.pageDown)
+                setOffset((o) => scrollBy(o, -(size - 1), maxOffset));
+            else if (input === 'G')
+                setOffset(0);
+            else if (input === 'g')
+                setOffset(Math.max(0, total - size));
+            else if (input === 'l')
+                setMode('main');
+            return;
+        }
+        if (input === 'o') {
+            setForm(emptyForm());
+            setMode('form');
+        }
+        else if (input === 'f') {
+            void ctx.actions.run({
+                args: ['awake', 'off'],
+                title: 'Turn awake off?',
+                body: 'The Mac goes back to sleeping normally when the lid closes.',
+                confirmLabel: 'Turn off',
+                cancelLabel: 'Keep awake',
+            });
+        }
+        else if (input === 'l') {
+            setOffset(0);
+            setMode('log');
+        }
+    });
+    if (!a) {
+        return h(Box, { paddingX: 1 }, h(Text, { color: state.errors.awake ? theme.red : theme.dim }, state.errors.awake ?? (state.loaded ? 'awake is not added. Run vsf add awake.' : 'Loading...')));
+    }
+    if (mode === 'form')
+        return h(OnFormView, { form, setForm, onClose: () => setMode('main') });
+    if (mode === 'log') {
+        const lines = tailLines(log, 100000);
+        const end = lines.length - offset;
+        const shown = lines.slice(Math.max(0, end - size), end);
+        return h(Panel, { title: 'Watchdog log', focused: true, subtitle: offset ? `${offset} lines above the end` : 'following', flexGrow: 1 }, shown.length ? h(Lines, { lines: shown.map((l) => [seg(l, theme.text)]) }) : h(Text, { color: theme.dim }, 'No watchdog log yet.'));
+    }
+    const last = tailLines(log, 20);
+    return h(Box, { flexDirection: 'column' }, h(Panel, { title: 'Awake' }, h(Lines, { lines: statusLines(a) })), h(Panel, { title: 'Watchdog log', subtitle: 'last 20 lines' }, last.length ? h(Lines, { lines: last.map((l) => [seg(l, theme.dim)]) }) : h(Text, { color: theme.dim }, 'No watchdog log yet.')));
+}
+export const awakeScreen = {
+    id: 'awake',
+    title: 'Awake',
+    component: () => h(Awake),
+    hints: () => [{ key: 'o', label: 'turn on' }, { key: 'f', label: 'turn off' }, { key: 'l', label: 'full log' }, { key: 'esc', label: 'back' }],
+};

package/dist/tui/screens/checks.d.ts

@@ -0,0 +1,11 @@
+import { type Cell } from '../widgets.ts';
+import type { Check } from '../../tool.ts';
+import type { Screen } from '../screens.ts';
+export declare function sortChecks(checks: Check[]): Check[];
+export declare const mark: (s: Check["status"]) => {
+    text: string;
+    colour: string;
+};
+export declare function fixCommand(fix: string | undefined): string[] | null;
+export declare function checkRows(checks: Check[]): Cell[][];
+export declare const checksScreen: Screen;