npm - @pikku/core - Versions diffs - 0.12.69 → 0.12.71 - Mend

@pikku/core 0.12.69 → 0.12.71

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (118) hide show

package/CHANGELOG.md +422 -0
package/LICENSE +21 -0
package/README.md +34 -2
package/dist/function/functions.types.d.ts +27 -0
package/dist/index.d.ts +1 -1
package/dist/internal.d.ts +1 -1
package/dist/internal.js +1 -1
package/dist/pikku-state.js +1 -0
package/dist/services/http-scenario-actors.d.ts +12 -4
package/dist/services/http-scenario-actors.js +47 -45
package/dist/services/in-memory-queue-service.d.ts +6 -0
package/dist/services/in-memory-queue-service.js +8 -1
package/dist/services/in-memory-workflow-service.d.ts +3 -5
package/dist/services/in-memory-workflow-service.js +10 -19
package/dist/services/index.d.ts +2 -1
package/dist/services/index.js +1 -0
package/dist/services/meta-service.d.ts +5 -1
package/dist/services/meta-service.js +44 -18
package/dist/services/scenario-actors-service.d.ts +108 -2
package/dist/services/scenario-actors-service.js +40 -1
package/dist/services/workflow-service.d.ts +7 -5
package/dist/types/core.types.d.ts +28 -3
package/dist/types/state.types.d.ts +3 -1
package/dist/wirings/actor-flow/actor-flow.types.d.ts +1 -1
package/dist/wirings/actor-flow/index.d.ts +1 -1
package/dist/wirings/actor-flow/run-conversation.d.ts +10 -10
package/dist/wirings/actor-flow/run-conversation.js +27 -27
package/dist/wirings/ai-agent/ai-agent-agui.js +0 -8
package/dist/wirings/ai-agent/ai-agent-prepare.js +1 -2
package/dist/wirings/ai-agent/ai-agent.types.d.ts +0 -6
package/dist/wirings/cli/command-parser.js +11 -1
package/dist/wirings/rpc/rpc-runner.js +1 -1
package/dist/wirings/workflow/dsl/workflow-dsl.types.d.ts +52 -3
package/dist/wirings/workflow/feature.d.ts +28 -0
package/dist/wirings/workflow/feature.js +57 -0
package/dist/wirings/workflow/graph/graph-runner.js +3 -2
package/dist/wirings/workflow/graph/graph-validation.d.ts +0 -2
package/dist/wirings/workflow/graph/graph-validation.js +0 -142
package/dist/wirings/workflow/graph/index.d.ts +1 -1
package/dist/wirings/workflow/graph/index.js +1 -1
package/dist/wirings/workflow/index.d.ts +13 -3
package/dist/wirings/workflow/index.js +15 -2
package/dist/wirings/workflow/pikku-scenario-service.d.ts +121 -0
package/dist/wirings/workflow/pikku-scenario-service.js +419 -0
package/dist/wirings/workflow/pikku-workflow-service.d.ts +170 -23
package/dist/wirings/workflow/pikku-workflow-service.js +338 -297
package/dist/wirings/workflow/scenario-cookie-jar.d.ts +29 -0
package/dist/wirings/workflow/scenario-cookie-jar.js +51 -0
package/dist/wirings/workflow/scenario-poll.d.ts +20 -0
package/dist/wirings/workflow/scenario-poll.js +25 -0
package/dist/wirings/workflow/scenario-prose.d.ts +38 -0
package/dist/wirings/workflow/scenario-prose.js +45 -0
package/dist/wirings/workflow/scenario-step-guards.d.ts +16 -0
package/dist/wirings/workflow/scenario-step-guards.js +29 -0
package/dist/wirings/workflow/scenario-step.types.d.ts +148 -0
package/dist/wirings/workflow/scenario-step.types.js +1 -0
package/dist/wirings/workflow/workflow.types.d.ts +82 -8
package/package.json +3 -1
package/src/function/functions.types.ts +32 -0
package/src/index.ts +1 -0
package/src/internal.ts +5 -1
package/src/pikku-state.ts +1 -0
package/src/services/http-scenario-actors.test.ts +85 -1
package/src/services/http-scenario-actors.ts +65 -51
package/src/services/in-memory-queue-service.test.ts +66 -1
package/src/services/in-memory-queue-service.ts +13 -2
package/src/services/in-memory-workflow-service.ts +12 -25
package/src/services/index.ts +5 -0
package/src/services/meta-service.test.ts +79 -0
package/src/services/meta-service.ts +61 -26
package/src/services/scenario-actors-service.ts +157 -2
package/src/services/workflow-service.ts +7 -4
package/src/types/core.types.ts +34 -2
package/src/types/state.types.ts +3 -0
package/src/wirings/actor-flow/actor-flow.types.ts +1 -1
package/src/wirings/actor-flow/index.ts +1 -1
package/src/wirings/actor-flow/run-conversation.test.ts +12 -6
package/src/wirings/actor-flow/run-conversation.ts +36 -41
package/src/wirings/ai-agent/ai-agent-agui.test.ts +0 -16
package/src/wirings/ai-agent/ai-agent-agui.ts +0 -9
package/src/wirings/ai-agent/ai-agent-prepare.ts +1 -2
package/src/wirings/ai-agent/ai-agent.types.ts +0 -7
package/src/wirings/cli/command-parser.test.ts +60 -0
package/src/wirings/cli/command-parser.ts +12 -1
package/src/wirings/rpc/rpc-runner.test.ts +28 -5
package/src/wirings/rpc/rpc-runner.ts +1 -1
package/src/wirings/workflow/dsl/workflow-dsl.types.ts +86 -2
package/src/wirings/workflow/feature.test.ts +131 -0
package/src/wirings/workflow/feature.ts +78 -0
package/src/wirings/workflow/graph/graph-runner.ts +3 -2
package/src/wirings/workflow/graph/graph-validation.test.ts +1 -144
package/src/wirings/workflow/graph/graph-validation.ts +0 -196
package/src/wirings/workflow/graph/index.ts +1 -5
package/src/wirings/workflow/index.ts +73 -6
package/src/wirings/workflow/pikku-scenario-service.ts +682 -0
package/src/wirings/workflow/pikku-workflow-service.test.ts +55 -0
package/src/wirings/workflow/pikku-workflow-service.ts +572 -419
package/src/wirings/workflow/scenario-cookie-jar.test.ts +108 -0
package/src/wirings/workflow/scenario-cookie-jar.ts +65 -0
package/src/wirings/workflow/scenario-expectations.test.ts +153 -0
package/src/wirings/workflow/scenario-hooks.test.ts +212 -0
package/src/wirings/workflow/scenario-poll.test.ts +66 -0
package/src/wirings/workflow/scenario-poll.ts +36 -0
package/src/wirings/workflow/scenario-prose.test.ts +152 -0
package/src/wirings/workflow/scenario-prose.ts +79 -0
package/src/wirings/workflow/scenario-service.test.ts +155 -0
package/src/wirings/workflow/scenario-step-guards.ts +43 -0
package/src/wirings/workflow/scenario-step.test.ts +442 -9
package/src/wirings/workflow/scenario-step.types.ts +157 -0
package/src/wirings/workflow/workflow-dispatch-durability.test.ts +1 -1
package/src/wirings/workflow/workflow-dispatch-payload.test.ts +59 -0
package/src/wirings/workflow/workflow-mirror.test.ts +178 -0
package/src/wirings/workflow/workflow-replay-snapshot.test.ts +139 -0
package/src/wirings/workflow/workflow-run-context.test.ts +177 -0
package/src/wirings/workflow/workflow-run-polling.test.ts +132 -0
package/src/wirings/workflow/workflow-step-ordinal.test.ts +4 -4
package/src/wirings/workflow/workflow.types.ts +99 -5
package/tsconfig.tsbuildinfo +1 -1

