@pikku/core 0.12.38 → 0.12.39

package/src/services/in-memory-queue-service.test.ts

@@ -0,0 +1,97 @@
+import { describe, test, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { InMemoryQueueService } from './in-memory-queue-service.js'
+import { wireQueueWorker } from '../wirings/queue/queue-runner.js'
+import { resetPikkuState, pikkuState } from '../pikku-state.js'
+
+beforeEach(() => {
+  resetPikkuState()
+  pikkuState(null, 'package', 'singletonServices', {
+    logger: { error() {}, info() {}, warn() {}, debug() {} },
+  } as any)
+  pikkuState(null, 'package', 'factories', {
+    createWireServices: async () => ({}),
+  } as any)
+})
+
+// Register a queue worker whose handler runs `behavior` (which may throw) and
+// counts invocations. Returns the live call counter.
+const registerWorker = (
+  queueName: string,
+  behavior: (count: number) => void
+) => {
+  const calls = { count: 0 }
+  const funcId = `queue_${queueName}`
+  pikkuState(null, 'queue', 'meta')[queueName] = { pikkuFuncId: funcId, name: queueName }
+  pikkuState(null, 'function', 'meta')[funcId] = {
+    pikkuFuncId: funcId,
+    inputSchemaName: null,
+    outputSchemaName: null,
+    sessionless: true,
+  } as any
+  wireQueueWorker({
+    name: queueName,
+    func: {
+      auth: false,
+      func: async () => {
+        calls.count++
+        behavior(calls.count)
+      },
+    },
+  } as any)
+  return calls
+}
+
+const waitUntil = async (
+  predicate: () => boolean,
+  timeoutMs = 2000
+): Promise<boolean> => {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (predicate()) return true
+    await new Promise((r) => setTimeout(r, 10))
+  }
+  return predicate()
+}
+
+describe('InMemoryQueueService retry', () => {
+  test('redelivers a transiently-failing job until it succeeds', async () => {
+    const calls = registerWorker('flaky', (count) => {
+      if (count <= 2) throw new Error(`transient ${count}`)
+    })
+    const queue = new InMemoryQueueService()
+
+    await queue.add('flaky', {}, { attempts: 5, delay: 0 })
+
+    // Succeeds on the 3rd attempt; must not exceed the configured attempts.
+    assert.equal(await waitUntil(() => calls.count >= 3), true)
+    await new Promise((r) => setTimeout(r, 150))
+    assert.equal(calls.count, 3, 'should stop retrying once the job succeeds')
+  })
+
+  test('stops after `attempts` when a job always fails', async () => {
+    const calls = registerWorker('always-fails', () => {
+      throw new Error('boom')
+    })
+    const queue = new InMemoryQueueService()
+
+    await queue.add('always-fails', {}, { attempts: 3, delay: 0 })
+
+    assert.equal(await waitUntil(() => calls.count >= 3), true)
+    await new Promise((r) => setTimeout(r, 150))
+    assert.equal(calls.count, 3, 'must not redeliver beyond `attempts`')
+  })
+
+  test('runs once and does not retry when no attempts are configured', async () => {
+    const calls = registerWorker('no-retry', () => {
+      throw new Error('boom')
+    })
+    const queue = new InMemoryQueueService()
+
+    await queue.add('no-retry', {}, { delay: 0 })
+
+    await new Promise((r) => setTimeout(r, 150))
+    assert.equal(calls.count, 1, 'a job without attempts runs exactly once')
+  })
+})

package/src/services/in-memory-queue-service.ts

@@ -5,6 +5,13 @@ import type {
 } from '../wirings/queue/queue.types.js'
 import { runQueueJob } from '../wirings/queue/queue-runner.js'
 
