@pikku/core 0.12.37 → 0.12.39

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/oauth2/oauth2-client.test.ts

@@ -1,4 +1,6 @@
-import { describe, test, afterEach, mock } from 'node:test'
+import { describe, test, afterEach } from 'node:test'
+
+const mockFn = <T extends (...args: any[]) => any>(fn: T): T => fn
 import * as assert from 'node:assert/strict'
 import { OAuth2Client } from './oauth2-client.js'
 import type { OAuth2Token, OAuth2AppCredential } from './oauth2.types.js'
@@ -94,7 +96,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           access_token: 'new-access-token',
           refresh_token: 'new-refresh-token',
@@ -141,7 +143,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           access_token: 'refreshed-token',
           expires_in: 3600,
@@ -183,7 +185,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           access_token: 'refreshed-due-to-buffer',
           expires_in: 3600,
@@ -215,7 +217,7 @@ describe('OAuth2Client', () => {
 
       let capturedRequest: { url: string; options: RequestInit } | null = null
 
-      globalThis.fetch = mock.fn(
+      globalThis.fetch = mockFn(
         async (url: RequestInfo | URL, options?: RequestInit) => {
           capturedRequest = { url: url.toString(), options: options! }
           return mockFetchResponse({
@@ -259,7 +261,7 @@ describe('OAuth2Client', () => {
       })
 
       let fetchCallCount = 0
-      globalThis.fetch = mock.fn(async () => {
+      globalThis.fetch = mockFn(async () => {
         fetchCallCount++
         return mockFetchResponse({
           access_token: 'new-cached-token',
@@ -293,7 +295,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({ error: 'invalid_grant' }, 400, false)
       )
 
@@ -339,7 +341,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           access_token: 'new-persisted-token',
           refresh_token: 'new-refresh-token',
@@ -374,7 +376,7 @@ describe('OAuth2Client', () => {
       })
 
       let fetchCallCount = 0
-      globalThis.fetch = mock.fn(async () => {
+      globalThis.fetch = mockFn(async () => {
         fetchCallCount++
         // Simulate network delay
         await new Promise((resolve) => setTimeout(resolve, 50))
@@ -417,7 +419,7 @@ describe('OAuth2Client', () => {
       })
 
       // Response doesn't include refresh_token
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           access_token: 'new-token',
           expires_in: 3600,
@@ -453,7 +455,7 @@ describe('OAuth2Client', () => {
 
       let capturedHeaders: Record<string, string> | null = null
 
-      globalThis.fetch = mock.fn(
+      globalThis.fetch = mockFn(
         async (_url: RequestInfo | URL, options?: RequestInit) => {
           capturedHeaders = options?.headers as Record<string, string>
           return mockFetchResponse({ data: 'test' })
@@ -482,7 +484,7 @@ describe('OAuth2Client', () => {
       })
 
       let requestCount = 0
-      globalThis.fetch = mock.fn(
+      globalThis.fetch = mockFn(
         async (url: RequestInfo | URL, options?: RequestInit) => {
           requestCount++
           const urlStr = url.toString()
@@ -529,7 +531,7 @@ describe('OAuth2Client', () => {
       })
 
       let apiRequestCount = 0
-      globalThis.fetch = mock.fn(async (url: RequestInfo | URL) => {
+      globalThis.fetch = mockFn(async (url: RequestInfo | URL) => {
         const urlStr = url.toString()
 
         if (urlStr === 'https://example.com/oauth/token') {
@@ -565,7 +567,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({ error: 'forbidden' }, 403, false)
       )
 
@@ -589,7 +591,7 @@ describe('OAuth2Client', () => {
 
       let capturedHeaders: Record<string, string> | null = null
 
-      globalThis.fetch = mock.fn(
+      globalThis.fetch = mockFn(
         async (_url: RequestInfo | URL, options?: RequestInit) => {
           capturedHeaders = options?.headers as Record<string, string>
           return mockFetchResponse({ data: 'test' })
@@ -704,7 +706,7 @@ describe('OAuth2Client', () => {
 
       let capturedRequest: { url: string; options: RequestInit } | null = null
 
-      globalThis.fetch = mock.fn(
+      globalThis.fetch = mockFn(
         async (url: RequestInfo | URL, options?: RequestInit) => {
           capturedRequest = { url: url.toString(), options: options! }
           return mockFetchResponse({
@@ -738,7 +740,7 @@ describe('OAuth2Client', () => {
       })
 
       let fetchCallCount = 0
-      globalThis.fetch = mock.fn(async () => {
+      globalThis.fetch = mockFn(async () => {
         fetchCallCount++
         return mockFetchResponse({
           access_token: 'new-token',
@@ -767,7 +769,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({ error: 'invalid_code' }, 400, false)
       )
 
@@ -785,7 +787,7 @@ describe('OAuth2Client', () => {
         APP_CREDS: defaultAppCredential,
       })
 
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           access_token: 'token-only',
           // No refresh_token, expires_in, or scope
@@ -813,7 +815,7 @@ describe('OAuth2Client', () => {
       })
 
       // Response without access_token
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           refresh_token: 'refresh-only',
           expires_in: 3600,
@@ -835,7 +837,7 @@ describe('OAuth2Client', () => {
       })
 
       // Response with non-string access_token
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse({
           access_token: 12345, // Number instead of string
           expires_in: 3600,
@@ -865,7 +867,7 @@ describe('OAuth2Client', () => {
       })
 
       // Error response with sensitive info
-      globalThis.fetch = mock.fn(async () =>
+      globalThis.fetch = mockFn(async () =>
         mockFetchResponse(
           {
             error: 'invalid_grant',
@@ -910,7 +912,7 @@ describe('OAuth2Client', () => {
       // Instead, we verify that the signal is being passed
       // by checking that an abort signal is present in the fetch call
       let signalPassed = false
-      globalThis.fetch = mock.fn(
+      globalThis.fetch = mockFn(
         async (_url: RequestInfo | URL, options?: RequestInit) => {
           signalPassed = options?.signal instanceof AbortSignal
           return mockFetchResponse({

package/src/wirings/workflow/dsl/workflow-dsl.types.ts

@@ -295,10 +295,28 @@ export type WorkflowStepMeta =
 export interface WorkflowStepWire {
   /** The workflow run ID */
   runId: string
-  /** The unique step ID */
+  /**
+   * The step row ID. Whether it stays the same or is minted fresh per attempt is
+   * STORE-SPECIFIC (in-memory mints a new one each attempt; the SQL store reuses
+   * the row) — do NOT use it as a dedupe key. Use `invocationId`.
+   */
   stepId: string
+  /**
+   * Stable identity of this step invocation — the idempotency / dedupe key.
+   * Identical across every retry of the same call (derived from runId + step
+   * name) regardless of storage backend, so a step can `ON CONFLICT (invocationId)`
+   * or pass it as an external idempotency key and have retries collapse onto the
+   * first attempt.
+   */
+  invocationId: string
   /** Current attempt number (1-indexed, increments on retry) */
   attemptCount: number
+  /**
+   * Invocation ID of the predecessor step this one was reached from (the walked
+   * transition/edge). Undefined for entry steps. Lets a step know its origin —
+   * e.g. in a cyclic graph `a → b → a → c`, the second `a` carries `b`'s id.
+   */
+  fromInvocationId?: string
 }
 
 /**

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

@@ -10,6 +10,7 @@ import {
 import type { WorkflowRuntimeMeta } from '../workflow.types.js'
 import { pikkuState } from '../../../pikku-state.js'
 import { RPCNotFoundError } from '../../rpc/rpc-runner.js'
+import { DEFAULT_STEP_RETRIES } from '../pikku-workflow-service.js'
 
 describe('graph-runner bugs', () => {
   test('continueGraph should NOT mark workflow completed while nodes are still running', async () => {
@@ -240,6 +241,84 @@ describe('graph-runner bugs', () => {
     assert.deepEqual(queuedNodes, ['c'])
   })
 
+  test('continueGraph revisits a cyclic node and records the walked path via fromStepName', async () => {
+    const ws = new InMemoryWorkflowService()
+    const queued: Array<{ stepName: string; fromStepName?: string }> = []
+
+    pikkuState(null, 'package', 'singletonServices', {
+      queueService: {
+        add: async (_queueName: string, data: any) => {
+          if (data?.stepName) {
+            queued.push({
+              stepName: data.stepName,
+              fromStepName: data.fromStepName,
+            })
+          }
+        },
+      },
+    } as any)
+
+    // start → a, where a loops back through b once, then exits to c:
+    //   start → a --retry--> b → a --done--> c
+    const meta: WorkflowRuntimeMeta = {
+      name: 'testCyclicGraph',
+      pikkuFuncId: 'testCyclicGraph',
+      source: 'graph',
+      entryNodeIds: ['start'],
+      graphHash: 'cyclic-hash',
+      nodes: {
+        start: { nodeId: 'start', rpcName: 'doStart', next: 'a' },
+        a: { nodeId: 'a', rpcName: 'doA', next: { retry: 'b', done: 'c' } },
+        b: { nodeId: 'b', rpcName: 'doB', next: 'a' },
+        c: { nodeId: 'c', rpcName: 'doC' },
+      },
+    }
+
+    const runId = await ws.createRun('testCyclicGraph', {}, false, 'cyclic-hash', {
+      type: 'test',
+    })
+
+    // Succeed a queued step (taking an optional branch), then advance the graph.
+    const advance = async (stepName: string, branch?: string) => {
+      const step = await ws.getStepState(runId, stepName)
+      await ws.setStepRunning(step.stepId)
+      if (branch) await ws.setBranchTaken(step.stepId, branch)
+      await ws.setStepResult(step.stepId, { ok: true })
+      await continueGraph(ws, runId, 'testCyclicGraph', meta)
+    }
+
+    await continueGraph(ws, runId, 'testCyclicGraph', meta) // fire entry
+    await advance('start')
+    await advance('a', 'retry') // a → b (b reaches a, but first visit ⇒ bare 'b')
+    await advance('b') // b → a revisit ⇒ a#1
+    await advance('a#1', 'done') // a#1 → c (forward edge, terminal)
+    await advance('c')
+
+    // Each step records the predecessor it was reached from; the cyclic
+    // revisit is a fresh ordinal instance (a#1) with its own provenance.
+    assert.deepEqual(queued, [
+      { stepName: 'start', fromStepName: undefined },
+      { stepName: 'a', fromStepName: 'start' },
+      { stepName: 'b', fromStepName: 'a' },
+      { stepName: 'a#1', fromStepName: 'b' },
+      { stepName: 'c', fromStepName: 'a#1' },
+    ])
+
+    const run = await ws.getRun(runId)
+    assert.equal(run?.status, 'completed')
+
+    // Reconstruct the walked path purely from the fromStepName chain.
+    const instances = await ws.getStepInstances(runId)
+    const from = new Map(instances.map((i) => [i.stepName, i.fromStepName]))
+    const path: string[] = []
+    let cursor: string | undefined = 'c'
+    while (cursor) {
+      path.unshift(cursor)
+      cursor = from.get(cursor) ?? undefined
+    }
+    assert.deepEqual(path, ['start', 'a', 'b', 'a#1', 'c'])
+  })
+
   test('inline graph should execute converging next node only once', async () => {
     const ws = new InMemoryWorkflowService()
     let cCalls = 0
@@ -337,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()
 
@@ -618,9 +769,14 @@ describe('graph-runner bugs', () => {
     const cJob = enqueued.find((e) => e.data?.stepName === 'c')
     assert.ok(cJob, 'node c should have been enqueued')
     assert.equal(
-      cJob!.options,
-      undefined,
-      'no retries → no queue options (preserves prior queue defaults)'
+      cJob!.options?.attempts,
+      DEFAULT_STEP_RETRIES + 1,
+      'no retries → workflow default (5) + 1 attempt; queue never decides retries'
+    )
+    assert.equal(
+      cJob!.options?.backoff,
+      'exponential',
+      'default retries get exponential backoff so they ride out transient outages'
     )
   })
 })