@pikku/cli 0.10.0 → 0.10.2

package/dist/src/functions/commands/all.js

@@ -2,8 +2,10 @@ 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 = pikkuVoidFunc({
     func: async ({ logger, config, rpc, getInspectorState }) => {
+        const summary = new CommandSummary('all');
         const allImports = [];
         let typesDeclarationFileExists = true;
         if (!existsSync(config.typesDeclarationFile)) {
@@ -12,7 +14,7 @@ export const all = pikkuVoidFunc({
         await rpc.invoke('pikkuFunctionTypes', null);
         // 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);
         }
         // Generate wiring-specific type files for tree-shaking
@@ -97,7 +99,7 @@ export const all = pikkuVoidFunc({
             await rpc.invoke('pikkuNext', null);
         }
         if (config.openAPI) {
-            logger.info(`• OpenAPI requires a reinspection to pickup new generated types..`);
+            logger.debug(`• OpenAPI requires a reinspection to pickup new generated types..`);
             await getInspectorState(true);
             await rpc.invoke('pikkuOpenAPI', null);
         }
@@ -106,6 +108,33 @@ export const all = pikkuVoidFunc({
             .map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`)
             .sort((to) => (to.includes('meta') ? -1 : 1)) // Ensure meta files are at the top
             .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);
+        }
+        // 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/dist/src/functions/commands/bootstrap.d.ts

@@ -0,0 +1 @@
+export declare const bootstrap: any;

package/dist/src/functions/commands/bootstrap.js

@@ -0,0 +1,23 @@
+import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js';
+export const bootstrap = 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('pikkuMCPTypes', null);
+        await rpc.invoke('pikkuCLITypes', null);
+        // Check for critical errors and exit if any were logged
+        if (logger.hasCriticalErrors()) {
+            process.exit(1);
+        }
+    },
+});

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-backend-wrapper.js

@@ -1,13 +1,16 @@
 export const serializeNextJsBackendWrapper = (bootstrapPath, routesMapPath, configImport, singleServicesFactoryImport, sessionServicesImport) => {
     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}
@@ -15,6 +18,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.
@@ -172,8 +180,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/dist/src/functions/wirings/channels/serialize-channel-types.js

@@ -10,11 +10,12 @@ export const serializeChannelTypes = (functionTypesImportPath) => {
 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/dist/src/functions/wirings/channels/serialize-websocket-wrapper.js

@@ -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/dist/src/functions/wirings/cli/pikku-command-cli-entry.js

@@ -35,8 +35,8 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
             for (const entrypointConfig of configs) {
                 // 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') {
                     if (typeof entrypointConfig === 'string' ||
@@ -85,10 +85,10 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
                     }
                     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;
                 if (!entrypointPath) {

package/dist/src/functions/wirings/cli/serialize-channel-cli-client.js

@@ -102,8 +102,27 @@ export async function ${capitalizedName}CLIClient(
   url: string,
   args?: string[]
 ): Promise<void> {
+  // Get WebSocket implementation (browser or Node.js)
+  let WebSocketImpl: any
+  if (typeof WebSocket !== 'undefined') {
+    WebSocketImpl = WebSocket
+  } else {
+    // Node.js environment - dynamically import 'ws'
+    try {
+      const wsModule = await import('ws')
+      WebSocketImpl = wsModule.default
+    } catch (e) {
+      throw new Error(
+        'No WebSocket implementation found. In Node.js environments, you need to:\\n' +
+        '1. Install the "ws" package: npm install ws\\n' +
+        'Learn more: https://www.npmjs.com/package/ws'
+      )
+    }
+  }
+
   // Create WebSocket connection
-  const pikkuWS = new CorePikkuWebsocket(url)
+  const ws = new WebSocketImpl(url) as WebSocket
+  const pikkuWS = new CorePikkuWebsocket(ws)
 
   // Register renderers for CLI commands
   const renderers = ${renderersMap}
@@ -121,10 +140,11 @@ 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}'
+  const url = process.env.PIKKU_WS_URL || 'ws://localhost:4002${finalChannelRoute}'
   ${capitalizedName}CLIClient(url, process.argv.slice(2)).catch(error => {
-    console.error('Fatal error:', error.message)
-    process.exit(1)
+    console.error('Fatal channel CLI error:', error)
+    // TODO: We get an error code even when it exists cleanly, investigate
+    // process.exit(1)
   })
 }
 `;

package/dist/src/functions/wirings/cli/serialize-channel-cli.js

@@ -24,12 +24,6 @@ export function serializeChannelCLI(programName, programMeta, channelFile, funct
         }
     };
     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)),
@@ -46,19 +40,50 @@ export function serializeChannelCLI(programName, programMeta, channelFile, funct
         .join('\n');
     // Get relative path to channel types file
     const channelTypesPath = getFileImportRelativePath(channelFile, channelTypesFile, 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/dist/src/functions/wirings/cli/serialize-cli-types.js

@@ -24,6 +24,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/dist/src/functions/wirings/functions/pikku-command-services.d.ts

@@ -1,2 +1,2 @@
-export declare const serializeServicesMap: (requiredServices: Set<string>, forceRequiredServices: string[] | undefined, servicesImport: string, sessionServicesImport: string) => string;
+export declare const serializeServicesMap: (allSingletonServices: string[], allSessionServices: string[], requiredServices: Set<string>, forceRequiredServices: string[] | undefined, servicesImport: string, sessionServicesImport: string) => string;
 export declare const pikkuServices: any;

package/dist/src/functions/wirings/functions/pikku-command-services.js

@@ -3,7 +3,7 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-export const serializeServicesMap = (requiredServices, forceRequiredServices = [], servicesImport, sessionServicesImport) => {
+export const serializeServicesMap = (allSingletonServices, allSessionServices, requiredServices, forceRequiredServices = [], servicesImport, sessionServicesImport) => {
     // Use pre-aggregated services from inspector state
     // This includes services from:
     // - Wired functions (HTTP, channels, queues, schedulers, MCP, CLI, RPC)
@@ -11,45 +11,73 @@ export const serializeServicesMap = (requiredServices, forceRequiredServices = [
     // - Permissions used by wired functions
     // - 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) => {
         if (!internalServices.has(service)) {
             usedServices.add(service);
         }
     });
-    // 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'];
-    // Combine default services with detected services
-    const allRequiredServices = [
-        ...new Set([...defaultServices, ...serviceKeys]),
-    ].sort();
-    // 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
+    defaultServices.forEach((service) => usedServices.add(service));
+    // Create singleton services map: all singleton services with true/false based on usage
+    const singletonServicesMap = {};
+    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 = {};
+    allSessionServices.forEach((service) => {
+        if (!internalServices.has(service)) {
+            sessionServicesMap[service] = usedServices.has(service);
+        }
+    });
+    // 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');
     return code;
@@ -68,7 +96,7 @@ export const pikkuServices = pikkuSessionlessFunc({
         }
         const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, singletonServicesType.typePath, config.packageMappings)}'`;
         const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, sessionServicesType.typePath, config.packageMappings)}'`;
-        const servicesCode = serializeServicesMap(visitState.serviceAggregation.requiredServices, config.forceRequiredServices, servicesImport, sessionServicesImport);
+        const servicesCode = serializeServicesMap(visitState.serviceAggregation.allSingletonServices, visitState.serviceAggregation.allSessionServices, visitState.serviceAggregation.requiredServices, config.forceRequiredServices, servicesImport, sessionServicesImport);
         await writeFileInDir(logger, config.servicesFile, servicesCode);
     },
     middleware: [

package/dist/src/functions/wirings/functions/schemas.js

@@ -7,8 +7,8 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 export const pikkuSchemas = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const schemas = await generateSchemas(logger, config.tsconfig, visitState.functions.typesMap, visitState.functions.meta, visitState.http.meta, config.schemasFromTypes);
-        await saveSchemas(logger, config.schemaDirectory, schemas, visitState.functions.typesMap, visitState.functions.meta, config.supportsImportAttributes, config.schemasFromTypes);
+        const schemas = await generateSchemas(logger, config.tsconfig, visitState.functions.typesMap, visitState.functions.meta, visitState.http.meta, config.schemasFromTypes, config.schema?.additionalProperties);
+        await saveSchemas(logger, config.schemaDirectory, schemas, visitState.functions.typesMap, visitState.functions.meta, config.schemasFromTypes, config.schema?.supportsImportAttributes);
         return true;
     },
     middleware: [

package/dist/src/functions/wirings/http/pikku-command-openapi.js

@@ -16,7 +16,7 @@ export const pikkuOpenAPI = pikkuSessionlessFunc({
             return;
         }
         const { http, functions } = await getInspectorState();
-        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta, schemasFromTypes);
+        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta, schemasFromTypes, config.schema?.additionalProperties);
         const openAPISpec = await generateOpenAPISpec(logger, functions.meta, http.meta, schemas, openAPI.additionalInfo);
         if (openAPI.outputFile.endsWith('.json')) {
             await writeFileInDir(logger, openAPI.outputFile, JSON.stringify(openAPISpec, null, 2), { ignoreModifyComment: true });

package/dist/src/functions/wirings/middleware/pikku-command-middleware.js

@@ -9,20 +9,13 @@ export const pikkuMiddleware = pikkuSessionlessFunc({
         const { middleware } = state;
         const { middlewareFile, packageMappings } = config;
         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;
-        // Generate middleware imports file if there are factories
-        if (hasFactories) {
-            await writeFileInDir(logger, middlewareFile, serializeMiddlewareImports(middlewareFile, middleware, state.http, packageMappings));
-            filesGenerated = true;
-        }
-        // Generate middleware groups metadata file
+        // 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));
+            // Always generate middleware imports file when groups exist (even if empty)
+            await writeFileInDir(logger, middlewareFile, serializeMiddlewareImports(middlewareFile, middleware, state.http, packageMappings));
             filesGenerated = true;
         }
         return filesGenerated;

package/dist/src/middleware/log-command-info-and-time.d.ts

@@ -7,7 +7,7 @@ export interface LogCommandInfoOptions {
 }
 /**
  * Middleware to log command execution timing and status
- * Replaces the logCommandInfoAndTime wrapper function
+ * Uses debug level so it only shows with --verbose flag
  */
 export declare const logCommandInfoAndTime: ({ commandStart, commandEnd, }: LogCommandInfoOptions) => PikkuMiddleware;
 export {};

package/dist/src/middleware/log-command-info-and-time.js

@@ -1,15 +1,18 @@
 /**
  * Middleware to log command execution timing and status
- * Replaces the logCommandInfoAndTime wrapper function
+ * Uses debug level so it only shows with --verbose flag
  */
 export const logCommandInfoAndTime = ({ commandStart, commandEnd, }) => {
     return async ({ logger }, _interaction, next) => {
-        // Log start
+        // Log start (debug level - only shows with --verbose)
         const start = Date.now();
-        logger.info(`• ${commandStart}...`);
+        logger.debug(`• ${commandStart}...`);
         // Execute the function
         await next();
-        // Log completion
-        logger.info(`✓ ${commandEnd} in ${Date.now() - start}ms.`);
+        // Log completion (debug level - only shows with --verbose)
+        logger.debug({
+            type: 'success',
+            message: `✓ ${commandEnd} in ${Date.now() - start}ms.`,
+        });
     };
 };

package/dist/src/services/cli-logger.service.d.ts

@@ -9,15 +9,20 @@ export declare class CLILogger implements Logger {
         silent?: boolean;
     });
     setLevel(level: LogLevel): void;
+    setSilent(silent: boolean): void;
+    isSilent(): boolean;
     info(message: string | {
         message: string;
         type?: string;
     }): void;
     error(message: string): void;
     warn(message: string): void;
-    debug(message: string): void;
+    debug(message: string | {
+        message: string;
+        type?: string;
+    }): void;
     critical(code: ErrorCode, message: string): void;
     hasCriticalErrors(): boolean;
-    private logPikkuLogo;
+    logLogo(): void;
     private primary;
 }