@pikku/cli 0.9.15 → 0.10.0

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

@@ -0,0 +1,114 @@
+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';
+export const all = pikkuVoidFunc({
+    func: async ({ logger, config, rpc, getInspectorState }) => {
+        const allImports = [];
+        let typesDeclarationFileExists = true;
+        if (!existsSync(config.typesDeclarationFile)) {
+            typesDeclarationFileExists = false;
+        }
+        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`);
+            await getInspectorState(true);
+        }
+        // Generate wiring-specific type files for tree-shaking
+        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);
+        const hasFunctionRegistrations = await rpc.invoke('pikkuFunctions', null);
+        // Generate and register middleware
+        const middleware = await rpc.invoke('pikkuMiddleware', null);
+        // Middleware must be imported before functions meta to ensure registration happens first
+        if (middleware) {
+            allImports.push(config.middlewareFile);
+        }
+        // Generate and register permissions
+        const permissions = await rpc.invoke('pikkuPermissions', null);
+        // Permissions must be imported before functions meta to ensure registration happens first
+        if (permissions) {
+            allImports.push(config.permissionsFile);
+        }
+        // Always import functions meta (needed for all function metadata)
+        allImports.push(config.functionsMetaFile);
+        // Only import functionsFile if it was generated (has internal/external RPCs)
+        if (hasFunctionRegistrations) {
+            allImports.push(config.functionsFile);
+        }
+        // Generate services map
+        await rpc.invoke('pikkuServices', null);
+        const hasInternalRPCs = await rpc.invoke('pikkuRPC', null);
+        await rpc.invoke('pikkuRPCInternalMap', null);
+        await rpc.invoke('pikkuRPCExposedMap', null);
+        await rpc.invoke('pikkuRPCClient', null);
+        if (hasInternalRPCs) {
+            allImports.push(config.rpcInternalWiringMetaFile);
+        }
+        const schemas = await rpc.invoke('pikkuSchemas', null);
+        if (schemas) {
+            allImports.push(`${config.schemaDirectory}/register.gen.ts`);
+        }
+        // Generate HTTP
+        const http = await rpc.invoke('pikkuHTTP', null);
+        if (http) {
+            await rpc.invoke('pikkuHTTPMap', null);
+            await rpc.invoke('pikkuFetch', null);
+            allImports.push(config.httpWiringMetaFile, config.httpWiringsFile);
+        }
+        // Generate Scheduler
+        const scheduler = await rpc.invoke('pikkuScheduler', null);
+        if (scheduler) {
+            allImports.push(config.schedulersWiringMetaFile, config.schedulersWiringFile);
+        }
+        // Generate Queues
+        const queues = await rpc.invoke('pikkuQueue', null);
+        if (queues) {
+            await rpc.invoke('pikkuQueueMap', null);
+            await rpc.invoke('pikkuQueueService', null);
+            allImports.push(config.queueWorkersWiringMetaFile, config.queueWorkersWiringFile);
+        }
+        // Generate Channels
+        const channels = await rpc.invoke('pikkuChannels', null);
+        if (channels) {
+            await rpc.invoke('pikkuChannelsMap', null);
+            await rpc.invoke('pikkuWebSocketTyped', null);
+            allImports.push(config.channelsWiringMetaFile, config.channelsWiringFile);
+        }
+        // Generate MCP
+        const mcp = await rpc.invoke('pikkuMCP', null);
+        if (mcp) {
+            await rpc.invoke('pikkuMCPJSON', null);
+            allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile);
+        }
+        // Generate CLI
+        const cli = await rpc.invoke('pikkuCLI', null);
+        if (cli) {
+            await rpc.invoke('pikkuCLIEntry', null);
+            allImports.push(config.cliWiringMetaFile, config.cliWiringsFile);
+        }
+        if (config.nextBackendFile || config.nextHTTPFile) {
+            await rpc.invoke('pikkuNext', null);
+        }
+        if (config.openAPI) {
+            logger.info(`• OpenAPI requires a reinspection to pickup new generated types..`);
+            await getInspectorState(true);
+            await rpc.invoke('pikkuOpenAPI', null);
+        }
+        // Generate main bootstrap file (pass all imports directly since this is the main file)
+        await writeFileInDir(logger, config.bootstrapFile, allImports
+            .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'));
+        // Check for critical errors and exit if any were logged
+        if (logger.hasCriticalErrors()) {
+            process.exit(1);
+        }
+    },
+});

package/dist/src/functions/commands/watch.d.ts

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

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

@@ -0,0 +1,47 @@
+import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js';
+import chokidar from 'chokidar';
+export const watch = pikkuVoidFunc({
+    func: async ({ logger, config, rpc }) => {
+        const configWatcher = chokidar.watch(config.srcDirectories, {
+            ignoreInitial: true,
+            ignored: /.*\.gen\.tsx?/,
+        });
+        let watcher = new chokidar.FSWatcher({});
+        const generatorWatcher = () => {
+            watcher.close();
+            logger.info(`• Watching directories: \n  - ${config.srcDirectories.join('\n  - ')}`);
+            watcher = chokidar.watch(config.srcDirectories, {
+                ignoreInitial: true,
+                ignored: /.*\.gen\.ts/,
+            });
+            watcher.on('ready', async () => {
+                const handle = async () => {
+                    try {
+                        const start = Date.now();
+                        await rpc.invoke('all', null);
+                        logger.info({
+                            message: `✓ Generated in ${Date.now() - start}ms`,
+                            type: 'timing',
+                        });
+                    }
+                    catch (err) {
+                        logger.error(err);
+                    }
+                };
+                await handle();
+                let timeout;
+                const deduped = (_file) => {
+                    if (timeout) {
+                        clearTimeout(timeout);
+                    }
+                    timeout = setTimeout(handle, 10);
+                };
+                watcher.on('change', deduped);
+                watcher.on('add', deduped);
+                watcher.on('unlink', deduped);
+            });
+        };
+        configWatcher.on('ready', generatorWatcher);
+        configWatcher.on('change', generatorWatcher);
+    },
+});

package/dist/src/functions/runtimes/nextjs/pikku-command-nextjs.d.ts

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

package/dist/src/{runtimes → functions/runtimes}/nextjs/pikku-command-nextjs.js

@@ -1,29 +1,44 @@
-import { logCommandInfoAndTime, getPikkuFilesAndMethods, getFileImportRelativePath, writeFileInDir, } from '../../utils.js';
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { checkRequiredTypes } from '../../../utils/check-required-types.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from './serialize-nextjs-backend-wrapper.js';
 import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from './serialize-nextjs-http-wrapper.js';
-export const pikkuNext = async (logger, { nextBackendFile, nextHTTPFile, httpMapDeclarationFile, packageMappings, fetchFile, bootstrapFiles, }, visitState, options = {}) => {
-    return await logCommandInfoAndTime(logger, 'Generating nextjs wrapper', 'Generated nextjs wrapper', [
-        nextBackendFile === undefined && nextHTTPFile === undefined,
-        'nextjs outfile is not defined',
-    ], async () => {
+export const pikkuNext = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { nextBackendFile, nextHTTPFile, httpMapDeclarationFile, packageMappings, fetchFile, } = config;
+        // If both files are undefined, clean up any existing files and return
         if (!nextBackendFile && !nextHTTPFile) {
-            throw new Error('nextBackendFile or nextHTTPFile is required in pikku config for nextJS');
+            logger.info({
+                message: 'Skipping generating nextjs wrapper since nextjs outfile is not defined.',
+                type: 'skip',
+            });
+            return;
         }
+        const visitState = await getInspectorState();
         if (nextHTTPFile && !fetchFile) {
             throw new Error('fetchFile is required in pikku config in order for nextJS http wrapper to work');
         }
         if (nextBackendFile) {
-            const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, } = await getPikkuFilesAndMethods(logger, visitState, packageMappings, nextBackendFile, options, {
+            // Check for required types
+            checkRequiredTypes(visitState.filesAndMethodsErrors, {
                 config: true,
                 singletonServicesFactory: true,
                 sessionServicesFactory: true,
             });
+            const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, } = visitState.filesAndMethods;
+            if (!pikkuConfigFactory ||
+                !singletonServicesFactory ||
+                !sessionServicesFactory) {
+                throw new Error('Required types not found');
+            }
             const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`;
             const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`;
             const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextBackendFile, sessionServicesFactory.file, packageMappings)}'`;
-            const httpBootstrapPath = getFileImportRelativePath(nextBackendFile, bootstrapFiles.http, packageMappings);
+            const bootstrapPath = getFileImportRelativePath(nextBackendFile, config.bootstrapFile, packageMappings);
             const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpMapDeclarationFile, packageMappings);
-            const content = serializeNextBackendWrapper(httpBootstrapPath, routesMapDeclarationPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
+            const content = serializeNextBackendWrapper(bootstrapPath, routesMapDeclarationPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
             await writeFileInDir(logger, nextBackendFile, content);
         }
         if (nextHTTPFile && fetchFile) {
@@ -32,5 +47,11 @@ export const pikkuNext = async (logger, { nextBackendFile, nextHTTPFile, httpMap
             const content = serializeNextHTTPWrapper(routesMapDeclarationPath, fetchPath);
             await writeFileInDir(logger, nextHTTPFile, content);
         }
-    });
-};
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating nextjs wrapper',
+            commandEnd: 'Generated nextjs wrapper',
+        }),
+    ],
+});

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

