@pikku/core 0.12.36 → 0.12.38

package/src/services/meta-service.ts

@@ -26,6 +26,7 @@ import type {
   PermissionMetadata,
 } from '../types/core.types.js'
 import type { AIAgentMeta } from '../wirings/ai-agent/ai-agent.types.js'
+import type { GatewaysMeta } from '../wirings/gateway/gateway.types.js'
 
 // Re-export core types for consumers
 export type {
@@ -166,6 +167,7 @@ export interface MetaService {
   getQueueMeta(): Promise<QueueWorkersMeta>
   getCliMeta(): Promise<CLIMeta>
   getMcpMeta(): Promise<MCPMeta>
+  getGatewayMeta(): Promise<GatewaysMeta>
   getRpcMeta(): Promise<RPCMetaRecord>
   getWorkflowMeta(): Promise<WorkflowsMeta>
   getTriggerMeta(): Promise<TriggerMeta>
@@ -203,6 +205,7 @@ export class LocalMetaService implements MetaService {
   private queueMetaCache: QueueWorkersMeta | null = null
   private cliMetaCache: CLIMeta | null = null
   private mcpMetaCache: MCPMeta | null = null
+  private gatewayMetaCache: GatewaysMeta | null = null
   private rpcMetaCache: RPCMetaRecord | null = null
   private workflowMetaCache: WorkflowsMeta | null = null
   private triggerMetaCache: TriggerMeta | null = null
@@ -252,6 +255,7 @@ export class LocalMetaService implements MetaService {
     this.queueMetaCache = null
     this.cliMetaCache = null
     this.mcpMetaCache = null
+    this.gatewayMetaCache = null
     this.rpcMetaCache = null
     this.workflowMetaCache = null
     this.triggerMetaCache = null
@@ -357,6 +361,17 @@ export class LocalMetaService implements MetaService {
     return this.mcpMetaCache!
   }
 
+  async getGatewayMeta(): Promise<GatewaysMeta> {
+    if (this.gatewayMetaCache) return this.gatewayMetaCache
+
+    const content = await this.readMetaJson(
+      'gateway',
+      'pikku-gateway-wirings-meta'
+    )
+    this.gatewayMetaCache = content ? JSON.parse(content) : {}
+    return this.gatewayMetaCache!
+  }
+
   async getRpcMeta(): Promise<RPCMetaRecord> {
     if (this.rpcMetaCache) return this.rpcMetaCache
 

package/src/wirings/gateway/gateway.types.ts

@@ -112,13 +112,16 @@ export type CoreGateway<
   PikkuFunctionConfig = CorePikkuFunctionConfig<any, any>,
   PikkuPermission extends CorePikkuPermission = CorePikkuPermission,
   PikkuMiddleware extends CorePikkuMiddleware = CorePikkuMiddleware,
-> = {
+> = Partial<
+  Pick<CommonWireMeta, 'title' | 'summary' | 'description' | 'errors'>
+> & {
   /** Unique name for this gateway */
   name: string
   /** Transport type */
   type: GatewayTransportType
   /** HTTP route for webhook/websocket types */
   route?: string
+  platform?: string
   /** The gateway adapter (parse inbound, send outbound) */
   adapter: GatewayAdapter
   /** The handler function that processes parsed messages */
@@ -140,6 +143,8 @@ export type GatewayMeta = CommonWireMeta & {
   name: string
   type: GatewayTransportType
   route?: string
+  platform?: string
+  auth?: boolean
   gateway: true
 }
 

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
@@ -618,9 +697,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'
     )
   })
 })