@pikku/core 0.12.80 → 0.12.82

package/src/wirings/mcp/mcp-runner.test.ts

@@ -9,8 +9,11 @@ import {
   wireMCPPrompt,
   wireMCPResource,
 } from './mcp-runner.js'
+import { addGlobalMiddleware } from '../../middleware-runner.js'
 import { addFunction } from '../../function/function-runner.js'
 import { pikkuState, resetPikkuState } from '../../pikku-state.js'
+import { pikkuMiddleware } from '../../types/core.types.js'
+import { addTagMiddleware } from '../../middleware-runner.js'
 
 const logger = {
   debug: () => {},
@@ -166,6 +169,49 @@ describe('runMCPResource', () => {
       },
     })
   })
+
+  test('runs a templated resource middleware when invoked by concrete uri', async () => {
+    let middlewareRan = false
+    // A tag-derived middleware group (this is where a tag-based auth gate lands).
+    addTagMiddleware('secure', [
+      pikkuMiddleware(async (_services, _wire, next) => {
+        middlewareRan = true
+        await next()
+      }),
+    ])
+    pikkuState(null, 'mcp', 'resourcesMeta')['resource://secure/{id}'] = {
+      uri: 'resource://secure/{id}',
+      title: 'Secure',
+      description: 'Secure',
+      pikkuFuncId: 'secureResourceFunc',
+      inputSchema: null,
+      outputSchema: null,
+      // The resource's merged middleware metadata. It must resolve for a concrete
+      // request against the template, or the resource is reachable with its gate
+      // skipped.
+      middleware: [{ type: 'tag', tag: 'secure' }],
+    } as never
+    registerFunction('secureResourceFunc', async () => ({ ok: true }))
+
+    wireMCPResource({
+      uri: 'resource://secure/{id}',
+      title: 'Secure',
+      description: 'Secure',
+      func: { func: async () => ({ ok: true }) } as never,
+    })
+
+    await runMCPResource(
+      { jsonrpc: '2.0', id: 'req-2', params: {} },
+      { mcp: mcpWire as never },
+      'resource://secure/99'
+    )
+
+    assert.equal(
+      middlewareRan,
+      true,
+      'the templated resource middleware must run for a concrete uri'
+    )
+  })
 })
 
 describe('runMCPTool', () => {
@@ -371,6 +417,141 @@ describe('runMCPTool', () => {
   })
 })
 
