@pikku/core 0.12.20 → 0.12.21

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

@@ -1,6 +1,8 @@
 import { describe, test, beforeEach } from 'node:test'
 import assert from 'node:assert'
 import { InMemoryWorkflowService } from './in-memory-workflow-service.js'
+import { getQueueWorkers } from '../wirings/queue/queue-runner.js'
+import { pikkuState } from '../pikku-state.js'
 
 let service: InMemoryWorkflowService
 
@@ -48,17 +50,10 @@ describe('InMemoryWorkflowService', () => {
     })
 
     test('should persist deterministic planned steps metadata', async () => {
-      const runId = await service.createRun(
-        'wf',
-        {},
-        true,
-        'h',
-        {} as any,
-        {
-          deterministic: true,
-          plannedSteps: [{ stepName: 'Step 1' }, { stepName: 'Step 2' }],
-        }
-      )
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any, {
+        deterministic: true,
+        plannedSteps: [{ stepName: 'Step 1' }, { stepName: 'Step 2' }],
+      })
 
       const run = await service.getRun(runId)
       assert.strictEqual(run?.deterministic, true)
@@ -369,4 +364,31 @@ describe('InMemoryWorkflowService', () => {
       assert.deepStrictEqual(history, [])
     })
   })
+
+  describe('queue worker registration', () => {
+    test('rewireQueueWorkers registers workflow queues added after construction', () => {
+      const stepQueue = 'wf-step-regression-enrich'
+      const orchQueue = 'wf-orchestrator-regression-onboarding'
+
+      const ws = new InMemoryWorkflowService()
+
+      const queueMeta = pikkuState(null, 'queue', 'meta')
+      queueMeta[stepQueue] = {
+        name: stepQueue,
+        pikkuFuncId: 'pikkuWorkflowWorker:regressionEnrich',
+      }
+      queueMeta[orchQueue] = {
+        name: orchQueue,
+        pikkuFuncId: 'pikkuWorkflowOrchestrator:regressionOnboarding',
+      }
+
+      assert.strictEqual(getQueueWorkers().has(stepQueue), false)
+      assert.strictEqual(getQueueWorkers().has(orchQueue), false)
+
+      ws.rewireQueueWorkers()
+
+      assert.strictEqual(getQueueWorkers().has(stepQueue), true)
+      assert.strictEqual(getQueueWorkers().has(orchQueue), true)
+    })
+  })
 })

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

