@pikku/core 0.12.80 → 0.12.83

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

@@ -396,6 +396,74 @@ describe('CLI Runner', () => {
       const programs = pikkuState(null, 'cli', 'programs')
       assert.strictEqual(programs['nonexistent'], undefined)
     })
+
+    test('enforces command-level permissions declared on a CLI command', async () => {
+      let functionRan = false
+
+      pikkuState(null, 'cli', 'meta', {
+        programs: {
+          'sec-cli': {
+            program: 'sec-cli',
+            commands: {
+              secret: {
+                command: 'secret',
+                pikkuFuncId: 'secretFunc',
+                positionals: [],
+                options: {},
+              },
+            },
+            options: {},
+          },
+        },
+        renderers: {},
+      })
+      pikkuState(null, 'function', 'meta', {
+        secretFunc: {
+          pikkuFuncId: 'secretFunc',
+          inputSchemaName: null,
+          outputSchemaName: null,
+          sessionless: true,
+        },
+      })
+
+      wireCLI({
+        program: 'sec-cli',
+        commands: {
+          // command.func is a function-config object, so unwrapFunc reads the
+          // inner func's auth/permissions and previously dropped the
+          // command-level ones — the branch this fix restores.
+          secret: {
+            func: {
+              func: async () => {
+                functionRan = true
+                return {}
+              },
+            },
+            // A permission that always denies.
+            permissions: { deny: async () => false },
+          } as any,
+        },
+      })
+
+      const result = await runCLICommand({
+        program: 'sec-cli',
+        commandPath: ['secret'],
+        data: {},
+        singletonServices,
+        createWireServices,
+      }).catch((error) => ({ success: false, error }))
+
+      assert.equal(
+        functionRan,
+        false,
+        'the function must not run when a declared permission denies'
+      )
+      assert.notEqual(
+        (result as any).success,
+        true,
+        'the command must not report success when permission is denied'
+      )
+    })
   })
 
   describe('pikkuCLIRender', () => {

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

@@ -169,7 +169,24 @@ function registerCLICommands(
       }
     }
 
-    addFunction(funcName, unwrapFunc(command), currentMeta?.packageName)
+    // Merge the command-level auth/permissions into the registered config so
+    // they are actually enforced by the function runner. They were accepted by
+    // the types but dropped here, making a command's declared access control a
+    // silent no-op. Command-level wins over the handler's own, then falls back
+    // to it.
+    const unwrapped = unwrapFunc(command)
+    const commandAuth = typeof command === 'object' ? command.auth : undefined
+    const commandPermissions =
+      typeof command === 'object' ? command.permissions : undefined
+    addFunction(
+      funcName,
+      {
+        ...unwrapped,
+        auth: commandAuth ?? unwrapped.auth,
+        permissions: commandPermissions ?? unwrapped.permissions,
+      },
+      currentMeta?.packageName
+    )
 
     if (typeof command === 'object' && command.render) {
       if (programs[program]) {

package/src/wirings/credential/index.ts

@@ -2,7 +2,6 @@ export { defineCredential } from './define-credential.js'
 export { validateAndBuildCredentialDefinitionsMeta } from './validate-credential-definitions.js'
 export type {
   CoreCredential,
-  CredentialDefinitionMeta,
   CredentialDefinitionsMeta,
   CredentialDefinitions,
 } from './credential.types.js'

package/src/wirings/gateway/index.ts

@@ -6,13 +6,10 @@ export {
 export type {
   GatewayAdapter,
   GatewayAdapterFactory,
-  GatewayAttachment,
   GatewayInboundMessage,
   GatewayOutboundMessage,
-  GatewayMeta,
   GatewaysMeta,
   GatewayTransportType,
   CoreGateway,
-  PikkuGateway,
   WebhookVerificationResult,
 } from './gateway.types.js'

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

@@ -70,6 +70,11 @@ class TestResponse extends PikkuMockResponse {
     return this
   }
 
+  redirect(location: string, status: number = 302): this {
+    this.status(status)
+    return this.header('Location', location)
+  }
+
   setMode(mode: 'stream') {
     this.mode = mode
   }
@@ -365,6 +370,67 @@ describe('http-runner helpers', () => {
     assert.equal(response.statusCode, 204)
   })
 
+  test('fetchData keeps a redirect status when the route returns undefined', async () => {
+    setRouteMeta('/redirect')
+    addFunction('pikku_func_name', {
+      func: async (_services: any, _data: any, { http }: any) => {
+        http?.response?.redirect('https://example.com/done', 302)
+      },
+    })
+    wireHTTP({
+      route: '/redirect',
+      method: 'get',
+      auth: false,
+      func: {
+        func: async (_services: any, _data: any, { http }: any) => {
+          http?.response?.redirect('https://example.com/done', 302)
+        },
+      },
+    })
+    httpRouter.initialize()
+
+    const request = new TestRequest('/redirect', 'get')
+    const response = new TestResponse()
+
+    await fetchData(request, response)
+
+    assert.equal(response.statusCode, 302)
+    assert.equal(
+      response.headersMap.get('Location'),
+      'https://example.com/done'
+    )
+  })
+
+  test('fetchData keeps a status the route set alongside a body', async () => {
+    setRouteMeta('/created')
+    addFunction('pikku_func_name', {
+      func: async (_services: any, _data: any, { http }: any) => {
+        http?.response?.status(201)
+        return { id: 'thing-1' }
+      },
+    })
+    wireHTTP({
+      route: '/created',
+      method: 'get',
+      auth: false,
+      func: {
+        func: async (_services: any, _data: any, { http }: any) => {
+          http?.response?.status(201)
+          return { id: 'thing-1' }
+        },
+      },
+    })
+    httpRouter.initialize()
+
+    const request = new TestRequest('/created', 'get')
+    const response = new TestResponse()
+
+    await fetchData(request, response)
+
+    assert.equal(response.statusCode, 201)
+    assert.deepEqual(response.jsonBody, { id: 'thing-1' })
+  })
+
   test('fetchData writes binary responses when returnsJSON is false', async () => {
     setRouteMeta('/binary')
     wireHTTP({

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

@@ -283,6 +283,8 @@ const executeRoute = async (
     hasSessionChanged: () => userSession.sessionChanged,
   }
 
+  const statusBeforeRoute = http?.response?.statusCode
+
   try {
     result = await runPikkuFunc(
       'http',
@@ -323,14 +325,20 @@ const executeRoute = async (
   if (matchedRoute.route.sse) {
     http?.response?.flushHeaders?.()
   } else {
+    const statusSetByRoute = http?.response?.statusCode !== statusBeforeRoute
+
     if (result instanceof Response) {
       await applyWebResponse(http!.response!, result)
     } else if (result === undefined || result === null) {
-      http?.response?.status(204)
+      if (!statusSetByRoute) {
+        http?.response?.status(204)
+      }
     } else if (route.returnsJSON === false) {
       http?.response?.arrayBuffer(result)
     } else {
-      http?.response?.status(200)
+      if (!statusSetByRoute) {
+        http?.response?.status(200)
+      }
       http?.response?.json(result)
     }
   }

package/src/wirings/http/index.ts

@@ -2,7 +2,6 @@ export {
   PikkuFetchHTTPRequest,
   DEFAULT_MAX_BODY_SIZE,
 } from './pikku-fetch-http-request.js'
-export type { PikkuFetchHTTPRequestOptions } from './pikku-fetch-http-request.js'
 export { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js'
 export { logRoutes } from './log-http-routes.js'
 
@@ -19,6 +18,7 @@ export type {
   HTTPRouteContract,
   HTTPRouteMap,
   HTTPWiringsMeta,
+  PikkuHTTP,
   PikkuHTTPRequest,
   PikkuHTTPResponse,
   PikkuQuery,

package/src/wirings/mcp/index.ts

@@ -16,7 +16,6 @@ export type {
   AssertMCPResourceURIParams,
   CoreMCPPrompt,
   CoreMCPResource,
-  CoreMCPTool,
   MCPPromptResponse,
   MCPResourceMeta,
   MCPResourceResponse,

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'