@@ -0,0 +1 @@
+export declare const serializeNextJsBackendWrapper: (bootstrapPath: string, routesMapPath: string, configImport: string, singleServicesFactoryImport: string, sessionServicesImport: string) => string;

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

@@ -1,4 +1,4 @@
-export const serializeNextJsBackendWrapper = (httpBootstrapPath, routesMapPath, configImport, singleServicesFactoryImport, sessionServicesImport) => {
+export const serializeNextJsBackendWrapper = (bootstrapPath, routesMapPath, configImport, singleServicesFactoryImport, sessionServicesImport) => {
     return `'server-only'
   
 /**
@@ -12,7 +12,7 @@ ${configImport}
 ${singleServicesFactoryImport}
 ${sessionServicesImport}
 
-import '${httpBootstrapPath}'
+import '${bootstrapPath}'
 
 let _pikku: PikkuNextJS | undefined
 

package/dist/src/functions/wirings/channels/pikku-channels.d.ts

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

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

@@ -0,0 +1,19 @@
+import { pikkuVoidFunc } 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';
+export const pikkuChannels = pikkuVoidFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { channelsWiringFile, channelsWiringMetaFile, packageMappings } = config;
+        const { channels } = visitState;
+        await writeFileInDir(logger, channelsWiringFile, serializeFileImports('addChannel', channelsWiringFile, channels.files, packageMappings));
+        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding Channels',
+            commandEnd: 'Found channels',
+        }),
+    ],
+});

package/dist/src/functions/wirings/channels/pikku-command-channel-types.d.ts

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

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

@@ -0,0 +1,19 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeChannelTypes } from './serialize-channel-types.js';
+export const pikkuChannelTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { channelsTypesFile, functionTypesFile, packageMappings } = config;
+        const functionTypesImportPath = getFileImportRelativePath(channelsTypesFile, functionTypesFile, packageMappings);
+        const content = serializeChannelTypes(functionTypesImportPath);
+        await writeFileInDir(logger, channelsTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating channel types',
+            commandEnd: 'Created channel types',
+        }),
+    ],
+});

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

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

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

@@ -0,0 +1,18 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeTypedChannelsMap } from './serialize-typed-channel-map.js';
+export const pikkuChannelsMap = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const state = await getInspectorState();
+        const { channelsMapDeclarationFile, packageMappings } = config;
+        const content = serializeTypedChannelsMap(channelsMapDeclarationFile, packageMappings, state.functions.typesMap, state.functions.meta, state.channels.meta);
+        await writeFileInDir(logger, channelsMapDeclarationFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating channels map',
+            commandEnd: 'Created channels map',
+        }),
+    ],
+});

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

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

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

@@ -0,0 +1,20 @@
+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';
+export const pikkuChannels = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { channelsWiringFile, channelsWiringMetaFile, packageMappings } = config;
+        const { channels } = visitState;
+        await writeFileInDir(logger, channelsWiringFile, serializeFileImports('addChannel', channelsWiringFile, channels.files, packageMappings));
+        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`);
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding Channels',
+            commandEnd: 'Found channels',
+        }),
+    ],
+});

