@alecsibilia/luca 14.0.0-alpha.2 → 14.0.0-alpha.21

package/board/client/timeline-rows.tsx

@@ -20,6 +20,7 @@ import {
     usageColor,
     useNow,
 } from './board-look'
+import { StuckActions } from './stuck-actions'
 
 import type { EventRow, LimitRow, RunRow, StuckRow } from '../shared/board-rows'
 import { currentStepText, USAGE_LABEL } from '../shared/board-state'
@@ -294,9 +295,14 @@ export const EventRowLine = ({
     )
 }
 
-/** Stuck work, with the exact replies; resolved in place. */
+/**
+ * Stuck work, with a button per reply and "Help me", which sends
+ * `/luca-unstick` to this chat (#503); resolved in place. A row added
+ * before the buttons shows the replies as text.
+ */
 export const StuckRowCard = ({
     item,
+    agentId,
     theme,
     layout,
 }: PluginTimelineItemProps<StuckRow>) => {
@@ -333,20 +339,41 @@ export const StuckRowCard = ({
                             · {line}
                         </Text>
                     ))}
-                    <View style={styles.replyRow}>
-                        <Text style={styles.muted}>
-                            Reply with a comment on{' '}
-                            {row.spec_number === null
-                                ? 'the spec issue'
-                                : `spec issue #${row.spec_number}`}
-                            :
-                        </Text>
-                        {row.replies.map((reply) => (
-                            <Text key={reply} style={styles.reply} selectable>
-                                {reply}
+                    {row.run_id !== null &&
+                    row.key !== null &&
+                    row.since !== null ? (
+                        <StuckActions
+                            run_id={row.run_id}
+                            item={{
+                                key: row.key,
+                                ticket: row.ticket,
+                                since: row.since,
+                            }}
+                            spec_number={row.spec_number}
+                            posted={[]}
+                            chat_agent_id={agentId}
+                            theme={theme}
+                        />
+                    ) : (
+                        <View style={styles.replyRow}>
+                            <Text style={styles.muted}>
+                                Reply with a comment on{' '}
+                                {row.spec_number === null
+                                    ? 'the spec issue'
+                                    : `spec issue #${row.spec_number}`}
+                                :
                             </Text>
-                        ))}
-                    </View>
+                            {row.replies.map((reply) => (
+                                <Text
+                                    key={reply}
+                                    style={styles.reply}
+                                    selectable
+                                >
+                                    {reply}
+                                </Text>
+                            ))}
+                        </View>
+                    )}
                 </>
             ) : (
                 <Text style={styles.muted}>{row.resolution}</Text>

package/board/client/usage-line.tsx

@@ -0,0 +1,51 @@
+/**
+ * The plan usage line: the five-hour and weekly windows, colored by level.
+ */
+import { Icon } from '@getpaseo/plugin/client/react-native'
+import { Text, View } from 'react-native'
+
+import { percentText, usageColor } from './board-look'
+import type { Look } from './board-panel-styles'
+
+import type { BoardState } from '../shared/board-state'
+
+export const UsageLine = ({
+    state,
+    theme,
+    styles,
+}: { state: BoardState } & Look) => {
+    const { usage, usage_label } = state
+    return (
+        <View style={styles.row}>
+            <Icon name="Gauge" size={13} color={theme.colors.foregroundMuted} />
+            {usage ? (
+                <Text style={styles.mono}>
+                    {usage_label}: 5h{' '}
+                    <Text
+                        style={{
+                            color: usageColor({
+                                level: usage.five_hour_level,
+                                theme,
+                            }),
+                        }}
+                    >
+                        {percentText({ percent: usage.five_hour_percent })}
+                    </Text>{' '}
+                    · week{' '}
+                    <Text
+                        style={{
+                            color: usageColor({
+                                level: usage.weekly_level,
+                                theme,
+                            }),
+                        }}
+                    >
+                        {percentText({ percent: usage.weekly_percent })}
+                    </Text>
+                </Text>
+            ) : (
+                <Text style={styles.mono}>{usage_label}: no reading yet</Text>
+            )}
+        </View>
+    )
+}

package/board/client/wait-line.tsx

@@ -0,0 +1,39 @@
+/**
+ * A waiting card's step-dots line (#559): what it waits for, cut to fit,
+ * how long it has waited, counting up by itself, and the amber bar that
+ * takes the heartbeat's place.
+ */
+import { Text, View } from 'react-native'
+
+import { useNow } from './board-look'
+import type { Look } from './board-panel-styles'
+import { CutLine } from './one-line'
+import type { ShownWait } from './ticket-wait'
+
+import { elapsedText } from '../shared/board-state'
+
+export const WaitLine = ({
+    wait,
+    theme,
+    styles,
+}: { wait: ShownWait } & Look) => {
+    const now = useNow()
+    return (
+        <>
+            <CutLine text={wait.text} style={styles.muted} styles={styles} />
+            {wait.since === null ? null : (
+                <Text style={[styles.mono, styles.fixed]} numberOfLines={1}>
+                    {`· ${elapsedText({ ms: now - Date.parse(wait.since) })}`}
+                </Text>
+            )}
+            <View style={styles.spacer} />
+            <View
+                accessibilityLabel="waiting"
+                style={[
+                    styles.waitBar,
+                    { backgroundColor: theme.colors.statusWarning },
+                ]}
+            />
+        </>
+    )
+}

package/board/index.client.tsx

@@ -31,7 +31,7 @@ export default function contribute(client: PluginClientContext) {
     client.addSlashCommand({
         name: 'luca-run',
         description:
-            'Start a Luca run for a spec: live rows here, and the Luca board panel',
+            'Start a Luca run for a spec, or resume one: live rows here, and the Luca board panel',
         argumentHint: RUN_USAGE.replace('/luca-run ', ''),
         context: 'agent',
         onSubmit: async ({ args, agent, workspace, rpc, openPanel }) => {

package/board/index.server.ts

@@ -23,6 +23,7 @@ import {
     boardReadRpc,
     boardVersionRpc,
     engineEventRpc,
+    replyPostRpc,
     runStartRpc,
 } from './shared/board-rpc'
 import { PLUGIN_ID } from './shared/board-state'
@@ -40,7 +41,8 @@ const log = (message: string) => console.error(`[${PLUGIN_ID}] ${message}`)
  * The board plugin's daemon side: the engine settings (their usage lines
  * kept in a file for the engine), `run.start` (launch a
  * run from `/luca-run`), `engine.event` (the engine's journal records in),
- * and `board.read` (the side panel's poll). On start, and every 15 s after,
+ * `board.read` (the side panel's poll), and `reply.post` (a reply button on
+ * stuck work posts its word on the spec, #503). On start, and every 15 s after,
  * it checks for runs whose engine is gone and restarts the ones that can go
  * on (#375). The logic lives in `createBoardServer`; this entry only wires it
  * to Paseo.
@@ -130,6 +132,10 @@ export default function contribute(server: PluginServerContext) {
         connect({ context })
         return board.readBoard(input)
     })
+    server.handle(replyPostRpc, (input, context) => {
+        connect({ context })
+        return board.postReply(input)
+    })
     // Fixed as loaded: after an upgrade it differs until a reload.
     server.handle(boardVersionRpc, () => ({ version: LUCA_VERSION }))
 

package/board/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luca/board",
-    "version": "14.0.0-alpha.2",
+    "version": "14.0.0-alpha.21",
     "private": true,
     "type": "module"
 }

package/board/server/board-panel-state-helpers.ts

@@ -0,0 +1,67 @@
+import { createHarness, type Harness } from './testing/board-harness'
+import {
+    agentFinished,
+    agentStarted,
+    gatesRun,
+    intakeOfThree,
+    redCheck,
+    sessionOf,
+    ticketWorktreeCreated,
+    type Entry,
+} from './testing/journal-fixtures'
+
+/**
+ * Helpers shared by the panel state tests (`board-panel-state.test.ts` and
+ * the `board-panel-state-*.test.ts` files beside it).
+ *
+ * The harness is the one the running test started; `runWith` sets it, and
+ * each test file cleans it up after every test.
+ */
+
+export let harness: Harness
+
+/** Starts a run and sends intake plus `entries` in one go. */
+export const runWith = async ({ entries }: { entries: Entry[] }) => {
+    harness = await createHarness()
+    const { run_id, token } = await harness.start()
+    const reply = await harness.send({
+        run_id,
+        token,
+        entries: [...intakeOfThree(), ...entries],
+    })
+    return { run_id, token, reply, next: reply.next_seq }
+}
+
+export const rowsOfKind = ({ kind }: { kind: string }) =>
+    harness.latestRows().filter(({ row }) => row.kind === kind)
+
+/** The chat's event rows, as text and tone, oldest first. */
+export const eventRows = () =>
+    harness
+        .latestRows()
+        .flatMap(({ row }) =>
+            row.kind === 'luca-board-event'
+                ? [{ text: row.data.text, tone: row.data.tone }]
+                : []
+        )
+
+/** Gates that failed, then the implementer's follow-up in its session. */
+export const failedGatesRound = ({ ticket }: { ticket: number }): Entry[] => [
+    gatesRun({ ticket, ok: false }),
+    agentStarted({
+        ticket,
+        role: 'implementer',
+        follow_up_of: sessionOf({ ticket, role: 'implementer' }),
+    }),
+    agentFinished({ ticket, role: 'implementer' }),
+]
+
+/** Ticket 13 up to its first implementer result. */
+export const codedTicket13 = (): Entry[] => [
+    ticketWorktreeCreated({ ticket: 13 }),
+    agentStarted({ ticket: 13, role: 'test-writer' }),
+    agentFinished({ ticket: 13, role: 'test-writer' }),
+    redCheck({ ticket: 13, ok: true, failing: 1, passing: 3 }),
+    agentStarted({ ticket: 13, role: 'implementer' }),
+    agentFinished({ ticket: 13, role: 'implementer' }),
+]

package/board/server/board-server-check.ts

@@ -0,0 +1,294 @@
+/**
+ * The engine check: finds runs whose engine process is gone although the run
+ * hasn't ended, restarts the ones that can go on from their journal, and
+ * marks the rest as stopped, with why. The runs the plugin didn't start are
+ * only labelled (#635), never restarted.
+ */
+
+import type { EngineProcess } from './board-server-engine'
+import type { RunStore } from './board-server-store'
+import type {
+    BoardServerConfig,
+    EngineCheck,
+    OutsideRun,
+    RunMemory,
+} from './board-server-types'
+import { errorText } from './board-server-util'
+import {
+    engineStoppedText,
+    liveRunIds,
+    MAX_AUTO_RESTARTS,
+    parseUnfinished,
+    restartRow,
+    restartText,
+    UNFINISHED_TIMEOUT_MS,
+    type StopWhy,
+    type UnfinishedRun,
+} from './engine-watch'
+import { readLiveFile } from './live-file'
+
+import { liveIsFresh, needsEngine } from '../shared/board-state'
+
+export const createEngineChecks = ({
+    config,
+    store,
+    engine,
+    reads,
+}: {
+    config: BoardServerConfig
+    store: RunStore
+    engine: EngineProcess
+    /** The runs the plugin didn't start, and how to read them again. */
+    reads: {
+        outside: Map<string, OutsideRun>
+        readOutside: () => Promise<void>
+    }
+}) => {
+    const {
+        list_processes,
+        run_command,
+        home_dir,
+        log,
+        now,
+        runs_dir = null,
+    } = config
+    const { runs, enqueue, appendRows, header, updateEntry, endRun, ready } =
+        store
+    const { childEnv, findEngine, exclusive, spawnResume } = engine
+
+    /**
+     * Labels each run the plugin didn't start whose engine is gone: no
+     * process names it, and its live file (if any) isn't fresh, as a run
+     * started from the command line without `--run-id` has no id on its
+     * command line. Never restarts them.
+     */
+    const labelOutside = async ({
+        others,
+        live,
+    }: {
+        others: OutsideRun[]
+        live: Set<string>
+    }) => {
+        let at: number | null = null
+        await Promise.all(
+            others.map(async (run) => {
+                const { run_id } = run.state.run
+                if (live.has(run_id) || runs_dir === null) {
+                    run.engine_gone = false
+                    return
+                }
+                const file = await readLiveFile({ runs_dir, run_id })
+                at ??= now().getTime()
+                run.engine_gone =
+                    file === null ||
+                    !liveIsFresh({ written_at: file.written_at, now: at })
+            })
+        )
+    }
+
+    /**
+     * Asks the engine which unfinished runs may be restarted
+     * (`luca-run --unfinished`), with the engine to restart them with.
+     */
+    const listUnfinished = async (): Promise<
+        | {
+              ok: true
+              runs: Map<string, UnfinishedRun>
+              engine: { command: string; lead_args: string[] }
+          }
+        | { ok: false; error: string }
+    > => {
+        const engine = await findEngine()
+        if (!engine.ok) return { ok: false, error: engine.message }
+        const result = await run_command({
+            command: engine.command,
+            args: [...engine.lead_args, '--unfinished'],
+            cwd: home_dir,
+            env: childEnv({ token: null }),
+            timeout_ms: UNFINISHED_TIMEOUT_MS,
+        })
+        if (result.exit_code === null) {
+            return {
+                ok: false,
+                error: `luca-run --unfinished did not finish in ${UNFINISHED_TIMEOUT_MS / 1000} s (it timed out or was killed)`,
+            }
+        }
+        if (result.exit_code !== 0) {
+            return {
+                ok: false,
+                error: `luca-run --unfinished exited with ${result.exit_code}: ${result.stderr.trim().slice(0, 300)}`,
+            }
+        }
+        const parsed = parseUnfinished({ stdout: result.stdout })
+        if (!parsed.ok) {
+            return {
+                ok: false,
+                error: `luca-run --unfinished ${parsed.error}`,
+            }
+        }
+        return { ok: true, runs: parsed.runs, engine }
+    }
+
+    /**
+     * Restarts a run from its journal (`--resume`) with its token, appending
+     * to its log, and counts the restart. An error when the spawn threw.
+     */
+    const restartRun = async ({
+        memory,
+        engine,
+    }: {
+        memory: RunMemory
+        engine: { command: string; lead_args: string[] }
+    }): Promise<{ ok: true } | { ok: false; error: string }> => {
+        const { run_id, log_path } = memory.entry
+        let pid: number | null = null
+        try {
+            pid = spawnResume({
+                memory,
+                engine,
+                on_failed: 'the restarted engine failed',
+            })
+        } catch (error) {
+            return { ok: false, error: errorText({ error }) }
+        }
+        const restart = memory.entry.restarts + 1
+        updateEntry({ memory, change: { restarts: restart } })
+        const time = now().toISOString()
+        const row = restartRow({ run_id, restart, time })
+        memory.state = {
+            ...memory.state,
+            run: { ...memory.state.run, engine_ended: null },
+            latest: restartText({ restart }),
+            latest_at: time,
+        }
+        log(
+            `[${run_id}] restarted ${engine.command} with --resume (pid ${pid ?? '?'}, restart ${restart} of ${MAX_AUTO_RESTARTS}), log ${log_path}`
+        )
+        await appendRows({ memory, rows: [row, header({ memory })] })
+        return { ok: true }
+    }
+
+    /** One check: see `checkEngines`. */
+    const runCheck = async (): Promise<EngineCheck> => {
+        await ready
+        await reads.readOutside()
+        const summary: EngineCheck = { restarted: [], stopped: [] }
+        const candidates = [...runs.values()].filter((memory) =>
+            needsEngine({ state: memory.state })
+        )
+        const others = [...reads.outside.values()].filter((run) =>
+            needsEngine({ state: run.state })
+        )
+        if (candidates.length === 0 && others.length === 0) return summary
+        let command_lines: string[]
+        try {
+            command_lines = await list_processes()
+        } catch (error) {
+            // Never restart when unsure: two engines on one run is far worse
+            // than a late restart.
+            log(
+                `Couldn't list the processes, so no engine was checked: ${errorText({ error })}`
+            )
+            return summary
+        }
+        const live = liveRunIds({ command_lines })
+        await labelOutside({ others, live })
+        const dead = candidates.filter(
+            (memory) => !live.has(memory.entry.run_id)
+        )
+        if (dead.length === 0) return summary
+        const unfinished = dead.some((memory) => !memory.entry.demo)
+            ? await listUnfinished()
+            : null
+        if (unfinished && !unfinished.ok) {
+            log(`Couldn't check which runs can go on: ${unfinished.error}`)
+        }
+
+        const settle = async ({ memory }: { memory: RunMemory }) => {
+            // The engine may have ended the run while this check ran.
+            if (!needsEngine({ state: memory.state })) return
+            const { run_id, log_path } = memory.entry
+            const stop = async ({ why }: { why: StopWhy }) => {
+                const message = engineStoppedText({ why, run_id, log_path })
+                log(`[${run_id}] the engine is gone: ${message}`)
+                await endRun({ memory, ended: { ok: false, message } })
+                summary.stopped.push(run_id)
+            }
+            if (memory.entry.demo) return stop({ why: { kind: 'demo' } })
+            if (!unfinished?.ok) {
+                return stop({
+                    why: {
+                        kind: 'check_failed',
+                        error: unfinished?.error ?? 'no answer',
+                    },
+                })
+            }
+            const listed = unfinished.runs.get(run_id)
+            if (!listed) return stop({ why: { kind: 'not_listed' } })
+            if (!listed.restart) {
+                const reason = listed.message ?? 'no reason given'
+                return stop({
+                    why:
+                        listed.reason === 'billing_stopped'
+                            ? { kind: 'billing_stopped', reason }
+                            : { kind: 'launcher_stopped', reason },
+                })
+            }
+            if (memory.entry.restarts >= MAX_AUTO_RESTARTS) {
+                return stop({ why: { kind: 'restarts_used_up' } })
+            }
+            const restarted = await restartRun({
+                memory,
+                engine: unfinished.engine,
+            })
+            if (!restarted.ok) {
+                return stop({
+                    why: { kind: 'spawn_failed', error: restarted.error },
+                })
+            }
+            summary.restarted.push(run_id)
+        }
+
+        await Promise.all(
+            dead.map((memory) =>
+                enqueue({
+                    run_id: memory.entry.run_id,
+                    work: () => settle({ memory }),
+                })
+            )
+        )
+        return summary
+    }
+
+    let checking: Promise<EngineCheck> | null = null
+
+    /**
+     * Finds runs whose engine process is gone although the run hasn't ended,
+     * and restarts the ones that can go on from their journal
+     * (`--resume`, at most `MAX_AUTO_RESTARTS` times per run). The rest show
+     * "engine stopped" with why. The runs the plugin didn't start are only
+     * labelled when their engine is gone (#635). When the processes can't be listed, nothing
+     * is done. Only one check runs at a time: a call while one runs gets the
+     * same promise. Never rejects.
+     *
+     * @example
+     * const { restarted, stopped } = await board.checkEngines()
+     */
+    const checkEngines = (): Promise<EngineCheck> => {
+        checking ??= exclusive(runCheck)
+            .catch((error: unknown) => {
+                log(`The engine check failed: ${errorText({ error })}`)
+                return { restarted: [], stopped: [] }
+            })
+            .finally(() => {
+                checking = null
+            })
+        return checking
+    }
+
+    return {
+        checkEngines,
+        /** The check in flight, `null` when none runs. */
+        checking: () => checking,
+    }
+}