team 0.0.1 → 0.1.1

package/dist/commands/watch.js

@@ -0,0 +1,324 @@
+import { readArgs } from "../args.js";
+import { budgetsInForce, watchInForce } from "../approve/approval.js";
+import { saveReadings, saveSpendReadings } from "../budgets/readings.js";
+import { runChecks } from "../budgets/run.js";
+import { currentTeam } from "../file/current.js";
+import { homedir } from 'node:os';
+import { agentStatus, paneRead, pressEnter, typeText } from "../herdr.js";
+import { logLine } from "../log.js";
+import { emptySession, readState, updateState } from "../state.js";
+import { readMachine } from "../watch/machine.js";
+import { notify } from "../watch/notify.js";
+import { newMemory, pass } from "../watch/pass.js";
+import { readScreen } from "../watch/screen.js";
+import { judgeTemporary, judgeWorktree } from "../watch/close.js";
+import { readEnd } from "../watch/end.js";
+import { stopRunning, realSources as removeSources } from "./remove.js";
+import { removeWorktree } from "./worktree.js";
+import { stateOf } from "./down.js";
+import { realSources } from "./status.js";
+function waitOrStop(seconds) {
+    return new Promise((done) => {
+        const stop = () => {
+            clearTimeout(timer);
+            done(false);
+        };
+        const timer = setTimeout(() => {
+            process.off('SIGINT', stop);
+            process.off('SIGTERM', stop);
+            done(true);
+        }, seconds * 1000);
+        process.once('SIGINT', stop);
+        process.once('SIGTERM', stop);
+    });
+}
+export const realWatchSources = {
+    live: realSources.live,
+    machine: readMachine,
+    approval: realSources.approval,
+    watchInForce: (team, root) => watchInForce(team, root),
+    budgetsInForce: (team, root) => budgetsInForce(team, root),
+    readChecks: (team, root, now) => runChecks(team, root, now),
+    screen: (pane, session) => paneRead(pane, 14, session),
+    status: agentStatus,
+    typeText,
+    pressEnter,
+    notify,
+    now: () => new Date(),
+    wait: waitOrStop,
+    alive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (error) {
+            return error.code === 'EPERM';
+        }
+    },
+    pid: process.pid,
+};
+export const watch = (argv, io) => runWatch(argv, io, realWatchSources);
+export default watch;
+export const USAGE = 'Usage: team watch [--session <name>] [--file <path>] [--no-nudge] [--no-notify]\n';
+export async function runWatch(argv, io, sources) {
+    const args = readArgs(argv, ['session', 'file'], ['no-nudge', 'no-notify']);
+    if (args.error || args.rest.length) {
+        io.stderr(`team watch: ${args.error ?? `unexpected "${args.rest[0]}"`}\n${USAGE}`);
+        return 2;
+    }
+    const first = currentTeam(io.cwd, args.values.file, sources.now());
+    if (!first.ok) {
+        for (const problem of first.errors)
+            io.stderr(`team watch: ${problem.line ? `team.yaml line ${problem.line}: ` : ''}${problem.message}\n`);
+        return 2;
+    }
+    const session = args.values.session ?? first.team.session;
+    const { dir } = first;
+    const other = readState(dir).sessions[session]?.watch;
+    if (other && other.pid !== sources.pid && sources.alive(other.pid)) {
+        io.stderr(`team watch: a watch already runs for the session "${session}" (pid ${other.pid})\n`);
+        return 1;
+    }
+    const say = (text, desktop) => {
+        io.stdout(`${sources.now().toISOString()} ${text}\n`);
+        logLine(dir, 'watch', 'watch', text, sources.now());
+        if (desktop && !args.flags.has('no-notify'))
+            sources.notify(text);
+    };
+    const beat = () => updateState(dir, (state) => {
+        const record = (state.sessions[session] ??= emptySession());
+        record.watch = { pid: sources.pid, heartbeat: sources.now().toISOString() };
+    });
+    const memory = newMemory();
+    const told = new Set();
+    let outcomes = [];
+    let checksAt = null;
+    let notice;
+    let silent = false;
+    say(`watching the session "${session}" every ${sources.watchInForce(first.team, first.root).interval}s${args.flags.has('no-nudge') ? ', without nudges' : ''}`, false);
+    try {
+        for (;;) {
+            // The file is read again on every pass, so a seat parked or stopped since is seen.
+            const current = currentTeam(io.cwd, args.values.file, sources.now());
+            const team = current.ok ? current.team : first.team;
+            const root = current.ok ? current.root : first.root;
+            const problem = current.ok ? current.notice : `team.yaml can't be read (${current.errors[0]?.message ?? 'unknown'}); watching with the team as it was`;
+            if (problem !== notice) {
+                notice = problem;
+                if (problem)
+                    say(problem, true);
+            }
+            // The values in force, read with the file: until the owner approves an edit to `watch`,
+            // the watch keeps running with what was approved, or with the defaults.
+            const inForce = sources.watchInForce(team, root);
+            // The budget values in force, read with the file like the watch's: an unapproved edit to the
+            // marks, the accounts or the cadence silences nothing here until the owner approves it.
+            const budget = sources.budgetsInForce(team, root);
+            const live = sources.live(session, team);
+            if (!live) {
+                if (!silent)
+                    say('herdr doesn\'t answer; the watch keeps trying', true);
+                silent = true;
+            }
+            else {
+                silent = false;
+                noteWorked(dir, session, live);
+                const state = readState(dir).sessions[session] ?? emptySession();
+                const now = sources.now().getTime();
+                // The check commands run here, outside the pass, at most every `check_every` (§ 5): the
+                // pass reads what they read, and nothing else. Only their state is ever said — a
+                // contract failure or a timeout says `unreadable`, never a line of what they printed.
+                if (checksAt === null || now - checksAt >= budget.checkEvery * 1000) {
+                    checksAt = now;
+                    outcomes = sources.readChecks(team, root, now);
+                    // The money a spend check counted is kept, like the pass's screen readings: the launch
+                    // gate of `up` and `add` reads it later, and one that is stale by then reads unknown
+                    // (§ 5). An account whose check did not run keeps its stored reading.
+                    saveSpendReadings(dir, session, spendOf(outcomes));
+                    for (const outcome of outcomes) {
+                        const key = `check:${outcome.account}`;
+                        if (outcome.state === 'read') {
+                            told.delete(key);
+                            continue;
+                        }
+                        if (told.has(key))
+                            continue;
+                        told.add(key);
+                        say(outcome.state === 'unreadable'
+                            ? `${outcome.account}: its check is unreadable`
+                            : `the check for ${outcome.account} is unapproved; that account reads unknown`, false);
+                    }
+                }
+                const result = pass({
+                    team, state, live, machine: sources.machine(root), now, memory,
+                    approval: sources.approval(team, root), watch: inForce, outcomes, budgets: budget,
+                });
+                for (const report of result.reports)
+                    say(report.text, true);
+                saveReadings(dir, session, result.readings, now);
+                if (result.nudge) {
+                    if (args.flags.has('no-nudge'))
+                        say(`nudge not typed (--no-nudge): ${result.nudge.text}`, false);
+                    else
+                        deliver(result.nudge, team, session, sources, memory, say);
+                }
+                if (result.fallback)
+                    say(result.fallback, true);
+                await closeEnded({ team, root, dir, session, live, sources, say, io, told });
+            }
+            beat();
+            if (!(await sources.wait(inForce.interval)))
+                break;
+        }
+    }
+    finally {
+        updateState(dir, (state) => {
+            const record = state.sessions[session];
+            if (record?.watch?.pid === sources.pid)
+                delete record.watch;
+        });
+        say(`the watch of "${session}" stopped`, true);
+    }
+    return 0;
+}
+/** The spend readings among a pass's check outcomes, for the state. */
+function spendOf(outcomes) {
+    const list = [];
+    for (const outcome of outcomes) {
+        if (outcome.state !== 'read' || outcome.reading.kind !== 'spend')
+            continue;
+        list.push({
+            account: outcome.account,
+            amount: outcome.reading.amount,
+            currency: outcome.reading.currency,
+            at: outcome.reading.at,
+        });
+    }
+    return list;
+}
+// Types the nudge, after reading the operator's screen once more: the pass saw it free, and a
+// prompt may have appeared since. Anything but an empty idle prompt keeps the nudge pending.
+function deliver(nudge, team, session, sources, memory, say) {
+    const cli = team.seats.find((seat) => seat.name === team.operator)?.cli ?? '';
+    const look = () => readScreen(cli, sources.screen(nudge.pane, session) ?? undefined).kind;
+    const status = sources.status(nudge.pane, session);
+    const keep = () => {
+        // The nudge's text carries no report, so the reports it was raised for go back to pending:
+        // the fallback notification and the next passes need them.
+        memory.pending.push(...nudge.pending);
+        memory.pendingSince ??= sources.now().getTime();
+    };
+    if ((status !== 'idle' && status !== 'done') || look() !== 'idle' || !sources.typeText(nudge.pane, nudge.text, session)) {
+        keep();
+        return;
+    }
+    // The text is in the box. A dialog that opened meanwhile must not get the Enter: the text
+    // then stays unsent, which the next passes report, and the nudge is kept.
+    const after = look();
+    if (after !== 'idle' && after !== 'unsent') {
+        say('a nudge was typed and not sent: the operator\'s screen changed before the Enter', true);
+        keep();
+        return;
+    }
+    if (sources.pressEnter(nudge.pane, session))
+        say(`nudged the operator: ${nudge.text}`, false);
+    else
+        keep();
+}
+function noteWorked(dir, session, live) {
+    const recorded = readState(dir).sessions[session];
+    if (!recorded)
+        return;
+    const due = live.agents.some((agent) => {
+        const seat = agent.name ? recorded.seats[agent.name] : undefined;
+        return seat?.temporary && seat.stage === 'ready' && !seat.worked && agent.status === 'working';
+    });
+    if (!due)
+        return;
+    updateState(dir, (file) => {
+        const seats = (file.sessions[session] ??= emptySession()).seats;
+        for (const agent of live.agents) {
+            const seat = agent.name ? seats[agent.name] : undefined;
+            if (seat?.temporary && seat.stage === 'ready' && agent.status === 'working')
+                seat.worked = true;
+        }
+    });
+}
+function sayOnce(told, key, text, say) {
+    if (!text || told.has(key))
+        return;
+    told.add(key);
+    say(text, true);
+}
+// Closes a temporary seat whose end holds, and removes an on-merge worktree whose branch is merged.
+// Anything that is not free, or not proved, is left as it is.
+async function closeEnded(input) {
+    const { team, root, dir, session, live, sources, say, io, told } = input;
+    const endOf = sources.readEnd ?? readEnd;
+    const state = readState(dir).sessions[session] ?? emptySession();
+    for (const [name, recorded] of Object.entries(state.seats)) {
+        const temporary = recorded.temporary;
+        if (!temporary)
+            continue;
+        const task = temporary.task;
+        const work = task ? state.worktrees[task] : undefined;
+        const ownBefore = work ? work.own_commits === true : temporary.own_commits === true;
+        const end = endOf(root, temporary.until, team.workspace.base, ownBefore);
+        const agent = live.agents.find((item) => item.name === name);
+        const cli = team.seats.find((seat) => seat.name === temporary.like)?.cli ?? '';
+        const free = agent
+            ? stateOf(sources.status(agent.pane, session) ?? agent.status, readScreen(cli, sources.screen(agent.pane, session) ?? undefined)) === 'free'
+            : false;
+        const decision = judgeTemporary({ worked: recorded.worked === true, free, ownBefore, end });
+        if (decision.ownCommits) {
+            updateState(dir, (file) => {
+                const current = (file.sessions[session] ??= emptySession());
+                if (work && task) {
+                    const tree = current.worktrees[task];
+                    if (tree)
+                        tree.own_commits = true;
+                }
+                else {
+                    const seat = current.seats[name];
+                    if (seat?.temporary)
+                        seat.temporary.own_commits = true;
+                }
+            });
+        }
+        sayOnce(told, `end:${name}`, decision.report, say);
+        if (!decision.close || !agent)
+            continue;
+        const seat = { name, cli, pane: agent.pane, workspace: agent.workspace, state: 'free' };
+        const stopped = sources.stopSeat
+            ? await sources.stopSeat(session, seat)
+            : await stopRunning({
+                io, dir, session, seat, abandon: false, sources: removeSources, logCommand: 'watch', caller: 'watch',
+            });
+        if (stopped)
+            say(`closed ${name}; its end ${temporary.until} holds`, false);
+    }
+    const again = readState(dir);
+    const here = again.sessions[session] ?? emptySession();
+    for (const [task, work] of Object.entries(here.worktrees)) {
+        const occupied = Object.values(again.sessions).some((recorded) => Object.values(recorded.seats).some((seat) => seat.temporary?.task === task));
+        const end = endOf(root, `merged:${work.branch}`, team.workspace.base, work.own_commits === true);
+        const decision = judgeWorktree({
+            policy: team.workspace.remove, occupied, ownBefore: work.own_commits === true, end,
+        });
+        if (decision.ownCommits) {
+            updateState(dir, (file) => {
+                const tree = file.sessions[session]?.worktrees[task];
+                if (tree)
+                    tree.own_commits = true;
+            });
+        }
+        sayOnce(told, `worktree:${task}`, decision.report, say);
+        if (!decision.close)
+            continue;
+        const code = sources.removeWorktree
+            ? sources.removeWorktree(task)
+            : removeWorktree(io, { home: homedir(), now: sources.now }, team, root, dir, session, task, 'watch');
+        if (code !== 0)
+            say(`worktree ${task} was not removed`, true);
+    }
+}

package/dist/commands/worktree.d.ts

@@ -0,0 +1,12 @@
+import type { TeamFile } from '../file/types.ts';
+import type { Command, Io } from '../io.ts';
+export type WorktreeSources = {
+    home: string;
+    now(): Date;
+};
+export declare const realSources: WorktreeSources;
+export declare const USAGE = "Usage: team worktree new <task> [--kind <kind>] [--seat <name>] [--session <name>] [--file <path>]\n       team worktree remove <task> [--session <name>] [--file <path>]\nIgnored files in the worktree are deleted with it.\n";
+export declare const worktree: Command;
+export default worktree;
+export declare function runWorktree(argv: string[], io: Io, sources?: WorktreeSources): Promise<number>;
+export declare function removeWorktree(io: Io, sources: WorktreeSources, team: TeamFile, root: string, dir: string, session: string, task: string, who: string): number;