package/dist/src/functions/wirings/channels/pikku-command-websocket-typed.d.ts

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

package/dist/src/functions/wirings/channels/pikku-command-websocket-typed.js

@@ -0,0 +1,27 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeWebsocketWrapper } from './serialize-websocket-wrapper.js';
+export const pikkuWebSocketTyped = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { websocketFile, channelsMapDeclarationFile, packageMappings } = config;
+        // If websocketFile is not set, clean up any existing file and return
+        if (!websocketFile) {
+            logger.info({
+                message: "Skipping generating websocket wrapper since websocketFile isn't set in the pikku config.",
+                type: 'skip',
+            });
+            return;
+        }
+        const channelsMapDeclarationPath = getFileImportRelativePath(websocketFile, channelsMapDeclarationFile, packageMappings);
+        const content = [serializeWebsocketWrapper(channelsMapDeclarationPath)];
+        await writeFileInDir(logger, websocketFile, content.join('\n'));
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating websocket wrapper',
+            commandEnd: 'Generated websocket wrapper',
+        }),
+    ],
+});

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

@@ -0,0 +1,4 @@
+/**
+ * Generates type definitions for WebSocket channel wirings
+ */
+export declare const serializeChannelTypes: (functionTypesImportPath: string) => string;

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

@@ -0,0 +1,94 @@
+/**
+ * Generates type definitions for WebSocket channel wirings
+ */
+export const serializeChannelTypes = (functionTypesImportPath) => {
+    return `/**
+
+ * 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 { PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
+
+/**
+ * Type definition for WebSocket channels with typed data exchange.
+ * Supports connection, disconnection, and message handling.
+ *
+ * @template ChannelData - Type of data exchanged through the channel
+ * @template Channel - String literal type for the channel name
+ */
+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
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ */
+export const pikkuChannelConnectionFunc = <Out = unknown>(
+  func:
+    | PikkuFunctionSessionless<void, Out, unknown>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, Out, unknown>, PikkuPermission<void>, PikkuMiddleware>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Creates a function that handles WebSocket channel disconnections.
+ * Called when a client disconnects from a channel.
+ *
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ */
+export const pikkuChannelDisconnectionFunc = (
+  func:
+    | PikkuFunctionSessionless<void, void, unknown>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void, unknown>, PikkuPermission<void>, PikkuMiddleware>
+) => {
+  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
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ */
+export const pikkuChannelFunc = <In, Out = unknown>(
+  func:
+    | PikkuFunctionSessionless<In, Out, unknown>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out, unknown>, PikkuPermission<In>, PikkuMiddleware>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Registers a WebSocket channel with the Pikku framework.
+ *
+ * @template ChannelData - Type of data associated with the channel
+ * @template Channel - String literal type for the channel name
+ * @param channel - Channel definition with connection, disconnection, and message handlers
+ */
+export const wireChannel = <ChannelData, Channel extends string>(
+  channel: ChannelWiring<ChannelData, Channel> & AssertHTTPWiringParams<ChannelData, Channel>
+) => {
+  wireChannelCore(channel as any) // TODO
+}
+`;
+};

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