+describe("MCP carries the caller's HTTP request", () => {
+  // Without this, every auth middleware bails on its first line — each one
+  // opens with `if (!http?.request) return`, so an MCP call arrived at the
+  // function with no session, and a tool fronting a session-requiring function
+  // answered 'Authentication required' to every caller. Nothing else was
+  // missing: global middleware already runs for MCP, and the runner already
+  // builds a session service. Only the request was being dropped.
+  test('exposes http on the wire so session middleware can read it', async () => {
+    pikkuState(null, 'mcp', 'toolsMeta').whoami = {
+      name: 'whoami',
+      title: 'Who am I',
+      description: 'Who am I',
+      pikkuFuncId: 'whoamiFunc',
+      inputSchema: null,
+      outputSchema: 'MCPToolResponse',
+    } as never
+
+    let seenAuthorization: string | undefined
+    registerFunction('whoamiFunc', async (_services, _data, wire) => {
+      seenAuthorization = wire.http?.request?.header('authorization')
+      return [{ type: 'text', text: seenAuthorization ?? 'anonymous' }]
+    })
+
+    const http = {
+      request: {
+        header: (name: string) =>
+          name.toLowerCase() === 'authorization'
+            ? 'Bearer token-abc'
+            : undefined,
+      },
+    }
+
+    const response = await runMCPTool(
+      { jsonrpc: '2.0', id: 'req-http', params: {} },
+      { mcp: mcpWire as never, http: http as never },
+      'whoami'
+    )
+
+    assert.equal(seenAuthorization, 'Bearer token-abc')
+    assert.deepEqual(response, {
+      id: 'req-http',
+      result: [{ type: 'text', text: 'Bearer token-abc' }],
+    })
+  })
+
+  test('omitting http leaves the wire without one rather than inventing it', async () => {
+    pikkuState(null, 'mcp', 'toolsMeta').anon = {
+      name: 'anon',
+      title: 'Anon',
+      description: 'Anon',
+      pikkuFuncId: 'anonFunc',
+      inputSchema: null,
+      outputSchema: 'MCPToolResponse',
+    } as never
+
+    let sawHttp: unknown = 'unset'
+    registerFunction('anonFunc', async (_services, _data, wire) => {
+      sawHttp = wire.http
+      return [{ type: 'text', text: 'ok' }]
+    })
+
+    await runMCPTool(
+      { jsonrpc: '2.0', id: 'req-anon', params: {} },
+      { mcp: mcpWire as never },
+      'anon'
+    )
+
+    assert.equal(sawHttp, undefined)
+  })
+})
+
+describe('MCP tools fronting a session-requiring function', () => {
+  // The whole point of carrying the request: this is the template failure,
+  // reproduced. `listRoomsTool` and five others front a `pikkuFunc`, which
+  // requires a session, and answered 'Authentication required' to every caller
+  // because no request ever reached the middleware that would have set one.
+  test('receive the session set by global middleware from the request', async () => {
+    addGlobalMiddleware([
+      async (_services, wire, next) => {
+        const header = wire.http?.request?.header('authorization')
+        if (header === 'Bearer token-abc') {
+          wire.setSession?.({ userId: 'usr_1', name: 'Rafa' } as never)
+        }
+        await next()
+      },
+    ] as never)
+
+    pikkuState(null, 'mcp', 'toolsMeta').listRooms = {
+      name: 'listRooms',
+      title: 'List rooms',
+      description: 'List rooms',
+      pikkuFuncId: 'listRoomsFunc',
+      inputSchema: null,
+      outputSchema: 'MCPToolResponse',
+    } as never
+
+    // sessionless: false — the distinction that made these tools fail.
+    addFunction(
+      'listRoomsFunc',
+      {
+        func: async (_services: any, _data: any, wire: any) => [
+          { type: 'text', text: wire.session?.userId ?? 'anonymous' },
+        ],
+      } as never,
+      null
+    )
+    pikkuState(null, 'function', 'meta').listRoomsFunc = {
+      name: 'listRoomsFunc',
+      sessionless: false,
+      permissions: [],
+    } as never
+
+    const response = await runMCPTool(
+      { jsonrpc: '2.0', id: 'req-session', params: {} },
+      {
+        mcp: mcpWire as never,
+        http: {
+          request: {
+            header: (name: string) =>
+              name.toLowerCase() === 'authorization'
+                ? 'Bearer token-abc'
+                : undefined,
+          },
+        } as never,
+      },
+      'listRooms'
+    )
+
+    assert.deepEqual(response, {
+      id: 'req-session',
+      result: [{ type: 'text', text: 'usr_1' }],
+    })
+  })
+})
+
 describe('runMCPPrompt', () => {
   test('maps missing prompt registration to not found MCP errors', async () => {
     pikkuState(null, 'mcp', 'promptsMeta').missingPrompt = {

package/src/wirings/mcp/mcp-runner.ts

@@ -1,4 +1,5 @@
 import type { PikkuRawWire } from '../../types/core.types.js'
+import type { PikkuHTTP } from '../http/http.types.js'
 import type {
   CoreMCPResource,
   CoreMCPPrompt,
@@ -35,6 +36,20 @@ export class MCPError extends Error {
 
 export type RunMCPEndpointParams<Tools extends string = any> = {
   mcp?: PikkuMCP<Tools>
+  /**
+   * The HTTP request the MCP call arrived on, when it arrived over HTTP.
+   *
+   * Auth middleware reads the session off `wire.http.request` — every
+   * implementation opens with `if (!http?.request) return` — so without this an
+   * MCP call reaches the function unauthenticated no matter what middleware the
+   * app has registered, and a tool fronting a session-requiring function can
+   * only ever answer 'Authentication required'.
+   *
+   * Left undefined for transports that have no request to offer, such as stdio.
+   * Those remain anonymous, which is a property of the transport rather than a
+   * default chosen here.
+   */
+  http?: PikkuHTTP
   /** Defaults to enabled outside production. */
   exposeErrors?: boolean
 }
@@ -97,6 +112,12 @@ export async function runMCPResource(
   const metas = pikkuState(null, 'mcp', 'resourcesMeta')
   const endpoints = pikkuState(null, 'mcp', 'resources')
 
+  // The key the resource's meta (and its middleware) is stored under. For a
+  // templated resource this is the template, not the concrete request URI — so
+  // it must be carried forward, or the meta lookup downstream misses and the
+  // resource's declared middleware (including auth) is silently skipped.
+  let metaKey = uri
+
   if (endpoints.has(uri)) {
     endpoint = endpoints.get(uri)
     pikkuFuncId = metas[uri]?.pikkuFuncId
@@ -113,6 +134,7 @@ export async function runMCPResource(
 
       if (match) {
         endpoint = value
+        metaKey = uriTemplate
         pikkuFuncId = metas[uriTemplate]?.pikkuFuncId
 
         for (let i = 0; i < paramNames.length; i++) {
@@ -134,7 +156,8 @@ export async function runMCPResource(
     pikkuFuncId,
     { ...params, mcp: { ...params.mcp, uri } } as RunMCPEndpointParams<
       keyof CoreMCPResource
-    >
+    >,
+    metaKey
   )
 }
 
@@ -177,7 +200,11 @@ async function runMCPPikkuFunc(
   name: string,
   mcp: CoreMCPResource | CoreMCPPrompt | undefined,
   pikkuFuncId: string | undefined,
-  { mcp: mcpWire, exposeErrors = !isProduction() }: RunMCPEndpointParams
+  { mcp: mcpWire, http, exposeErrors = !isProduction() }: RunMCPEndpointParams,
+  // The key the endpoint's meta is stored under. Differs from `name` only for a
+  // templated resource, where `name` is the concrete URI and the meta lives
+  // under the template. Defaults to `name` for tools and prompts.
+  metaKey: string = name
 ): Promise<JsonRpcResponse> {
   const singletonServices = getSingletonServices()
   const createWireServices = getCreateWireServices()
@@ -208,16 +235,19 @@ async function runMCPPikkuFunc(
     )
     const wire: PikkuRawWire = {
       mcp: mcpWire,
+      // Only when the transport supplied one. Setting `http: undefined`
+      // explicitly would be the same to a reader and different to a spread.
+      ...(http ? { http } : {}),
       ...createMiddlewareSessionWireProps(mcpSessionService),
     }
 
     let meta: any
     if (type === 'resource') {
-      meta = pikkuState(null, 'mcp', 'resourcesMeta')[name]
+      meta = pikkuState(null, 'mcp', 'resourcesMeta')[metaKey]
     } else if (type === 'tool') {
-      meta = pikkuState(null, 'mcp', 'toolsMeta')[name]
+      meta = pikkuState(null, 'mcp', 'toolsMeta')[metaKey]
     } else if (type === 'prompt') {
-      meta = pikkuState(null, 'mcp', 'promptsMeta')[name]
+      meta = pikkuState(null, 'mcp', 'promptsMeta')[metaKey]
     }
 
     let resolvedFuncName = pikkuFuncId

package/src/wirings/persona/index.ts

@@ -10,7 +10,6 @@ export type { RoleVerification } from './validate-personas.js'
 export {
   personaEnvironmentErrors,
   personaEnvironmentRefusal,
-  resolvePersonaEnvironments,
 } from './persona-environments.js'
 export type {
   PersonaEnvironment,
@@ -18,14 +17,8 @@ export type {
 } from './persona-environments.js'
 export {
   personaEmail,
-  personaEmailLabel,
   personaEmails,
 } from './persona-email.js'
-export {
-  allowedLinks,
-  applyMailboxAllowlist,
-  isAllowedSender,
-} from './persona-mailbox.js'
 export type {
   MailboxAllowlist,
   PersonaMailbox,
@@ -33,7 +26,6 @@ export type {
 } from './persona-mailbox.js'
 export type {
   CorePersona,
-  CorePersonaAccount,
   CorePersonas,
   PersonaAccountMeta,
   PersonaDefinitions,

package/src/wirings/queue/index.ts

@@ -17,26 +17,12 @@ export type {
 export {
   wireQueueWorker,
   runQueueJob,
-  getQueueWorkers,
-  removeQueueWorker,
   QueueJobDiscardedError,
   QueueJobFailedError,
 } from './queue-runner.js'
-
-export {
-  QUEUE_IDENTITY_CLAIM_VERSION,
-  QUEUE_IDENTITY_INFO,
-  QUEUE_IDENTITY_SECRET_NAME,
-  getQueueIdentitySecret,
-  resolveQueueJobIdentity,
-  signQueueIdentity,
-  verifyQueueIdentity,
-} from './queue-identity.js'
 export type { QueueIdentityBinding } from './queue-identity.js'
 
 export { SignedQueueService } from './signed-queue-service.js'
-
-export { validateWorkerConfig } from './validate-worker-config.js'
 export type { QueueConfigMapping } from './validate-worker-config.js'
 
 export { registerQueueWorkers } from './register-queue-helper.js'

package/src/wirings/rpc/addon-runner.ts

@@ -4,6 +4,8 @@ import type {
   CoreSingletonServices,
 } from '../../types/core.types.js'
 import type { SecretService } from '../../services/secret-service.js'
+import { ScopedSecretService } from '../../services/scoped-secret-service.js'
+import { ScopedCredentialService } from '../../services/scoped-credential-service.js'
 import type { VariablesService } from '../../services/variables-service.js'
 
 export type AddonInstance = {
@@ -11,6 +13,10 @@ export type AddonInstance = {
   secretOverrides?: Record<string, string>
   variableOverrides?: Record<string, string>
   credentialOverrides?: Record<string, string>
+  /** Set by the consuming app to opt this instance out of secret scoping. */
+  globalSecrets?: string
+  /** Set by the consuming app to opt this instance out of credential scoping. */
+  globalCredentials?: string
 }
 
 const aliasSecretService = (
@@ -111,9 +117,6 @@ export const getOrCreatePackageSingletonServices = async (
   }
 
   const factories = pikkuState(packageName, 'package', 'factories')
-  if (!factories || !factories.createSingletonServices) {
-    return parentServices
-  }
 
   let existingServices = parentServices
   if (addonInstance?.secretOverrides && parentServices.secrets) {
@@ -134,6 +137,32 @@ export const getOrCreatePackageSingletonServices = async (
       ),
     }
   }
+  if (!addonInstance?.globalSecrets && existingServices.secrets) {
+    existingServices = {
+      ...existingServices,
+      secrets: new ScopedSecretService(
+        existingServices.secrets,
+        new Set(pikkuState(packageName, 'package', 'declaredSecrets') ?? [])
+      ),
+    }
+  }
+  if (!addonInstance?.globalCredentials && existingServices.credentialService) {
+    existingServices = {
+      ...existingServices,
+      credentialService: new ScopedCredentialService(
+        existingServices.credentialService,
+        new Set(
+          Object.keys(
+            pikkuState(packageName, 'package', 'credentialsMeta') ?? {}
+          )
+        )
+      ),
+    }
+  }
+
+  if (!factories || !factories.createSingletonServices) {
+    return existingServices
+  }
 
   let config: CoreConfig = existingServices.config
   if (factories.createConfig) {
@@ -173,5 +202,7 @@ export const addonInstanceForNamespace = (
     secretOverrides: cfg.secretOverrides,
     variableOverrides: cfg.variableOverrides,
     credentialOverrides: cfg.credentialOverrides,
+    globalSecrets: cfg.globalSecrets,
+    globalCredentials: cfg.globalCredentials,
   }
 }

package/src/wirings/rpc/addon-secrets.test.ts

@@ -0,0 +1,261 @@
+import { beforeEach, describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { pikkuState, resetPikkuState } from '../../pikku-state.js'
+import { getOrCreatePackageSingletonServices } from './addon-runner.js'
+import { wireAddon } from './wire-addon.js'
+import type { SecretService } from '../../services/secret-service.js'
+import type { CredentialService } from '../../services/credential-service.js'
+import type { CoreSingletonServices } from '../../types/core.types.js'
+
+const ADDON_PACKAGE = '@addon/example'
+
+const createSecretService = (): SecretService =>
+  ({
+    getSecret: async (key: string) => `value-of-${key}` as never,
+    hasSecret: async () => true,
+    setSecret: async () => {},
+    deleteSecret: async () => {},
+    getSecrets: async (keys: string[]) =>
+      Object.fromEntries(keys.map((k) => [k, `value-of-${k}`])) as never,
+  }) as SecretService
+
+const createCredentialService = (): CredentialService =>
+  ({
+    get: async (name: string) => `credential-of-${name}`,
+    set: async () => {},
+    delete: async () => {},
+    has: async () => true,
+    getAll: async () => ({ slack: 'a', stripe: 'b' }),
+    getUsersWithCredential: async () => ['user-1'],
+    getAllUsers: async () => ['user-1'],
+  }) as unknown as CredentialService
+
+const createParentServices = () =>
+  ({
+    config: {},
+    logger: {
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+    },
+    secrets: createSecretService(),
+    credentialService: createCredentialService(),
+  }) as unknown as CoreSingletonServices
+
+/**
+ * Registers an addon package whose singleton factory hands back whatever
+ * secrets service the host decided it should see.
+ */
+const registerAddon = (
+  declaredSecrets: string[] | null,
+  declaredCredentials?: string[]
+) => {
+  pikkuState(ADDON_PACKAGE, 'package', 'factories', {
+    createSingletonServices: (async (_config: unknown, parent: any) => ({
+      ...parent,
+      secretsSeenByAddon: parent.secrets,
+      credentialsSeenByAddon: parent.credentialService,
+    })) as never,
+  })
+  if (declaredSecrets) {
+    pikkuState(ADDON_PACKAGE, 'package', 'declaredSecrets', declaredSecrets)
+  }
+  if (declaredCredentials) {
+    pikkuState(
+      ADDON_PACKAGE,
+      'package',
+      'credentialsMeta',
+      Object.fromEntries(
+        declaredCredentials.map((name) => [
+          name,
+          { name, displayName: name, type: 'singleton' },
+        ])
+      )
+    )
+  }
+}
+
+const servicesHandedToAddon = async (namespace: string) =>
+  (await getOrCreatePackageSingletonServices(
+    ADDON_PACKAGE,
+    createParentServices(),
+    pikkuState(null, 'addons', 'packages').get(namespace) as never
+  )) as any
+
+const secretsHandedToAddon = async (namespace: string) =>
+  (await servicesHandedToAddon(namespace)).secretsSeenByAddon as SecretService
+
+const credentialsHandedToAddon = async (namespace: string) =>
+  (await servicesHandedToAddon(namespace))
+    .credentialsSeenByAddon as CredentialService
+
+describe('addon secrets are scoped to what the addon declared', () => {
+  beforeEach(() => {
+    resetPikkuState()
+  })
+
+  test('a declared secret is readable', async () => {
+    registerAddon(['ADDON_KEY'])
+    wireAddon({
+      name: 'example',
+      package: ADDON_PACKAGE,
+    })
+
+    const secrets = await secretsHandedToAddon('example')
+    assert.equal(await secrets.getSecret('ADDON_KEY'), 'value-of-ADDON_KEY')
+  })
+
+  test('an undeclared secret is denied', async () => {
+    registerAddon(['ADDON_KEY'])
+    wireAddon({
+      name: 'example',
+      package: ADDON_PACKAGE,
+    })
+
+    const secrets = await secretsHandedToAddon('example')
+    await assert.rejects(
+      () => secrets.getSecret('SOMEONE_ELSES_KEY'),
+      /denied/i
+    )
+  })
+
+  test('a scoped addon cannot write secrets', async () => {
+    registerAddon(['ADDON_KEY'])
+    wireAddon({
+      name: 'example',
+      package: ADDON_PACKAGE,
+    })
+
+    const secrets = await secretsHandedToAddon('example')
+    await assert.rejects(() => secrets.setSecret('ADDON_KEY', 'x'))
+  })
+
+  test('an addon that declares nothing is scoped to nothing', async () => {
+    registerAddon([])
+    wireAddon({
+      name: 'example',
+      package: ADDON_PACKAGE,
+    })
+
+    const secrets = await secretsHandedToAddon('example')
+    await assert.rejects(() => secrets.getSecret('ADDON_KEY'), /denied/i)
+  })
+
+  test('globalSecrets, set by the host, hands over the whole service', async () => {
+    registerAddon(['ADDON_KEY'])
+    wireAddon({
+      name: 'example',
+      package: ADDON_PACKAGE,
+      globalSecrets: 'administers secrets named by the operator at runtime',
+    })
+
+    const secrets = await secretsHandedToAddon('example')
+    assert.equal(
+      await secrets.getSecret('SOMEONE_ELSES_KEY'),
+      'value-of-SOMEONE_ELSES_KEY'
+    )
+    await assert.doesNotReject(() => secrets.setSecret('ADDON_KEY', 'x'))
+  })
+
+  test('an addon with no singleton factory is still scoped', async () => {
+    pikkuState(ADDON_PACKAGE, 'package', 'declaredSecrets', ['ADDON_KEY'])
+    wireAddon({
+      name: 'example',
+      package: ADDON_PACKAGE,
+    })
+
+    const services = await getOrCreatePackageSingletonServices(
+      ADDON_PACKAGE,
+      createParentServices(),
+      pikkuState(null, 'addons', 'packages').get('example') as never
+    )
+
+    assert.equal(
+      await services.secrets.getSecret('ADDON_KEY'),
+      'value-of-ADDON_KEY'
+    )
+    await assert.rejects(
+      () => services.secrets.getSecret('SOMEONE_ELSES_KEY'),
+      /denied/i
+    )
+  })
+
+  test('scoping applies to the key the addon asks for, not the aliased one', async () => {
+    registerAddon(['ADDON_KEY'])
+    wireAddon({
+      name: 'example',
+      package: ADDON_PACKAGE,
+      secretOverrides: { ADDON_KEY: 'PROD_ADDON_KEY' },
+    })
+
+    const secrets = await secretsHandedToAddon('example')
+    assert.equal(
+      await secrets.getSecret('ADDON_KEY'),
+      'value-of-PROD_ADDON_KEY'
+    )
+    await assert.rejects(() => secrets.getSecret('PROD_ADDON_KEY'), /denied/i)
+  })
+})
+
+describe('addon credentials are scoped to what the addon declared', () => {
+  beforeEach(() => {
+    resetPikkuState()
+  })
+
+  test('a declared credential is reachable', async () => {
+    registerAddon(['ADDON_KEY'], ['slack'])
+    wireAddon({ name: 'example', package: ADDON_PACKAGE })
+
+    const credentials = await credentialsHandedToAddon('example')
+    assert.equal(await credentials.get('slack'), 'credential-of-slack')
+  })
+
+  test('an undeclared credential is denied', async () => {
+    registerAddon(['ADDON_KEY'], ['slack'])
+    wireAddon({ name: 'example', package: ADDON_PACKAGE })
+
+    const credentials = await credentialsHandedToAddon('example')
+    await assert.rejects(() => credentials.get('stripe'), /denied/i)
+  })
+
+  test('a scoped addon cannot enumerate the app users', async () => {
+    registerAddon(['ADDON_KEY'], ['slack'])
+    wireAddon({ name: 'example', package: ADDON_PACKAGE })
+
+    const credentials = await credentialsHandedToAddon('example')
+    await assert.rejects(() => credentials.getAllUsers(), /denied/i)
+  })
+
+  test('an addon with no singleton factory is still scoped', async () => {
+    pikkuState(ADDON_PACKAGE, 'package', 'credentialsMeta', {
+      slack: { name: 'slack', displayName: 'slack', type: 'singleton' },
+    } as never)
+    wireAddon({ name: 'example', package: ADDON_PACKAGE })
+
+    const services = await getOrCreatePackageSingletonServices(
+      ADDON_PACKAGE,
+      createParentServices(),
+      pikkuState(null, 'addons', 'packages').get('example') as never
+    )
+    const credentials = services.credentialService as CredentialService
+
+    assert.equal(await credentials.get('slack'), 'credential-of-slack')
+    await assert.rejects(() => credentials.get('stripe'), /denied/i)
+    await assert.rejects(() => credentials.getAllUsers(), /denied/i)
+  })
+
+  test('globalCredentials, set by the host, hands over the whole service', async () => {
+    registerAddon(['ADDON_KEY'], ['slack'])
+    wireAddon({
+      name: 'example',
+      package: ADDON_PACKAGE,
+      globalCredentials: 'links credentials an operator names at runtime',
+    })
+
+    const credentials = await credentialsHandedToAddon('example')
+    assert.equal(await credentials.get('stripe'), 'credential-of-stripe')
+    assert.deepEqual(await credentials.getAllUsers(), ['user-1'])
+  })
+})

package/src/wirings/rpc/rpc-runner.test.ts

@@ -708,6 +708,7 @@ describe('multi-instance addons', () => {
         return svc
       },
     } as never)
+    pikkuState('@addon/slack', 'package', 'declaredSecrets', ['slackToken'])
     registerFunction(
       'send',
       async (services: any) => ({ token: services.token }),
@@ -753,6 +754,7 @@ describe('multi-instance addons', () => {
         }
       },
     } as never)
+    pikkuState('@addon/slack', 'package', 'declaredSecrets', ['slackToken'])
 
     registerFunction(
       'leaf',