package/src/services/http-scenario-actors.test.ts CHANGED Viewed

@@ -38,11 +38,27 @@ const startTarget = async () => {
           res.writeHead(401).end()
           return
         }
+        const rpcName = req.url.slice('/api/rpc/'.length)
+        if (rpcName === 'html-error') {
+          res
+            .writeHead(500, { 'content-type': 'text/html' })
+            .end('<html><body>Gateway blew up</body></html>')
+          return
+        }
+        if (rpcName === 'forbidden') {
+          res
+            .writeHead(403, { 'content-type': 'application/json' })
+            .end(
+              JSON.stringify({ message: 'MissingScopeError', scope: 'admin' })
+            )
+          return
+        }
         res.writeHead(200, { 'content-type': 'application/json' }).end(
           JSON.stringify({
-            rpcName: req.url.slice('/api/rpc/'.length),
+            rpcName,
             echoed: body.data,
             cookie,
+            userHeader: req.headers['x-user-id'] ?? null,
           })
         )
         return
@@ -115,6 +131,74 @@ describe('HttpScenarioActor', async () => {
     assert.match(result.cookie, new RegExp(`session=s${loginsBefore + 1}`))
   })
+  test('invokeRaw returns the status and body instead of throwing', async () => {
+    const actors = makeActors()
+    // A refusal is the expected outcome of a permissions scenario, so the
+    // status and the payload that names the missing scope both have to survive.
+    const res = await actors.customer!.invokeRaw('forbidden', {})
+    assert.equal(res.status, 403)
+    assert.equal(res.ok, false)
+    assert.deepEqual(res.body, {
+      message: 'MissingScopeError',
+      scope: 'admin',
+    })
+  })
+  test('invokeRaw reports a success the same way', async () => {
+    const actors = makeActors()
+    const res = await actors.manager!.invokeRaw('listTodos', { page: 2 })
+    assert.equal(res.status, 200)
+    assert.equal(res.ok, true)
+    assert.deepEqual((res.body as any).echoed, { page: 2 })
+  })
+  test('invokeRaw carries the response text so a step can search it', async () => {
+    const actors = makeActors()
+    const res = await actors.customer!.invokeRaw('forbidden', {})
+    assert.match(res.serialized, /MissingScopeError/)
+    assert.match(res.serialized, /admin/)
+  })
+  test('invokeRaw keeps a non-JSON error body instead of failing to parse it', async () => {
+    const actors = makeActors()
+    const res = await actors.manager!.invokeRaw('html-error', {})
+    assert.equal(res.status, 500)
+    assert.equal(res.ok, false)
+    assert.equal(res.body, '<html><body>Gateway blew up</body></html>')
+    assert.match(res.serialized, /Gateway blew up/)
+  })
+  test('invokeRaw reports an empty body as an empty string', async () => {
+    const actors = makeActors()
+    const res = await actors.manager!.invokeRaw('listTodos', {})
+    assert.equal(typeof res.serialized, 'string')
+  })
+  test('invokeRaw passes extra headers through', async () => {
+    const actors = makeActors()
+    const res = await actors.manager!.invokeRaw(
+      'whoAmI',
+      {},
+      { headers: { 'x-user-id': 'impersonated-1' } }
+    )
+    assert.equal((res.body as any).userHeader, 'impersonated-1')
+  })
+  test('invoke still throws on a refusal, naming the status and body', async () => {
+    const actors = makeActors()
+    await assert.rejects(
+      actors.customer!.invoke('forbidden', {}),
+      /'forbidden' as 'customer' returned 403.*MissingScopeError/
+    )
+  })
   test('a wrong impersonation secret surfaces status and body', async () => {
     const actors = makeActors('wrong-secret')
     await assert.rejects(

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

@@ -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-queue-service.test.ts CHANGED Viewed

@@ -23,7 +23,10 @@ const registerWorker = (
 ) => {
   const calls = { count: 0 }
   const funcId = `queue_${queueName}`
-  pikkuState(null, 'queue', 'meta')[queueName] = { pikkuFuncId: funcId, name: queueName }
+  pikkuState(null, 'queue', 'meta')[queueName] = {
+    pikkuFuncId: funcId,
+    name: queueName,
+  }
   pikkuState(null, 'function', 'meta')[funcId] = {
     pikkuFuncId: funcId,
     inputSchemaName: null,
@@ -55,6 +58,68 @@ const waitUntil = async (
   return predicate()
 }
+// Register a queue worker that records the payload each delivery carried.
+const registerRecordingWorker = (queueName: string) => {
+  const received: any[] = []
+  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 (_services: any, data: any) => {
+        received.push(data)
+      },
+    },
+  } as any)
+  return received
+}
+describe('InMemoryQueueService payload isolation', () => {
+  test('a job carries the payload as it was when added', async () => {
+    const received = registerRecordingWorker('mutated')
+    const queue = new InMemoryQueueService()
+    const payload = { items: ['a'] }
+    await queue.add('mutated', payload, { delay: 0 })
+    payload.items.push('b')
+    assert.equal(await waitUntil(() => received.length === 1), true)
+    assert.deepEqual(
+      received[0].items,
+      ['a'],
+      'the worker saw a mutation made after the job was queued — a real queue would have serialised it away'
+    )
+  })
+  test('a payload arrives shaped the way a real queue would deliver it', async () => {
+    const received = registerRecordingWorker('serialised')
+    const queue = new InMemoryQueueService()
+    await queue.add(
+      'serialised',
+      { when: new Date('2020-01-01T00:00:00.000Z') },
+      { delay: 0 }
+    )
+    assert.equal(await waitUntil(() => received.length === 1), true)
+    assert.equal(
+      received[0].when,
+      '2020-01-01T00:00:00.000Z',
+      'a Date survived as a Date, so dev behaviour diverges from every real queue backend'
+    )
+  })
+})
 describe('InMemoryQueueService retry', () => {
   test('redelivers a transiently-failing job until it succeeds', async () => {
     const calls = registerWorker('flaky', (count) => {

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

@@ -11,6 +11,12 @@ import { runQueueJob } from '../wirings/queue/queue-runner.js'
  * 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.
+ *
+ * Payloads are JSON round-tripped on the way in, because every real backend
+ * puts the job on a wire (SQS body, Redis value, jsonb column) and the worker
+ * therefore never sees the caller's live object. Doing it here keeps dev
+ * behaviour honest, and keeps the callers — who cannot know which backend they
+ * are talking to — from having to serialise defensively.
  */
 export class InMemoryQueueService implements QueueService {
   readonly supportsResults = false
@@ -25,13 +31,15 @@ export class InMemoryQueueService implements QueueService {
     const maxAttempts = Math.max(1, options?.attempts ?? 1)
     let attemptsMade = 0
     const createdAt = new Date()
+    const payload: T =
+      data === undefined ? data : (JSON.parse(JSON.stringify(data)) as T)
     const runAttempt = async () => {
       attemptsMade++
       const job: QueueJob<T> = {
         id: jobId,
         queueName,
-        data,
+        data: payload,
         status: () => 'active',
         metadata: () => ({ attemptsMade, maxAttempts, createdAt }),
         pikkuUserId: options?.pikkuUserId,
@@ -41,7 +49,10 @@ export class InMemoryQueueService implements QueueService {
       } catch (e: any) {
         if (attemptsMade < maxAttempts) {
           // Transient failure — redeliver with backoff, mirroring a real queue.
-          setTimeout(runAttempt, this.backoffDelay(options?.backoff, attemptsMade))
+          setTimeout(
+            runAttempt,
+            this.backoffDelay(options?.backoff, attemptsMade)
+          )
         } else {
           console.error(
             `[InMemoryQueue] Job ${jobId} on ${queueName} failed after ${attemptsMade} attempt(s):`,

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

@@ -456,6 +456,18 @@ export class InMemoryWorkflowService
     return nodeIds.filter((id) => !existingSteps.has(id))
   }
+  protected override async listStepStates(
+    runId: string
+  ): Promise<Array<StepState & { stepName: string }>> {
+    const prefix = `${runId}:`
+    const steps: Array<StepState & { stepName: string }> = []
+    for (const [key, step] of this.steps.entries()) {
+      if (!key.startsWith(prefix)) continue
+      steps.push({ ...step, stepName: key.substring(prefix.length) })
+    }
+    return steps
+  }
   async getStepInstances(
     runId: string
   ): Promise<
@@ -560,29 +572,4 @@ export class InMemoryWorkflowService
     if (!version) return null
     return { graph: version.graph, source: version.source }
   }
-  async getAIGeneratedWorkflows(
-    agentName?: string
-  ): Promise<Array<{ workflowName: string; graphHash: string; graph: any }>> {
-    const results: Array<{
-      workflowName: string
-      graphHash: string
-      graph: any
-    }> = []
-    const prefix = agentName ? `ai:${agentName}:` : 'ai:'
-    for (const [key, value] of this.workflowVersions) {
-      if (value.source !== 'ai-agent' || value.status !== 'active') continue
-      const separatorIdx = key.lastIndexOf(':')
-      const wfName = key.substring(0, separatorIdx)
-      const hash = key.substring(separatorIdx + 1)
-      if (wfName.startsWith(prefix)) {
-        results.push({
-          workflowName: wfName,
-          graphHash: hash,
-          graph: value.graph,
-        })
-      }
-    }
-    return results
-  }
 }

package/src/services/index.ts CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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 })
+  })
+})