@@ -1,10 +1,13 @@
-import { serializeImportMap } from '../../serialize-import-map.js';
-import { generateCustomTypes } from '../../utils.js';
+import { serializeImportMap } from '../../../utils/serialize-import-map.js';
+import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
 export const serializeTypedChannelsMap = (relativeToPath, packageMappings, typesMap, functionsMeta, channelsMeta) => {
     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.d.ts

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

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

@@ -0,0 +1,123 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { checkRequiredTypes } from '../../../utils/check-required-types.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { join } from 'node:path';
+import { serializeLocalCLIBootstrap } from './serialize-local-cli-bootstrap.js';
+import { serializeChannelCLI } from './serialize-channel-cli.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();
+        // Check if CLI entrypoints are configured
+        if (!config.cli?.entrypoints ||
+            Object.keys(config.cli.entrypoints).length === 0) {
+            logger.info({
+                message: 'No CLI entrypoints configured in config.cli.entrypoints, skipping CLI bootstrap generation',
+                type: 'skip',
+            });
+            return;
+        }
+        // Generate bootstrap files for each configured entrypoint
+        for (const [programName, entrypointConfigs] of Object.entries(config.cli.entrypoints)) {
+            const programMeta = visitState.cli.meta.programs[programName];
+            if (!programMeta) {
+                logger.warn(`CLI program '${programName}' not found in metadata, skipping`);
+                continue;
+            }
+            // Normalize to array
+            const configs = Array.isArray(entrypointConfigs)
+                ? entrypointConfigs
+                : [entrypointConfigs];
+            for (const entrypointConfig of configs) {
+                // Normalize entrypoint config to get type
+                const entrypointType = typeof entrypointConfig === 'string'
+                    ? 'cli'
+                    : entrypointConfig.type || 'cli';
+                // Handle channel type entrypoint
+                if (entrypointType === 'channel') {
+                    if (typeof entrypointConfig === 'string' ||
+                        entrypointConfig.type !== 'channel') {
+                        throw new Error('Channel entrypoint must be a channel type object');
+                    }
+                    const channelWirePath = entrypointConfig.wirePath;
+                    const channelClientPath = entrypointConfig.path;
+                    const channelName = entrypointConfig.name;
+                    const channelRoute = entrypointConfig.route;
+                    const channelWireFile = join(config.rootDir, channelWirePath);
+                    const channelCode = serializeChannelCLI(programName, programMeta, channelWireFile, visitState.functions.files, config.packageMappings, config.channelsTypesFile, config.functionTypesFile, channelName, channelRoute);
+                    await writeFileInDir(logger, channelWireFile, channelCode);
+                    logger.debug(`Serialized CLI channel for ${programName}: ${channelWireFile}`);
+                    // Generate client code if clientPath is provided
+                    if (channelClientPath) {
+                        const channelClientFile = join(config.rootDir, channelClientPath);
+                        // 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}`);
+                    }
+                    continue;
+                }
+                // Handle CLI type entrypoint (default)
+                const entrypointPath = typeof entrypointConfig === 'string'
+                    ? entrypointConfig
+                    : entrypointConfig.type === 'cli'
+                        ? entrypointConfig.path
+                        : undefined;
+                if (!entrypointPath) {
+                    throw new Error(`CLI entrypoint must have a path: ${JSON.stringify(entrypointConfig)}`);
+                }
+                const bootstrapFile = join(config.rootDir, entrypointPath);
+                // Get service factories for local mode
+                // Check for required types
+                checkRequiredTypes(visitState.filesAndMethodsErrors, {
+                    config: true,
+                    singletonServicesFactory: true,
+                    sessionServicesFactory: true,
+                });
+                const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, } = visitState.filesAndMethods;
+                if (!pikkuConfigFactory ||
+                    !singletonServicesFactory ||
+                    !sessionServicesFactory) {
+                    throw new Error('Required types not found');
+                }
+                const bootstrapCode = serializeLocalCLIBootstrap(programName, programMeta, bootstrapFile, config, pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory);
+                await writeFileInDir(logger, bootstrapFile, bootstrapCode);
+                logger.debug(`Serialized CLI bootstrap for ${programName}: ${bootstrapFile}`);
+            }
+        }
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Serializing CLI',
+            commandEnd: 'Serialized CLI',
+        }),
+    ],
+});

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

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