@pikku/cli 0.9.16-next.0 → 0.10.0

package/dist/src/functions/wirings/channels/serialize-channel-types.js

@@ -3,14 +3,14 @@
  */
 export const serializeChannelTypes = (functionTypesImportPath) => {
     return `/**
- * This file was generated by the @pikku/cli
+
  * Channel-specific type definitions for tree-shaking optimization
  */
 
 import { CoreChannel, wireChannel as wireChannelCore } from '@pikku/core/channel'
 import { CorePikkuFunctionConfig } from '@pikku/core'
 import { AssertHTTPWiringParams } from '@pikku/core/http'
-import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
+import type { PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
 
 /**
  * Type definition for WebSocket channels with typed data exchange.
@@ -19,64 +19,63 @@ import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMid
  * @template ChannelData - Type of data exchanged through the channel
  * @template Channel - String literal type for the channel name
  */
-type ChannelWiringFunction<I, O, C = {}> = PikkuFunctionSessionless<I, O, C> | PikkuFunction<I, O, C>
-type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<ChannelData, Channel, ChannelWiringFunction<void, unknown> | ChannelWiringFunction<void, unknown, ChannelData>, ChannelWiringFunction<void, void> | ChannelWiringFunction<void, void, ChannelData>, ChannelWiringFunction<any, any> | ChannelWiringFunction<any, any, ChannelData>, PikkuPermission, PikkuMiddleware>
+type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<
+  ChannelData,
+  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>,
+  PikkuPermission,
+  PikkuMiddleware
+>
 
 /**
  * Creates a function that handles WebSocket channel connections.
  * Called when a client connects to a channel.
  *
  * @template Out - Output type for connection response
- * @template ChannelData - Type of data associated with the channel
  * @param func - Function definition, either direct function or configuration object
- * @returns The unwrapped function for internal use
+ * @returns The normalized configuration object
  */
-export const pikkuChannelConnectionFunc = <Out = unknown, ChannelData = unknown>(
+export const pikkuChannelConnectionFunc = <Out = unknown>(
   func:
-    | PikkuFunctionSessionless<void, Out, ChannelData>
-    | {
-        func: PikkuFunctionSessionless<void, Out, ChannelData>
-        name?: string
-      }
+    | PikkuFunctionSessionless<void, Out, unknown>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, Out, unknown>, PikkuPermission<void>, PikkuMiddleware>
 ) => {
-  return typeof func === 'function' ? func : func.func
+  return typeof func === 'function' ? { func } : func
 }
 
 /**
  * Creates a function that handles WebSocket channel disconnections.
  * Called when a client disconnects from a channel.
  *
- * @template ChannelData - Type of data associated with the channel
  * @param func - Function definition, either direct function or configuration object
- * @returns The unwrapped function for internal use
+ * @returns The normalized configuration object
  */
-export const pikkuChannelDisconnectionFunc = <ChannelData = unknown>(
+export const pikkuChannelDisconnectionFunc = (
   func:
-    | PikkuFunctionSessionless<void, void, ChannelData>
-    | {
-        func: PikkuFunction<void, void, ChannelData>
-        name?: string
-      }
+    | PikkuFunctionSessionless<void, void, unknown>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void, unknown>, PikkuPermission<void>, PikkuMiddleware>
 ) => {
-  return typeof func === 'function' ? func : func.func
+  return typeof func === 'function' ? { func } : func
 }
 
 /**
  * Creates a function that handles WebSocket channel messages.
  * Called when a message is received on a channel.
+ * This is the same as pikkuSessionlessFunc but with ChannelData = unknown by default.
  *
  * @template In - Input type for channel messages
  * @template Out - Output type for channel responses
- * @template ChannelData - Type of data associated with the channel
  * @param func - Function definition, either direct function or configuration object
- * @returns The unwrapped function for internal use
+ * @returns The normalized configuration object
  */
-export const pikkuChannelFunc = <In = unknown, Out = unknown, ChannelData = unknown>(
+export const pikkuChannelFunc = <In, Out = unknown>(
   func:
-    | PikkuFunctionSessionless<In, Out, ChannelData>
-    | CorePikkuFunctionConfig<PikkuFunction<In, Out, ChannelData>, PikkuPermission<In>>
+    | PikkuFunctionSessionless<In, Out, unknown>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out, unknown>, PikkuPermission<In>, PikkuMiddleware>
 ) => {
-  return typeof func === 'function' ? func : func.func
+  return typeof func === 'function' ? { func } : func
 }
 
 /**

package/dist/src/functions/wirings/channels/serialize-typed-channel-map.js

@@ -4,7 +4,10 @@ export const serializeTypedChannelsMap = (relativeToPath, packageMappings, types
     const { channels, requiredTypes } = generateChannels(functionsMeta, channelsMeta);
     typesMap.customTypes.forEach(({ references }) => {
         for (const reference of references) {
-            requiredTypes.add(reference);
+            // Skip __object types (placeholder types for invalid/broken functions)
+            if (reference !== '__object' && !reference.startsWith('__object_')) {
+                requiredTypes.add(reference);
+            }
         }
     });
     const imports = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);

package/dist/src/functions/wirings/cli/pikku-command-cli-entry.js

@@ -5,7 +5,10 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { join } from 'node:path';
 import { serializeLocalCLIBootstrap } from './serialize-local-cli-bootstrap.js';
 import { serializeChannelCLI } from './serialize-channel-cli.js';
-import { serializeChannelCLIClient } from './serialize-channel-cli-client.js';
+import { serializeChannelCLIClient, collectRendererNames, } from './serialize-channel-cli-client.js';
+import { existsSync } from 'fs';
+import { rm } from 'fs/promises';
+import { ErrorCode } from '@pikku/inspector';
 export const pikkuCLIEntry = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
@@ -20,7 +23,7 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
         }
         // Generate bootstrap files for each configured entrypoint
         for (const [programName, entrypointConfigs] of Object.entries(config.cli.entrypoints)) {
-            const programMeta = visitState.cli.meta[programName];
+            const programMeta = visitState.cli.meta.programs[programName];
             if (!programMeta) {
                 logger.warn(`CLI program '${programName}' not found in metadata, skipping`);
                 continue;
@@ -51,7 +54,32 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
                     // Generate client code if clientPath is provided
                     if (channelClientPath) {
                         const channelClientFile = join(config.rootDir, channelClientPath);
-                        const clientCode = serializeChannelCLIClient(programName, programMeta, channelClientFile, config, config.bootstrapFiles.cli, channelRoute);
+                        // Validate that renderers don't depend on services (client-side renderers can't access server services)
+                        const rendererNames = collectRendererNames(programMeta);
+                        const problematicRenderers = [];
+                        for (const rendererName of rendererNames) {
+                            const rendererMeta = visitState.cli.meta.renderers[rendererName];
+                            if (rendererMeta?.services?.services?.length > 0) {
+                                problematicRenderers.push({
+                                    name: rendererName,
+                                    services: rendererMeta.services.services,
+                                });
+                            }
+                        }
+                        // If any renderers depend on services, abort client generation
+                        if (problematicRenderers.length > 0) {
+                            const details = problematicRenderers
+                                .map((r) => `  - ${r.name} depends on: ${r.services.join(', ')}`)
+                                .join('\n');
+                            logger.critical(ErrorCode.CLI_CLIENTSIDE_RENDERER_HAS_SERVICES, `Cannot generate CLI channel client for '${programName}': renderers cannot depend on services (client-side execution)\n${details}\n\nRenderers used in CLI-over-channel must be service-free since they execute on the client.`);
+                            // Delete existing client file if it exists
+                            if (existsSync(channelClientFile)) {
+                                await rm(channelClientFile);
+                                logger.debug(`Deleted existing CLI channel client: ${channelClientFile}`);
+                            }
+                            continue;
+                        }
+                        const clientCode = serializeChannelCLIClient(programName, programMeta, channelClientFile, config, config.bootstrapFile, channelRoute, visitState.cli.meta.renderers);
                         await writeFileInDir(logger, channelClientFile, clientCode);
                         logger.debug(`Serialized CLI channel client for ${programName}: ${channelClientFile}`);
                     }
@@ -90,11 +118,6 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Serializing CLI',
             commandEnd: 'Serialized CLI',
-            skipCondition: async ({ getInspectorState }) => {
-                const visitState = await getInspectorState();
-                return visitState.cli.files.size === 0;
-            },
-            skipMessage: 'none found',
         }),
     ],
 });

package/dist/src/functions/wirings/cli/pikku-command-cli-types.js

@@ -26,8 +26,6 @@ export const pikkuCLITypes = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Creating CLI types',
             commandEnd: 'Created CLI types',
-            skipCondition: false,
-            skipMessage: '',
         }),
     ],
 });

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

@@ -17,8 +17,6 @@ export const pikkuCLI = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Finding CLI commands',
             commandEnd: 'Found CLI commands',
-            skipCondition: false,
-            skipMessage: 'none found',
         }),
     ],
 });

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

@@ -1,7 +1,11 @@
-import { CLIProgramMeta } from '@pikku/core';
+import { CLIProgramMeta } from '@pikku/core/cli';
 import { Config } from '../../../../types/application-types.js';
+/**
+ * Collect all unique renderer names from CLI metadata (populated by inspector)
+ */
+export declare function collectRendererNames(programMeta: CLIProgramMeta): Set<string>;
 /**
  * Serializes a CLI-over-Channel client bootstrap file
  * Similar to local CLI bootstrap but uses WebSocket connection
  */
-export declare function serializeChannelCLIClient(programName: string, programMeta: CLIProgramMeta, clientFile: string, config: Config, cliBootstrapPath: string, channelRoute?: string): string;
+export declare function serializeChannelCLIClient(programName: string, programMeta: CLIProgramMeta, clientFile: string, config: Config, cliBootstrapPath: string, channelRoute?: string, renderersMeta?: Record<string, any>): string;

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

@@ -1,22 +1,99 @@
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+/**
+ * Collect all unique renderer names from CLI metadata (populated by inspector)
+ */
+export function collectRendererNames(programMeta) {
+    const rendererNames = new Set();
+    // Add program-level default renderer
+    if (programMeta.defaultRenderName) {
+        rendererNames.add(programMeta.defaultRenderName);
+    }
+    // Recursively collect renderer names from commands
+    function collectFromCommand(command) {
+        if (command.renderName) {
+            rendererNames.add(command.renderName);
+        }
+        // Recursively process subcommands
+        if (command.subcommands) {
+            for (const subCommand of Object.values(command.subcommands)) {
+                collectFromCommand(subCommand);
+            }
+        }
+    }
+    // Process all commands
+    for (const command of Object.values(programMeta.commands)) {
+        collectFromCommand(command);
+    }
+    return rendererNames;
+}
+/**
+ * Build a renderers map for CLI commands
+ */
+function buildRenderersMap(programMeta) {
+    const entries = [];
+    // Build map entries for each command that has a renderer
+    function addCommandRenderer(command, path) {
+        const commandId = path.join('.');
+        if (command.renderName) {
+            entries.push(`    '${commandId}': ${command.renderName}`);
+        }
+        // Recursively process subcommands
+        if (command.subcommands) {
+            for (const [subName, subCommand] of Object.entries(command.subcommands)) {
+                addCommandRenderer(subCommand, [...path, subName]);
+            }
+        }
+    }
+    // Process all commands
+    for (const [commandName, command] of Object.entries(programMeta.commands)) {
+        addCommandRenderer(command, [commandName]);
+    }
+    if (entries.length === 0) {
+        return '{}';
+    }
+    return `{\n${entries.join(',\n')}\n  }`;
+}
 /**
  * Serializes a CLI-over-Channel client bootstrap file
  * Similar to local CLI bootstrap but uses WebSocket connection
  */
-export function serializeChannelCLIClient(programName, programMeta, clientFile, config, cliBootstrapPath, channelRoute) {
+export function serializeChannelCLIClient(programName, programMeta, clientFile, config, cliBootstrapPath, channelRoute, renderersMeta) {
     const capitalizedName = programName.charAt(0).toUpperCase() + programName.slice(1).replace(/-/g, '');
     const finalChannelRoute = channelRoute || `/cli/${programName}`;
     // Get relative import path to CLI bootstrap (for metadata)
     const bootstrapImportPath = getFileImportRelativePath(clientFile, cliBootstrapPath, config.packageMappings);
-    // TODO: Collect renderer imports and create renderers map
-    // For now, renderers are not implemented
-    return `/**
- * This file was generated by the @pikku/cli
- */
+    // Collect all unique renderer names from CLI metadata (populated by inspector)
+    const rendererNames = collectRendererNames(programMeta);
+    // Generate renderer imports from their source files
+    let rendererImports = '';
+    if (rendererNames.size > 0 && renderersMeta) {
+        const importsByFile = new Map();
+        for (const rendererName of rendererNames) {
+            const meta = renderersMeta[rendererName];
+            if (meta?.exportedName && meta?.filePath) {
+                const relativePath = getFileImportRelativePath(clientFile, meta.filePath, config.packageMappings);
+                if (!importsByFile.has(relativePath)) {
+                    importsByFile.set(relativePath, []);
+                }
+                importsByFile.get(relativePath).push(meta.exportedName);
+            }
+        }
+        // Generate import statements
+        for (const [path, names] of importsByFile) {
+            rendererImports += `import { ${names.join(', ')} } from '${path}'\n`;
+        }
+    }
+    // Build renderers map
+    const renderersMap = buildRenderersMap(programMeta);
+    // Determine default renderer
+    const defaultRendererCode = programMeta.defaultRenderName
+        ? `,\n    defaultRenderer: ${programMeta.defaultRenderName}`
+        : '';
+    return `
 import { executeCLIViaChannel } from '@pikku/core/cli/channel'
 import { CorePikkuWebsocket } from '@pikku/websocket'
 import '${bootstrapImportPath}'
-
+${rendererImports}
 /**
  * ${capitalizedName} CLI Client (via WebSocket Channel)
  * Executes CLI commands over a WebSocket connection
@@ -28,14 +105,14 @@ export async function ${capitalizedName}CLIClient(
   // Create WebSocket connection
   const pikkuWS = new CorePikkuWebsocket(url)
 
-  // TODO: Import and register renderers when renderer tracking is implemented
-  const renderers = {}
+  // Register renderers for CLI commands
+  const renderers = ${renderersMap}
 
   await executeCLIViaChannel({
     programName: '${programName}',
     pikkuWS,
     args,
-    renderers,
+    renderers${defaultRendererCode},
   })
 }
 
@@ -45,7 +122,7 @@ 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).catch(error => {
+  ${capitalizedName}CLIClient(url, process.argv.slice(2)).catch(error => {
     console.error('Fatal error:', error.message)
     process.exit(1)
   })

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

@@ -1,4 +1,4 @@
-import { CLIProgramMeta } from '@pikku/core';
+import { CLIProgramMeta } from '@pikku/core/cli';
 /**
  * Serializes a wireChannel call from CLI metadata
  * This creates a WebSocket backend for all CLI commands

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

@@ -44,35 +44,18 @@ export function serializeChannelCLI(programName, programMeta, channelFile, funct
         return `import { ${fileInfo.exportedName} } from '${importPath}'`;
     })
         .join('\n');
-    // Get relative paths to type files
+    // Get relative path to channel types file
     const channelTypesPath = getFileImportRelativePath(channelFile, channelTypesFile, packageMappings);
-    const functionTypesPath = getFileImportRelativePath(channelFile, functionTypesFile, packageMappings);
     return `/**
- * This file was generated by the @pikku/cli
  * WebSocket channel backend for '${programName}' CLI commands
  */
 import { wireChannel } from '${channelTypesPath}'
-import { PikkuMiddleware } from '${functionTypesPath}'
 ${imports}
 
-// Middleware to close channel after command execution
-const closeAfterExecution: PikkuMiddleware = async (_services, interaction, next) => {
-  try {
-    const result = await next()
-    return result
-  } finally {
-    // Close the channel after function completes
-    if (interaction.channel) {
-      await interaction.channel.close()
-    }
-  }
-}
-
 wireChannel({
   name: '${finalChannelName}',
   route: '${finalChannelRoute}',
   auth: false,
-  middleware: [closeAfterExecution],
   onMessageWiring: {
     command: {
 ${commandEntries}

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

@@ -3,11 +3,11 @@
  */
 export const serializeCLITypes = (functionTypesImportPath, userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName) => {
     return `/**
- * This file was generated by the @pikku/cli
+
  * CLI-specific type definitions for tree-shaking optimization
  */
 
-import { CoreCLI, wireCLI as wireCLICore, CorePikkuCLIRender, CoreCLICommandConfig } from '@pikku/core'
+import { CoreCLI, wireCLI as wireCLICore, CorePikkuCLIRender, CoreCLICommandConfig } from '@pikku/core/cli'
 import type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImportPath}'
 ${userSessionTypeImport}
 ${singletonServicesTypeImport}
@@ -28,12 +28,7 @@ type PikkuCLIRender<Data, RequiredServices extends SingletonServices = Singleton
  * CLI command configuration with project-specific types.
  * Uses CoreCLICommandConfig from @pikku/core with local middleware and render types.
  */
-type CLICommandConfig<Func extends PikkuFunctionConfig<any, any>> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>>
-
-/**
- * Result type for CLI command configuration
- */
-type CLICommandResult<Func extends PikkuFunctionConfig<any, any>> = CLICommandConfig<Func>
+type CLICommandConfig<Func extends PikkuFunctionConfig<In, Out>, In = any, Out = any, Params extends string = string> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>, Params>
 
 /**
  * Type definition for CLI applications with commands and global options.
@@ -41,7 +36,7 @@ type CLICommandResult<Func extends PikkuFunctionConfig<any, any>> = CLICommandCo
  * @template Commands - Type describing the command structure
  * @template GlobalOptions - Type for global CLI options
  */
-type CLIWiring<Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>>>, GlobalOptions> = CoreCLI<Commands, GlobalOptions, PikkuMiddleware, PikkuCLIRender<any>>
+type CLIWiring<Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>, any>>, GlobalOptions> = CoreCLI<Commands, GlobalOptions, PikkuMiddleware, PikkuCLIRender<any>>
 
 /**
  * Registers a CLI application with the Pikku framework.
@@ -51,7 +46,7 @@ type CLIWiring<Commands extends Record<string, CoreCLICommandConfig<any, PikkuMi
  * @template GlobalOptions - Type for global CLI options
  * @param cli - CLI definition with program name, commands, and global options
  */
-export const wireCLI = <Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>>>, GlobalOptions>(
+export const wireCLI = <Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>, any>>, GlobalOptions>(
   cli: CLIWiring<Commands, GlobalOptions>
 ) => {
   wireCLICore(cli as any)
@@ -61,13 +56,17 @@ export const wireCLI = <Commands extends Record<string, CoreCLICommandConfig<any
  * Creates a CLI command definition with automatic option inference from the function's input type.
  * This allows TypeScript to automatically derive CLI options from the function signature.
  *
- * @template Func - The Pikku function config type to create a CLI command for
+ * @template FuncConfig - The Pikku function config type
+ * @template Params - The parameters string literal type
  * @param config - CLI command configuration
  * @returns CLI command configuration with inferred types
  */
-export const pikkuCLICommand = <Func extends PikkuFunctionConfig<any, any>>(
-  config: CLICommandConfig<Func>
-): CLICommandResult<Func> => {
+export const pikkuCLICommand = <
+  FuncConfig extends PikkuFunctionConfig<any, any>,
+  Params extends string
+>(
+  config: CLICommandConfig<FuncConfig, any, any, Params>
+): CoreCLICommandConfig<FuncConfig, PikkuMiddleware, PikkuCLIRender<any>, string> => {
   return config as any
 }
 `;

package/dist/src/functions/wirings/cli/serialize-local-cli-bootstrap.js

@@ -8,11 +8,9 @@ export function serializeLocalCLIBootstrap(programName, _programMeta, bootstrapF
     const pikkuConfigPath = getFileImportRelativePath(bootstrapFile, pikkuConfigFactory.file, config.packageMappings);
     const singletonServicesPath = getFileImportRelativePath(bootstrapFile, singletonServicesFactory.file, config.packageMappings);
     const sessionServicesPath = getFileImportRelativePath(bootstrapFile, sessionServicesFactory.file, config.packageMappings);
-    const cliBootstrapPath = getFileImportRelativePath(bootstrapFile, config.bootstrapFiles.cli, config.packageMappings);
-    return `/**
- * This file was generated by the @pikku/cli
- */
-import { executeCLI } from '@pikku/core'
+    const cliBootstrapPath = getFileImportRelativePath(bootstrapFile, config.bootstrapFile, config.packageMappings);
+    return `
+import { executeCLI, CLIError } from '@pikku/core/cli'
 import { ${pikkuConfigFactory.variable} as createConfig } from '${pikkuConfigPath}'
 import { ${singletonServicesFactory.variable} as createSingletonServices } from '${singletonServicesPath}'
 import { ${sessionServicesFactory.variable} as createSessionServices } from '${sessionServicesPath}'
@@ -22,14 +20,21 @@ import '${cliBootstrapPath}'
  * ${capitalizedName} CLI function
  * Handles command line arguments and executes the appropriate function
  */
-export async function ${capitalizedName}CLI(args?: string[]): Promise<void> {
-  await executeCLI({
-    programName: '${programName}',
-    args,
-    createConfig,
-    createSingletonServices,
-    createSessionServices,
-  })
+export async function ${capitalizedName}CLI(args: string[]): Promise<void> {
+  try {
+    await executeCLI({
+      programName: '${programName}',
+      args: args || process.argv.slice(2),
+      createConfig,
+      createSingletonServices,
+      createSessionServices,
+    })
+  } catch (error) {
+    if (error instanceof CLIError) {
+      process.exit(error.exitCode)
+    }
+    throw error
+  }
 }
 
 // Export as default for easy importing
@@ -37,7 +42,7 @@ export default ${capitalizedName}CLI
 
 // For direct execution (if this file is run directly)
 if (import.meta.url === \`file://\${process.argv[1]}\`) {
-  ${capitalizedName}CLI().catch(error => {
+  ${capitalizedName}CLI(process.argv.slice(2)).catch(error => {
     console.error('Fatal error:', error.message)
     process.exit(1)
   })

package/dist/src/functions/wirings/fetch/index.js

@@ -6,8 +6,13 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 export const pikkuFetch = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
         const { fetchFile, httpMapDeclarationFile, packageMappings } = config;
+        // If fetchFile is not set, clean up any existing file and return
         if (!fetchFile) {
-            throw new Error("fetchFile is isn't set in the pikku config");
+            logger.info({
+                message: "Skipping generating fetch wrapper since fetchFile isn't set in the pikku config.",
+                type: 'skip',
+            });
+            return;
         }
         const routesMapDeclarationPath = getFileImportRelativePath(fetchFile, httpMapDeclarationFile, packageMappings);
         const content = [serializeFetchWrapper(routesMapDeclarationPath)];
@@ -17,8 +22,6 @@ export const pikkuFetch = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Generating fetch wrapper',
             commandEnd: 'Generated fetch wrapper',
-            skipCondition: ({ config }) => config.fetchFile === undefined,
-            skipMessage: "fetchFile isn't set in the pikku config",
         }),
     ],
 });

package/dist/src/functions/wirings/functions/pikku-command-function-types-split.js

@@ -7,26 +7,27 @@ import { serializeFunctionTypes } from './serialize-function-types.js';
 export const pikkuFunctionTypesSplit = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const { functionTypesFile, packageMappings, rpcInternalMapDeclarationFile, } = config;
+        const { functionTypesFile, packageMappings, rpcInternalMapDeclarationFile, servicesFile, } = config;
         // Check for required types
         checkRequiredTypes(visitState.filesAndMethodsErrors, {
             userSessionType: true,
             sessionServiceType: true,
             singletonServicesType: true,
         });
-        const { userSessionType, sessionServicesType, singletonServicesType } = visitState.filesAndMethods;
+        const { userSessionType, sessionServicesType, singletonServicesType, pikkuConfigType, } = visitState.filesAndMethods;
         if (!userSessionType || !sessionServicesType || !singletonServicesType) {
             throw new Error('Required types not found');
         }
-        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, sessionServicesType.typePath, packageMappings)}'`, sessionServicesType.type, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`);
+        const configTypeImport = pikkuConfigType
+            ? `import type { ${pikkuConfigType.type} } from '${getFileImportRelativePath(functionTypesFile, pikkuConfigType.typePath, packageMappings)}'`
+            : '// Config type not found, will use fallback';
+        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, sessionServicesType.typePath, packageMappings)}'`, sessionServicesType.type, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`, `import type { RequiredSingletonServices, RequiredSessionServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`, configTypeImport);
         await writeFileInDir(logger, functionTypesFile, content);
     },
     middleware: [
         logCommandInfoAndTime({
             commandStart: 'Creating function types',
             commandEnd: 'Created function types',
-            skipCondition: false,
-            skipMessage: '',
         }),
     ],
 });

package/dist/src/functions/wirings/functions/pikku-command-function-types.js

@@ -13,8 +13,6 @@ export const pikkuFunctionTypes = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Creating api types hub',
             commandEnd: 'Created api types hub',
-            skipCondition: false,
-            skipMessage: '',
         }),
     ],
 });

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

@@ -21,8 +21,6 @@ export const pikkuFunctions = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Serializing Pikku functions',
             commandEnd: 'Serialized Pikku functions',
-            skipCondition: false,
-            skipMessage: '',
         }),
     ],
 });

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

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