@pikku/core 0.12.20 → 0.12.21

package/src/wirings/http/web-request.test.ts

@@ -154,6 +154,42 @@ describe('toWebRequest', () => {
     assert.equal(text, bodyContent)
   })
 
+  test('reconstructs JSON body from pre-parsed request data when arrayBuffer is empty', async () => {
+    const req = createMockRequest({
+      method: 'post',
+      path: '/json-body',
+      headers: { 'content-type': 'application/json', host: 'localhost' },
+      body: new ArrayBuffer(0),
+    })
+
+    req.json = async () => ({ hello: 'world' })
+
+    const webReq = toWebRequest(req)
+
+    assert.equal(await webReq.text(), '{"hello":"world"}')
+  })
+
+  test('reconstructs form-urlencoded body from pre-parsed request data when arrayBuffer is empty', async () => {
+    const req = createMockRequest({
+      method: 'post',
+      path: '/form-body',
+      headers: {
+        'content-type': 'application/x-www-form-urlencoded',
+        host: 'localhost',
+      },
+      body: new ArrayBuffer(0),
+    })
+
+    req.json = async () => ({ name: 'Alice', role: 'admin' })
+
+    const webReq = toWebRequest(req)
+    const text = await webReq.text()
+
+    assert.ok(
+      text === 'name=Alice&role=admin' || text === 'role=admin&name=Alice'
+    )
+  })
+
   test('GET request has no body', async () => {
     const req = createMockRequest({ method: 'get' })
     const webReq = toWebRequest(req)
@@ -233,4 +269,83 @@ describe('applyWebResponse', () => {
     assert.equal(state.body, null)
     assert.equal(state.statusCode, 204)
   })
+
+  test('collects multiple set-cookie headers via getSetCookie without duplicates', async () => {
+    const { res, state } = createMockResponse()
+    const webRes = new Response('{"csrfToken":"abc"}', { status: 200 })
+    const cookies = [
+      'authjs.csrf-token=abc; Path=/; HttpOnly',
+      'authjs.callback-url=http%3A%2F%2Flocalhost; Path=/; HttpOnly',
+    ]
+    ;(webRes.headers as any).getSetCookie = () => cookies
+
+    await applyWebResponse(res, webRes)
+
+    assert.deepEqual(state.headers['set-cookie'], cookies)
+    assert.equal(state.body, '{"csrfToken":"abc"}')
+  })
+
+  test('falls back to forEach for set-cookie when getSetCookie is absent', async () => {
+    const { res, state } = createMockResponse()
+    const headers = new Headers()
+    headers.append('Set-Cookie', 'a=1; Path=/')
+    headers.append('Set-Cookie', 'b=2; Path=/')
+    const webRes = new Response(null, { status: 200, headers })
+    delete (webRes.headers as any).getSetCookie
+
+    await applyWebResponse(res, webRes)
+
+    const setCookies = state.headers['set-cookie'] as string[]
+    assert.ok(setCookies.some((c) => c.includes('a=1')))
+    assert.ok(setCookies.some((c) => c.includes('b=2')))
+  })
+
+  test('uses res.send when available and skips transport headers', async () => {
+    const sent: string[] = []
+    const { state } = createMockResponse()
+    const res: PikkuHTTPResponse = {
+      status(code: number) {
+        state.statusCode = code
+        return res
+      },
+      header(name: string, value: string | string[]) {
+        state.headers[name.toLowerCase()] = value
+        return res
+      },
+      cookie() {
+        return res
+      },
+      json() {
+        return res
+      },
+      arrayBuffer() {
+        throw new Error('arrayBuffer should not be used when send exists')
+      },
+      send(data: string | ArrayBuffer | Buffer) {
+        sent.push(String(data))
+        return res
+      },
+      redirect(location: string, status?: number) {
+        state.redirectUrl = location
+        state.redirectStatus = status ?? 302
+        return res
+      },
+    }
+
+    const webRes = new Response('payload', {
+      status: 200,
+      headers: {
+        'content-length': '7',
+        'transfer-encoding': 'chunked',
+        'x-custom': 'ok',
+      },
+    })
+
+    await applyWebResponse(res, webRes)
+
+    assert.deepEqual(sent, ['payload'])
+    assert.equal(state.headers['x-custom'], 'ok')
+    assert.equal(state.headers['content-length'], undefined)
+    assert.equal(state.headers['transfer-encoding'], undefined)
+  })
 })

package/src/wirings/http/web-request.ts

