aicodeman 1.12.2 → 1.13.0

package/dist/web/session-wait-registry.d.ts

@@ -0,0 +1,407 @@
+/**
+ * @fileoverview Blocking-wait registry backing the agent wait primitives.
+ *
+ * Codeman's only "tell me when" channel today is SSE, which an agent driving the
+ * API from a shell tool cannot practically consume (it would have to hold a
+ * streaming connection and parse events inline). This registry is the piece that
+ * lets a request *block* until something happens instead, so an orchestrating
+ * agent can `curl` and wait. Plan: `docs/agent-control-plan.md`.
+ *
+ * Two waiter kinds:
+ * - **signal waiters** resolve on the first of a requested set of lifecycle
+ *   signals (`idle`, `working`, `stop`, `blocked`, `exit`).
+ * - **output waiters** resolve when a literal string appears in a session's
+ *   ANSI-stripped output.
+ *
+ * ## What "ANSI-stripped output" means here
+ *
+ * `normalizeForMatch()` defines it, and it is a superset of `stripAnsi()`: that helper
+ * knows three escape families and leaves the rest, which is enough for `ESC ( B` from a
+ * stock bash prompt to break `match=tnode:` on a prompt that reads `tnode:`. Everything
+ * downstream derives from one call to it, so the carry, the haystack and the snippet
+ * window are all the same text. The returned `snippet` is then RENDERED from that window
+ * (control bytes removed, blank runs collapsed) and so is not a byte-for-byte quotation
+ * of what was matched — see `findMatch`.
+ *
+ * ## Signal provenance (why `stop` is the good one)
+ *
+ * `idle` / `working` / `exit` come from `Session`'s own events (heuristic: output
+ * stabilization plus prompt detection), so `idle` can flap mid-turn when a spinner
+ * pauses. `stop` and `blocked` come from Claude Code hooks (`POST /api/hook-event`)
+ * and are definitive. Only `claude` mode installs those hooks, so `stop` and
+ * `blocked` never fire for anything else: callers must be rejected up front rather
+ * than left to hit the timeout. `hooksAvailableForMode()` keeps that rule in one
+ * place, and it is keyed on the MODE rather than on `isExternalCliMode()` because
+ * `shell` is not an external CLI yet installs no hooks either.
+ *
+ * ## Ordering contract for the wiring
+ *
+ * A session that exits must `notifySignal(id, 'exit')` BEFORE `cancelAll(id)`, so
+ * a caller waiting on `exit` gets `signal: 'exit'` rather than `ended: true`.
+ *
+ * ## Lifetime discipline (24h sessions)
+ *
+ * Every waiter owns exactly one timer, cleared on resolve, and waiter sets are
+ * deleted when they empty. Session teardown must call `cancelAll()` and shutdown
+ * `stop()`: timers are deliberately NOT unref'd, because an unref'd timer can let
+ * the process exit mid-wait and strand the HTTP response.
+ *
+ * Two things keep a slot from outliving its caller:
+ * - `abortSignal`, so a client that hangs up frees its waiter immediately instead of
+ *   holding one for the rest of its timeout. Routes wire it to `req.raw.on('close')`.
+ * - the latched stopped flag, so a request that lands in the window between shutdown
+ *   starting and the HTTP server actually closing cannot register a fresh waiter that
+ *   nothing will ever cancel.
+ *
+ * This module holds no IO and no `Session` reference, which is what keeps it
+ * unit-testable in isolation.
+ */
+import type { SessionMode, SessionStatus } from '../types.js';
+/** A lifecycle signal a caller can block on. */
+export type WaitSignal = 'idle' | 'working' | 'stop' | 'blocked' | 'exit';
+/** Every valid signal, in documentation order. */
+export declare const WAIT_SIGNALS: readonly WaitSignal[];
+/**
+ * Applied when a caller omits `until`. `stop` first because it is the definitive
+ * end-of-turn signal, `idle` as the fallback for sessions that emit no hooks, and
+ * `exit` so a worker that CRASHES resolves the wait promptly instead of burning
+ * the caller's whole timeout on something that can no longer happen.
+ */
+export declare const DEFAULT_WAIT_SIGNALS: readonly WaitSignal[];
+/** Result of parsing a caller-supplied `until` value. */
+export interface ParsedWaitSignals {
+    /** Valid signals, deduped, in the order given. */
+    signals: WaitSignal[];
+    /** Tokens that are not signals. Non-empty means the caller should get a 400. */
+    invalid: string[];
+}
+/**
+ * Parse an `until` query value: a comma-separated string, an array of strings, or
+ * absent. Invalid tokens are REPORTED rather than dropped: silently falling back
+ * to the default would leave an agent believing it is waiting for `stop` when a
+ * typo means it is waiting for something else entirely.
+ *
+ * @param raw - `"stop,idle"`, `["stop","idle"]`, or undefined
+ * @returns valid signals plus any unrecognized tokens
+ */
+export declare function parseWaitSignals(raw: unknown): ParsedWaitSignals;
+/**
+ * The signal a session is *already* emitting, given its status, so a wait can
+ * resolve immediately instead of hanging until something changes.
+ *
+ * ⚠️ **What this CANNOT tell you: whether the session is alive.** It sees only the
+ * four-value `SessionStatus` enum, and that enum does not distinguish a finished
+ * worker from a dead one. Both PTY `onExit` handlers in `session.ts` (Claude
+ * interactive and shell) park the session at `'idle'`, and a PTY exit does not remove
+ * the session from the map, so a crashed worker reports `'idle'` indefinitely and this
+ * function will answer `'idle'` for it forever. `'stopped'` is set only on a spawn
+ * failure and by `stop(killMux:true)` (which deletes the session moments later), so in
+ * practice the `'stopped' → 'exit'` arm almost never fires for a session that merely
+ * died.
+ *
+ * Read the return value as "what state is it in", never as "is it still running". A
+ * caller that must tell a completed turn from a corpse has to consult liveness itself
+ * (`session.pid`, which is null after a PTY exit) and cannot get it from here. The
+ * live `exit` signal is still delivered by `notifySignal(id, 'exit')` at the moment
+ * the PTY dies; this function is only about the state a LATER caller finds.
+ *
+ * `stopped` and `error` both map to `exit` because both mean "not running", so a
+ * caller that does catch one of them does not block. `blocked` is deliberately
+ * underivable here, it exists only as a hook event until it becomes a real
+ * `SessionStatus` (see the deferred Part 3 in the plan).
+ */
+export declare function signalForStatus(status: SessionStatus): WaitSignal | null;
+/**
+ * Whether a session in this mode ever POSTs Codeman hook events, and therefore
+ * whether `stop` / `blocked` can ever fire for it.
+ *
+ * True for `claude` and nothing else. The tempting predicate is
+ * `!isExternalCliMode(mode)`, and it is WRONG: that helper covers only
+ * opencode/codex/gemini/antigravity, so `shell` falls through it — and a shell session
+ * is a plain bash PTY with no Claude Code and no hooks installed. `until=stop` on one
+ * was accepted and then blocked for the caller's whole timeout, which is precisely the
+ * infinite-wait-dressed-as-a-timeout this guard exists to prevent.
+ */
+export declare function hooksAvailableForMode(mode: SessionMode): boolean;
+/** Outcome of resolving a caller-supplied wait target against a session's mode. */
+export interface ResolvedWaitSignals {
+    /** Signals to actually wait on. Empty when `error` is set. */
+    until: WaitSignal[];
+    /** Caller-facing 400 message, or null when the request is usable. */
+    error: string | null;
+}
+/**
+ * Turn a raw `until` / `wait` value into the set to wait on, applying both rules
+ * every wait endpoint shares:
+ *
+ * 1. An unknown token is an ERROR, never a silent fallback to the default.
+ * 2. Hook-only signals are rejected when asked for EXPLICITLY on a mode that emits
+ *    no hooks, but merely dropped from the DEFAULT set: omitting the parameter must
+ *    never 400.
+ *
+ * Shared by `GET .../wait` and the `wait` field on `POST .../input` so the two can
+ * not drift; the second-guessing that produces is worse than the duplication.
+ *
+ * @param raw - the caller's value (comma string, array, `true` for "the default")
+ * @param options - `mode` decides whether the hook-only signals are available, and
+ *                  names the mode in the error message so the caller can see why
+ */
+export declare function resolveWaitSignals(raw: unknown, options: {
+    mode: SessionMode;
+}): ResolvedWaitSignals;
+/** Fields every wait result carries, whichever kind it is. */
+interface WaitResultBase {
+    /** True when the wait hit its timeout. */
+    timedOut: boolean;
+    /** True when the answer came from state already present at call time. */
+    immediate: boolean;
+    /** True when the session went away (deleted / torn down) before the wait resolved. */
+    ended: boolean;
+    /**
+     * True when the caller's `abortSignal` fired: the client hung up, so nobody is
+     * reading this result. `ended` is set alongside it, since the wait did end without
+     * an answer. False on every other path.
+     */
+    aborted: boolean;
+    /** Wall-clock ms spent waiting (0 for an immediate resolve). */
+    waitedMs: number;
+    /**
+     * The timeout actually applied, after clamping. Echoed because a caller that asked
+     * for 30 minutes and silently got 600s otherwise reads the timeout as a stalled
+     * worker and kills a session that was working fine.
+     */
+    timeoutMs: number;
+}
+/** Outcome of a signal wait. A timeout is a normal outcome, never an error. */
+export interface SignalWaitResult extends WaitResultBase {
+    /** The signal that fired, or null if the wait ended without one. */
+    signal: WaitSignal | null;
+}
+/** Outcome of an output wait. */
+export interface OutputWaitResult extends WaitResultBase {
+    matched: boolean;
+    /** Bounded window of output around the match, or null if nothing matched. */
+    snippet: string | null;
+}
+/**
+ * Thrown when a waiter would exceed a configured cap.
+ *
+ * `scope` is what the route needs to answer honestly: `'session'` is the caller's own
+ * session being oversubscribed (409 SESSION_BUSY), while `'owner'` and `'total'` are
+ * caps the caller may have no part in and cannot fix by switching sessions, so those
+ * map to 429 RATE_LIMITED. Reporting a process-wide cap as SESSION_BUSY tells the
+ * caller the wrong session is at fault.
+ */
+export declare class WaitCapacityError extends Error {
+    /** Which cap was hit, so the route can say something useful. */
+    readonly scope: 'session' | 'owner' | 'total';
+    readonly name = "WaitCapacityError";
+    constructor(message: string, 
+    /** Which cap was hit, so the route can say something useful. */
+    scope: 'session' | 'owner' | 'total');
+}
+/** Options shared by both wait kinds. */
+interface WaitOptionsBase {
+    /** Timeout in ms. Callers pass the CLAMPED value; it is echoed back in the result. */
+    timeoutMs: number;
+    /**
+     * Owner to charge this waiter to (multi-user mode). Omit in single-user mode: the
+     * per-owner cap applies only when this is set, so leaving it undefined behaves
+     * exactly as if the cap did not exist.
+     */
+    owner?: string;
+    /**
+     * Fires when the caller goes away (routes wire this to `req.raw.on('close')`).
+     * The waiter is removed and its timer cleared at once, resolving `ended: true,
+     * aborted: true`. Freeing the slot is the entire point: the response can no longer
+     * be sent, so holding one for the rest of the timeout only denies the pool to
+     * someone else. An already-aborted signal registers no waiter at all.
+     */
+    abortSignal?: AbortSignal;
+}
+export interface SignalWaitOptions extends WaitOptionsBase {
+    /** Signals to wait for; the first to fire wins. An empty set can only time out. */
+    until: readonly WaitSignal[];
+    /**
+     * When true, ignore `currentSignal` and require an actual transition. This is
+     * the `fresh=1` behavior: "tell me about the NEXT one", not "is it already so".
+     */
+    requireTransition?: boolean;
+    /** The session's current signal (from `signalForStatus`), if known. */
+    currentSignal?: WaitSignal | null;
+}
+export interface OutputWaitOptions extends WaitOptionsBase {
+    /** Literal substring to look for. No regex: see the note on `waitForOutput`. */
+    match: string;
+    /** Case-insensitive compare. */
+    nocase?: boolean;
+    /**
+     * Existing buffered output to scan before waiting (the `from=buffer` mode).
+     * Callers should pass a BOUNDED slice: a session's text buffer can be tens of
+     * megabytes and this is scanned synchronously. `assertCapacity()` runs BEFORE this
+     * is touched, so a request that cannot get a slot never pays for the scan.
+     */
+    initialText?: string;
+}
+export interface SessionWaitRegistryOptions {
+    maxWaitersPerSession?: number;
+    maxWaitersPerOwner?: number;
+    maxWaitersTotal?: number;
+}
+/**
+ * Holds pending waiters keyed by session id.
+ *
+ * One instance is shared process-wide (`sessionWaits` below); tests construct
+ * their own so no state leaks between cases.
+ */
+export declare class SessionWaitRegistry {
+    private readonly signalWaiters;
+    private readonly outputWaiters;
+    /**
+     * Live waiter count per owner. A derived count would mean walking every waiter in
+     * the process on each registration, so it is maintained incrementally instead:
+     * incremented once at registration, decremented once in the remove* helpers, which
+     * are the only paths that take a waiter out of a set.
+     */
+    private readonly ownerCounts;
+    /**
+     * Trailing bytes of a PTY chunk that look like the START of an ANSI sequence whose
+     * terminator has not arrived yet, held back until the next chunk completes it. Keyed
+     * by session because every output waiter on a session sees the same stream, which
+     * keeps `notifyOutput` at ONE `stripAnsi` per chunk rather than one per waiter.
+     * Deleted with the session's waiter set.
+     */
+    private readonly pendingAnsi;
+    private readonly maxPerSession;
+    private readonly maxPerOwner;
+    private readonly maxTotal;
+    /** Latched by `stop()` / `cancelEverything()`. Never cleared: shutdown is one-way. */
+    private stopped;
+    constructor(options?: SessionWaitRegistryOptions);
+    /** Pending signal waiters for a session. */
+    signalWaiterCount(sessionId: string): number;
+    /** Pending output waiters for a session. */
+    outputWaiterCount(sessionId: string): number;
+    /** Pending waiters of both kinds for a session. */
+    waiterCount(sessionId: string): number;
+    /** Pending waiters of both kinds across every session. */
+    totalWaiterCount(): number;
+    /** Pending waiters of both kinds charged to one owner. */
+    ownerWaiterCount(owner: string): number;
+    /** True once `stop()` / `cancelEverything()` has run: no new waiter can register. */
+    get isStopped(): boolean;
+    /**
+     * Throw if registering one more waiter would exceed a cap.
+     *
+     * PUBLIC so a route can check BEFORE doing expensive setup work. `/wait-output`'s
+     * `from=buffer` mode is the case that matters: reading `session.terminalBuffer`
+     * joins the whole 32MB accumulator, and paying that for a request that is about to
+     * be refused turns the cap into an amplifier instead of a protection. Both
+     * `waitForSignal` and `waitForOutput` call it themselves too, so a caller that skips
+     * the pre-check is still bounded.
+     *
+     * @throws {WaitCapacityError} naming the cap that was hit in `scope`.
+     */
+    assertCapacity(sessionId: string, owner?: string): void;
+    private chargeOwner;
+    private releaseOwner;
+    /**
+     * Wire a caller's abort signal to `onAbort`, returning the detach function.
+     * Detaching matters even though request signals are short-lived: without it a
+     * caller reusing one controller across several waits accumulates listeners on it.
+     */
+    private attachAbort;
+    /**
+     * Block until one of `until` fires, the timeout elapses, or the session ends.
+     *
+     * Resolves immediately (`immediate: true`) when the session's `currentSignal` is
+     * already in `until` and `requireTransition` is not set.
+     *
+     * @throws {WaitCapacityError} when a waiter cap is already reached.
+     */
+    waitForSignal(sessionId: string, options: SignalWaitOptions): Promise<SignalWaitResult>;
+    /**
+     * Deliver a lifecycle signal. Every waiter for this session that asked for it
+     * resolves; the rest keep waiting.
+     *
+     * @returns how many waiters were resolved (0 is the overwhelmingly common case,
+     *          which is why this is safe to call from the session event hot path).
+     */
+    notifySignal(sessionId: string, signal: WaitSignal): number;
+    private removeSignalWaiter;
+    /**
+     * Block until `match` appears in the session's output.
+     *
+     * **Literal matching only, deliberately.** `search-service.ts` avoids regex so
+     * there is no ReDoS surface, and this endpoint is more exposed still: the
+     * pattern is caller-supplied and the input is a live stream. herdr can offer
+     * `--regex` because Rust's regex crate is linear-time with no backtracking;
+     * JavaScript's `RegExp` backtracks.
+     *
+     * ⚠️ "New output" is not the same as "output produced after you asked". tmux
+     * REPAINTS the visible screen (on attach, resize, or a TUI redraw), and a repaint
+     * arrives as ordinary `terminal` data, so text that was already on screen can
+     * match a `from=now` wait. Observed live: a marker echoed a minute earlier matched
+     * instantly on a fresh wait. Callers must use a marker unique to the call
+     * (`echo DONE_$RANDOM`), not a generic one like `BUILD OK`.
+     *
+     * @throws {WaitCapacityError} when a waiter cap is already reached.
+     */
+    waitForOutput(sessionId: string, options: OutputWaitOptions): Promise<OutputWaitResult>;
+    /**
+     * Feed a raw PTY chunk to this session's output waiters.
+     *
+     * Called from the always-attached `terminal` listener, so it sits on the PTY hot
+     * path: it must stay a single Map lookup when nobody is waiting, which is why the
+     * no-waiter check comes before the ANSI strip.
+     *
+     * ⚠️ A PTY read boundary can fall INSIDE an escape sequence, which is routine under
+     * tmux (it emits SGR runs constantly). `stripAnsi` needs a complete sequence, so a
+     * split one used to survive the strip, land in the carry, and split the needle: the
+     * same text matched or not depending on where the kernel happened to cut the read.
+     * The incomplete tail is therefore held back in `pendingAnsi` and stripped together
+     * with the next chunk. That is the same class of bug the carry buffer exists to
+     * solve, one level down.
+     *
+     * @returns how many waiters matched.
+     */
+    notifyOutput(sessionId: string, chunk: string): number;
+    private removeOutputWaiter;
+    /**
+     * Resolve every waiter for a session with `ended: true`.
+     *
+     * Call on session deletion and PTY teardown. A session that EXITS should
+     * `notifySignal(id, 'exit')` first, so an `until=exit` caller sees the signal
+     * rather than a bare `ended`.
+     *
+     * @returns how many waiters were resolved.
+     */
+    cancelAll(sessionId: string): number;
+    /**
+     * Resolve every waiter in the process and refuse every later one.
+     *
+     * Shutdown must call this: waiter timers are not unref'd, so a pending 10-minute
+     * wait would otherwise hold the event loop open and strand its HTTP response.
+     *
+     * ⚠️ The latch is the point, not just the sweep. `server.stop()` cancels waiters
+     * well before `app.close()`, with several awaits in between (orchestrator teardown,
+     * scheduled-run stops that each await a session stop and a tmux kill), and the
+     * listener is still accepting requests throughout. A `GET .../wait?timeout=600000`
+     * landing in that window used to register a fresh waiter that nothing would ever
+     * cancel, stalling shutdown for up to `MAX_WAIT_MS` — exactly the outcome cancelling
+     * was meant to prevent. Once latched, a wait resolves at once with `ended: true`.
+     */
+    stop(): number;
+    /**
+     * Resolve every waiter in the process. Latches the stopped flag, so this is
+     * shutdown-shaped; `stop()` is the same call under the name that says so.
+     */
+    cancelEverything(): number;
+}
+/**
+ * Process-wide registry used by the routes and the session/hook wiring.
+ * Tests should construct their own `SessionWaitRegistry` instead of touching this.
+ */
+export declare const sessionWaits: SessionWaitRegistry;
+export {};
+//# sourceMappingURL=session-wait-registry.d.ts.map

package/dist/web/session-wait-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-wait-registry.d.ts","sourceRoot":"","sources":["../../src/web/session-wait-registry.ts"],"names":[],"mappings":"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"}