@pikku/cli 0.11.1 → 0.11.2

package/src/functions/wirings/functions/serialize-function-types.ts

@@ -6,8 +6,8 @@ export const serializeFunctionTypes = (
   userSessionTypeName: string,
   singletonServicesTypeImport: string,
   singletonServicesTypeName: string,
-  sessionServicesTypeImport: string,
-  sessionServicesTypeName: string,
+  wireServicesTypeImport: string,
+  wireServicesTypeName: string,
   rpcMapTypeImport: string,
   requiredServicesTypeImport: string,
   configTypeImport: string
@@ -16,20 +16,18 @@ export const serializeFunctionTypes = (
  * Core function, middleware, and permission types for all wirings
  */
 
-import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore } from '@pikku/core'
+import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired } from '@pikku/core'
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
-import { PikkuChannel } from '@pikku/core/channel'
-import { PikkuMCP } from '@pikku/core/mcp'
 
 ${userSessionTypeImport}
 ${singletonServicesTypeImport}
-${sessionServicesTypeImport}
+${wireServicesTypeImport}
 ${configTypeImport}
 ${rpcMapTypeImport}
 ${requiredServicesTypeImport}
 
 ${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
-${sessionServicesTypeName !== 'Services' ? `type Services = ${sessionServicesTypeName}` : ''}
+${wireServicesTypeName !== 'Services' ? `type Services = ${wireServicesTypeName}` : ''}
 ${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` : ''}
 ${configTypeImport.includes('Config type not found') ? 'type Config = any' : ''}
 
@@ -40,7 +38,7 @@ ${configTypeImport.includes('Config type not found') ? 'type Config = any' : ''}
  * @template In - The input type that the permission check will receive
  * @template RequiredServices - The services required for this permission check
  */
-export type PikkuPermission<In = unknown, RequiredServices extends Services = Services> = CorePikkuPermission<In, RequiredServices, Session>
+export type PikkuPermission<In = unknown, RequiredServices extends Services = Services> = CorePikkuPermission<In, RequiredServices, PikkuWire<In, never, false, Session>>
 
 /**
  * Type-safe middleware definition that can access your application's services and session.
@@ -48,7 +46,7 @@ export type PikkuPermission<In = unknown, RequiredServices extends Services = Se
  *
  * @template RequiredServices - The services required for this middleware
  */
-export type PikkuMiddleware<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuMiddleware<RequiredServices, Session>
+export type PikkuMiddleware<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuMiddleware<RequiredServices>
 
 /**
  * Configuration object for creating a permission with metadata
@@ -69,7 +67,8 @@ export type PikkuPermissionConfig<In = unknown, RequiredServices extends Service
  * @example
  * \`\`\`typescript
  * // Direct function syntax
- * const permission = pikkuPermission(({ logger }, data, session) => {
+ * const permission = pikkuPermission(async ({ logger }, data, { session }) => {
+ *   const session = await session?.get()
  *   return session?.role === 'admin'
  * })
  *
@@ -77,7 +76,8 @@ export type PikkuPermissionConfig<In = unknown, RequiredServices extends Service
  * const adminPermission = pikkuPermission({
  *   name: 'Admin Permission',
  *   description: 'Checks if user has admin role',
- *   func: async ({ logger }, data, session) => {
+ *   func: async ({ logger }, data, { session }) => {
+ *     const session = await session?.get()
  *     return session?.role === 'admin'
  *   }
  * })
@@ -108,7 +108,7 @@ export type PikkuMiddlewareConfig<RequiredServices extends SingletonServices = S
  * @example
  * \`\`\`typescript
  * // Direct function syntax
- * const middleware = pikkuMiddleware(({ logger }, interactions, next) => {
+ * const middleware = pikkuMiddleware(({ logger }, wires, next) => {
  *   logger.info('Middleware executed')
  *   await next()
  * })
@@ -117,7 +117,7 @@ export type PikkuMiddlewareConfig<RequiredServices extends SingletonServices = S
  * const logMiddleware = pikkuMiddleware({
  *   name: 'Request Logger',
  *   description: 'Logs all incoming requests',
- *   func: async ({ logger }, interactions, next) => {
+ *   func: async ({ logger }, wires, next) => {
  *     logger.info('Request started')
  *     await next()
  *   }
@@ -140,7 +140,7 @@ export const pikkuMiddleware = <RequiredServices extends SingletonServices = Sin
  *   message,
  *   level = 'info'
  * }) => {
- *   return pikkuMiddleware(async ({ logger }, _interaction, next) => {
+ *   return pikkuMiddleware(async ({ logger }, next) => {
  *     logger[level](message)
  *     await next()
  *   })
@@ -162,8 +162,8 @@ export const pikkuMiddlewareFactory = <In = any>(
  * export const requireRole = pikkuPermissionFactory<{ role: string }>(({
  *   role
  * }) => {
- *   return pikkuPermission(async ({ logger }, data, session) => {
- *     if (!session || session.role !== role) {
+ *   return pikkuPermission(async ({ logger }, data, { initialSession }) => {
+ *     if (!initialSession || initialSession.role !== role) {
  *       logger.warn(\`Permission denied: required role '\${role}'\`)
  *       return false
  *     }
@@ -184,25 +184,19 @@ export const pikkuPermissionFactory = <In = any>(
  *
  * @template In - The input type
  * @template Out - The output type that the function returns
- * @template ChannelData - Channel data type (null = optional channel)
- * @template MCPData - MCP data type (null = optional MCP)
  * @template RequiredServices - Services required by this function
  */
 export type PikkuFunctionSessionless<
   In = unknown,
   Out = never,
-  ChannelData = null,  // null means optional channel
-  MCPData = null, // null means optional MCP
-  RequiredServices extends Services = Omit<Services, 'rpc' | 'channel' | 'mcp'> &
-    { rpc: TypedPikkuRPC } & (
-    [ChannelData] extends [null]
-      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
-      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
-  ) & ([MCPData] extends [null]
-    ? { mcp?: PikkuMCP }  // Optional MCP
-    : { mcp: PikkuMCP }  // Required MCP
-  )
-> = CorePikkuFunctionSessionless<In, Out, ChannelData, RequiredServices, Session>
+  RequiredWires extends keyof PikkuWire = never,
+  RequiredServices extends Services = Services
+> = CorePikkuFunctionSessionless<
+    In,
+    Out,
+    RequiredServices,
+    PickRequired<PikkuWire<In, Out, false, Session, TypedPikkuRPC, null, any>, RequiredWires>
+  >
 
 /**
  * A session-aware API function that requires user authentication.
@@ -210,25 +204,19 @@ export type PikkuFunctionSessionless<
  *
  * @template In - The input type
  * @template Out - The output type that the function returns
- * @template ChannelData - Channel data type (null = optional channel)
- * @template MCPData - MCP data type (null = optional MCP)
  * @template RequiredServices - Services required by this function
  */
 export type PikkuFunction<
   In = unknown,
   Out = never,
-  ChannelData = null,  // null means optional channel
-  MCPData = null, // null means optional MCP
-  RequiredServices extends Services = Omit<Services, 'rpc' | 'channel' | 'mcp'> &
-    { rpc: TypedPikkuRPC } & (
-    [ChannelData] extends [null]
-      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
-      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
-  ) & ([MCPData] extends [null]
-    ? { mcp?: PikkuMCP }  // Optional MCP
-    : { mcp: PikkuMCP }  // Required MCP
-  )
-> = CorePikkuFunction<In, Out, ChannelData, RequiredServices, Session>
+  RequiredWires extends keyof PikkuWire = 'session',
+  RequiredServices extends Services = Services
+> = CorePikkuFunction<
+    In,
+    Out,
+    RequiredServices,
+    PickRequired<PikkuWire<In, Out, true, Session, TypedPikkuRPC, null, any>, RequiredWires>
+  >
 
 /**
  * Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation.
@@ -236,16 +224,13 @@ export type PikkuFunction<
  *
  * @template In - The input type
  * @template Out - The output type
- * @template ChannelData - Channel data type
- * @template MCPData - MCP data type
  * @template PikkuFunc - The function type (can be narrowed to PikkuFunction or PikkuFunctionSessionless)
  */
 export type PikkuFunctionConfig<
   In = unknown,
   Out = unknown,
-  ChannelData = unknown,
-  MCPData = unknown,
-  PikkuFunc extends PikkuFunction<In, Out, ChannelData, MCPData> | PikkuFunctionSessionless<In, Out, ChannelData, MCPData> = PikkuFunction<In, Out, ChannelData, MCPData> | PikkuFunctionSessionless<In, Out, ChannelData, MCPData>
+  RequiredWires extends keyof PikkuWire = never,
+  PikkuFunc extends PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires> = PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires>
 > = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware>
 
 /**
@@ -260,7 +245,8 @@ export type PikkuFunctionConfig<
  * @example
  * \\\`\\\`\\\`typescript
  * const createUser = pikkuFunc<{name: string, email: string}, {id: number, message: string}>({
- *   func: async ({db, logger}, input) => {
+ *   func: async ({db, logger}, input, wire) => {
+ *     const session = await wire.session.get()
  *     logger.info('Creating user', input.name)
  *     const user = await db.users.create(input)
  *     return {id: user.id, message: \\\`User \\\${input.name} created successfully\\\`}
@@ -271,8 +257,8 @@ export type PikkuFunctionConfig<
  */
 export const pikkuFunc = <In, Out = unknown>(
   func:
-    | PikkuFunction<In, Out>
-    | CorePikkuFunctionConfig<PikkuFunction<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+    | PikkuFunction<In, Out, 'session' | 'rpc'>
+    | PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
 ) => {
   return typeof func === 'function' ? { func } : func
 }
@@ -289,7 +275,7 @@ export const pikkuFunc = <In, Out = unknown>(
  * @example
  * \\\`\\\`\\\`typescript
  * const healthCheck = pikkuSessionlessFunc<void, {status: string, timestamp: string}>({
- *   func: async ({logger}) => {
+ *   func: async ({logger}, input) => {
  *     logger.info('Health check requested')
  *     return {status: 'healthy', timestamp: new Date().toISOString()}
  *   },
@@ -299,8 +285,8 @@ export const pikkuFunc = <In, Out = unknown>(
  */
 export const pikkuSessionlessFunc = <In, Out = unknown>(
   func:
-    | PikkuFunctionSessionless<In, Out>
-    | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+    | PikkuFunctionSessionless<In, Out, 'session' | 'rpc'>
+    | PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
 ) => {
   return typeof func === 'function' ? { func } : func
 }
@@ -323,8 +309,8 @@ export const pikkuSessionlessFunc = <In, Out = unknown>(
  */
 export const pikkuVoidFunc = (
   func:
-    | PikkuFunctionSessionless<void, void>
-    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void>, PikkuPermission<void>>
+    | PikkuFunctionSessionless<void, void, 'session' | 'rpc'>
+    | PikkuFunctionConfig<void, void, 'session' | 'rpc'>
 ) => {
   return typeof func === 'function' ? { func } : func
 }
@@ -373,27 +359,27 @@ export const pikkuServices = (
 ) => func
 
 /**
- * Creates a Pikku session services factory.
+ * Creates a Pikku wire services factory.
  * Use this to define services that are created per-request/session.
  *
- * @param func - Session services factory function
- * @returns The session services factory function
+ * @param func - Wire services factory function
+ * @returns The wire services factory function
  *
  * @example
  * \`\`\`typescript
- * export const createSessionServices = pikkuSessionServices(async (services, interaction, session) => {
+ * export const createWireServices = pikkuWireServices(async (services, wire) => {
+ *   const session = await wire.session?.get()
  *   return {
  *     userCache: new UserCache(session?.userId)
  *   }
  * })
  * \`\`\`
  */
-export const pikkuSessionServices = (
+export const pikkuWireServices = (
   func: (
     services: SingletonServices,
-    interaction: any,
-    session: Session | undefined
-  ) => Promise<RequiredSessionServices>
+    wire: any
+  ) => Promise<RequiredWireServices>
 ) => func
 
 /**

package/src/functions/wirings/http/openapi-spec-generator.ts

@@ -120,8 +120,17 @@ export async function generateOpenAPISpec(
 
   for (const routeMeta of Object.values(httpMeta)) {
     for (const meta of Object.values(routeMeta)) {
-      const { route, method, inputTypes, pikkuFuncName, params, query, docs } =
-        meta
+      const {
+        route,
+        method,
+        inputTypes,
+        pikkuFuncName,
+        params,
+        query,
+        errors,
+        description,
+        tags,
+      } = meta
       const functionMeta = functionsMeta[pikkuFuncName]
       if (!functionMeta) {
         logger.error(
@@ -139,7 +148,7 @@ export async function generateOpenAPISpec(
       }
 
       const responses = {}
-      docs?.errors?.forEach((error) => {
+      errors?.forEach((error) => {
         const errorResponse = getErrorResponseForConstructorName(error)
         if (errorResponse) {
           responses[errorResponse.status] = {
@@ -150,9 +159,9 @@ export async function generateOpenAPISpec(
 
       const operation: any = {
         description:
-          docs?.description ||
+          description ||
           `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
-        tags: docs?.tags || [route.split('/')[1] || 'default'],
+        tags: tags || [route.split('/')[1] || 'default'],
         parameters: [],
         responses: {
           ...responses,

package/src/functions/wirings/http/pikku-http-routes.ts

@@ -2,11 +2,18 @@ import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
 import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 
 export const pikkuHTTP: any = pikkuSessionlessFunc<void, boolean>({
   func: async ({ logger, config, getInspectorState }) => {
     const visitState = await getInspectorState()
-    const { httpWiringsFile, httpWiringMetaFile, packageMappings } = config
+    const {
+      httpWiringsFile,
+      httpWiringMetaFile,
+      httpWiringMetaJsonFile,
+      packageMappings,
+      schema,
+    } = config
     const { http } = visitState
 
     await writeFileInDir(
@@ -19,11 +26,30 @@ export const pikkuHTTP: any = pikkuSessionlessFunc<void, boolean>({
         packageMappings
       )
     )
+
+    await writeFileInDir(
+      logger,
+      httpWiringMetaJsonFile,
+      JSON.stringify(http.meta, null, 2)
+    )
+
+    const jsonImportPath = getFileImportRelativePath(
+      httpWiringMetaFile,
+      httpWiringMetaJsonFile,
+      packageMappings
+    )
+
+    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
+    const importStatement = supportsImportAttributes
+      ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+      : `import metaData from '${jsonImportPath}'`
+
     await writeFileInDir(
       logger,
       httpWiringMetaFile,
-      `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
+      `import { pikkuState, HTTPWiringsMeta } from '@pikku/core'\n${importStatement}\npikkuState('http', 'meta', metaData as HTTPWiringsMeta)`
     )
+
     return true
   },
   middleware: [

package/src/functions/wirings/http/serialize-http-types.ts

@@ -18,7 +18,7 @@ import type { CoreHTTPFunctionWiring } from '@pikku/core/http'
  * @template Out - Output type for the HTTP wiring
  * @template Route - String literal type for the HTTP path (e.g., "/users/:id")
  */
-type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction<In, Out>, PikkuFunctionSessionless<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction<In, Out, 'rpc' | 'session'>, PikkuFunctionSessionless<In, Out, 'rpc' | 'session'>, PikkuPermission<In>, PikkuMiddleware>
 
 /**
  * Registers an HTTP wiring with the Pikku framework.

package/src/functions/wirings/mcp/pikku-command-mcp.ts

@@ -4,6 +4,7 @@ import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
 import { readFile } from 'fs/promises'
 import { join } from 'path'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 
 // Helper function to generate arguments from schema
 const generateArgumentsFromSchema = async (
@@ -66,6 +67,7 @@ export const pikkuMCP: any = pikkuSessionlessFunc<void, boolean | undefined>({
       mcpWiringsMetaFile,
       packageMappings,
       schemaDirectory,
+      schema,
     } = config
 
     await writeFileInDir(
@@ -81,7 +83,7 @@ export const pikkuMCP: any = pikkuSessionlessFunc<void, boolean | undefined>({
 
     // Populate arguments for prompts meta before serializing
     const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta }
-    for (const promptMeta of Object.values(promptsMetaWithArguments)) {
+    for (const promptMeta of Object.values(promptsMetaWithArguments) as any[]) {
       const functionMeta = functions.meta[promptMeta.pikkuFuncName]
       if (functionMeta) {
         const inputType = functionMeta.inputs?.[0]
@@ -94,13 +96,37 @@ export const pikkuMCP: any = pikkuSessionlessFunc<void, boolean | undefined>({
       }
     }
 
+    const metaData = {
+      resourcesMeta: mcpEndpoints.resourcesMeta,
+      toolsMeta: mcpEndpoints.toolsMeta,
+      promptsMeta: promptsMetaWithArguments,
+    }
+    await writeFileInDir(
+      logger,
+      config.mcpWiringsMetaJsonFile,
+      JSON.stringify(metaData, null, 2)
+    )
+
+    const jsonImportPath = getFileImportRelativePath(
+      mcpWiringsMetaFile,
+      config.mcpWiringsMetaJsonFile,
+      packageMappings
+    )
+
+    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
+    const importStatement = supportsImportAttributes
+      ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+      : `import metaData from '${jsonImportPath}'`
+
     await writeFileInDir(
       logger,
       mcpWiringsMetaFile,
       `import { pikkuState } from '@pikku/core'
-pikkuState('mcp', 'resourcesMeta', ${JSON.stringify(mcpEndpoints.resourcesMeta, null, 2)})
-pikkuState('mcp', 'toolsMeta', ${JSON.stringify(mcpEndpoints.toolsMeta, null, 2)})
-pikkuState('mcp', 'promptsMeta', ${JSON.stringify(promptsMetaWithArguments, null, 2)})`
+import type { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
+${importStatement}
+pikkuState('mcp', 'resourcesMeta', metaData.resourcesMeta as MCPResourceMeta)
+pikkuState('mcp', 'toolsMeta', metaData.toolsMeta as MCPToolMeta)
+pikkuState('mcp', 'promptsMeta', metaData.promptsMeta as MCPPromptMeta)`
     )
 
     return true

package/src/functions/wirings/mcp/serialize-mcp-types.ts

@@ -27,21 +27,21 @@ import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTy
  * @template In - Input type for the resource request
  * @template URI - URI template string type for compile-time parameter validation
  */
-type MCPResourceWiring<In, URI extends string> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse>> & { uri: URI }
+type MCPResourceWiring<In, URI extends string> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse, 'rpc' | 'session' | 'mcp'>> & { uri: URI }
 
 /**
  * Type definition for MCP tools that AI models can invoke.
  *
  * @template In - Input type for the tool invocation
  */
-type MCPToolWiring<In> = CoreMCPTool<PikkuFunctionConfig<In, MCPToolResponse>>
+type MCPToolWiring<In> = CoreMCPTool<PikkuFunctionConfig<In, MCPToolResponse, 'rpc' | 'session' | 'mcp'>>
 
 /**
  * Type definition for MCP prompts that provide templates to AI models.
  *
  * @template In - Input type for the prompt parameters
  */
-type MCPPromptWiring<In> = CoreMCPPrompt<PikkuFunctionConfig<In, MCPPromptResponse>>
+type MCPPromptWiring<In> = CoreMCPPrompt<PikkuFunctionConfig<In, MCPPromptResponse, 'rpc' | 'session' | 'mcp'>>
 
 /**
  * Registers an MCP resource with the Pikku framework.
@@ -93,12 +93,12 @@ export const wireMCPPrompt = <In>(
  */
 export const pikkuMCPPromptFunc = <In>(
   func:
-    | PikkuFunctionSessionless<In, MCPPromptResponse>
+    | PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp'>
     | {
-        func: PikkuFunctionSessionless<In, MCPPromptResponse>
+        func: PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp'>
         name?: string
       }
-): PikkuFunctionConfig<In, MCPPromptResponse> => {
+): PikkuFunctionConfig<In, MCPPromptResponse, 'mcp'> => {
   return typeof func === 'function' ? { func } : func
 }
 
@@ -112,12 +112,12 @@ export const pikkuMCPPromptFunc = <In>(
  */
 export const pikkuMCPToolFunc = <In>(
   func:
-    | PikkuFunctionSessionless<In, MCPToolResponse, null, true>
+    | PikkuFunctionSessionless<In, MCPToolResponse, 'mcp'>
     | {
-      func: PikkuFunctionSessionless<In, MCPToolResponse, null, true>
+      func: PikkuFunctionSessionless<In, MCPToolResponse, 'mcp'>
       name?: string
     }
-): PikkuFunctionConfig<In, MCPToolResponse> => {
+): PikkuFunctionConfig<In, MCPToolResponse, 'mcp'> => {
   return typeof func === 'function' ? { func } : func
 }
 
@@ -131,12 +131,12 @@ export const pikkuMCPToolFunc = <In>(
  */
 export const pikkuMCPResourceFunc = <In>(
   func:
-    | PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
+    | PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp'>
     | {
-      func: PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
+      func: PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp'>
       name?: string
     }
-): PikkuFunctionConfig<In, MCPResourceResponse> => {
+): PikkuFunctionConfig<In, MCPResourceResponse, 'mcp'> => {
   return typeof func === 'function' ? { func } : func
 }
 `

package/src/functions/wirings/middleware/pikku-command-middleware.ts

@@ -3,6 +3,7 @@ import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
 import { serializeMiddlewareImports } from './serialize-middleware-imports.js'
 import { serializeMiddlewareGroupsMeta } from './serialize-middleware-groups-meta.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 
 export const pikkuMiddleware: any = pikkuSessionlessFunc<
   void,
@@ -11,7 +12,7 @@ export const pikkuMiddleware: any = pikkuSessionlessFunc<
   func: async ({ logger, config, getInspectorState }) => {
     const state = await getInspectorState()
     const { middleware } = state
-    const { middlewareFile, packageMappings } = config
+    const { middlewareFile, packageMappings, schema } = config
 
     let filesGenerated = false
 
@@ -20,12 +21,44 @@ export const pikkuMiddleware: any = pikkuSessionlessFunc<
     const hasTagGroups = state.middleware.tagMiddleware.size > 0
 
     if (hasHTTPGroups || hasTagGroups) {
+      const metaData = serializeMiddlewareGroupsMeta(state)
+
+      // Write JSON file
       await writeFileInDir(
         logger,
+        config.middlewareGroupsMetaJsonFile,
+        JSON.stringify(metaData, null, 2)
+      )
+
+      // Calculate relative path from TS file to JSON file
+      const jsonImportPath = getFileImportRelativePath(
         config.middlewareGroupsMetaFile,
-        serializeMiddlewareGroupsMeta(state)
+        config.middlewareGroupsMetaJsonFile,
+        packageMappings
       )
 
+      // Write TypeScript file that imports JSON
+      const supportsImportAttributes = schema?.supportsImportAttributes ?? false
+      const importStatement = supportsImportAttributes
+        ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+        : `import metaData from '${jsonImportPath}'`
+
+      const tsContent = `import { pikkuState } from '@pikku/core'
+${importStatement}
+
+// HTTP middleware groups metadata
+if (metaData.httpGroups && Object.keys(metaData.httpGroups).length > 0) {
+  pikkuState('middleware', 'httpGroupMeta', metaData.httpGroups)
+}
+
+// Tag middleware groups metadata
+if (metaData.tagGroups && Object.keys(metaData.tagGroups).length > 0) {
+  pikkuState('middleware', 'tagGroupMeta', metaData.tagGroups)
+}
+`
+
+      await writeFileInDir(logger, config.middlewareGroupsMetaFile, tsContent)
+
       // Always generate middleware imports file when groups exist (even if empty)
       await writeFileInDir(
         logger,

package/src/functions/wirings/middleware/serialize-middleware-groups-meta.ts

@@ -1,14 +1,12 @@
 import type { InspectorState } from '@pikku/inspector'
 
 /**
- * Generates the middleware groups metadata file that stores metadata about
+ * Generates the middleware groups metadata that stores metadata about
  * tag-based and HTTP middleware groups for visualization and inspection.
  *
  * This includes services, middleware count, factory status, etc.
  */
 export const serializeMiddlewareGroupsMeta = (state: InspectorState) => {
-  const lines: string[] = [`import { pikkuState } from '@pikku/core'`, ``]
-
   // Serialize HTTP middleware groups metadata
   const httpGroups: Record<string, any> = {}
   for (const [pattern, meta] of state.http.routeMiddleware.entries()) {
@@ -22,14 +20,6 @@ export const serializeMiddlewareGroupsMeta = (state: InspectorState) => {
     }
   }
 
-  if (Object.keys(httpGroups).length > 0) {
-    lines.push(`// HTTP middleware groups metadata`)
-    lines.push(
-      `pikkuState('middleware', 'httpGroupMeta', ${JSON.stringify(httpGroups, null, 2)})`
-    )
-    lines.push(``)
-  }
-
   // Serialize tag middleware groups metadata
   const tagGroups: Record<string, any> = {}
   for (const [tag, meta] of state.middleware.tagMiddleware.entries()) {
@@ -43,13 +33,8 @@ export const serializeMiddlewareGroupsMeta = (state: InspectorState) => {
     }
   }
 
-  if (Object.keys(tagGroups).length > 0) {
-    lines.push(`// Tag middleware groups metadata`)
-    lines.push(
-      `pikkuState('middleware', 'tagGroupMeta', ${JSON.stringify(tagGroups, null, 2)})`
-    )
-    lines.push(``)
+  return {
+    httpGroups,
+    tagGroups,
   }
-
-  return lines.join('\n')
 }

package/src/functions/wirings/permissions/pikku-command-permissions.ts

@@ -17,10 +17,10 @@ export const pikkuPermissions: any = pikkuSessionlessFunc<
     // Check if there are any permission group factories
     const hasHTTPFactories = Array.from(
       state.http.routePermissions.values()
-    ).some((meta) => meta.exportName && meta.isFactory)
+    ).some((meta: any) => meta.exportName && meta.isFactory)
     const hasTagFactories = Array.from(
       state.permissions.tagPermissions.values()
-    ).some((meta) => meta.exportName && meta.isFactory)
+    ).some((meta: any) => meta.exportName && meta.isFactory)
     const hasFactories = hasHTTPFactories || hasTagFactories
 
     // Generate permissions imports file if there are factories