@@ -7,11 +7,9 @@ import type { PikkuHTTPResponse } from './http.types.js'
  */
 export function toWebRequest(req: PikkuHTTPRequest, baseUrl?: string): Request {
   const proto = req.header('x-forwarded-proto') ?? 'http'
-  const host = req.header('x-forwarded-host') ?? req.header('host') ?? 'localhost'
-  const url = new URL(
-    req.path(),
-    baseUrl ?? `${proto}://${host}`
-  )
+  const host =
+    req.header('x-forwarded-host') ?? req.header('host') ?? 'localhost'
+  const url = new URL(req.path(), baseUrl ?? `${proto}://${host}`)
 
   const query = req.query()
   for (const [key, value] of Object.entries(query)) {
@@ -73,6 +71,37 @@ export function toWebRequest(req: PikkuHTTPRequest, baseUrl?: string): Request {
 
 const SKIP_RESPONSE_HEADERS = new Set(['content-length', 'transfer-encoding'])
 
+function collectSetCookieHeaders(webResponse: Response): string[] {
+  const seen = new Set<string>()
+  const values: string[] = []
+
+  const add = (cookie: string) => {
+    if (!cookie || seen.has(cookie)) {
+      return
+    }
+    seen.add(cookie)
+    values.push(cookie)
+  }
+
+  const headersWithGetSetCookie = webResponse.headers as Headers & {
+    getSetCookie?: () => string[]
+  }
+
+  if (typeof headersWithGetSetCookie.getSetCookie === 'function') {
+    for (const cookie of headersWithGetSetCookie.getSetCookie()) {
+      add(cookie)
+    }
+  } else {
+    webResponse.headers.forEach((value, name) => {
+      if (name.toLowerCase() === 'set-cookie') {
+        add(value)
+      }
+    })
+  }
+
+  return values
+}
+
 /**
  * Applies a Web API Response to a PikkuHTTPResponse.
  * Copies status, headers (including Set-Cookie), redirects, and body.
@@ -83,11 +112,16 @@ export async function applyWebResponse(
 ): Promise<void> {
   res.status(webResponse.status)
 
+  const setCookieValues = collectSetCookieHeaders(webResponse)
+
   webResponse.headers.forEach((value, name) => {
     const lower = name.toLowerCase()
     if (SKIP_RESPONSE_HEADERS.has(lower)) {
       return
     }
+    if (lower === 'set-cookie') {
+      return
+    }
     if (lower === 'location') {
       res.redirect(value, webResponse.status)
     } else {
@@ -95,6 +129,10 @@ export async function applyWebResponse(
     }
   })
 
+  if (setCookieValues.length > 0) {
+    res.header('Set-Cookie', setCookieValues)
+  }
+
   const body = await webResponse.text()
   if (body) {
     if (res.send) {

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

@@ -0,0 +1,367 @@
+import { beforeEach, describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  MCPError,
+  runMCPPrompt,
+  runMCPResource,
+  runMCPTool,
+  wireMCPPrompt,
+  wireMCPResource,
+} from './mcp-runner.js'
+import { addFunction } from '../../function/function-runner.js'
+import { pikkuState, resetPikkuState } from '../../pikku-state.js'
+
+const logger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+}
+
+const mcpWire = {
+  sendResourceUpdated: () => {},
+  enableResources: async () => true,
+  enablePrompts: async () => true,
+  enableTools: async () => true,
+}
+
+const registerFunction = (
+  funcName: string,
+  func: (services: any, data: any, wire: any) => Promise<unknown> | unknown,
+  packageName: string | null = null
+) => {
+  addFunction(funcName, { func } as never, packageName)
+  pikkuState(packageName, 'function', 'meta')[funcName] = {
+    name: funcName,
+    sessionless: true,
+    permissions: [],
+  } as never
+}
+
+beforeEach(() => {
+  resetPikkuState()
+  pikkuState(null, 'package', 'singletonServices', {
+    logger,
+  } as never)
+})
+
+describe('wireMCPResource', () => {
+  test('skips registration when metadata is missing', () => {
+    const warnings: string[] = []
+    const originalWarn = console.warn
+    console.warn = (message: string) => {
+      warnings.push(message)
+    }
+
+    try {
+      wireMCPResource({
+        uri: 'resource://missing',
+        title: 'Missing',
+        description: 'Missing',
+        func: { func: async () => ({ ok: true }) } as never,
+      })
+    } finally {
+      console.warn = originalWarn
+    }
+
+    assert.equal(getResourceMap().has('resource://missing'), false)
+    assert.match(
+      warnings[0] || '',
+      /Skipping MCP resource 'resource:\/\/missing'/
+    )
+  })
+
+  test('throws when resource is registered twice', () => {
+    pikkuState(null, 'mcp', 'resourcesMeta')['resource://users'] = {
+      uri: 'resource://users',
+      title: 'Users',
+      description: 'Users',
+      pikkuFuncId: 'resourceFunc',
+      inputSchema: null,
+      outputSchema: null,
+    } as never
+    registerFunction('resourceFunc', async () => ({ ok: true }))
+
+    const resource = {
+      uri: 'resource://users',
+      title: 'Users',
+      description: 'Users',
+      func: { func: async () => ({ ok: true }) } as never,
+    }
+
+    wireMCPResource(resource)
+
+    assert.throws(() => wireMCPResource(resource), {
+      message: 'MCP resource already exists: resource://users',
+    })
+  })
+})
+
+describe('wireMCPPrompt', () => {
+  test('skips registration when metadata is missing', () => {
+    const warnings: string[] = []
+    const originalWarn = console.warn
+    console.warn = (message: string) => {
+      warnings.push(message)
+    }
+
+    try {
+      wireMCPPrompt({
+        name: 'missing-prompt',
+        description: 'Missing',
+        func: { func: async () => [] } as never,
+      })
+    } finally {
+      console.warn = originalWarn
+    }
+
+    assert.equal(
+      pikkuState(null, 'mcp', 'prompts').has('missing-prompt'),
+      false
+    )
+    assert.match(warnings[0] || '', /Skipping MCP prompt 'missing-prompt'/)
+  })
+})
+
+describe('runMCPResource', () => {
+  test('matches uri templates and merges extracted params into the request', async () => {
+    pikkuState(null, 'mcp', 'resourcesMeta')['resource://todos/{id}'] = {
+      uri: 'resource://todos/{id}',
+      title: 'Todo',
+      description: 'Todo',
+      pikkuFuncId: 'resourceFunc',
+      inputSchema: null,
+      outputSchema: null,
+    } as never
+    registerFunction('resourceFunc', async () => ({ ok: false }))
+
+    wireMCPResource({
+      uri: 'resource://todos/{id}',
+      title: 'Todo',
+      description: 'Todo',
+      func: {
+        func: async (_services: any, data: any, wire: any) => ({
+          data,
+          uri: wire.mcp?.uri,
+        }),
+      } as never,
+    })
+
+    const response = await runMCPResource(
+      {
+        jsonrpc: '2.0',
+        id: 'req-1',
+        params: { include: 'details' },
+      },
+      { mcp: mcpWire as never },
+      'resource://todos/42'
+    )
+
+    assert.deepEqual(response, {
+      id: 'req-1',
+      result: {
+        data: { include: 'details', id: '42' },
+        uri: 'resource://todos/42',
+      },
+    })
+  })
+})
+
+describe('runMCPTool', () => {
+  test('wraps non-MCPToolResponse output as text', async () => {
+    pikkuState(null, 'mcp', 'toolsMeta').echo = {
+      name: 'echo',
+      title: 'Echo',
+      description: 'Echo',
+      pikkuFuncId: 'toolFunc',
+      inputSchema: null,
+      outputSchema: null,
+    } as never
+    registerFunction('toolFunc', async (_services, data) => data)
+
+    const response = await runMCPTool(
+      {
+        jsonrpc: '2.0',
+        id: 'req-2',
+        params: { hello: 'world' },
+      },
+      { mcp: mcpWire as never },
+      'echo'
+    )
+
+    assert.deepEqual(response, {
+      id: 'req-2',
+      result: [{ type: 'text', text: '{"hello":"world"}' }],
+    })
+  })
+
+  test('preserves MCPToolResponse output without wrapping', async () => {
+    pikkuState(null, 'mcp', 'toolsMeta').toolResponse = {
+      name: 'toolResponse',
+      title: 'Tool Response',
+      description: 'Tool Response',
+      pikkuFuncId: 'toolResponseFunc',
+      inputSchema: null,
+      outputSchema: 'MCPToolResponse',
+    } as never
+    registerFunction('toolResponseFunc', async () => [
+      { type: 'text', text: 'hello' },
+    ])
+
+    const response = await runMCPTool(
+      {
+        jsonrpc: '2.0',
+        id: 'req-3',
+        params: {},
+      },
+      { mcp: mcpWire as never },
+      'toolResponse'
+    )
+
+    assert.deepEqual(response, {
+      id: 'req-3',
+      result: [{ type: 'text', text: 'hello' }],
+    })
+  })
+
+  test('resolves namespaced tool function ids through addon packages', async () => {
+    pikkuState(null, 'addons', 'packages').set('addon', {
+      package: '@addon/pkg',
+    } as never)
+    pikkuState(null, 'mcp', 'toolsMeta').addonTool = {
+      name: 'addonTool',
+      title: 'Addon Tool',
+      description: 'Addon Tool',
+      pikkuFuncId: 'addon:toolFunc',
+      inputSchema: null,
+      outputSchema: null,
+    } as never
+    registerFunction(
+      'toolFunc',
+      async () => ({
+        packageName: 'root',
+      }),
+      null
+    )
+    registerFunction(
+      'toolFunc',
+      async (_services, data) => ({
+        data,
+        packageName: '@addon/pkg',
+      }),
+      '@addon/pkg'
+    )
+
+    const response = await runMCPTool(
+      {
+        jsonrpc: '2.0',
+        id: 'req-4',
+        params: { ok: true },
+      },
+      { mcp: mcpWire as never },
+      'addonTool'
+    )
+
+    assert.deepEqual(response, {
+      id: 'req-4',
+      result: [
+        {
+          type: 'text',
+          text: '{"data":{"ok":true},"packageName":"@addon/pkg"}',
+        },
+      ],
+    })
+  })
+
+  test('maps bad jsonrpc version to MCP error code', async () => {
+    pikkuState(null, 'mcp', 'toolsMeta').echo = {
+      name: 'echo',
+      title: 'Echo',
+      description: 'Echo',
+      pikkuFuncId: 'toolFunc',
+      inputSchema: null,
+      outputSchema: null,
+    } as never
+    registerFunction('toolFunc', async () => ({ ok: true }))
+
+    await assert.rejects(
+      () =>
+        runMCPTool(
+          { jsonrpc: '1.0', id: 'bad-version', params: {} },
+          { mcp: mcpWire as never },
+          'echo'
+        ),
+      (error: unknown) => {
+        assert.ok(error instanceof MCPError)
+        assert.equal(error.error.code, -32600)
+        assert.equal(error.error.id, 'bad-version')
+        return true
+      }
+    )
+  })
+
+  test('maps unmapped runtime errors to internal MCP errors', async () => {
+    pikkuState(null, 'mcp', 'toolsMeta').boom = {
+      name: 'boom',
+      title: 'Boom',
+      description: 'Boom',
+      pikkuFuncId: 'boomFunc',
+      inputSchema: null,
+      outputSchema: null,
+    } as never
+    registerFunction('boomFunc', async () => {
+      throw new Error('boom')
+    })
+
+    await assert.rejects(
+      () =>
+        runMCPTool(
+          { jsonrpc: '2.0', id: 'boom-1', params: {} },
+          { mcp: mcpWire as never },
+          'boom'
+        ),
+      (error: unknown) => {
+        assert.ok(error instanceof MCPError)
+        assert.equal(error.error.code, -32603)
+        assert.equal(error.error.data?.message, 'boom')
+        return true
+      }
+    )
+  })
+})
+
+describe('runMCPPrompt', () => {
+  test('maps missing prompt registration to not found MCP errors', async () => {
+    pikkuState(null, 'mcp', 'promptsMeta').missingPrompt = {
+      name: 'missingPrompt',
+      description: 'Missing Prompt',
+      pikkuFuncId: 'missingPromptFunc',
+      inputSchema: null,
+      outputSchema: null,
+      arguments: [],
+    } as never
+
+    await assert.rejects(
+      () =>
+        runMCPPrompt(
+          { jsonrpc: '2.0', id: 'prompt-1', params: {} },
+          { mcp: mcpWire as never },
+          'missingPrompt'
+        ),
+      (error: unknown) => {
+        assert.ok(error instanceof MCPError)
+        assert.equal(error.error.code, -32601)
+        assert.match(
+          error.error.message,
+          /server cannot find the requested resource/i
+        )
+        return true
+      }
+    )
+  })
+})
+
+const getResourceMap = () => {
+  return pikkuState(null, 'mcp', 'resources')
+}

package/src/wirings/queue/queue.types.ts

@@ -161,11 +161,8 @@ export type QueueWorkersMeta = Record<
  * Core queue processor definition
  */
 export type CoreQueueWorker<
-  PikkuFunctionConfig extends CorePikkuFunctionConfig<
-    any,
-    any,
-    any
-  > = CorePikkuFunctionConfig<any, any, any>,
+  PikkuFunctionConfig extends CorePikkuFunctionConfig<any, any, any> =
+    CorePikkuFunctionConfig<any, any, any>,
 > = {
   name: string
   func: PikkuFunctionConfig