@pikku/core 0.12.106 → 0.12.111

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

@@ -1,382 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-import { toWebRequest, applyWebResponse } from './web-request.js'
-import type {
-  PikkuHTTPRequest,
-  PikkuHTTPResponse,
-  PikkuQuery,
-} from './http.types.js'
-
-const createMockRequest = (
-  overrides: Partial<{
-    method: string
-    path: string
-    headers: Record<string, string>
-    query: Record<string, string>
-    body: ArrayBuffer
-  }> = {}
-): PikkuHTTPRequest => ({
-  method: () => (overrides.method ?? 'get') as any,
-  path: () => overrides.path ?? '/test',
-  headers: () => overrides.headers ?? {},
-  header: (name: string) =>
-    (overrides.headers ?? {})[name.toLowerCase()] ?? null,
-  cookie: () => null,
-  params: () => ({}),
-  setParams: () => {},
-  query: () => (overrides.query ?? {}) as PikkuQuery,
-  json: async () => ({}),
-  arrayBuffer: async () => overrides.body ?? new ArrayBuffer(0),
-  data: async () => ({}) as any,
-})
-
-const createMockResponse = () => {
-  const state = {
-    statusCode: 0,
-    headers: {} as Record<string, string | string[]>,
-    body: null as string | Uint8Array | null,
-    redirectUrl: null as string | null,
-    redirectStatus: null as number | null,
-  }
-
-  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(data: any) {
-      // Recorded as given. Coercing a non-string to null here would have hidden
-      // a body that arrived as bytes, which is the case worth testing.
-      state.body = data ?? null
-      return res
-    },
-    redirect(location: string, status?: number) {
-      state.redirectUrl = location
-      state.redirectStatus = status ?? 302
-      return res
-    },
-  }
-
-  return { res, state }
-}
-
-describe('toWebRequest', () => {
-  test('converts a GET request with correct URL and method', async () => {
-    const req = createMockRequest({
-      method: 'get',
-      path: '/api/test',
-      headers: { host: 'example.com' },
-    })
-
-    const webReq = toWebRequest(req)
-
-    assert.equal(webReq.method, 'GET')
-    assert.equal(new URL(webReq.url).pathname, '/api/test')
-    assert.equal(new URL(webReq.url).host, 'example.com')
-    assert.equal(webReq.body, null)
-  })
-
-  test('copies query parameters', async () => {
-    const req = createMockRequest({
-      query: { search: 'hello', page: '2' },
-    })
-
-    const webReq = toWebRequest(req)
-    const url = new URL(webReq.url)
-
-    assert.equal(url.searchParams.get('search'), 'hello')
-    assert.equal(url.searchParams.get('page'), '2')
-  })
-
-  test('copies all headers', async () => {
-    const req = createMockRequest({
-      headers: {
-        'content-type': 'application/json',
-        authorization: 'Bearer abc123',
-        host: 'localhost',
-      },
-    })
-
-    const webReq = toWebRequest(req)
-
-    assert.equal(webReq.headers.get('content-type'), 'application/json')
-    assert.equal(webReq.headers.get('authorization'), 'Bearer abc123')
-  })
-
-  test('uses custom baseUrl when provided', async () => {
-    const req = createMockRequest({ path: '/callback' })
-
-    const webReq = toWebRequest(req, 'https://myapp.com')
-    const url = new URL(webReq.url)
-
-    assert.equal(url.origin, 'https://myapp.com')
-    assert.equal(url.pathname, '/callback')
-  })
-
-  test('falls back to localhost when no host header', async () => {
-    const req = createMockRequest({ path: '/test' })
-
-    const webReq = toWebRequest(req)
-    const url = new URL(webReq.url)
-
-    assert.equal(url.host, 'localhost')
-  })
-
-  test('POST request includes streaming body', async () => {
-    const bodyContent = JSON.stringify({
-      username: 'admin',
-      password: 'secret',
-    })
-    const encoder = new TextEncoder()
-    const bodyBuffer = encoder.encode(bodyContent).buffer as ArrayBuffer
-
-    const req = createMockRequest({
-      method: 'post',
-      path: '/signin',
-      headers: { 'content-type': 'application/json', host: 'localhost' },
-      body: bodyBuffer,
-    })
-
-    const webReq = toWebRequest(req)
-
-    assert.equal(webReq.method, 'POST')
-    assert.notEqual(webReq.body, null)
-
-    const text = await webReq.text()
-    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)
-    assert.equal(webReq.body, null)
-  })
-
-  test('HEAD request has no body', async () => {
-    const req = createMockRequest({ method: 'head' })
-    const webReq = toWebRequest(req)
-    assert.equal(webReq.body, null)
-  })
-
-  test('OPTIONS request has no body', async () => {
-    const req = createMockRequest({ method: 'options' })
-    const webReq = toWebRequest(req)
-    assert.equal(webReq.body, null)
-  })
-})
-
-describe('applyWebResponse', () => {
-  test('copies status code', async () => {
-    const { res, state } = createMockResponse()
-    const webRes = new Response('OK', { status: 201 })
-
-    await applyWebResponse(res, webRes)
-
-    assert.equal(state.statusCode, 201)
-  })
-
-  test('copies response headers', async () => {
-    const { res, state } = createMockResponse()
-    const webRes = new Response('', {
-      status: 200,
-      headers: {
-        'content-type': 'text/html',
-        'x-custom': 'value',
-      },
-    })
-
-    await applyWebResponse(res, webRes)
-
-    assert.equal(state.headers['content-type'], 'text/html')
-    assert.equal(state.headers['x-custom'], 'value')
-  })
-
-  test('handles redirect via location header', async () => {
-    const { res, state } = createMockResponse()
-    const webRes = new Response(null, {
-      status: 302,
-      headers: { location: 'https://github.com/login/oauth/authorize' },
-    })
-
-    await applyWebResponse(res, webRes)
-
-    assert.equal(state.redirectUrl, 'https://github.com/login/oauth/authorize')
-    assert.equal(state.statusCode, 302)
-  })
-
-  test('writes text body', async () => {
-    const { res, state } = createMockResponse()
-    const webRes = new Response('{"session": true}', {
-      status: 200,
-      headers: { 'content-type': 'application/json' },
-    })
-
-    await applyWebResponse(res, webRes)
-
-    assert.equal(state.body, '{"session": true}')
-  })
-
-  test('does not write empty body', async () => {
-    const { res, state } = createMockResponse()
-    const webRes = new Response(null, { status: 204 })
-
-    await applyWebResponse(res, webRes)
-
-    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 = [
-      'better-auth.session_token=abc; Path=/; HttpOnly',
-      'better-auth.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)
-  })
-
-  test('passes a binary body through byte for byte', async () => {
-    // Reading a body as text is lossy for anything that is not valid UTF-8:
-    // 0x8e is not, and decoding it produces U+FFFD, which re-encodes to three
-    // bytes. A WASM module or a model file goes over the wire bigger than it
-    // started and no longer parses, with a 200 and nothing logged either side.
-    const { res, state } = createMockResponse()
-    const bytes = new Uint8Array([0x00, 0x61, 0x73, 0x6d, 0x01, 0x8e, 0xff])
-    const webRes = new Response(bytes, {
-      status: 200,
-      headers: { 'content-type': 'application/wasm' },
-    })
-
-    await applyWebResponse(res, webRes)
-
-    assert.deepEqual(new Uint8Array(state.body as Uint8Array), bytes)
-  })
-
-  test('still writes a JSON body as text', async () => {
-    const { res, state } = createMockResponse()
-    const webRes = new Response('{"ok":true}', {
-      status: 200,
-      headers: { 'content-type': 'application/json; charset=utf-8' },
-    })
-
-    await applyWebResponse(res, webRes)
-
-    assert.equal(state.body, '{"ok":true}')
-  })
-})

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

@@ -1,162 +0,0 @@
-import type { PikkuHTTPRequest } from './http.types.js'
-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 query = req.query()
-  for (const [key, value] of Object.entries(query)) {
-    if (value != null) {
-      url.searchParams.set(key, String(value))
-    }
-  }
-
-  const headers = new Headers(req.headers())
-
-  const method = req.method().toUpperCase()
-  const hasBody = !['GET', 'HEAD', 'OPTIONS'].includes(method)
-
-  if (!hasBody) {
-    return new Request(url, { method, headers })
-  }
-
-  return new Request(url, {
-    method,
-    headers,
-    body: new ReadableStream({
-      async pull(controller) {
-        try {
-          const buffer = await req.arrayBuffer()
-          if (buffer.byteLength > 0) {
-            controller.enqueue(new Uint8Array(buffer))
-          } else {
-            const contentType = (
-              headers.get('content-type') || ''
-            ).toLowerCase()
-            const parsed = await req.json()
-            if (
-              parsed &&
-              typeof parsed === 'object' &&
-              Object.keys(parsed as object).length > 0
-            ) {
-              let reconstructed: string
-              if (contentType.includes('application/x-www-form-urlencoded')) {
-                reconstructed = new URLSearchParams(
-                  parsed as Record<string, string>
-                ).toString()
-              } else {
-                reconstructed = JSON.stringify(parsed)
-              }
-              controller.enqueue(new TextEncoder().encode(reconstructed))
-            }
-          }
-        } catch {}
-        controller.close()
-      },
-    }),
-    // @ts-ignore - duplex is needed for streaming body in Node.js
-    duplex: 'half',
-  })
-}
-
-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
-}
-
-/**
- * Content types whose bodies are text. Everything else is bytes.
- *
- * The distinction matters because reading a body as text is lossy for anything
- * that is not valid UTF-8: every byte that does not decode becomes U+FFFD, and
- * re-encoding turns each of those into three bytes. A WASM module or an ONNX
- * model served that way arrives larger than it left and no longer parses, with
- * a 200 and no error anywhere to say why.
- */
-const TEXTUAL_CONTENT_TYPE =
-  /^(text\/|application\/(json|javascript|ecmascript|xml|x-www-form-urlencoded)|[^;]*\+(json|xml)\b)/i
-
-/**
- * Read a response body as text where that is meaningful, and as bytes
- * otherwise. An absent content type is treated as text, which is what a body
- * built from a string gets by default and so preserves existing behaviour.
- */
-async function readBody(
-  webResponse: Response
-): Promise<string | Uint8Array | null> {
-  const contentType = webResponse.headers.get('content-type')
-  if (contentType === null || TEXTUAL_CONTENT_TYPE.test(contentType)) {
-    const text = await webResponse.text()
-    return text === '' ? null : text
-  }
-  const bytes = new Uint8Array(await webResponse.arrayBuffer())
-  return bytes.byteLength === 0 ? null : bytes
-}
-
-export async function applyWebResponse(
-  res: PikkuHTTPResponse,
-  webResponse: Response
-): 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 {
-      res.header(name, value)
-    }
-  })
-
-  if (setCookieValues.length > 0) {
-    res.header('Set-Cookie', setCookieValues)
-  }
-
-  const body = await readBody(webResponse)
-  if (body !== null) {
-    if (res.send) {
-      res.send(body)
-    } else {
-      res.arrayBuffer(body)
-    }
-  }
-}

package/src/wirings/mcp/index.ts

@@ -1,26 +0,0 @@
-export { MCPEndpointRegistry } from './mcp-endpoint-registry.js'
-export {
-  MCPError,
-  wireMCPResource,
-  wireMCPPrompt,
-  runMCPResource,
-  runMCPTool,
-  runMCPPrompt,
-} from './mcp-runner.js'
-export {
-  getMCPResourcesMeta,
-  getMCPToolsMeta,
-  getMCPPromptsMeta,
-} from './mcp-runner.js'
-export type {
-  AssertMCPResourceURIParams,
-  CoreMCPPrompt,
-  CoreMCPResource,
-  MCPPromptResponse,
-  MCPResourceMeta,
-  MCPResourceResponse,
-  MCPToolMeta,
-  MCPToolResponse,
-  MCPPromptMeta,
-  PikkuMCP,
-} from './mcp.types.js'