@defrex/autobuild 0.8.0 → 0.10.0

package/packages/core/src/cli/wait.ts

@@ -9,7 +9,7 @@
  *
  * The command shares `ab watch`'s machinery — target selection, ambient
  * scoping (via the extracted `assertReadScope`), the cursor codec, the record
- * projection, the poll cadence, and the read-failure policy — but ends on the
+ * projection, the cadence, and the read-failure policy — but ends on the
  * first satisfied condition instead of streaming. Conditions are derived from
  * the same reducer that produces `ab build status` (`status`, `prState`,
  * `phase`), so "blocked" means an open escalation exactly as it does
@@ -17,6 +17,17 @@
  * wait`, a state condition that already holds when the command starts returns
  * immediately with the build's latest event.
  *
+ * Cadence follows the store kind, exactly as `ab watch` does since AUT-334
+ * (verified and corrected for `ab wait` in AUT-368). Against a local store
+ * the loop is the sequential interval tick. Against an `http(s)` store every
+ * tracked build long-polls instead: one held `getEvents` request per stream
+ * is in flight (tasks run concurrently), `--interval` is the floor between
+ * request starts (elapsed request time counts toward the gap), and a hold's
+ * window is the remote default (25 s, whole seconds, under the store's
+ * ceiling) capped at the remaining `--timeout` budget. Every stop — a
+ * satisfied condition, an all-terminal named set, the timeout, an interrupt —
+ * cancels the in-flight holds promptly instead of waiting out a full window.
+ *
  * Read-only: it appends no event, claims or renews no lease, and creates no
  * build or repository record. Output carries no ANSI, ever, in either form.
  */
@@ -26,7 +37,13 @@ import type { BuildState, PrLifecycle } from '../kernel/reducer'
 import { reduceBuild } from '../kernel/reducer'
 import { isPhase, type BuildStatus, type Phase } from '../ontology'
 import type { Exec } from '../ports/workspace/git-worktree'
-import { buildInRepository, normalizeGitRemoteUrl } from './repo-state'
+import {
+  createRemotePollRunner,
+  defaultDelay,
+  makeFailureStreak,
+  type RemotePollReadOpts,
+} from './remote-poll'
+import { buildInRepository, isRemoteStoreRef, normalizeGitRemoteUrl } from './repo-state'
 import type { BuildRecord } from '../store/types'
 import { withAmbientReadStore, type StoreOpener } from './store-opening'
 import {
@@ -245,23 +262,6 @@ interface WaitStream {
   status: BuildStatus
 }
 
-function defaultDelay(ms: number, signal?: AbortSignal): Promise<void> {
-  return new Promise((resolve) => {
-    if (signal?.aborted === true) {
-      resolve()
-      return
-    }
-    const finish = (): void => {
-      clearTimeout(timer)
-      signal?.removeEventListener('abort', onAbort)
-      resolve()
-    }
-    const timer = setTimeout(finish, ms)
-    const onAbort = (): void => finish()
-    signal?.addEventListener('abort', onAbort, { once: true })
-  })
-}
-
 /**
  * `ab wait` — block until a targeted build satisfies a condition, then print
  * one record and exit 0; exit 2 when every named build went terminal without
@@ -386,6 +386,12 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
         if (streams.has(slug)) return
         const record = await store.getBuild(slug)
         if (record === null) return
+        // AUT-545: this full-log read is deliberate, accepted growth — the
+        // retained prefix is consumed at full replay depth by every later
+        // reduction (approvals, findings, answered escalations, PR facts,
+        // observations), so bounding it would need reducer-partition store
+        // machinery out of AUT-545's scope. Required for `--since` replay and
+        // the registration state check over the full reduction.
         const events = await store.getEvents(slug)
         const stream = registerStream(slug, events, slugs.includes(slug))
         if (resumeSeq !== undefined) {
@@ -410,6 +416,9 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
         if (satisfied === null) checkRegistrationState(stream)
       }
 
+      /** Builds discovery read in full and found terminal; never re-read. */
+      const retired = new Set<string>()
+
       /**
        * No-slug membership: every nonterminal build of this repository joins
        * the wait, baselined at its current maximum so no history replays, and
@@ -419,18 +428,42 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
        * build to appear.
        */
       const discoverBuilds = async (): Promise<void> => {
+        // AUT-545: the terminal filter is the AUT-487 digest, not a full-log read —
+        // one flat batch read replaces a full getEvents per candidate build, per
+        // discovery pass; `terminal` is reduceBuild's exact terminal rule
+        // (store/digest.ts, pinned by contract). The per-build full read below
+        // remains deliberate for builds the digest cannot retire: its retained
+        // prefix is consumed at full replay depth by every later reduction
+        // (approvals, findings, answered escalations, PR facts, observations), so
+        // bounding it would need reducer-partition store machinery out of
+        // AUT-545's scope. The reduceBuild re-check stays: it is the
+        // legacy-record fallback (a record whose `repo` predates origin
+        // normalization is in `mine` via `repoOrigin` but absent from the digest
+        // map, which keys on `record.repo`) and it keeps this filter unable to
+        // diverge from reduceBuild.
+        const digests = await store.getRepoBuildDigests(repo)
         for (const record of (await store.listBuilds()).filter(mine)) {
-          if (streams.has(record.slug)) continue
+          if (streams.has(record.slug) || retired.has(record.slug)) continue
+          const digest = digests.get(record.slug)
+          if (digest !== undefined && digest.terminal !== undefined) continue
           const events = await store.getEvents(record.slug)
           const status = reduceBuild(events).status
-          if (!NONTERMINAL_STATUSES.includes(status)) continue
+          if (!NONTERMINAL_STATUSES.includes(status)) {
+            // Terminal is permanent (reduceBuild never clears it): a legacy
+            // record the digest cannot retire is read once, not every pass.
+            retired.add(record.slug)
+            continue
+          }
           const stream = registerStream(record.slug, events, false)
           if (satisfied === null) checkRegistrationState(stream)
         }
       }
 
-      const pollBuild = async (stream: WaitStream): Promise<void> => {
-        const fresh = await store.getEvents(stream.slug, stream.lastSeq)
+      const pollBuild = async (
+        stream: WaitStream,
+        readOpts?: RemotePollReadOpts,
+      ): Promise<void> => {
+        const fresh = await store.getEvents(stream.slug, stream.lastSeq, readOpts)
         for (const event of fresh) {
           stream.events.push(event)
           stream.lastSeq = event.seq
@@ -482,13 +515,7 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
       /** One poll cycle: discovery, then per-stream reads. A failed read is
        * reported once per failure streak, advances nothing, and is retried at
        * the next interval; a fully successful cycle re-arms the report. */
-      let readFailureReported = false
-      const reportReadFailure = (error: unknown): void => {
-        if (readFailureReported) return
-        readFailureReported = true
-        const message = error instanceof Error ? error.message : String(error)
-        opts.stderr(`ab wait: a store read failed (${message}); retrying at the next interval`)
-      }
+      const tickStreak = makeFailureStreak('wait', opts.stderr)
 
       const tick = async (): Promise<void> => {
         let allReadsOk = true
@@ -497,7 +524,7 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
             await discoverBuilds()
           } catch (error) {
             allReadsOk = false
-            reportReadFailure(error)
+            tickStreak.onFailure(error)
           }
         }
         for (const stream of [...streams.values()]) {
@@ -506,10 +533,10 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
             await pollBuild(stream)
           } catch (error) {
             allReadsOk = false
-            reportReadFailure(error)
+            tickStreak.onFailure(error)
           }
         }
-        if (allReadsOk) readFailureReported = false
+        if (allReadsOk) tickStreak.onSuccess()
       }
 
       const finishSatisfied = (): number =>
@@ -561,17 +588,106 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
       const timeoutText = opts.timeout ?? '30m'
       const deadline = timeoutMs === 0 ? Number.POSITIVE_INFINITY : now().getTime() + timeoutMs
       const aborted = (): boolean => opts.signal?.aborted === true
-      while (!hasMatch()) {
-        if (aborted() || now().getTime() >= deadline) break
-        await sleep(interval, opts.signal)
-        if (aborted()) break
-        await tick()
-        if (!hasMatch() && namedAllTerminal()) {
-          const terminal = pickTerminalRecord()
-          return finish(null, terminal.event, terminal.state)
+
+      if (!isRemoteStoreRef(storeRef)) {
+        // Local cadence: one sequential tick per interval.
+        while (!hasMatch()) {
+          if (aborted() || now().getTime() >= deadline) break
+          await sleep(interval, opts.signal)
+          if (aborted()) break
+          await tick()
+          if (!hasMatch() && namedAllTerminal()) {
+            const terminal = pickTerminalRecord()
+            return finish(null, terminal.event, terminal.state)
+          }
+        }
+      } else {
+        // Remote cadence (AUT-334, verified and corrected in AUT-368): one
+        // long-poll task per tracked stream, running concurrently — a quiet
+        // stream keeps one held `getEvents` request in flight, so an appended
+        // event is seen within about a second of its append instead of at the
+        // next interval tick. Gap-fill spaces each stream's request starts at
+        // least `interval` apart (elapsed request time counts toward the
+        // gap), so a server that answers immediately still sees today's
+        // request rate. Discovery keeps its interval cadence. The pre-launch
+        // guard mirrors the local loop's top-of-cycle checks: a satisfied
+        // match, an abort, an elapsed deadline, or an all-terminal named set
+        // ends the wait before any held request (an already-satisfied wait
+        // issues zero held reads).
+        // Every stop is prompt: a satisfied condition, an all-terminal named
+        // set, an external abort, or an elapsed --timeout cancels the
+        // in-flight held reads (via `requestStop`) and wakes the gap sleeps
+        // (via the runner's stop controller) instead of waiting out a full
+        // hold. The held read's own bound is additionally capped at the
+        // wait's remaining time budget, so a hold can never outlive the
+        // deadline.
+        const shouldStop =
+          hasMatch() || aborted() || now().getTime() >= deadline || namedAllTerminal()
+        const remoteRunner = createRemotePollRunner({
+          command: 'wait',
+          stderr: opts.stderr,
+          now,
+          sleep,
+          intervalMs: interval,
+          deadlineMs: deadline,
+          aborted,
+          shouldStop: () =>
+            hasMatch() || aborted() || now().getTime() >= deadline || namedAllTerminal(),
+          drain: 'quiesce',
+        })
+        const requestStop = (): void => remoteRunner.requestStop()
+
+        const launch = (stream: WaitStream): void => {
+          remoteRunner.launch(
+            stream.slug,
+            (readOpts) => pollBuild(stream, readOpts),
+            () => hasMatch() || namedAllTerminal(),
+          )
+        }
+
+        // An external abort (SIGINT) is a stop like any other: it cancels
+        // the in-flight held reads and wakes the gap sleeps.
+        opts.signal?.addEventListener('abort', requestStop, { once: true })
+
+        if (!shouldStop) {
+          for (const stream of streams.values()) launch(stream)
+
+          if (slugs.length === 0) {
+            // Discovery keeps its interval cadence, launching a new per-
+            // stream task for each newly discovered nonterminal build. A
+            // discovered build that already satisfies ends the wait. The
+            // launch loop stays unconditional, after the catch — exactly
+            // where the inline loop ran: streams registered before a
+            // mid-discovery throw still get tasks whose polls then run
+            // independently.
+            void remoteRunner.runDiscovery({
+              step: async (): Promise<void> => {
+                await discoverBuilds()
+              },
+              launchPending: (): void => {
+                for (const stream of streams.values()) launch(stream)
+              },
+              endCheck: () => hasMatch(),
+            })
+          }
         }
+
+        await remoteRunner.drain()
+        opts.signal?.removeEventListener('abort', requestStop)
       }
+
       if (hasMatch()) return finishSatisfied()
+      if (namedAllTerminal()) {
+        // Decision 5, loop form: every named build went terminal without
+        // satisfying anything. The local loop checks this after each tick;
+        // on the remote path the runner records only that a stop was
+        // requested — its `shouldStop`/`endCheck` callbacks re-derive the
+        // conditions live — so after the quiesce drain this decision re-reads
+        // the same live predicates (`hasMatch`, `namedAllTerminal`, `aborted`,
+        // the deadline) to pick the exit.
+        const terminal = pickTerminalRecord()
+        return finish(null, terminal.event, terminal.state)
+      }
       if (aborted()) {
         opts.stderr('ab wait: interrupted — no condition was satisfied before the signal')
         if (json) opts.stdout(JSON.stringify({ cursor: encodeCurrent() }))