@cat-factory/app 0.79.0 → 0.79.1

package/app/components/panels/AgentStepDetail.vue

@@ -89,6 +89,14 @@ const executionId = computed(() => instance.value?.id ?? null)
 // "spinning up" phase, no spinner.
 const runFailed = computed(() => instance.value?.status === 'failed')
 
+// Whether the run is still doing something (can still spin infra up/down). A terminal
+// run (`done`/`failed`) has nothing left to provision, so the infra-attempts drawer
+// stops its background live-polling (manual refresh stays available).
+const runLive = computed(() => {
+  const status = instance.value?.status
+  return status != null && status !== 'done' && status !== 'failed'
+})
+
 // Live elapsed-time clock for the open step.
 const { isRunning, durationLabel } = useStepTimer({
   step: () => step.value,
@@ -406,6 +414,7 @@ async function copyOutput() {
                   v-if="showProvisioning"
                   class="mt-2"
                   :execution-id="executionId"
+                  :live="runLive"
                 />
               </div>
 

package/app/components/provisioning/ProvisioningLogsDrawer.vue

@@ -4,15 +4,28 @@
 // container), with its outcome and — for failures — the verbatim provider/runtime
 // error. Two modes, mutually exclusive: pass `subsystem` for the provider config
 // panels' drawer, or `executionId` for a run's "Infrastructure attempts" drawer (which
-// surfaces that run's container/runner/env attempts). Loaded on mount + re-loadable.
-import { onMounted } from 'vue'
+// surfaces that run's container/runner/env attempts).
+//
+// In `executionId` mode the drawer LIVE-tracks: while the run is active (`live`) it
+// silently re-polls so each container spin-up / tear-down appears with its timestamp as
+// it happens, and it does one final poll when the run goes terminal to catch the last
+// tear-down row (written just before the terminal event), after which the auto-poll
+// stops. Background polls never spin the refresh button (they're silent), but the manual
+// refresh control stays available even once the run is terminal — so a tear-down row that
+// was missed or not yet persisted at the terminal instant can always be refetched.
+import { onBeforeUnmount, onMounted, watch } from 'vue'
 import type {
   ProvisioningOperation,
   ProvisioningOutcome,
   ProvisioningSubsystem,
 } from '~/types/provisioningLogs'
 
-const props = defineProps<{ subsystem?: ProvisioningSubsystem; executionId?: string }>()
+const props = defineProps<{
+  subsystem?: ProvisioningSubsystem
+  executionId?: string
+  /** Run-details mode only: whether the run is still active (drives live polling). */
+  live?: boolean
+}>()
 
 const { t, d } = useI18n()
 
@@ -23,12 +36,47 @@ const state = computed(() =>
     : store.bySubsystem[props.subsystem ?? 'environment'],
 )
 
-function reload() {
-  if (props.executionId) void store.loadForExecution(props.executionId)
+function reload(silent = false) {
+  if (props.executionId) void store.loadForExecution(props.executionId, { silent })
   else if (props.subsystem) void store.load(props.subsystem)
 }
 
-onMounted(reload)
+// --- live polling (executionId mode only) --------------------------------
+const POLL_MS = 4000
+let timer: ReturnType<typeof setInterval> | undefined
+
+function stopPolling() {
+  if (timer) {
+    clearInterval(timer)
+    timer = undefined
+  }
+}
+
+function startPolling() {
+  stopPolling()
+  timer = setInterval(() => reload(true), POLL_MS)
+}
+
+watch(
+  () => props.live,
+  (live, wasLive) => {
+    if (live && props.executionId != null) {
+      startPolling()
+      return
+    }
+    // Cleanup must NOT depend on `executionId` still being set: when the run's instance
+    // clears, `live` and `executionId` fall away in the same tick, so stop the interval
+    // unconditionally or it leaks (firing no-op reloads) for the component's lifetime.
+    stopPolling()
+    // On the active→terminal transition, poll once more (silently) to pick up the
+    // tear-down row the engine writes just before it emits the terminal state.
+    if (wasLive && props.executionId != null) reload(true)
+  },
+  { immediate: true },
+)
+
+onMounted(() => reload())
+onBeforeUnmount(stopPolling)
 
 // Exhaustive enum→label maps of literal `t(...)` keys (keeps the typed-key drift guard
 // live for these runtime-indexed lookups).
@@ -62,7 +110,7 @@ function when(epochMs: number): string {
         variant="ghost"
         size="xs"
         :loading="state.loading"
-        @click="reload"
+        @click="reload()"
       >
         {{ t('provisioning.refresh') }}
       </UButton>

package/app/components/testing/TestReportWindow.vue

@@ -60,6 +60,12 @@ const qualityVerdicts = computed(() => [...(quality.value?.verdicts ?? [])].reve
 // run's infrastructure attempts + logs (container/runner/env spin-up), not just the
 // report. The container/subtask signals already flow onto the step via the generic poll.
 const runFailed = computed(() => instance.value?.status === 'failed')
+// A terminal run (done/failed) can't spin more infra: the attempts drawer stops its
+// background live-polling (manual refresh stays available).
+const runLive = computed(() => {
+  const status = instance.value?.status
+  return status != null && status !== 'done' && status !== 'failed'
+})
 const stepEnvironment = computed(() => step.value?.environment ?? null)
 const executionId = computed(() => instance.value?.id ?? null)
 // The infra-attempts log drawer is opened on demand (it fetches the per-run log rows).
@@ -486,6 +492,7 @@ const GROUP_STATUS_META: Record<ScenarioGroup['status'], { icon: string; text: s
                   v-if="showProvisioning"
                   class="mt-2"
                   :execution-id="executionId"
+                  :live="runLive"
                 />
               </div>
             </section>

package/app/stores/provisioningLogs.spec.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { useProvisioningLogsStore } from '~/stores/provisioningLogs'
+import { useWorkspaceStore } from '~/stores/workspace'
+import type { ProvisioningLogEntry } from '~/types/provisioningLogs'
+
+/** Minimal attempt-row factory — only the fields the store passes through. */
+function entry(over: Partial<ProvisioningLogEntry> = {}): ProvisioningLogEntry {
+  return {
+    id: 'p1',
+    workspaceId: 'ws1',
+    subsystem: 'container',
+    operation: 'dispatch',
+    outcome: 'success',
+    targetId: 'job1',
+    providerId: null,
+    blockId: null,
+    executionId: 'exec1',
+    error: null,
+    detail: null,
+    createdAt: 1,
+    ...over,
+  } as ProvisioningLogEntry
+}
+
+describe('provisioningLogs store — loadForExecution', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('a visible load flips the loading spinner and stores the entries', async () => {
+    let resolveFetch!: (r: { entries: ProvisioningLogEntry[] }) => void
+    const pending = new Promise<{ entries: ProvisioningLogEntry[] }>((res) => {
+      resolveFetch = res
+    })
+    vi.stubGlobal('useApi', () => ({ listProvisioningLogs: () => pending }))
+
+    const store = useProvisioningLogsStore()
+    const load = store.loadForExecution('exec1')
+    // In flight: the button spinner is on.
+    expect(store.byExecution.exec1!.loading).toBe(true)
+
+    resolveFetch({ entries: [entry()] })
+    await load
+
+    expect(store.byExecution.exec1!.loading).toBe(false)
+    expect(store.byExecution.exec1!.entries).toHaveLength(1)
+  })
+
+  it('a silent poll never flips the loading spinner', async () => {
+    vi.stubGlobal('useApi', () => ({
+      listProvisioningLogs: () => Promise.resolve({ entries: [entry({ operation: 'release' })] }),
+    }))
+
+    const store = useProvisioningLogsStore()
+    await store.loadForExecution('exec1', { silent: true })
+
+    // Never went truthy — a background poll must not show a "refreshing" spinner.
+    expect(store.byExecution.exec1!.loading).toBe(false)
+    // But it still updates the timeline (the tear-down row now shows).
+    expect(store.byExecution.exec1!.entries[0]!.operation).toBe('release')
+  })
+
+  it('a silent poll failure keeps the last-good entries and surfaces no error', async () => {
+    const store = useProvisioningLogsStore()
+
+    // Seed a good snapshot via a visible load.
+    vi.stubGlobal('useApi', () => ({
+      listProvisioningLogs: () => Promise.resolve({ entries: [entry()] }),
+    }))
+    await store.loadForExecution('exec1')
+    expect(store.byExecution.exec1!.entries).toHaveLength(1)
+
+    // A background poll then blips — the drawer must keep showing what it had.
+    vi.stubGlobal('useApi', () => ({
+      listProvisioningLogs: () => Promise.reject(new Error('network')),
+    }))
+    await store.loadForExecution('exec1', { silent: true })
+
+    expect(store.byExecution.exec1!.entries).toHaveLength(1)
+    expect(store.byExecution.exec1!.error).toBeNull()
+  })
+
+  it('a visible load failure clears entries and reports the error', async () => {
+    vi.stubGlobal('useApi', () => ({
+      listProvisioningLogs: () => Promise.reject(new Error('503')),
+    }))
+
+    const store = useProvisioningLogsStore()
+    await store.loadForExecution('exec1')
+
+    expect(store.byExecution.exec1!.loading).toBe(false)
+    expect(store.byExecution.exec1!.entries).toHaveLength(0)
+    expect(store.byExecution.exec1!.error).toBe('503')
+  })
+})

package/app/stores/provisioningLogs.ts

@@ -47,22 +47,34 @@ export const useProvisioningLogsStore = defineStore('provisioningLogs', () => {
     }
   }
 
-  async function loadForExecution(executionId: string) {
+  /**
+   * Load a run's provisioning attempts. `silent` is for the drawer's background poll
+   * while the run is live: it must NOT flip the `loading` spinner (it would flicker
+   * every poll) and a transient failure must NOT clear the last-good entries or surface
+   * an error banner — the visible refresh path (initial open / manual refresh) owns those.
+   */
+  async function loadForExecution(executionId: string, opts?: { silent?: boolean }) {
     const ws = useWorkspaceStore()
     const s = (byExecution[executionId] ??= emptyState())
-    s.loading = true
-    s.error = null
+    if (!opts?.silent) {
+      s.loading = true
+      s.error = null
+    }
     try {
       const { entries } = await api.listProvisioningLogs(ws.requireId(), {
         executionId,
         limit: 200,
       })
       s.entries = entries
+      s.error = null
     } catch (err) {
-      s.error = err instanceof Error ? err.message : 'Failed to load logs'
-      s.entries = []
+      // A background poll keeps the last snapshot on a blip; only a visible load reports.
+      if (!opts?.silent) {
+        s.error = err instanceof Error ? err.message : 'Failed to load logs'
+        s.entries = []
+      }
     } finally {
-      s.loading = false
+      if (!opts?.silent) s.loading = false
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.79.0",
+  "version": "0.79.1",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",