feat(workflows): standardized StepResult execution envelope + structured rendering

Backend: every workflow step now emits a uniform envelope
(status/summary/items/duration_ns/timestamp/data/error) via
StepResult + NewSuccess/ErrorStepResult + reflection-based SummarizeResult.
ExecuteWorkflow times each step and preserves transactional abort-on-error.

Frontend: WorkflowCenter renders status badge, summary, copy button,
key/value table or shell output block with duration/records/timestamp
footers (lib/workflowResults.ts helpers). No more raw JSON dumps.

Tests: common/workflow_test.go (11), app/Workflow_test.go (3),
workflowResults.test.ts (15). Also fixes inverted assertion in
TestAIOps_GetAISetupRecommendation_Logic (PullRequired == !QwythosExists).

Author: shahriarhaqueabir

cmd/opsforall-gui/frontend/src/lib/workflowResults.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from 'vitest'
+import {
+  formatDurationNs,
+  formatTimestamp,
+  formatValue,
+  getResultSummary,
+  isShellPayload,
+  isStepResult,
+  resultToRows,
+} from './workflowResults'
+
+describe('isStepResult', () => {
+  it('recognizes a standardized envelope', () => {
+    expect(isStepResult({ status: 'success', summary: '2 records', data: [] })).toBe(true)
+  })
+  it('rejects raw payloads and non-objects', () => {
+    expect(isStepResult({ Command: 'x', Output: 'y', ExitCode: 0 })).toBe(false)
+    expect(isStepResult('hello')).toBe(false)
+    expect(isStepResult(null)).toBe(false)
+    expect(isStepResult(undefined)).toBe(false)
+  })
+})
+
+describe('isShellPayload', () => {
+  it('recognizes the PascalCase shell payload nested in envelope.data', () => {
+    expect(isShellPayload({ Command: 'Get-Process', Output: 'a\nb', ExitCode: 0, Duration: 5 })).toBe(true)
+  })
+  it('rejects envelopes and non-shell shapes', () => {
+    expect(isShellPayload({ status: 'success', data: [] })).toBe(false)
+    expect(isShellPayload('nope')).toBe(false)
+  })
+})
+
+describe('formatDurationNs', () => {
+  it('formats ms, seconds, and minutes', () => {
+    expect(formatDurationNs(500_000)).toBe('<1ms')
+    expect(formatDurationNs(12_000_000)).toBe('12ms')
+    expect(formatDurationNs(1_500_000_000)).toBe('1.5s')
+    expect(formatDurationNs(125_000_000_000)).toBe('2m 5s')
+  })
+  it('returns empty for missing/zero values', () => {
+    expect(formatDurationNs(undefined)).toBe('')
+    expect(formatDurationNs(0)).toBe('')
+  })
+})
+
+describe('formatTimestamp', () => {
+  it('formats an RFC3339 timestamp', () => {
+    expect(formatTimestamp('2026-08-07T12:34:56Z')).toMatch(/\d{2}:\d{2}:\d{2}/)
+  })
+  it('returns empty for garbage', () => {
+    expect(formatTimestamp('not-a-date')).toBe('')
+    expect(formatTimestamp(undefined)).toBe('')
+  })
+})
+
+describe('resultToRows', () => {
+  it('flattens an array of objects with index prefixes', () => {
+    const rows = resultToRows([{ name: 'svc1', status: 'running' }, { name: 'svc2' }])
+    expect(rows).toEqual([
+      { key: '#1 · name', value: 'svc1' },
+      { key: '#1 · status', value: 'running' },
+      { key: '#2 · name', value: 'svc2' },
+    ])
+  })
+  it('flattens a plain object', () => {
+    expect(resultToRows({ cpu: 12, mem: 80 })).toEqual([
+      { key: 'cpu', value: 12 },
+      { key: 'mem', value: 80 },
+    ])
+  })
+  it('wraps a scalar in a single row', () => {
+    expect(resultToRows('done')).toEqual([{ key: 'value', value: 'done' }])
+  })
+  it('returns [] for empty arrays, null, and undefined', () => {
+    expect(resultToRows([])).toEqual([])
+    expect(resultToRows(null)).toEqual([])
+    expect(resultToRows(undefined)).toEqual([])
+  })
+})
+
+describe('formatValue', () => {
+  it('passes strings through and stringifies nested objects', () => {
+    expect(formatValue('plain')).toBe('plain')
+    expect(formatValue(42)).toBe('42')
+    expect(formatValue({ a: 1 })).toContain('"a": 1')
+  })
+  it('returns empty for null/undefined', () => {
+    expect(formatValue(null)).toBe('')
+    expect(formatValue(undefined)).toBe('')
+  })
+})
+
+describe('getResultSummary', () => {
+  it('uses summary for success and error message for failures', () => {
+    expect(getResultSummary({ status: 'success', summary: '3 services' })).toBe('3 services')
+    expect(getResultSummary({ status: 'error', error: 'boom' })).toBe('boom')
+    expect(getResultSummary({ status: 'error' })).toBe('Step failed')
+    expect(getResultSummary({ status: 'success' })).toBe('Completed')
+  })
+})

