@defrex/autobuild 0.8.0

package/packages/core/src/cli/upgrade-notice.ts

@@ -0,0 +1,91 @@
+export const UPGRADE_NOTICE_INTERVAL_MS = 4 * 60 * 60 * 1_000
+export const UPGRADE_NOTICE_DEADLINE_MS = 30_000
+
+export type AvailableReleaseProbe = (signal: AbortSignal) => Promise<string | undefined>
+
+export interface UpgradeNoticeTimer {
+  clear(): void
+  unref?(): void
+}
+
+export interface UpgradeNoticeScheduler {
+  interval(callback: () => void, ms: number): UpgradeNoticeTimer
+  timeout(callback: () => void, ms: number): UpgradeNoticeTimer
+}
+
+const productionScheduler: UpgradeNoticeScheduler = {
+  interval(callback, ms) {
+    const timer = setInterval(callback, ms)
+    return {
+      clear: () => clearInterval(timer),
+      unref: () => timer.unref?.(),
+    }
+  },
+  timeout(callback, ms) {
+    const timer = setTimeout(callback, ms)
+    return {
+      clear: () => clearTimeout(timer),
+      unref: () => timer.unref?.(),
+    }
+  },
+}
+
+export interface UpgradeNoticeOptions {
+  probe: AvailableReleaseProbe
+  onAvailable: (version: string) => void
+  scheduler?: UpgradeNoticeScheduler
+}
+
+/** Run the dashboard's release courtesy in the background. The returned stop
+ * function is synchronous and idempotent: teardown never joins a probe that
+ * ignores cancellation. */
+export function startUpgradeNotice(options: UpgradeNoticeOptions): () => void {
+  const scheduler = options.scheduler ?? productionScheduler
+  let stopped = false
+  let current: AbortController | undefined
+
+  const check = (): void => {
+    if (stopped || current !== undefined) return
+    const controller = new AbortController()
+    current = controller
+    let deadline: UpgradeNoticeTimer
+    try {
+      deadline = scheduler.timeout(() => {
+        controller.abort()
+        // A probe may ignore cancellation forever. Release the overlap guard at
+        // the deadline so the next four-hour boundary can still try again.
+        if (current === controller) current = undefined
+      }, UPGRADE_NOTICE_DEADLINE_MS)
+      deadline.unref?.()
+    } catch {
+      current = undefined
+      return
+    }
+
+    void (async () => {
+      try {
+        const version = await options.probe(controller.signal)
+        if (!stopped && !controller.signal.aborted && version !== undefined) {
+          options.onAvailable(version)
+        }
+      } catch {
+        // Upgrade discovery is a silent courtesy, never a dispatcher warning.
+      } finally {
+        deadline.clear()
+        if (current === controller) current = undefined
+      }
+    })()
+  }
+
+  const cadence = scheduler.interval(check, UPGRADE_NOTICE_INTERVAL_MS)
+  cadence.unref?.()
+  check()
+
+  return () => {
+    if (stopped) return
+    stopped = true
+    cadence.clear()
+    current?.abort()
+    current = undefined
+  }
+}

package/packages/core/src/cli/upgrade-progress.ts

@@ -0,0 +1,110 @@
+import type { TerminalInput, TerminalOut } from './terminal'
+import {
+  UpgradeResolutionCancelledError,
+  type ResolveConflict,
+  type ResolveConflictOptions,
+} from './upgrade'
+
+const SPINNER = ['|', '/', '-', '\\'] as const
+const DEFAULT_REFRESH_MS = 250
+const CLEAR_LINE = '\r\u001b[2K'
+
+/** Keep every repaint on one physical terminal row. */
+function fitToColumns(frame: string, columns: number): string {
+  const width = Math.max(0, Math.floor(columns))
+  if (frame.length <= width) return frame
+  if (width === 0) return ''
+  if (width === 1) return '~'
+  return `${frame.slice(0, width - 1)}~`
+}
+
+export interface UpgradeProgressOptions {
+  terminal: TerminalOut
+  input: TerminalInput
+  /** Deterministic time/scheduling seams for the renderer tests. */
+  now?: () => number
+  refreshMs?: number
+  schedule?: (callback: () => void, milliseconds: number) => unknown
+  cancelSchedule?: (timer: unknown) => void
+}
+
+/**
+ * Decorate one per-file upgrade resolver with an interactive-only live line.
+ * Plain output never enters the progress path, preserving piped stdout bytes.
+ */
+export function withUpgradeProgress(
+  resolve: ResolveConflict,
+  options: UpgradeProgressOptions,
+): ResolveConflict {
+  if (!options.terminal.interactive) return resolve
+
+  return async (conflict, callOptions?: ResolveConflictOptions) => {
+    const now = options.now ?? Date.now
+    const schedule =
+      options.schedule ?? ((callback, milliseconds) => setInterval(callback, milliseconds))
+    const cancelSchedule =
+      options.cancelSchedule ?? ((timer) => clearInterval(timer as NodeJS.Timeout))
+    const startedAt = now()
+    const controller = new AbortController()
+    let frame = 0
+    let cleaned = false
+    let cancelled = false
+    let rejectCancellation!: (error: Error) => void
+    const cancellation = new Promise<never>((_resolve, reject) => {
+      rejectCancellation = reject
+    })
+
+    const cancel = (): void => {
+      if (cancelled) return
+      cancelled = true
+      controller.abort()
+      rejectCancellation(new UpgradeResolutionCancelledError())
+    }
+    const onCallerCancel = (): void => cancel()
+    if (callOptions?.signal !== undefined) {
+      callOptions.signal.addEventListener('abort', onCallerCancel, { once: true })
+      if (callOptions.signal.aborted) cancel()
+    }
+
+    const paint = (): void => {
+      const elapsed = Math.max(0, Math.floor((now() - startedAt) / 1_000))
+      const spinner = SPINNER[frame % SPINNER.length]
+      frame += 1
+      const status =
+        `${spinner} Resolving ${conflict.skill}/${conflict.path} — ` +
+        `elapsed ${elapsed}s — Ctrl-C to cancel`
+      options.terminal.write(`${CLEAR_LINE}${fitToColumns(status, options.terminal.columns)}`)
+    }
+
+    let timer: unknown
+    let stopInput = (): void => {}
+    const cleanup = (): void => {
+      if (cleaned) return
+      cleaned = true
+      try {
+        if (timer !== undefined) cancelSchedule(timer)
+      } finally {
+        try {
+          stopInput()
+        } finally {
+          callOptions?.signal?.removeEventListener('abort', onCallerCancel)
+          options.terminal.write(CLEAR_LINE)
+        }
+      }
+    }
+
+    try {
+      paint()
+      timer = schedule(paint, Math.min(1_000, Math.max(1, options.refreshMs ?? DEFAULT_REFRESH_MS)))
+      stopInput = options.input.start((event) => {
+        if (event.type === 'interrupt') cancel()
+      })
+      if (cancelled) return await cancellation
+      // The race is deliberate: even an injected or defective resolver that
+      // ignores its signal cannot return a proposal after the human cancels.
+      return await Promise.race([resolve(conflict, { signal: controller.signal }), cancellation])
+    } finally {
+      cleanup()
+    }
+  }
+}