@pikku/core 0.12.67 → 0.12.70

package/src/services/http-scenario-actors.ts

@@ -2,13 +2,20 @@ import type {
   ScenarioActor,
   ScenarioActorConfig,
   ScenarioActors,
+  ScenarioInvokeOptions,
+  ScenarioHttpResponse,
 } from './scenario-actors-service.js'
+import { readScenarioHttpResponse } from './scenario-actors-service.js'
 import type {
   ConverseOptions,
   ActorFlowVerdict,
   TargetAgentReply,
 } from '../wirings/actor-flow/actor-flow.types.js'
 import { runConversation } from '../wirings/actor-flow/run-conversation.js'
+import {
+  createCookieJar,
+  type ScenarioCookieJar,
+} from '../wirings/workflow/scenario-cookie-jar.js'
 import { getSingletonServices } from '../pikku-state.js'
 import { AIProviderNotConfiguredError } from '../errors/errors.js'
 
@@ -48,15 +55,21 @@ export interface HttpScenarioActorsConfig {
  * outlive a session).
  */
 export class HttpScenarioActor implements ScenarioActor {
-  private cookie: string | null = null
-  private origin: string
+  private jar: ScenarioCookieJar
+  /**
+   * Whether `login()` has succeeded since the last time the session was
+   * dropped. The jar cannot answer this — a target may set a cookie before
+   * anyone signs in, and it would then look like a session that was never
+   * established.
+   */
+  private signedIn = false
 
   constructor(
     readonly name: string,
     private actorConfig: ScenarioActorConfig,
     private config: HttpScenarioActorsConfig
   ) {
-    this.origin = new URL(config.apiUrl).origin
+    this.jar = createCookieJar(config.apiUrl)
   }
 
   get email(): string {
@@ -64,17 +77,31 @@ export class HttpScenarioActor implements ScenarioActor {
   }
 
   async invoke(rpcName: string, data: unknown): Promise<unknown> {
-    const cookie = this.cookie ?? (await this.login())
-    const res = await this.postRpc(rpcName, data, cookie)
+    const res = await this.invokeRaw(rpcName, data)
+    if (!res.ok) {
+      throw new Error(
+        `[scenario] '${rpcName}' as '${this.name}' returned ${res.status}: ${res.serialized.slice(0, 300)}`
+      )
+    }
+    return res.body
+  }
+
+  async invokeRaw(
+    rpcName: string,
+    data: unknown,
+    options?: ScenarioInvokeOptions
+  ): Promise<ScenarioHttpResponse> {
+    if (!this.signedIn) {
+      await this.login()
+    }
+    let res = await this.postRpc(rpcName, data, options?.headers)
     if (res.status === 401) {
       // Session expired mid-run — re-login once and retry.
-      this.cookie = null
-      return this.readRpcResponse(
-        rpcName,
-        await this.postRpc(rpcName, data, await this.login())
-      )
+      this.signOut()
+      await this.login()
+      res = await this.postRpc(rpcName, data, options?.headers)
     }
-    return this.readRpcResponse(rpcName, res)
+    return readScenarioHttpResponse(res)
   }
 
   async converse(options: ConverseOptions): Promise<ActorFlowVerdict> {
@@ -92,8 +119,8 @@ export class HttpScenarioActor implements ScenarioActor {
     const resourceId = `actor:${this.name}`
 
     return runConversation({
-      persona: this.actorConfig,
-      personaName: this.actorConfig.name ?? this.name,
+      actor: this.actorConfig,
+      actorName: this.actorConfig.name ?? this.name,
       agentName: options.agent,
       task: options.task,
       evaluate: options.evaluate,
@@ -148,21 +175,18 @@ export class HttpScenarioActor implements ScenarioActor {
   private async postAgent(subPath: string, body: unknown): Promise<unknown> {
     const rpcPath = this.config.rpcPath ?? '/rpc'
     const url = `${this.config.apiUrl}${rpcPath}/${subPath}`
-    const send = (cookie: string | null) =>
-      fetch(url, {
+    const send = () =>
+      this.jar.fetch(url, {
         method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          origin: this.origin,
-          ...(cookie ? { cookie } : {}),
-        },
+        headers: { 'content-type': 'application/json' },
         body: JSON.stringify(body),
       })
 
-    let res = await send(this.cookie)
+    let res = await send()
     if (res.status === 401) {
-      this.cookie = null
-      res = await send(await this.login())
+      this.signOut()
+      await this.login()
+      res = await send()
     }
     if (!res.ok) {
       const text = (await res.text().catch(() => '')).slice(0, 300)
@@ -175,36 +199,30 @@ export class HttpScenarioActor implements ScenarioActor {
     return text ? JSON.parse(text) : undefined
   }
 
-  private async postRpc(rpcName: string, data: unknown, cookie: string) {
+  private async postRpc(
+    rpcName: string,
+    data: unknown,
+    extraHeaders?: Record<string, string>
+  ) {
     const rpcPath = this.config.rpcPath ?? '/rpc'
-    return fetch(`${this.config.apiUrl}${rpcPath}/${rpcName}`, {
+    return this.jar.fetch(`${this.config.apiUrl}${rpcPath}/${rpcName}`, {
       method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        origin: this.origin,
-        cookie,
-      },
+      headers: { 'content-type': 'application/json', ...extraHeaders },
       body: JSON.stringify({ data }),
     })
   }
 
-  private async readRpcResponse(rpcName: string, res: Response) {
-    if (!res.ok) {
-      const body = (await res.text().catch(() => '')).slice(0, 300)
-      throw new Error(
-        `[scenario] '${rpcName}' as '${this.name}' returned ${res.status}: ${body}`
-      )
-    }
-    if (res.status === 204) return undefined
-    const text = await res.text()
-    return text ? JSON.parse(text) : undefined
+  /** Drop the session, so the next call signs in again before it goes out. */
+  private signOut(): void {
+    this.jar.clear()
+    this.signedIn = false
   }
 
-  private async login(): Promise<string> {
+  private async login(): Promise<void> {
     const signInPath = this.config.signInPath ?? '/auth/sign-in/actor'
-    const res = await fetch(`${this.config.apiUrl}${signInPath}`, {
+    const res = await this.jar.fetch(`${this.config.apiUrl}${signInPath}`, {
       method: 'POST',
-      headers: { 'content-type': 'application/json', origin: this.origin },
+      headers: { 'content-type': 'application/json' },
       body: JSON.stringify({
         email: this.actorConfig.email,
         name: this.actorConfig.name ?? this.name,
@@ -217,18 +235,14 @@ export class HttpScenarioActor implements ScenarioActor {
         `[scenario] actor sign-in failed for '${this.name}' (${res.status}): ${body}`
       )
     }
-    const setCookies = res.headers.getSetCookie?.() ?? []
-    const cookie = setCookies
-      .map((c) => c.split(';')[0]!)
-      .filter(Boolean)
-      .join('; ')
-    if (!cookie) {
+    // What proves a session was established is this response setting a cookie,
+    // not the jar being non-empty — the target may have set one earlier.
+    if (res.headers.getSetCookie().length === 0) {
       throw new Error(
         `[scenario] actor sign-in for '${this.name}' returned no session cookie`
       )
     }
-    this.cookie = cookie
-    return cookie
+    this.signedIn = true
   }
 }
 

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

@@ -2,7 +2,7 @@ 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'
+import { pikkuState, resetPikkuState } from '../pikku-state.js'
 
 let service: InMemoryWorkflowService
 
@@ -390,5 +390,54 @@ describe('InMemoryWorkflowService', () => {
       assert.strictEqual(getQueueWorkers().has(stepQueue), true)
       assert.strictEqual(getQueueWorkers().has(orchQueue), true)
     })
+
+    test('shared-groups leaves per-workflow queues unconsumed', () => {
+      const orchQueue = 'wf-orchestrator-shared-strategy-check'
+
+      const queueMeta = pikkuState(null, 'queue', 'meta')
+      queueMeta[orchQueue] = {
+        name: orchQueue,
+        pikkuFuncId: 'pikkuWorkflowOrchestrator:sharedStrategyCheck',
+      }
+
+      const ws = new InMemoryWorkflowService({
+        queueStrategy: 'shared-groups',
+      })
+      ws.wireQueueWorkers()
+
+      // The whole point: one set of pollers, not one per workflow.
+      assert.strictEqual(getQueueWorkers().has(orchQueue), false)
+      assert.strictEqual(
+        getQueueWorkers().has('pikku-workflow-orchestrator'),
+        true
+      )
+    })
+
+    test('shared-groups caps how much of the shared queue one workflow takes', () => {
+      // registerWorkflowFunc is first-write-wins, so start from clean state
+      // rather than inheriting the shared queues an earlier test registered.
+      resetPikkuState()
+      const ws = new InMemoryWorkflowService({
+        queueStrategy: 'shared-groups',
+        queueConcurrency: 20,
+        queueGroupConcurrency: 3,
+      })
+      ws.wireQueueWorkers()
+
+      const worker = getQueueWorkers().get('pikku-workflow-orchestrator')
+      assert.deepStrictEqual(worker?.config, {
+        batchSize: 20,
+        groupConcurrency: 3,
+      })
+    })
+
+    test('per-workflow (the default) leaves the shared queues unconstrained', () => {
+      resetPikkuState()
+      const ws = new InMemoryWorkflowService()
+      ws.wireQueueWorkers()
+
+      const worker = getQueueWorkers().get('pikku-workflow-orchestrator')
+      assert.strictEqual(worker?.config, undefined)
+    })
   })
 })

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

@@ -4,6 +4,7 @@ import { isExpectedError } from '../errors/error-handler.js'
 import type { SerializedError } from '../types/core.types.js'
 import type {
   WorkflowPlannedStep,
+  WorkflowQueueOptions,
   WorkflowRun,
   WorkflowRunService,
   WorkflowRunWire,
@@ -39,8 +40,8 @@ export class InMemoryWorkflowService
   extends PikkuWorkflowService
   implements WorkflowRunService
 {
-  constructor() {
-    super({ wireQueues: false })
+  constructor(options: WorkflowQueueOptions = {}) {
+    super({ ...options, wireQueues: false })
   }
 
   private sleepTimers = new Set<ReturnType<typeof setTimeout>>()

package/src/services/index.ts

@@ -43,8 +43,13 @@ export type {
 export type {
   ScenarioActor,
   ScenarioActorConfig,
+  ScenarioActorOf,
   ScenarioActors,
+  ScenarioInvokeOptions,
+  ScenarioRpcMap,
+  ScenarioHttpResponse,
 } from './scenario-actors-service.js'
+export { readScenarioHttpResponse } from './scenario-actors-service.js'
 export {
   HttpScenarioActor,
   createHttpScenarioActors,

package/src/services/meta-service.test.ts

@@ -0,0 +1,79 @@
+import { describe, test, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { LocalMetaService } from './meta-service.js'
+
+/**
+ * Scenarios and their steps are generated into `.pikku/scenarios/` so that no
+ * app-facing module imports them. Everything that reads meta off disk — the
+ * console's scenario list among them — must still see them.
+ */
+describe('LocalMetaService reads the scenario meta alongside the app meta', () => {
+  let pikkuDir: string
+
+  before(async () => {
+    pikkuDir = await mkdtemp(join(tmpdir(), 'pikku-meta-'))
+    await mkdir(join(pikkuDir, 'workflow', 'meta'), { recursive: true })
+    await mkdir(join(pikkuDir, 'scenarios', 'meta'), { recursive: true })
+    await mkdir(join(pikkuDir, 'function'), { recursive: true })
+    await mkdir(join(pikkuDir, 'scenarios'), { recursive: true })
+
+    await writeFile(
+      join(pikkuDir, 'workflow', 'meta', 'orderWorkflow.gen.json'),
+      JSON.stringify({ name: 'orderWorkflow', source: 'dsl' })
+    )
+    await writeFile(
+      join(pikkuDir, 'scenarios', 'meta', 'codeEditorScenario.gen.json'),
+      JSON.stringify({ name: 'codeEditorScenario', source: 'scenario' })
+    )
+    await writeFile(
+      join(pikkuDir, 'function', 'pikku-functions-meta.gen.json'),
+      JSON.stringify({ createTodo: { pikkuFuncId: 'createTodo' } })
+    )
+    await writeFile(
+      join(pikkuDir, 'scenarios', 'pikku-scenario-functions-meta.gen.json'),
+      JSON.stringify({
+        opensPage: { pikkuFuncId: 'opensPage', scenarioStep: true },
+      })
+    )
+  })
+
+  after(async () => {
+    await rm(pikkuDir, { recursive: true, force: true })
+  })
+
+  test('a scenario is still a workflow to whoever reads the meta', async () => {
+    const meta = await new LocalMetaService(pikkuDir).getWorkflowMeta()
+    assert.deepEqual(Object.keys(meta).sort(), [
+      'codeEditorScenario',
+      'orderWorkflow',
+    ])
+    assert.equal(meta['codeEditorScenario']!.source, 'scenario')
+  })
+
+  test('a scenario step is still a function to whoever reads the meta', async () => {
+    const meta = await new LocalMetaService(pikkuDir).getFunctionsMeta()
+    assert.deepEqual(Object.keys(meta).sort(), ['createTodo', 'opensPage'])
+    assert.equal(meta['opensPage']!.scenarioStep, true)
+  })
+
+  test('a project with no scenarios reads exactly what it has', async () => {
+    const empty = await mkdtemp(join(tmpdir(), 'pikku-meta-empty-'))
+    await mkdir(join(empty, 'workflow', 'meta'), { recursive: true })
+    await writeFile(
+      join(empty, 'workflow', 'meta', 'orderWorkflow.gen.json'),
+      JSON.stringify({ name: 'orderWorkflow', source: 'dsl' })
+    )
+
+    const service = new LocalMetaService(empty)
+    assert.deepEqual(Object.keys(await service.getWorkflowMeta()), [
+      'orderWorkflow',
+    ])
+    assert.deepEqual(Object.keys(await service.getFunctionsMeta()), [])
+
+    await rm(empty, { recursive: true, force: true })
+  })
+})

package/src/services/meta-service.ts

@@ -13,7 +13,10 @@ import type {
   MCPToolMeta,
   MCPPromptMeta,
 } from '../wirings/mcp/mcp.types.js'
-import type { WorkflowsMeta } from '../wirings/workflow/workflow.types.js'
+import type {
+  FeaturesMeta,
+  WorkflowsMeta,
+} from '../wirings/workflow/workflow.types.js'
 import type { ScenarioActorConfig } from './scenario-actors-service.js'
 import type {
   TriggerMeta,
@@ -186,6 +189,7 @@ export interface MetaService {
   getRpcMeta(): Promise<RPCMetaRecord>
   getWorkflowMeta(): Promise<WorkflowsMeta>
   getScenarioActorsMeta(): Promise<Record<string, ScenarioActorConfig>>
+  getFeaturesMeta(): Promise<FeaturesMeta>
   getTriggerMeta(): Promise<TriggerMeta>
   getTriggerSourceMeta(): Promise<TriggerSourceMeta>
   getFunctionsMeta(): Promise<FunctionsMeta>
@@ -226,6 +230,7 @@ export class LocalMetaService implements MetaService {
   private workflowMetaCache: WorkflowsMeta | null = null
   private scenarioActorsMetaCache: Record<string, ScenarioActorConfig> | null =
     null
+  private featuresMetaCache: FeaturesMeta | null = null
   private triggerMetaCache: TriggerMeta | null = null
   private triggerSourceMetaCache: TriggerSourceMeta | null = null
   private functionsMetaCache: FunctionsMeta | null = null
@@ -328,6 +333,7 @@ export class LocalMetaService implements MetaService {
     this.rpcMetaCache = null
     this.workflowMetaCache = null
     this.scenarioActorsMetaCache = null
+    this.featuresMetaCache = null
     this.triggerMetaCache = null
     this.triggerSourceMetaCache = null
     this.functionsMetaCache = null
@@ -456,34 +462,47 @@ export class LocalMetaService implements MetaService {
     }
   }
 
+  private async readWorkflowMetaDir(
+    dir: string,
+    into: WorkflowsMeta
+  ): Promise<void> {
+    const files = await this.readDir(dir)
+    const jsonFiles = files.filter((f) => f.endsWith('.gen.json'))
+    const verboseFiles = jsonFiles.filter((f) => f.includes('-verbose'))
+    const minimalFiles = jsonFiles.filter((f) => !f.includes('-verbose'))
+    const verboseNames = new Set(
+      verboseFiles.map((f) => f.replace('-verbose.gen.json', ''))
+    )
+    const filesToRead = [
+      ...verboseFiles,
+      ...minimalFiles.filter(
+        (f) => !verboseNames.has(f.replace('.gen.json', ''))
+      ),
+    ]
+
+    await Promise.all(
+      filesToRead.map(async (file) => {
+        const content = await this.readFile(`${dir}/${file}`)
+        if (content) {
+          const meta = JSON.parse(content)
+          into[meta.name] = meta
+        }
+      })
+    )
+  }
+
   async getWorkflowMeta(): Promise<WorkflowsMeta> {
     if (this.workflowMetaCache) return this.workflowMetaCache
 
     try {
-      const files = await this.readDir('workflow/meta')
-      const jsonFiles = files.filter((f) => f.endsWith('.gen.json'))
-      const verboseFiles = jsonFiles.filter((f) => f.includes('-verbose'))
-      const minimalFiles = jsonFiles.filter((f) => !f.includes('-verbose'))
-      const verboseNames = new Set(
-        verboseFiles.map((f) => f.replace('-verbose.gen.json', ''))
-      )
-      const filesToRead = [
-        ...verboseFiles,
-        ...minimalFiles.filter(
-          (f) => !verboseNames.has(f.replace('.gen.json', ''))
-        ),
-      ]
-
       const result: WorkflowsMeta = {}
-      await Promise.all(
-        filesToRead.map(async (file) => {
-          const content = await this.readFile(`workflow/meta/${file}`)
-          if (content) {
-            const meta = JSON.parse(content)
-            result[meta.name] = meta
-          }
-        })
-      )
+      // Scenarios keep their meta in `scenarios/meta` so nothing app-facing
+      // imports them, but they are still workflows to anything reading meta off
+      // disk — the console's scenario list among them.
+      await Promise.all([
+        this.readWorkflowMetaDir('workflow/meta', result),
+        this.readWorkflowMetaDir('scenarios/meta', result),
+      ])
 
       this.workflowMetaCache = result
       return this.workflowMetaCache
@@ -502,6 +521,14 @@ export class LocalMetaService implements MetaService {
     return this.scenarioActorsMetaCache!
   }
 
+  async getFeaturesMeta(): Promise<FeaturesMeta> {
+    if (this.featuresMetaCache) return this.featuresMetaCache
+
+    const content = await this.readFile('scenarios/features.gen.json')
+    this.featuresMetaCache = content ? JSON.parse(content) : {}
+    return this.featuresMetaCache!
+  }
+
   async getTriggerMeta(): Promise<TriggerMeta> {
     if (this.triggerMetaCache) return this.triggerMetaCache
 
@@ -527,8 +554,16 @@ export class LocalMetaService implements MetaService {
   async getFunctionsMeta(): Promise<FunctionsMeta> {
     if (this.functionsMetaCache) return this.functionsMetaCache
 
-    const content = await this.readMetaJson('function', 'pikku-functions-meta')
-    this.functionsMetaCache = content ? JSON.parse(content) : {}
+    const [content, scenarioContent] = await Promise.all([
+      this.readMetaJson('function', 'pikku-functions-meta'),
+      // Scenario steps register only into the scenario bootstrap, but they are
+      // still functions to anything reading meta off disk.
+      this.readMetaJson('scenarios', 'pikku-scenario-functions-meta'),
+    ])
+    this.functionsMetaCache = {
+      ...(content ? JSON.parse(content) : {}),
+      ...(scenarioContent ? JSON.parse(scenarioContent) : {}),
+    }
     return this.functionsMetaCache!
   }