cmd/opsforall-gui/frontend/src/lib/workflowResults.ts

@@ -0,0 +1,121 @@
+/**
+ * Standardized Execution Result helpers for the Workflow Center.
+ *
+ * The backend wraps every workflow step payload in a StepResult envelope
+ * (see internal/common/workflow.go) with stable snake_case keys. These helpers
+ * decode that envelope for rendering: status badge, summary line, meta footer
+ * (duration / item count / timestamp), and a table-friendly row view.
+ */
+
+// StepResult mirrors internal/common.StepResult json tags.
+export interface StepResult {
+  status: 'success' | 'error'
+  summary?: string
+  items?: number
+  duration_ns?: number
+  timestamp?: string
+  data?: any
+  error?: string
+}
+
+export function isStepResult(r: any): r is StepResult {
+  return (
+    r !== null &&
+    typeof r === 'object' &&
+    typeof r.status === 'string' &&
+    ('data' in r || 'summary' in r || 'error' in r || 'duration_ns' in r)
+  )
+}
+
+// Shell payload nested inside envelope.data. devops.ShellResult has no json
+// tags, so it serializes with PascalCase keys — detect it the same way the
+// old duck-typing did, but scoped to the envelope's data field.
+export interface ShellPayload {
+  Command: string
+  Output: string
+  ExitCode: number
+  Duration: number
+}
+
+export function isShellPayload(d: any): d is ShellPayload {
+  return (
+    d !== null &&
+    typeof d === 'object' &&
+    typeof d.Command === 'string' &&
+    typeof d.Output === 'string' &&
+    typeof d.ExitCode === 'number'
+  )
+}
+
+export function formatDurationNs(ns?: number): string {
+  if (!ns || ns <= 0) return ''
+  if (ns < 1_000_000) return '<1ms'
+  const ms = Math.floor(ns / 1_000_000)
+  if (ms < 1000) return `${ms}ms`
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`
+  const min = Math.floor(ms / 60_000)
+  const sec = Math.floor((ms % 60_000) / 1000)
+  return `${min}m ${sec}s`
+}
+
+export function formatTimestamp(ts?: string): string {
+  if (!ts) return ''
+  const d = new Date(ts)
+  if (Number.isNaN(d.getTime())) return ''
+  return d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' })
+}
+
+export interface ResultRow {
+  key: string
+  value: any
+}
+
+/**
+ * Flattens an arbitrary payload into key/value rows for a table or grid.
+ * - Array of objects -> one row per entry per field, prefixed with the index.
+ * - Plain object      -> one row per key.
+ * - Scalar / string   -> single row.
+ */
+export function resultToRows(data: any): ResultRow[] {
+  if (data === null || data === undefined) return []
+
+  if (Array.isArray(data)) {
+    if (data.length === 0) return []
+    const rows: ResultRow[] = []
+    data.forEach((item, i) => {
+      if (item !== null && typeof item === 'object' && !Array.isArray(item)) {
+        const entries = Object.entries(item)
+        if (entries.length === 0) {
+          rows.push({ key: `#${i + 1}`, value: item })
+          return
+        }
+        for (const [k, v] of entries) {
+          rows.push({ key: `#${i + 1} · ${k}`, value: v })
+        }
+      } else {
+        rows.push({ key: `#${i + 1}`, value: item })
+      }
+    })
+    return rows
+  }
+
+  if (typeof data === 'object') {
+    return Object.entries(data).map(([k, v]) => ({ key: k, value: v }))
+  }
+
+  return [{ key: 'value', value: data }]
+}
+
+/** Renders a scalar value; nested objects/arrays are JSON-stringified. */
+export function formatValue(v: any): string {
+  if (v === null || v === undefined) return ''
+  if (typeof v === 'string') return v
+  if (typeof v === 'number' || typeof v === 'boolean') return String(v)
+  return JSON.stringify(v, null, 2)
+}
+
+/** Extracts the one-line interpretation for a step envelope. */
+export function getResultSummary(r: StepResult): string {
+  if (r.status === 'error') return r.error || 'Step failed'
+  return r.summary || 'Completed'
+}