+/**
+ * In-process queue for local/dev runs. Schedules jobs on the macrotask queue
+ * (setTimeout) so dispatch is genuinely asynchronous — the same timing shape as
+ * a real queue — and redelivers a failed job up to `options.attempts` times with
+ * backoff, so a transiently-failing workflow step recovers exactly as it would
+ * on pg-boss/bullmq instead of being silently dropped on its first error.
+ */
 export class InMemoryQueueService implements QueueService {
   readonly supportsResults = false
   private jobCounter = 0
@@ -15,31 +22,59 @@ export class InMemoryQueueService implements QueueService {
     options?: JobOptions
   ): Promise<string> {
     const jobId = `inmem-${++this.jobCounter}`
+    const maxAttempts = Math.max(1, options?.attempts ?? 1)
+    let attemptsMade = 0
+    const createdAt = new Date()
 
-    const job: QueueJob<T> = {
-      id: jobId,
-      queueName,
-      data,
-      status: () => 'active',
-      pikkuUserId: options?.pikkuUserId,
-    }
-
-    const delay = options?.delay ?? 100 + Math.floor(Math.random() * 201)
-
-    setTimeout(async () => {
+    const runAttempt = async () => {
+      attemptsMade++
+      const job: QueueJob<T> = {
+        id: jobId,
+        queueName,
+        data,
+        status: () => 'active',
+        metadata: () => ({ attemptsMade, maxAttempts, createdAt }),
+        pikkuUserId: options?.pikkuUserId,
+      }
       try {
         await runQueueJob({ job })
       } catch (e: any) {
-        console.error(
-          `[InMemoryQueue] Job ${jobId} on ${queueName} failed:`,
-          e.message
-        )
+        if (attemptsMade < maxAttempts) {
+          // Transient failure — redeliver with backoff, mirroring a real queue.
+          setTimeout(runAttempt, this.backoffDelay(options?.backoff, attemptsMade))
+        } else {
+          console.error(
+            `[InMemoryQueue] Job ${jobId} on ${queueName} failed after ${attemptsMade} attempt(s):`,
+            e.message
+          )
+        }
       }
-    }, delay)
+    }
+
+    const delay = options?.delay ?? 100 + Math.floor(Math.random() * 201)
+    setTimeout(runAttempt, delay)
 
     return jobId
   }
 
+  /** Delay before the next redelivery, honoring the job's backoff policy. */
+  private backoffDelay(
+    backoff: JobOptions['backoff'],
+    attemptsMade: number
+  ): number {
+    const baseDelay = typeof backoff === 'object' ? (backoff.delay ?? 50) : 50
+    if (
+      backoff === 'exponential' ||
+      (typeof backoff === 'object' && backoff?.type === 'exponential')
+    ) {
+      return Math.min(2 ** (attemptsMade - 1) * baseDelay, 2000)
+    }
+    if (typeof backoff === 'object' && backoff?.type === 'fixed') {
+      return backoff.delay ?? 50
+    }
+    return 50
+  }
+
   async getJob(): Promise<null> {
     return null
   }

package/src/services/in-memory-workflow-service.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from 'crypto'
 import { PikkuWorkflowService } from '../wirings/workflow/pikku-workflow-service.js'
+import { isExpectedError } from '../errors/error-handler.js'
 import type { SerializedError } from '../types/core.types.js'
 import type {
   WorkflowPlannedStep,
@@ -230,6 +231,7 @@ export class InMemoryWorkflowService
           name: error.name,
           message: error.message,
           stack: error.stack,
+          expected: isExpectedError(error),
         }
         step.failedAt = new Date()
         step.updatedAt = new Date()

package/src/services/workflow-service.ts

@@ -8,6 +8,10 @@ import type {
   WorkflowStatus,
   WorkflowVersionStatus,
 } from '../wirings/workflow/workflow.types.js'
+import type {
+  RunTimeline,
+  ReconstructedRunState,
+} from '../wirings/workflow/run-timeline.js'
 
 /**
  * Interface for workflow orchestration
@@ -29,6 +33,11 @@ export interface WorkflowService {
   getRun(id: string): Promise<WorkflowRun | null>
   getRunStatus(id: string): Promise<WorkflowRunStatus | null>
   getRunHistory(runId: string): Promise<Array<StepState & { stepName: string }>>
+  getRunTimeline(id: string): Promise<RunTimeline | null>
+  reconstructRunStateAt(
+    id: string,
+    at?: number | Date
+  ): Promise<ReconstructedRunState | null>
   updateRunStatus(
     id: string,
     status: WorkflowStatus,

package/src/testing/service-tests.ts

@@ -320,6 +320,71 @@ export function defineServiceTests(config: ServiceTestConfig): void {
         assert.equal(retried.result, undefined)
       })
 
+      test('getRunStatus reports per-step duration and attempts', async () => {
+        const runId = await service.createRun(
+          'status-timing-workflow',
+          {},
+          false,
+          'hash-timing',
+          wire
+        )
+        const step = await service.insertStepState(
+          runId,
+          'timed-step',
+          'myRpc',
+          {}
+        )
+        await service.setStepRunning(step.stepId)
+        await service.setStepResult(step.stepId, { ok: true })
+
+        const status = await service.getRunStatus(runId)
+        assert.ok(status)
+        const timed = status.steps.find((s) => s.name === 'timed-step')
+        assert.ok(timed, 'step appears in run status')
+        // running→succeeded must stamp runningAt/succeededAt so a duration is
+        // computable. Regression guard: the kysely store previously updated
+        // only the status on transitions, leaving the timestamps null and
+        // duration permanently undefined.
+        assert.ok(
+          timed.duration !== undefined,
+          'duration is computed from stamped transition timestamps'
+        )
+        assert.ok(timed.duration >= 0, 'duration is non-negative')
+        assert.equal(timed.attempts, 1, 'single attempt')
+      })
+
+      test('getRunStatus surfaces retried attempt count', async () => {
+        const runId = await service.createRun(
+          'status-retry-workflow',
+          {},
+          false,
+          'hash-retry-status',
+          wire
+        )
+        const step = await service.insertStepState(
+          runId,
+          'flaky-step',
+          'myRpc',
+          {},
+          { retries: 2 }
+        )
+        await service.setStepRunning(step.stepId)
+        await service.setStepError(step.stepId, new Error('first try'))
+        // Guarantee the retry's history row sorts after the failed attempt so
+        // getRunStatus picks the latest attempt (it tie-breaks on timestamps).
+        await new Promise((resolve) => setTimeout(resolve, 5))
+        const retry = await service.createRetryAttempt(step.stepId, 'pending')
+        await service.setStepRunning(retry.stepId)
+        await service.setStepResult(retry.stepId, { ok: true })
+
+        const status = await service.getRunStatus(runId)
+        assert.ok(status)
+        const flaky = status.steps.find((s) => s.name === 'flaky-step')
+        assert.ok(flaky, 'retried step collapses to a single status entry')
+        assert.equal(flaky.status, 'succeeded', 'latest attempt wins')
+        assert.equal(flaky.attempts, 2, 'attempt count surfaces in status')
+      })
+
       test('getNodesWithoutSteps', async () => {
         const runId = await service.createRun(
           'graph-workflow',

package/src/types/core.types.ts

@@ -558,5 +558,9 @@ export interface SerializedError {
   message: string
   stack?: string
   code?: string
+  // True when the original error was a deliberate, expected failure (a
+  // PikkuError). Survives the step-boundary rehydration so the workflow runner
+  // can log the message alone instead of a stack trace. See isExpectedError.
+  expected?: boolean
   [key: string]: any
 }

package/src/wirings/cli/cli-runner.ts

@@ -1,4 +1,5 @@
 import { NotFoundError } from '../../errors/errors.js'
+import { isExpectedError } from '../../errors/error-handler.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
 import { pikkuState } from '../../pikku-state.js'
 import type {
@@ -543,10 +544,17 @@ export async function executeCLI({
       throw error
     }
 
-    // Wrap other errors in CLIError
-    console.error('Error:', error)
+    // An expected failure (a deliberate PikkuError, e.g. a build gate
+    // tripping) — its message says everything, so print that alone (no
+    // `Error:` prefix). Anything else is an uncaught error: log the object so
+    // its stack shows.
+    if (isExpectedError(error)) {
+      console.error(error.message)
+    } else {
+      console.error('Error:', error)
+    }
 
-    // Show stack trace in verbose mode
+    // Show stack trace in verbose mode (even for expected errors).
     if (args.includes('--verbose') || args.includes('-v')) {
       console.error('Stack trace:', error.stack)
     }

package/src/wirings/workflow/graph/graph-runner.test.ts

@@ -416,6 +416,78 @@ describe('graph-runner bugs', () => {
     delete metaState['testInlineFailure']
   })
 
+  test('inline graph revisits a cyclic node and records the walked path via fromStepName', async () => {
+    const ws = new InMemoryWorkflowService()
+
+    // attempt loops back to itself via `again` until it converges to `done`.
+    const mockRpcService = {
+      rpcWithWire: async (rpcName: string, _data: any, wire: any) => {
+        if (rpcName === 'cyclicBegin') return { attempts: 3 }
+        if (rpcName === 'cyclicAttempt') {
+          const state = await wire.graph.getState()
+          const count = ((state.count as number) ?? 0) + 1
+          await wire.graph.setState('count', count)
+          wire.graph.branch(count >= 3 ? 'done' : 'again')
+          return { count }
+        }
+        if (rpcName === 'cyclicFinish') return { ok: true }
+        return {}
+      },
+    }
+
+    const metaState = pikkuState(null, 'workflows', 'meta')
+    metaState['testInlineCyclic'] = {
+      name: 'testInlineCyclic',
+      pikkuFuncId: 'testInlineCyclic',
+      source: 'graph',
+      entryNodeIds: ['begin'],
+      graphHash: 'inline-cyclic-hash',
+      nodes: {
+        begin: { nodeId: 'begin', rpcName: 'cyclicBegin', next: 'attempt' },
+        attempt: {
+          nodeId: 'attempt',
+          rpcName: 'cyclicAttempt',
+          next: { again: 'attempt', done: 'finish' },
+        },
+        finish: { nodeId: 'finish', rpcName: 'cyclicFinish' },
+      },
+    }
+
+    const { runId } = await runWorkflowGraph(
+      ws,
+      'testInlineCyclic',
+      {},
+      mockRpcService,
+      true
+    )
+
+    const run = await ws.getRun(runId)
+    assert.equal(run?.status, 'completed')
+
+    // The self-cycle produced three ordinal instances of `attempt`.
+    const instances = await ws.getStepInstances(runId)
+    const names = instances.map((i) => i.stepName).sort()
+    assert.ok(
+      names.includes('attempt') &&
+        names.includes('attempt#1') &&
+        names.includes('attempt#2'),
+      `expected attempt/attempt#1/attempt#2, got ${JSON.stringify(names)}`
+    )
+
+    // Walk the fromStepName chain back from the terminal node — inline now
+    // records provenance identical to the queued path.
+    const from = new Map(instances.map((i) => [i.stepName, i.fromStepName]))
+    const path: string[] = []
+    let cursor: string | undefined = 'finish'
+    while (cursor) {
+      path.unshift(cursor)
+      cursor = from.get(cursor) ?? undefined
+    }
+    assert.deepEqual(path, ['begin', 'attempt', 'attempt#1', 'attempt#2', 'finish'])
+
+    delete metaState['testInlineCyclic']
+  })
+
   test('executeGraphStep should throw after queueing onError nodes', async () => {
     const ws = new InMemoryWorkflowService()