@@ -37,6 +37,7 @@ export class InMemoryWorkflowService
   extends PikkuWorkflowService
   implements WorkflowRunService
 {
+  private sleepTimers = new Set<ReturnType<typeof setTimeout>>()
   private runs = new Map<string, WorkflowRun>()
   private steps = new Map<string, StepState>() // keyed by `${runId}:${stepName}`
   private stepData = new Map<string, InternalStepData>() // keyed by stepId
@@ -51,7 +52,7 @@ export class InMemoryWorkflowService
     { graph: any; source: string; status: WorkflowVersionStatus }
   >() // keyed by `${name}:${graphHash}`
 
-  async createRun(
+  protected async createRunImpl(
     workflowName: string,
     input: any,
     inline: boolean,
@@ -90,6 +91,25 @@ export class InMemoryWorkflowService
     return runId
   }
 
+  protected override async scheduleSleep(
+    runId: string,
+    stepId: string,
+    duration: number
+  ): Promise<boolean> {
+    const timer = setTimeout(async () => {
+      this.sleepTimers.delete(timer)
+      try {
+        await this.executeWorkflowSleepCompleted(runId, stepId)
+      } catch (error: any) {
+        this.logger?.error(
+          `Failed to resume workflow sleep for runId ${runId}: ${error?.message ?? error}`
+        )
+      }
+    }, duration)
+    this.sleepTimers.add(timer)
+    return true
+  }
+
   async getRun(id: string): Promise<WorkflowRun | null> {
     return this.runs.get(id) || null
   }
@@ -100,7 +120,7 @@ export class InMemoryWorkflowService
     return this.stepHistory.get(runId) || []
   }
 
-  async updateRunStatus(
+  protected async updateRunStatusImpl(
     id: string,
     status: WorkflowStatus,
     output?: any,
@@ -115,7 +135,7 @@ export class InMemoryWorkflowService
     }
   }
 
-  async insertStepState(
+  protected async insertStepStateImpl(
     runId: string,
     stepName: string,
     rpcName: string | null,
@@ -159,7 +179,7 @@ export class InMemoryWorkflowService
     return step
   }
 
-  async setStepRunning(stepId: string): Promise<void> {
+  protected async setStepRunningImpl(stepId: string): Promise<void> {
     for (const step of this.steps.values()) {
       if (step.stepId === stepId) {
         step.status = 'running'
@@ -170,7 +190,7 @@ export class InMemoryWorkflowService
     }
   }
 
-  async setStepScheduled(stepId: string): Promise<void> {
+  protected async setStepScheduledImpl(stepId: string): Promise<void> {
     for (const step of this.steps.values()) {
       if (step.stepId === stepId) {
         step.status = 'scheduled'
@@ -181,7 +201,10 @@ export class InMemoryWorkflowService
     }
   }
 
-  async setStepResult(stepId: string, result: any): Promise<void> {
+  protected async setStepResultImpl(
+    stepId: string,
+    result: any
+  ): Promise<void> {
     for (const step of this.steps.values()) {
       if (step.stepId === stepId) {
         step.status = 'succeeded'
@@ -193,7 +216,10 @@ export class InMemoryWorkflowService
     }
   }
 
-  async setStepError(stepId: string, error: Error): Promise<void> {
+  protected async setStepErrorImpl(
+    stepId: string,
+    error: Error
+  ): Promise<void> {
     for (const step of this.steps.values()) {
       if (step.stepId === stepId) {
         step.status = 'failed'
@@ -209,7 +235,10 @@ export class InMemoryWorkflowService
     }
   }
 
-  async setStepChildRunId(stepId: string, childRunId: string): Promise<void> {
+  protected async setStepChildRunIdImpl(
+    stepId: string,
+    childRunId: string
+  ): Promise<void> {
     for (const step of this.steps.values()) {
       if (step.stepId === stepId) {
         step.childRunId = childRunId
@@ -219,7 +248,7 @@ export class InMemoryWorkflowService
     }
   }
 
-  async createRetryAttempt(
+  protected async createRetryAttemptImpl(
     failedStepId: string,
     status: 'pending' | 'running'
   ): Promise<StepState> {
@@ -354,6 +383,10 @@ export class InMemoryWorkflowService
   }
 
   async close(): Promise<void> {
+    for (const timer of this.sleepTimers) {
+      clearTimeout(timer)
+    }
+    this.sleepTimers.clear()
     // Clear all in-memory state
     this.runs.clear()
     this.steps.clear()
@@ -439,11 +472,14 @@ export class InMemoryWorkflowService
     }
   }
 
-  async setBranchTaken(stepId: string, branchKey: string): Promise<void> {
+  protected async setBranchTakenImpl(
+    stepId: string,
+    branchKey: string
+  ): Promise<void> {
     this.branchKeys.set(stepId, branchKey)
   }
 
-  async updateRunState(
+  protected async updateRunStateImpl(
     runId: string,
     name: string,
     value: unknown
@@ -457,7 +493,7 @@ export class InMemoryWorkflowService
     return this.runState.get(runId) || {}
   }
 
-  async upsertWorkflowVersion(
+  protected async upsertWorkflowVersionImpl(
     name: string,
     graphHash: string,
     graph: any,
@@ -471,7 +507,7 @@ export class InMemoryWorkflowService
     })
   }
 
-  async updateWorkflowVersionStatus(
+  protected async updateWorkflowVersionStatusImpl(
     name: string,
     graphHash: string,
     status: WorkflowVersionStatus

package/src/services/local-content.test.ts

@@ -0,0 +1,54 @@
+import assert from 'node:assert/strict'
+import { describe, test } from 'node:test'
+
+import { LocalContent } from './local-content.js'
+
+describe('LocalContent signing', () => {
+  test('binds notBefore into the signature payload', async () => {
+    let capturedPayload:
+      | { signedAt: number; expiresAt: number; notBefore?: number }
+      | undefined
+
+    const content = new LocalContent(
+      {
+        localFileUploadPath: '/tmp/uploads',
+        uploadUrlPrefix: '/reaper',
+        assetUrlPrefix: '/assets',
+        server: 'http://localhost:3000',
+      },
+      {
+        info: () => {},
+        warn: () => {},
+        error: () => {},
+        debug: () => {},
+        setLevel: () => {},
+      } as any,
+      {
+        encode: async (_expiresIn: any, payload: any) => {
+          capturedPayload = payload
+          return 'signed-token'
+        },
+        decode: async () => ({}),
+      }
+    )
+
+    const dateGreaterThan = new Date(Date.now() + 60_000)
+    const dateLessThan = new Date(Date.now() + 120_000)
+    const signedUrl = await content.signContentKey({
+      bucket: 'avatars',
+      contentKey: 'user-1.png',
+      dateLessThan,
+      dateGreaterThan,
+    })
+
+    const url = new URL(signedUrl)
+    assert.equal(url.searchParams.get('signature'), 'signed-token')
+    assert.ok(capturedPayload)
+    assert.equal(capturedPayload?.expiresAt, dateLessThan.getTime())
+    assert.equal(capturedPayload?.notBefore, dateGreaterThan.getTime())
+    assert.equal(
+      url.searchParams.get('notBefore'),
+      String(dateGreaterThan.getTime())
+    )
+  })
+})

package/src/services/local-content.ts

@@ -65,9 +65,20 @@ export class LocalContent implements ContentService {
         1,
         Math.floor((expiresAt - signedAt) / 1000)
       )
+      const payload: {
+        signedAt: number
+        expiresAt: number
+        notBefore?: number
+      } = {
+        signedAt,
+        expiresAt,
+      }
+      if (dateGreaterThan) {
+        payload.notBefore = dateGreaterThan.getTime()
+      }
       const signature = await this.jwt.encode(
         { value: expiresInSeconds, unit: 'second' },
-        { signedAt, expiresAt }
+        payload
       )
       params.set('signature', signature)
     }

package/src/services/typed-credential-service.ts

@@ -15,9 +15,9 @@ export type CredentialMetaInfo = {
   oauth2?: boolean
 }
 
-export class TypedCredentialService<TMap = Record<string, unknown>>
-  implements CredentialService
-{
+export class TypedCredentialService<
+  TMap = Record<string, unknown>,
+> implements CredentialService {
   constructor(
     private credentials: CredentialService,
     private credentialsMeta: Record<string, CredentialMetaInfo>

package/src/services/typed-secret-service.ts

@@ -14,9 +14,9 @@ export type CredentialMeta = {
   oauth2?: { tokenSecretId: string }
 }
 
-export class TypedSecretService<TMap = Record<string, unknown>>
-  implements SecretService
-{
+export class TypedSecretService<
+  TMap = Record<string, unknown>,
+> implements SecretService {
   constructor(
     private secrets: SecretService,
     private credentialsMeta: Record<string, CredentialMeta>

package/src/services/typed-variables-service.ts

@@ -12,9 +12,9 @@ export type VariableMeta = {
   displayName: string
 }
 
-export class TypedVariablesService<TMap = Record<string, unknown>>
-  implements VariablesService
-{
+export class TypedVariablesService<
+  TMap = Record<string, unknown>,
+> implements VariablesService {
   constructor(
     private variables: VariablesService,
     private variablesMeta: Record<string, VariableMeta>

package/src/services/user-session-service.ts

@@ -11,12 +11,12 @@ export interface SessionService<UserSession extends CoreUserSession> {
   get(): UserSession | undefined
 }
 
-export class PikkuSessionService<UserSession extends CoreUserSession>
-  implements SessionService<UserSession>
-{
+export class PikkuSessionService<
+  UserSession extends CoreUserSession,
+> implements SessionService<UserSession> {
   public sessionChanged = false
   public initial: UserSession | undefined
-  private session: UserSession | undefined
+  protected session: UserSession | undefined
   private pikkuUserId?: string
 
   constructor(private sessionStore?: SessionStore<UserSession>) {}

package/src/testing/service-tests.ts

@@ -102,6 +102,36 @@ export function defineServiceTests(config: ServiceTestConfig): void {
       test('removeChannels with empty array is no-op', async () => {
         await store.removeChannels([])
       })
+
+      test('session round-trip — set / get / clear', async () => {
+        await store.addChannel({
+          channelId: 'ch-state',
+          channelName: 'test-channel',
+        })
+
+        // initially undefined
+        const empty = await store.getState('ch-state')
+        assert.equal(empty, undefined)
+
+        // set + get
+        const payload = { userId: 'u-7', meta: { foo: 1 } }
+        await store.setState('ch-state', payload)
+        const got = await store.getState('ch-state')
+        assert.deepEqual(got, payload)
+
+        // overwrite
+        const next = { userId: 'u-8' }
+        await store.setState('ch-state', next)
+        const got2 = await store.getState('ch-state')
+        assert.deepEqual(got2, next)
+
+        // clear
+        await store.clearState('ch-state')
+        const after = await store.getState('ch-state')
+        assert.equal(after, undefined)
+
+        await store.removeChannels(['ch-state'])
+      })
     })
   }
 

package/src/types/core.types.ts

@@ -9,6 +9,7 @@ import type {
   CorePikkuChannelMiddleware,
   CorePikkuChannelMiddlewareFactory,
 } from '../wirings/channel/channel.types.js'
+import type { EventHubService } from '../wirings/channel/eventhub-service.js'
 import type { PikkuRPC } from '../wirings/rpc/rpc-types.js'
 import type { PikkuMCP } from '../wirings/mcp/mcp.types.js'
 import type { PikkuScheduledTask } from '../wirings/scheduler/scheduler.types.js'
@@ -115,6 +116,7 @@ export type FunctionRuntimeMeta = {
   version?: number
   approvalRequired?: boolean
   approvalDescription?: string
+  implementationHash?: string
   contractHash?: string
   inputHash?: string
   outputHash?: string
@@ -216,6 +218,8 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
   workflowService?: WorkflowService
   /** The queue service */
   queueService?: QueueService
+  /** Event hub for realtime pub/sub across channels */
+  eventHub?: EventHubService<Record<string, any>>
   /** The scheduler service */
   schedulerService?: SchedulerService
   /** The deployment service for service discovery */
@@ -485,8 +489,8 @@ export type CreateSingletonServices<
  */
 export type CreateWireServices<
   SingletonServices extends CoreSingletonServices = CoreSingletonServices,
-  Services extends
-    CoreServices<SingletonServices> = CoreServices<SingletonServices>,
+  Services extends CoreServices<SingletonServices> =
+    CoreServices<SingletonServices>,
   UserSession extends CoreUserSession = CoreUserSession,
 > = (
   services: SingletonServices,

package/src/types/state.types.ts

@@ -138,6 +138,7 @@ export interface PikkuPackageState {
   middleware: {
     tagGroup: Record<string, CorePikkuMiddlewareGroup>
     httpGroup: Record<string, CorePikkuMiddlewareGroup>
+    global: CorePikkuMiddlewareGroup
   }
   channelMiddleware: {
     tagGroup: Record<string, CorePikkuChannelMiddleware[]>
@@ -145,6 +146,7 @@ export interface PikkuPackageState {
   permissions: {
     tagGroup: Record<string, CorePermissionGroup | CorePikkuPermission[]>
     httpGroup: Record<string, CorePermissionGroup | CorePikkuPermission[]>
+    global: (CorePermissionGroup | CorePikkuPermission)[]
   }
   misc: {
     errors: Map<PikkuError, ErrorDetails>
@@ -153,19 +155,6 @@ export interface PikkuPackageState {
     channelMiddleware: Record<string, CorePikkuChannelMiddleware[]>
     permissions: Record<string, CorePermissionGroup | CorePikkuPermission[]>
   }
-  models: {
-    config: {
-      models?: Record<
-        string,
-        string | { model: string; temperature?: number; maxSteps?: number }
-      >
-      agentDefaults?: { temperature?: number; maxSteps?: number }
-      agentOverrides?: Record<
-        string,
-        { model?: string; temperature?: number; maxSteps?: number }
-      >
-    } | null
-  }
   package: {
     /** Service factory functions for addon packages */
     factories: {