@pikku/cli 0.10.1 → 0.11.0

package/src/functions/commands/all.ts

@@ -2,9 +2,11 @@ import { existsSync } from 'fs'
 import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js'
 import { getFileImportRelativePath } from '../../utils/file-import-path.js'
 import { writeFileInDir } from '../../utils/file-writer.js'
+import { CommandSummary } from '../../utils/command-summary.js'
 
 export const all: any = pikkuVoidFunc({
   func: async ({ logger, config, rpc, getInspectorState }) => {
+    const summary = new CommandSummary('all')
     const allImports: string[] = []
     let typesDeclarationFileExists = true
 
@@ -16,7 +18,7 @@ export const all: any = pikkuVoidFunc({
 
     // This is needed since the wireHTTP function will add the routes to the visitState
     if (!typesDeclarationFileExists) {
-      logger.info(`• Type file first created, inspecting again...\x1b[0m`)
+      logger.debug(`• Type file first created, inspecting again...`)
       await getInspectorState(true)
     }
 
@@ -26,6 +28,7 @@ export const all: any = pikkuVoidFunc({
     await rpc.invoke('pikkuChannelTypes', null)
     await rpc.invoke('pikkuSchedulerTypes', null)
     await rpc.invoke('pikkuQueueTypes', null)
+    await rpc.invoke('pikkuWorkflowTypes', null)
     await rpc.invoke('pikkuMCPTypes', null)
     await rpc.invoke('pikkuCLITypes', null)
 
@@ -87,6 +90,30 @@ export const all: any = pikkuVoidFunc({
       )
     }
 
+    // Generate Workflows
+    const workflows = await rpc.invoke('pikkuWorkflow', null)
+
+    // Generate Remote RPC Workers (must be before queue discovery so wireQueueWorker calls are picked up)
+    const remoteRPC = await rpc.invoke('pikkuRemoteRPC', null)
+
+    // Reinspect to pick up generated workflow workers and remote RPC workers BEFORE generating maps
+    if (workflows || remoteRPC) {
+      await getInspectorState(true)
+    }
+
+    if (workflows) {
+      await rpc.invoke('pikkuWorkflowMap', null)
+      allImports.push(
+        config.workflowsWiringMetaFile,
+        config.workflowsWiringFile
+      )
+    }
+
+    if (remoteRPC && config.rpc?.remoteRpcWorkersPath) {
+      // Only add to imports if we actually generated the file
+      allImports.push(config.rpc.remoteRpcWorkersPath)
+    }
+
     // Generate Queues
     const queues = await rpc.invoke('pikkuQueue', null)
     if (queues) {
@@ -125,7 +152,7 @@ export const all: any = pikkuVoidFunc({
     }
 
     if (config.openAPI) {
-      logger.info(
+      logger.debug(
         `• OpenAPI requires a reinspection to pickup new generated types..`
       )
       await getInspectorState(true)
@@ -145,6 +172,43 @@ export const all: any = pikkuVoidFunc({
         .join('\n')
     )
 
+    // Get final inspector state and collect stats for summary
+    const state = await getInspectorState()
+    if (state.http?.meta)
+      summary.set('httpRoutes', Object.keys(state.http.meta).length)
+    if (state.channels?.meta)
+      summary.set('channels', Object.keys(state.channels.meta).length)
+    if (state.scheduledTasks?.meta)
+      summary.set(
+        'scheduledTasks',
+        Object.keys(state.scheduledTasks.meta).length
+      )
+    if (state.queueWorkers?.meta)
+      summary.set('queueWorkers', Object.keys(state.queueWorkers.meta).length)
+    if (state.mcpEndpoints) {
+      const mcpTotal =
+        Object.keys(state.mcpEndpoints.toolsMeta || {}).length +
+        Object.keys(state.mcpEndpoints.resourcesMeta || {}).length +
+        Object.keys(state.mcpEndpoints.promptsMeta || {}).length
+      if (mcpTotal > 0) summary.set('mcpEndpoints', mcpTotal)
+    }
+    if (state.cli?.meta) {
+      // Count total CLI commands across all programs
+      const totalCommands = Object.values(state.cli.meta).reduce(
+        (sum, program) => sum + (program.commands?.length || 0),
+        0
+      )
+      if (totalCommands > 0) summary.set('cliCommands', totalCommands)
+    }
+    if (state.workflows?.meta) {
+      summary.set('workflows', Object.keys(state.workflows.meta).length)
+    }
+
+    // Display summary (unless in silent mode)
+    if (!logger.isSilent()) {
+      console.log(summary.format())
+    }
+
     // Check for critical errors and exit if any were logged
     if (logger.hasCriticalErrors()) {
       process.exit(1)

package/src/functions/commands/bootstrap.ts

@@ -0,0 +1,28 @@
+import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js'
+
+export const bootstrap: any = pikkuVoidFunc({
+  func: async ({ logger, config, rpc, getInspectorState }) => {
+    // Initialize inspector state in bootstrap mode with core types only
+    // This allows bootstrap to run immediately without inspecting the codebase
+    // All subsequent RPC commands will use this cached state
+    await getInspectorState(false, false, true)
+
+    await rpc.invoke('pikkuFunctionTypes', null)
+
+    // Generate wiring-specific type files for tree-shaking
+    // These use the bootstrap mode state with core types
+    await rpc.invoke('pikkuFunctionTypesSplit', null)
+    await rpc.invoke('pikkuHTTPTypes', null)
+    await rpc.invoke('pikkuChannelTypes', null)
+    await rpc.invoke('pikkuSchedulerTypes', null)
+    await rpc.invoke('pikkuQueueTypes', null)
+    await rpc.invoke('pikkuWorkflowTypes', null)
+    await rpc.invoke('pikkuMCPTypes', null)
+    await rpc.invoke('pikkuCLITypes', null)
+
+    // Check for critical errors and exit if any were logged
+    if (logger.hasCriticalErrors()) {
+      process.exit(1)
+    }
+  },
+})

package/src/functions/runtimes/nextjs/serialize-nextjs-backend-wrapper.ts

@@ -6,14 +6,17 @@ export const serializeNextJsBackendWrapper = (
   sessionServicesImport: string
 ) => {
   return `'server-only'
-  
+
 /**
  * This file provides a wrapper around the PikkuNextJS class to allow for methods to be type checked against your routes.
  * It ensures type safety for route handling methods when integrating with the @pikku/core framework.
  */
 import { PikkuNextJS } from '@pikku/next'
+import { NextRequest } from 'next/server.js'
 import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
 
+type RouteContext = { params: Promise<Record<string, string | string[]>> }
+
 ${configImport}
 ${singleServicesFactoryImport}
 ${sessionServicesImport}
@@ -21,6 +24,11 @@ ${sessionServicesImport}
 import '${bootstrapPath}'
 
 let _pikku: PikkuNextJS | undefined
+let _removeAPIPrefix = true
+
+export const removeAPIPrefix = (enable: boolean) => {
+  _removeAPIPrefix = enable
+}
 
 /**
  * Initializes and returns an instance of PikkuNextJS with helper methods for handling route requests.
@@ -178,8 +186,44 @@ export const pikku = (_options?: any) => {
     patch: dynamicPatch,
     del: dynamicDel,
     staticGet,
-    staticPost
+    staticPost,
+  }
+}
+
+/**
+ * Pre-bound API request handler for Next.js App Router route handlers.
+ * Use this to directly export route handlers without losing context.
+ *
+ * @param req - The Next.js request object.
+ * @param context - Next.js route context (unused by Pikku, but required by Next.js signature).
+ * @returns A promise that resolves to a Next.js Response object.
+ *
+ * @example
+ * export const GET = pikkuAPIRequest
+ * export const POST = pikkuAPIRequest
+ */
+export const pikkuAPIRequest = (
+  req: NextRequest,
+  context: RouteContext
+): Promise<Response> => {
+  if (!_pikku) {
+    _pikku = new PikkuNextJS(
+      createConfig as any,
+      createSingletonServices as any,
+      createSessionServices
+    )
+  }
+  if (_removeAPIPrefix) {
+    const url = new URL(req.url)
+    url.pathname = url.pathname.replace(/^\\/api/, '') || '/'
+    req = new NextRequest(url.toString(), {
+      method: req.method,
+      headers: req.headers,
+      body: req.body,
+      duplex: 'half',
+    } as any)
   }
+  return _pikku.apiRequest(req)
 }
 `
 }

package/src/functions/wirings/channels/serialize-channel-types.ts

@@ -10,11 +10,12 @@ export const serializeChannelTypes = (functionTypesImportPath: string) => {
 import { CoreChannel, wireChannel as wireChannelCore } from '@pikku/core/channel'
 import { CorePikkuFunctionConfig } from '@pikku/core'
 import { AssertHTTPWiringParams } from '@pikku/core/http'
-import type { PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
+import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
 
 /**
  * Type definition for WebSocket channels with typed data exchange.
  * Supports connection, disconnection, and message handling.
+ * Accepts both session-based (PikkuFunction) and sessionless (PikkuFunctionSessionless) functions.
  *
  * @template ChannelData - Type of data exchanged through the channel
  * @template Channel - String literal type for the channel name
@@ -24,7 +25,7 @@ type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<
   Channel,
   CorePikkuFunctionConfig<PikkuFunctionSessionless<void, any, ChannelData>, PikkuPermission<void>, PikkuMiddleware>,
   CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void, ChannelData>, PikkuPermission<void>, PikkuMiddleware>,
-  CorePikkuFunctionConfig<PikkuFunctionSessionless<any, any, ChannelData>, PikkuPermission<any>, PikkuMiddleware>,
+  CorePikkuFunctionConfig<PikkuFunctionSessionless<any, any, ChannelData> | PikkuFunction<any, any, ChannelData>, PikkuPermission<any>, PikkuMiddleware>,
   PikkuPermission,
   PikkuMiddleware
 >

package/src/functions/wirings/channels/serialize-websocket-wrapper.ts

@@ -26,6 +26,20 @@ class PikkuWebSocketRoute<Channel extends keyof ChannelsMap, Route extends keyof
     }
 }
 
+/**
+ * Type-safe WebSocket wrapper for Pikku channels.
+ *
+ * @example
+ * // Browser usage
+ * const ws = new WebSocket('ws://localhost:3000')
+ * const pikkuWS = new PikkuWebSocket<'events'>(ws)
+ *
+ * @example
+ * // Node.js usage
+ * import WebSocket from 'ws'
+ * const ws = new WebSocket('ws://localhost:3000')
+ * const pikkuWS = new PikkuWebSocket<'events'>(ws)
+ */
 export class PikkuWebSocket<Channel extends keyof ChannelsMap, EventHubTopics extends Record<string, any> = {}> extends CorePikkuWebsocket {
     /**
      * Send a message to a specific route and method.

package/src/functions/wirings/cli/pikku-command-cli-entry.ts

@@ -52,8 +52,8 @@ export const pikkuCLIEntry: any = pikkuSessionlessFunc<void, void>({
         // Normalize entrypoint config to get type
         const entrypointType =
           typeof entrypointConfig === 'string'
-            ? 'cli'
-            : entrypointConfig.type || 'cli'
+            ? 'local'
+            : entrypointConfig.type || 'local'
 
         // Handle channel type entrypoint
         if (entrypointType === 'channel') {
@@ -152,11 +152,11 @@ export const pikkuCLIEntry: any = pikkuSessionlessFunc<void, void>({
           continue
         }
 
-        // Handle CLI type entrypoint (default)
+        // Handle local CLI type entrypoint (default)
         const entrypointPath =
           typeof entrypointConfig === 'string'
             ? entrypointConfig
-            : entrypointConfig.type === 'cli'
+            : entrypointConfig.type === 'local'
               ? entrypointConfig.path
               : undefined
 

package/src/functions/wirings/cli/serialize-channel-cli-client.ts

@@ -139,11 +139,11 @@ ${rendererImports}
  * Executes CLI commands over a WebSocket connection
  */
 export async function ${capitalizedName}CLIClient(
-  url: string,
+  ws: WebSocket,
   args?: string[]
 ): Promise<void> {
-  // Create WebSocket connection
-  const pikkuWS = new CorePikkuWebsocket(url)
+  // Create Pikku WebSocket wrapper
+  const pikkuWS = new CorePikkuWebsocket(ws)
 
   // Register renderers for CLI commands
   const renderers = ${renderersMap}
@@ -161,10 +161,23 @@ export default ${capitalizedName}CLIClient
 
 // For direct execution (if this file is run directly)
 if (import.meta.url === \`file://\${process.argv[1]}\`) {
-  const url = process.env.PIKKU_WS_URL || 'ws://localhost:3000${finalChannelRoute}'
-  ${capitalizedName}CLIClient(url, process.argv.slice(2)).catch(error => {
-    console.error('Fatal error:', error.message)
-    process.exit(1)
+  const url = process.env.PIKKU_WS_URL || 'ws://localhost:4002${finalChannelRoute}'
+
+  // Create WebSocket instance
+  let WebSocketImpl: any
+  if (typeof WebSocket !== 'undefined') {
+    WebSocketImpl = WebSocket
+  } else {
+    // Node.js environment - dynamically import 'ws'
+    const wsModule = await import('ws')
+    WebSocketImpl = wsModule.default
+  }
+
+  const ws = new WebSocketImpl(url) as WebSocket
+  ${capitalizedName}CLIClient(ws, process.argv.slice(2)).catch(error => {
+    console.error('Fatal channel CLI error:', error)
+    // TODO: We get an error code even when it exists cleanly, investigate
+    // process.exit(1)
   })
 }
 `

package/src/functions/wirings/cli/serialize-channel-cli.ts

@@ -47,13 +47,6 @@ export function serializeChannelCLI(
 
   collectCommands(programMeta.commands)
 
-  // Generate the wireChannel call
-  const commandEntries = Object.entries(commandMap)
-    .map(([commandKey, { pikkuFuncName }]) => {
-      return `      '${commandKey}': ${pikkuFuncName}`
-    })
-    .join(',\n')
-
   // Generate imports from function file locations
   const funcNames = [
     ...new Set(Object.values(commandMap).map((v) => v.pikkuFuncName)),
@@ -81,19 +74,58 @@ export function serializeChannelCLI(
     packageMappings
   )
 
+  // Get relative path to function types file
+  const functionTypesPath = getFileImportRelativePath(
+    channelFile,
+    functionTypesFile,
+    packageMappings
+  )
+
   return `/**
  * WebSocket channel backend for '${programName}' CLI commands
  */
 import { wireChannel } from '${channelTypesPath}'
+import { pikkuMiddleware } from '${functionTypesPath}'
 ${imports}
 
+// Middleware to close the channel after CLI command completes
+const cliCloseOnComplete = pikkuMiddleware(async (services, { channel }, next) => {
+  const closeChannel = () => {
+    setTimeout(async () => {
+      try {
+        // This gives time for the response to be sent before closing
+        await channel?.close()
+      } catch (err) {
+        // Ignore errors on close
+      }
+    }, 200)
+  }
+  
+  try {
+    const result = await next()
+    closeChannel()
+    return result
+  } catch (error) {
+    closeChannel()
+    throw error
+  }
+})
+
 wireChannel({
   name: '${finalChannelName}',
   route: '${finalChannelRoute}',
   auth: false,
   onMessageWiring: {
     command: {
-${commandEntries}
+${Object.entries(commandMap)
+  .map(
+    ([commandKey, { pikkuFuncName }]) =>
+      `      '${commandKey}': {
+        func: ${pikkuFuncName},
+        middleware: [cliCloseOnComplete],
+      }`
+  )
+  .join(',\n')}
     }
   },
   tags: ['cli', '${programName}']

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

@@ -30,6 +30,28 @@ ${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` :
  */
 type PikkuCLIRender<Data, RequiredServices extends SingletonServices = SingletonServices> = CorePikkuCLIRender<Data, RequiredServices, Session>
 
+/**
+ * Creates a type-safe CLI renderer with access to your application's singleton services.
+ * The renderer receives the full singleton services and output data to format and display results.
+ *
+ * @template Data - The output data type from the CLI command
+ * @template RequiredServices - The minimum services required for type checking (defaults to SingletonServices)
+ * @param render - Function that receives singleton services and data to render output
+ * @returns A CLI renderer configuration
+ *
+ * @example
+ * \`\`\`typescript
+ * const myRenderer = pikkuCLIRender<MyData>(({ logger }, data) => {
+ *   logger.info(data.message)
+ * })
+ * \`\`\`
+ */
+export const pikkuCLIRender = <Data, RequiredServices extends SingletonServices = SingletonServices>(
+  render: (services: SingletonServices, data: Data) => void | Promise<void>
+): PikkuCLIRender<Data, RequiredServices> => {
+  return render as any
+}
+
 /**
  * CLI command configuration with project-specific types.
  * Uses CoreCLICommandConfig from @pikku/core with local middleware and render types.

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

@@ -5,6 +5,8 @@ import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
 
 export const serializeServicesMap = (
+  allSingletonServices: string[],
+  allSessionServices: string[],
   requiredServices: Set<string>,
   forceRequiredServices: string[] = [],
   servicesImport: string,
@@ -18,8 +20,18 @@ export const serializeServicesMap = (
   // - Session factories
   const usedServices = new Set(requiredServices)
 
-  // Internal services that are created internally and not via the create service script
-  const internalServices = new Set(['rpc', 'mcp', 'channel', 'userSession'])
+  // Internal services that are created internally by the framework (PikkuInteraction)
+  // These should not appear in the services maps
+  const internalServices = new Set([
+    'rpc',
+    'mcp',
+    'channel',
+    'userSession',
+    'cli',
+    'http',
+    'queue',
+    'scheduledTask',
+  ])
 
   // Add force-required services that might not be detected from function inspection
   forceRequiredServices.forEach((service) => {
@@ -28,44 +40,59 @@ export const serializeServicesMap = (
     }
   })
 
-  // Create a map of services with true for all needed services
-  const servicesMap = Object.fromEntries(
-    Array.from(usedServices)
-      .sort()
-      .map((service) => [service, true])
-  )
-
-  // Generate the TypeScript code
-  const serviceKeys = Object.keys(servicesMap).sort()
-
   // Services that are always required internally by the framework
   const defaultServices = ['config', 'logger', 'variables', 'schema']
+  defaultServices.forEach((service) => usedServices.add(service))
 
-  // Combine default services with detected services
-  const allRequiredServices = [
-    ...new Set([...defaultServices, ...serviceKeys]),
-  ].sort()
+  // Create singleton services map: all singleton services with true/false based on usage
+  const singletonServicesMap: Record<string, boolean> = {}
+  allSingletonServices.forEach((service) => {
+    singletonServicesMap[service] = usedServices.has(service)
+  })
+
+  // Create session services map: all session services with true/false based on usage
+  // Exclude internal framework services (PikkuInteraction)
+  const sessionServicesMap: Record<string, boolean> = {}
+  allSessionServices.forEach((service) => {
+    if (!internalServices.has(service)) {
+      sessionServicesMap[service] = usedServices.has(service)
+    }
+  })
 
-  // For RequiredSingletonServices, we need to pick from the actual SingletonServices interface
-  // This will be resolved at compile time based on what's actually in the SingletonServices interface
-  // We don't need to hardcode which services are singletons beyond the core framework ones
+  // Get all required service names (those marked as true)
+  const requiredSingletonServiceNames = Object.keys(singletonServicesMap)
+    .filter((key) => singletonServicesMap[key])
+    .sort()
+  const requiredSessionServiceNames = Object.keys(sessionServicesMap)
+    .filter((key) => sessionServicesMap[key])
+    .sort()
 
   const code = [
     servicesImport,
     sessionServicesImport,
-    "import type { PikkuInteraction } from '@pikku/core'",
     '',
-    'export const singletonServices = {',
-    ...Object.keys(servicesMap).map((service) => `    '${service}': true,`),
+    '// Singleton services map: true if required, false if available but unused',
+    'export const requiredSingletonServices = {',
+    ...Object.keys(singletonServicesMap)
+      .sort()
+      .map((service) => `  '${service}': ${singletonServicesMap[service]},`),
+    '} as const',
+    '',
+    '// Session services map: true if required, false if available but unused',
+    'export const requiredSessionServices = {',
+    ...Object.keys(sessionServicesMap)
+      .sort()
+      .map((service) => `  '${service}': ${sessionServicesMap[service]},`),
     '} as const',
     '',
-    '// Singleton services (created once at startup)',
-    '// Only includes services that are both required and available in SingletonServices',
-    `export type RequiredSingletonServices = Pick<SingletonServices, Extract<keyof SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>> & Partial<Omit<SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>>`,
+    '// Type exports',
+    requiredSingletonServiceNames.length > 0
+      ? `export type RequiredSingletonServices = Pick<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
+      : 'export type RequiredSingletonServices = Partial<SingletonServices>',
     '',
-    '// Session services (created per request, can access singleton services)',
-    '// Omits singleton services and PikkuInteraction (mcp, rpc, http, channel)',
-    `export type RequiredSessionServices = Omit<Services, keyof SingletonServices | keyof PikkuInteraction>`,
+    requiredSessionServiceNames.length > 0
+      ? `export type RequiredSessionServices = Pick<Services, ${requiredSessionServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<Services, ${requiredSessionServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
+      : 'export type RequiredSessionServices = Partial<Services>',
     '',
   ].join('\n')
 
@@ -95,6 +122,8 @@ export const pikkuServices: any = pikkuSessionlessFunc<void, void>({
     const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, sessionServicesType.typePath, config.packageMappings)}'`
 
     const servicesCode = serializeServicesMap(
+      visitState.serviceAggregation.allSingletonServices,
+      visitState.serviceAggregation.allSessionServices,
       visitState.serviceAggregation.requiredServices,
       config.forceRequiredServices,
       servicesImport,

package/src/functions/wirings/functions/schemas.ts

@@ -21,7 +21,8 @@ export const pikkuSchemas: any = pikkuSessionlessFunc<
       visitState.functions.typesMap,
       visitState.functions.meta,
       visitState.http.meta,
-      config.schemasFromTypes
+      config.schemasFromTypes,
+      config.schema?.additionalProperties
     )
 
     await saveSchemas(
@@ -30,8 +31,8 @@ export const pikkuSchemas: any = pikkuSessionlessFunc<
       schemas,
       visitState.functions.typesMap,
       visitState.functions.meta,
-      config.supportsImportAttributes,
-      config.schemasFromTypes
+      config.schemasFromTypes,
+      config.schema?.supportsImportAttributes
     )
 
     return true

package/src/functions/wirings/http/pikku-command-openapi.ts

@@ -27,7 +27,8 @@ export const pikkuOpenAPI: any = pikkuSessionlessFunc<void, void>({
       functions.typesMap,
       functions.meta,
       http.meta,
-      schemasFromTypes
+      schemasFromTypes,
+      config.schema?.additionalProperties
     )
     const openAPISpec = await generateOpenAPISpec(
       logger,

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

@@ -15,17 +15,18 @@ export const pikkuMiddleware: any = pikkuSessionlessFunc<
 
     let filesGenerated = false
 
-    // Check if there are any middleware group factories
-    const hasHTTPFactories = Array.from(
-      state.http.routeMiddleware.values()
-    ).some((meta) => meta.exportName && meta.isFactory)
-    const hasTagFactories = Array.from(
-      state.middleware.tagMiddleware.values()
-    ).some((meta) => meta.exportName && meta.isFactory)
-    const hasFactories = hasHTTPFactories || hasTagFactories
+    // Check if there are any middleware groups
+    const hasHTTPGroups = state.http.routeMiddleware.size > 0
+    const hasTagGroups = state.middleware.tagMiddleware.size > 0
+
+    if (hasHTTPGroups || hasTagGroups) {
+      await writeFileInDir(
+        logger,
+        config.middlewareGroupsMetaFile,
+        serializeMiddlewareGroupsMeta(state)
+      )
 
-    // Generate middleware imports file if there are factories
-    if (hasFactories) {
+      // Always generate middleware imports file when groups exist (even if empty)
       await writeFileInDir(
         logger,
         middlewareFile,
@@ -36,19 +37,7 @@ export const pikkuMiddleware: any = pikkuSessionlessFunc<
           packageMappings
         )
       )
-      filesGenerated = true
-    }
 
-    // Generate middleware groups metadata file
-    const hasHTTPGroups = state.http.routeMiddleware.size > 0
-    const hasTagGroups = state.middleware.tagMiddleware.size > 0
-
-    if (hasHTTPGroups || hasTagGroups) {
-      await writeFileInDir(
-        logger,
-        config.middlewareGroupsMetaFile,
-        serializeMiddlewareGroupsMeta(state)
-      )
       filesGenerated = true
     }
 

package/src/functions/wirings/queue/pikku-queue.ts

@@ -14,10 +14,19 @@ export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean>({
     } = config
     const { queueWorkers } = visitState
 
+    // Add remote RPC worker to queue metadata if it exists
+    const queueMeta = { ...queueWorkers.meta }
+    if (config.rpc?.remoteRpcWorkersPath) {
+      queueMeta['pikku-remote-internal-rpc'] = {
+        pikkuFuncName: 'pikkuRemoteInternalRPC',
+        queueName: 'pikku-remote-internal-rpc',
+      }
+    }
+
     await writeFileInDir(
       logger,
       queueWorkersWiringMetaFile,
-      serializeQueueMeta(queueWorkers.meta)
+      serializeQueueMeta(queueMeta)
     )
     await writeFileInDir(
       logger,