@pikku/cli 0.11.3 → 0.12.1

package/dist/bin/pikku.js

@@ -1,50 +1,23 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import { createConfig, createSingletonServices } from '../src/services.js';
-import { LocalVariablesService } from '@pikku/core/services';
-import { all as allCommand } from '../src/functions/commands/all.js';
-import { watch as watchCommand } from '../src/functions/commands/watch.js';
-// Import bootstrap if it exists
-try {
-    await import('../.pikku/pikku-bootstrap.gen.js');
-}
-catch {
-    // Bootstrap doesn't exist yet, continue anyway
-}
-const action = async (command, cliConfig) => {
-    const config = await createConfig(new LocalVariablesService(), cliConfig);
-    const services = await createSingletonServices(config);
-    if (command === 'watch') {
-        await watchCommand.func(services);
+import { existsSync } from 'fs';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { dirname, join } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Use the generated Pikku CLI
+const pikkuCliPath = join(__dirname, '../.pikku/cli/pikku-cli.gen.js');
+if (existsSync(pikkuCliPath)) {
+    try {
+        const { PikkuCLI } = await import(pathToFileURL(pikkuCliPath).href);
+        await PikkuCLI(process.argv.slice(2));
+        process.exit(0);
     }
-    else {
-        await allCommand.func(services);
+    catch (error) {
+        console.error('Failed to run Pikku CLI:', error.message);
+        process.exit(1);
     }
-};
-const all = (program, name, description) => {
-    program
-        .command(name, { isDefault: name === 'all' })
-        .description(description)
-        .option('--pikku-config-type', 'The type of your pikku config object')
-        .option('--singleton-services-factory-type', 'The type of your singleton services factory')
-        .option('--session-services-factory-type', 'The type of your wire services factory')
-        .option('-c, --config <string>', 'The path to pikku cli config file')
-        .option('-t, --tags <tags...>', 'Which tags to filter by')
-        .option('--types <types...>', 'Which types to filter by (http, channel, queue, scheduler, rpc, mcp)')
-        .option('-d, --directories <directories...>', 'Which directories to filter by')
-        .option('-n, --names <names...>', 'Filter functions by name patterns (supports wildcards)')
-        .option('--httpMethods <methods...>', 'Filter HTTP routes by methods (comma-separated)')
-        .option('--httpRoutes <routes...>', 'Filter HTTP routes by route patterns (comma-separated)')
-        .option('-s, --silent', 'Silent mode - only show critical errors')
-        .option('--info', 'Show info messages and above (info, warn, error, critical)')
-        .option('--verbose', 'Show all debug messages (most detailed)')
-        .option('--loglevel <level>', 'Set explicit log level (trace, debug, info, warn, error, critical)')
-        .option('--state-output <path>', 'Save inspector state to JSON file for reuse')
-        .option('--state-input <path>', 'Load inspector state from JSON file (skips inspection)')
-        .action((c) => action(name, c));
-};
-const program = new Command('pikku');
-program.usage('[command]');
-all(program, 'all', 'Generate all pikku wirings and files');
-all(program, 'watch', 'Watch for changes in pikku files');
-program.parse(process.argv);
+}
+else {
+    console.error('Pikku CLI not found. Run build.sh first.');
+    process.exit(1);
+}

package/dist/src/cli.wiring.js

@@ -1,6 +1,6 @@
 import { pikkuSchemas } from './functions/wirings/functions/schemas.js';
-import { pikkuFetch } from './functions/wirings/fetch/index.js';
-import { pikkuWebSocketTyped } from './functions/wirings/channels/pikku-command-websocket-typed.js';
+import { pikkuFetch } from './functions/runtimes/fetch/index.js';
+import { pikkuWebSocketTyped } from './functions/runtimes/websocket/pikku-command-websocket-typed.js';
 import { pikkuRPCClient } from './functions/wirings/rpc/pikku-command-rpc-client.js';
 import { pikkuQueueService } from './functions/wirings/queue/pikku-command-queue-service.js';
 import { pikkuOpenAPI } from './functions/wirings/http/pikku-command-openapi.js';
@@ -9,6 +9,16 @@ import { pikkuCLICommand, wireCLI } from '../.pikku/cli/pikku-cli-types.gen.js';
 import { all } from './functions/commands/all.js';
 import { bootstrap } from './functions/commands/bootstrap.js';
 import { watch } from './functions/commands/watch.js';
+import { consoleCommand } from './functions/commands/console.js';
+import { pikkuVersionsInit } from './functions/commands/versions-init.js';
+import { pikkuVersionsCheck } from './functions/commands/versions-check.js';
+import { pikkuVersionsUpdate } from './functions/commands/versions-update.js';
+import { pikkuNewFunction } from './functions/commands/new-function.js';
+import { pikkuNewWiring } from './functions/commands/new-wiring.js';
+import { pikkuNewMiddleware } from './functions/commands/new-middleware.js';
+import { pikkuNewPermission } from './functions/commands/new-permission.js';
+import { pikkuNewAddon } from './functions/commands/new-addon.js';
+import { pikkuInfoFunctions, pikkuInfoTags, pikkuInfoMiddleware, pikkuInfoPermissions, } from './functions/commands/info.js';
 // import { clientCLIRenderer } from './services.js'
 wireCLI({
     program: 'pikku',
@@ -77,6 +87,17 @@ wireCLI({
             func: watch,
             description: 'Watch for file changes and regenerate automatically',
         }),
+        console: pikkuCLICommand({
+            func: consoleCommand,
+            description: 'Start the Pikku Console UI with live file watching',
+            options: {
+                port: {
+                    description: 'Port for the console server',
+                    default: '51442',
+                    short: 'p',
+                },
+            },
+        }),
         schemas: pikkuCLICommand({
             func: pikkuSchemas,
             description: 'Generate JSON schemas for function input/output types',
@@ -105,5 +126,192 @@ wireCLI({
             func: pikkuNext,
             description: 'Generate Next.js backend and HTTP wrappers',
         }),
+        new: {
+            description: 'Scaffold new functions and wirings',
+            subcommands: {
+                function: pikkuCLICommand({
+                    func: pikkuNewFunction,
+                    description: 'Create a new Pikku function file',
+                    parameters: '<name>',
+                    options: {
+                        type: {
+                            description: 'Function type: func, sessionless (default), or void',
+                            short: 't',
+                            default: 'sessionless',
+                        },
+                    },
+                }),
+                wiring: pikkuCLICommand({
+                    func: pikkuNewWiring,
+                    description: 'Create a new wiring file',
+                    parameters: '<name>',
+                    options: {
+                        type: {
+                            description: 'Wiring type: http (default), channel, scheduler, queue, mcp, cli, or trigger',
+                            short: 't',
+                            default: 'http',
+                        },
+                    },
+                }),
+                middleware: pikkuCLICommand({
+                    func: pikkuNewMiddleware,
+                    description: 'Create a new middleware file',
+                    parameters: '<name>',
+                    options: {
+                        type: {
+                            description: 'Middleware type: simple (default) or factory',
+                            short: 't',
+                            default: 'simple',
+                        },
+                    },
+                }),
+                permission: pikkuCLICommand({
+                    func: pikkuNewPermission,
+                    description: 'Create a new permission file',
+                    parameters: '<name>',
+                    options: {
+                        type: {
+                            description: 'Permission type: simple (default) or factory',
+                            short: 't',
+                            default: 'simple',
+                        },
+                    },
+                }),
+                addon: pikkuCLICommand({
+                    func: pikkuNewAddon,
+                    description: 'Scaffold a new addon package',
+                    parameters: '<name>',
+                    options: {
+                        displayName: {
+                            description: 'Human-readable display name (defaults to PascalCase of name)',
+                        },
+                        description: {
+                            description: 'Package description (defaults to "{displayName} integration for Pikku")',
+                        },
+                        category: {
+                            description: 'Forge category (defaults to "General")',
+                            default: 'General',
+                        },
+                        dir: {
+                            description: 'Override output directory (defaults to scaffold.addonDir or cwd)',
+                            short: 'd',
+                        },
+                        secret: {
+                            description: 'Include secret schema file',
+                            default: false,
+                        },
+                        variable: {
+                            description: 'Include variable definition file',
+                            default: false,
+                        },
+                        oauth: {
+                            description: 'Include OAuth2 credential wiring and OAuth2Client-based API service',
+                            default: false,
+                        },
+                        test: {
+                            description: 'Include test harness (default: true)',
+                            default: true,
+                        },
+                        openapi: {
+                            description: 'Path to OpenAPI YAML/JSON spec to generate functions from',
+                        },
+                    },
+                }),
+            },
+        },
+        versions: {
+            description: 'Manage function contract versions',
+            subcommands: {
+                init: pikkuCLICommand({
+                    func: pikkuVersionsInit,
+                    description: 'Initialize the version manifest (versions.json)',
+                    options: {
+                        force: {
+                            description: 'Overwrite existing manifest',
+                        },
+                    },
+                }),
+                check: pikkuCLICommand({
+                    func: pikkuVersionsCheck,
+                    description: 'Validate function contracts against the version manifest',
+                }),
+                update: pikkuCLICommand({
+                    func: pikkuVersionsUpdate,
+                    description: 'Update the version manifest with current contract hashes',
+                }),
+            },
+        },
+        info: pikkuCLICommand({
+            func: pikkuInfoFunctions,
+            description: 'Show information about Pikku project resources',
+            options: {
+                limit: {
+                    description: 'Maximum number of rows to display',
+                    default: '50',
+                },
+                verbose: {
+                    description: 'Show additional details (file paths, services, etc.)',
+                    default: false,
+                },
+            },
+            subcommands: {
+                functions: pikkuCLICommand({
+                    func: pikkuInfoFunctions,
+                    description: 'List all registered functions',
+                    options: {
+                        limit: {
+                            description: 'Maximum number of rows to display',
+                            default: '50',
+                        },
+                        verbose: {
+                            description: 'Show additional details (type, middleware, file)',
+                            default: false,
+                        },
+                    },
+                }),
+                tags: pikkuCLICommand({
+                    func: pikkuInfoTags,
+                    description: 'List all tags with associated functions, middleware, and permissions',
+                    options: {
+                        limit: {
+                            description: 'Maximum number of rows to display',
+                            default: '50',
+                        },
+                        verbose: {
+                            description: 'Show names instead of counts',
+                            default: false,
+                        },
+                    },
+                }),
+                middleware: pikkuCLICommand({
+                    func: pikkuInfoMiddleware,
+                    description: 'List all middleware definitions',
+                    options: {
+                        limit: {
+                            description: 'Maximum number of rows to display',
+                            default: '50',
+                        },
+                        verbose: {
+                            description: 'Show additional details (sourceFile, services)',
+                            default: false,
+                        },
+                    },
+                }),
+                permissions: pikkuCLICommand({
+                    func: pikkuInfoPermissions,
+                    description: 'List all permission definitions',
+                    options: {
+                        limit: {
+                            description: 'Maximum number of rows to display',
+                            default: '50',
+                        },
+                        verbose: {
+                            description: 'Show additional details (sourceFile, services)',
+                            default: false,
+                        },
+                    },
+                }),
+            },
+        }),
     },
 });

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

@@ -1 +1 @@
-export declare const all: any;
+export declare const all: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -1,241 +1,144 @@
 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';
-import { pikkuFunctionTypes } from '../wirings/functions/pikku-command-function-types.js';
-import { pikkuFunctionTypesSplit } from '../wirings/functions/pikku-command-function-types-split.js';
-import { pikkuHTTPTypes } from '../wirings/http/pikku-command-http-types.js';
-import { pikkuChannelTypes } from '../wirings/channels/pikku-command-channel-types.js';
-import { pikkuSchedulerTypes } from '../wirings/scheduler/pikku-command-scheduler-types.js';
-import { pikkuQueueTypes } from '../wirings/queue/pikku-command-queue-types.js';
-import { pikkuMCPTypes } from '../wirings/mcp/pikku-command-mcp-types.js';
-import { pikkuCLITypes } from '../wirings/cli/pikku-command-cli-types.js';
-import { pikkuFunctions } from '../wirings/functions/pikku-command-functions.js';
-import { pikkuMiddleware } from '../wirings/middleware/pikku-command-middleware.js';
-import { pikkuPermissions } from '../wirings/permissions/pikku-command-permissions.js';
-import { pikkuServices } from '../wirings/functions/pikku-command-services.js';
-import { pikkuServiceMetadata } from '../wirings/services/pikku-command-service-metadata.js';
-import { pikkuRPC } from '../wirings/rpc/pikku-command-rpc.js';
-import { pikkuRPCExposedMap, pikkuRPCInternalMap, } from '../wirings/rpc/pikku-command-rpc-map.js';
-import { pikkuPublicRPC } from '../wirings/rpc/pikku-command-public-rpc.js';
-import { pikkuRPCClient } from '../wirings/rpc/pikku-command-rpc-client.js';
-import { pikkuSchemas } from '../wirings/functions/schemas.js';
-import { pikkuHTTP } from '../wirings/http/pikku-command-http-routes.js';
-import { pikkuHTTPMap } from '../wirings/http/pikku-command-http-map.js';
-import { pikkuFetch } from '../wirings/fetch/index.js';
-import { pikkuScheduler } from '../wirings/scheduler/pikku-command-scheduler.js';
-import { pikkuWorkflow } from '../wirings/workflow/pikku-command-workflow.js';
-import { pikkuRemoteRPC } from '../wirings/rpc/pikku-command-remote-rpc.js';
-import { pikkuQueue } from '../wirings/queue/pikku-command-queue.js';
-import { pikkuQueueMap } from '../wirings/queue/pikku-command-queue-map.js';
-import { pikkuQueueService } from '../wirings/queue/pikku-command-queue-service.js';
-import { pikkuChannels } from '../wirings/channels/pikku-command-channels.js';
-import { pikkuChannelsMap } from '../wirings/channels/pikku-command-channels-map.js';
-import { pikkuWebSocketTyped } from '../wirings/channels/pikku-command-websocket-typed.js';
-import { pikkuMCP } from '../wirings/mcp/pikku-command-mcp.js';
-import { pikkuMCPJSON } from '../wirings/mcp/pikku-command-mcp-json.js';
-import { pikkuCLI } from '../wirings/cli/pikku-command-cli.js';
-import { pikkuCLIEntry } from '../wirings/cli/pikku-command-cli-entry.js';
-import { pikkuNext } from '../runtimes/nextjs/pikku-command-nextjs.js';
-import { pikkuOpenAPI } from '../wirings/http/pikku-command-openapi.js';
-import { pikkuPackage } from '../wirings/package/pikku-command-package.js';
-import { pikkuForgeNodes } from '../wirings/forge/pikku-command-forge-nodes.js';
-import { pikkuForgeTypes } from '../wirings/forge/pikku-command-forge-types.js';
+import { pikkuVoidFunc } from '#pikku';
 export const all = pikkuVoidFunc({
-    func: async ({ logger, config, getInspectorState }) => {
-        const wire = {};
-        const services = { logger, config, getInspectorState };
-        const summary = new CommandSummary('all');
+    remote: true,
+    func: async ({ logger, config, getInspectorState }, _data, { rpc }) => {
         const allImports = [];
         let typesDeclarationFileExists = true;
         if (!existsSync(config.typesDeclarationFile)) {
             typesDeclarationFileExists = false;
         }
-        await pikkuFunctionTypes.func(services, null, wire);
+        await rpc.invoke('pikkuFunctionTypes', null);
         if (!typesDeclarationFileExists) {
             logger.debug(`• Type file first created, inspecting again...`);
             await getInspectorState(true);
         }
-        await pikkuFunctionTypesSplit.func(services, null, wire);
-        if (!config.externalPackage) {
-            await pikkuHTTPTypes.func(services, null, wire);
-            await pikkuChannelTypes.func(services, null, wire);
-            await pikkuSchedulerTypes.func(services, null, wire);
-            await pikkuQueueTypes.func(services, null, wire);
-            await pikkuMCPTypes.func(services, null, wire);
-            await pikkuCLITypes.func(services, null, wire);
-        }
-        const hasFunctionRegistrations = await pikkuFunctions.func(services, wire, null);
-        const middleware = await pikkuMiddleware.func(services, null, wire);
+        await rpc.invoke('pikkuFunctionTypesSplit', null);
+        await rpc.invoke('pikkuTriggerTypes', null);
+        await rpc.invoke('pikkuAIAgentTypes', null);
+        if (!config.addon) {
+            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 middleware = await rpc.invoke('pikkuMiddleware', null);
         if (middleware) {
             allImports.push(config.middlewareFile);
         }
-        const permissions = await pikkuPermissions.func(services, null, wire);
+        const permissions = await rpc.invoke('pikkuPermissions', null);
         if (permissions) {
             allImports.push(config.permissionsFile);
         }
-        allImports.push(config.functionsMetaFile);
-        if (hasFunctionRegistrations) {
-            allImports.push(config.functionsFile);
-        }
-        await pikkuServices.func(services, null, wire);
-        await pikkuServiceMetadata.func(services, null, wire);
-        const hasPackageFactories = await pikkuPackage.func(services, null, wire);
+        await rpc.invoke('pikkuServices', null);
+        const hasPackageFactories = await rpc.invoke('pikkuPackage', null);
         if (hasPackageFactories) {
             allImports.push(config.packageFile);
         }
-        const hasInternalRPCs = await pikkuRPC.func(services, null, wire);
-        const schemas = await pikkuSchemas.func(services, null, wire);
-        if (schemas) {
-            allImports.push(`${config.schemaDirectory}/register.gen.ts`);
+        const hasInternalRPCs = await rpc.invoke('pikkuRPC', null);
+        const agents = await rpc.invoke('pikkuAIAgent', null);
+        if (agents) {
+            allImports.push(config.agentWiringMetaFile, config.agentWiringsFile);
+            if (config.agent?.publicAgentPath) {
+                await rpc.invoke('pikkuPublicAgent', null);
+            }
         }
-        await pikkuRPCInternalMap.func(services, null, wire);
-        await pikkuRPCExposedMap.func(services, null, wire);
-        await pikkuPublicRPC.func(services, null, wire);
-        await pikkuRPCClient.func(services, null, wire);
-        await pikkuForgeTypes.func(services, null, wire);
+        await rpc.invoke('pikkuPublicRPC', null);
+        await rpc.invoke('pikkuRPCClient', null);
+        await rpc.invoke('pikkuConsoleFunctions', null);
+        await rpc.invoke('pikkuNodeTypes', null);
+        await rpc.invoke('pikkuSecretDefinitionTypes', null);
+        await rpc.invoke('pikkuSecrets', null);
+        await rpc.invoke('pikkuVariableDefinitionTypes', null);
+        await rpc.invoke('pikkuVariables', null);
+        await rpc.invoke('pikkuAddonTypes', null);
         if (hasInternalRPCs) {
             allImports.push(config.rpcInternalWiringMetaFile);
         }
-        if (!config.externalPackage) {
-            const http = await pikkuHTTP.func(services, null, wire);
+        if (agents || !config.addon) {
+            await getInspectorState(true);
+        }
+        const schemas = await rpc.invoke('pikkuSchemas', null);
+        if (schemas) {
+            allImports.push(`${config.schemaDirectory}/register.gen.ts`);
+        }
+        await rpc.invoke('pikkuRPCInternalMap', null);
+        await rpc.invoke('pikkuRPCExposedMap', null);
+        if (!config.addon) {
+            const http = await rpc.invoke('pikkuHTTP', null);
             if (http) {
-                await pikkuHTTPMap.func(services, null, wire);
-                await pikkuFetch.func(services, null, wire);
+                await rpc.invoke('pikkuHTTPMap', null);
+                await rpc.invoke('pikkuFetch', null);
                 allImports.push(config.httpWiringMetaFile, config.httpWiringsFile);
             }
-            const scheduler = await pikkuScheduler.func(services, null, wire);
+            const scheduler = await rpc.invoke('pikkuScheduler', null);
             if (scheduler) {
                 allImports.push(config.schedulersWiringMetaFile, config.schedulersWiringFile);
             }
+            const triggers = await rpc.invoke('pikkuTrigger', null);
+            if (triggers) {
+                allImports.push(config.triggersWiringMetaFile, config.triggerSourcesMetaFile, config.triggersWiringFile);
+            }
         }
-        const workflows = await pikkuWorkflow.func(services, null, wire);
+        const workflows = await rpc.invoke('pikkuWorkflow', null);
         let remoteRPC = false;
-        if (!config.externalPackage) {
-            remoteRPC = await pikkuRemoteRPC.func(services, null, wire);
+        if (!config.addon) {
+            remoteRPC = await rpc.invoke('pikkuRemoteRPC', null);
         }
         if (workflows || remoteRPC) {
             await getInspectorState(true);
+            await rpc.invoke('pikkuSchemas', null);
+        }
+        const hasFunctionRegistrations = await rpc.invoke('pikkuFunctions', null);
+        allImports.push(config.functionsMetaFile);
+        if (hasFunctionRegistrations) {
+            allImports.push(config.functionsFile);
         }
         if (workflows) {
             allImports.push(config.workflowsWiringFile);
         }
-        if (!config.externalPackage) {
-            const queues = await pikkuQueue.func(services, null, wire);
+        if (!config.addon) {
+            const queues = await rpc.invoke('pikkuQueue', null);
             if (queues) {
-                await pikkuQueueMap.func(services, null, wire);
-                await pikkuQueueService.func(services, null, wire);
+                await rpc.invoke('pikkuQueueMap', null);
+                await rpc.invoke('pikkuQueueService', null);
                 allImports.push(config.queueWorkersWiringMetaFile, config.queueWorkersWiringFile);
             }
-            const channels = await pikkuChannels.func(services, null, wire);
+            const channels = await rpc.invoke('pikkuChannels', null);
             if (channels) {
-                await pikkuChannelsMap.func(services, null, wire);
-                await pikkuWebSocketTyped.func(services, null, wire);
+                await rpc.invoke('pikkuChannelsMap', null);
+                await rpc.invoke('pikkuWebSocketTyped', null);
                 allImports.push(config.channelsWiringMetaFile, config.channelsWiringFile);
             }
-            const mcp = await pikkuMCP.func(services, null, wire);
+            const mcp = await rpc.invoke('pikkuMCP', null);
             if (mcp) {
-                await pikkuMCPJSON.func(services, null, wire);
+                await rpc.invoke('pikkuMCPJSON', null);
                 allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile);
             }
-            const cli = await pikkuCLI.func(services, null, wire);
+            const cli = await rpc.invoke('pikkuCLI', null);
             if (cli) {
-                await pikkuCLIEntry.func(services, null, wire);
+                await rpc.invoke('pikkuCLIEntry', null);
                 allImports.push(config.cliWiringMetaFile, config.cliWiringsFile);
             }
         }
-        await pikkuForgeNodes.func(services, null, wire);
+        await rpc.invoke('pikkuNodesMeta', null);
         if (config.nextBackendFile || config.nextHTTPFile) {
-            await pikkuNext.func(services, null, wire);
+            await rpc.invoke('pikkuNext', null);
         }
         if (config.openAPI) {
             logger.debug(`• OpenAPI requires a reinspection to pickup new generated types..`);
             await getInspectorState(true);
-            await pikkuOpenAPI.func(services, null, wire);
-        }
-        const stateBeforeBootstrap = await getInspectorState();
-        const externalPackageBootstraps = [];
-        const usedExternalPackages = {};
-        if (config.externalPackages &&
-            stateBeforeBootstrap.rpc?.usedExternalPackages?.size > 0) {
-            for (const namespace of stateBeforeBootstrap.rpc.usedExternalPackages) {
-                const packageName = config.externalPackages[namespace];
-                if (packageName) {
-                    const packageBootstrap = `${packageName}/.pikku/pikku-bootstrap.gen.js`;
-                    externalPackageBootstraps.push(packageBootstrap);
-                    usedExternalPackages[namespace] = packageName;
-                    logger.debug(`• External package detected: ${namespace} (${packageName})`);
-                }
-            }
+            await rpc.invoke('pikkuOpenAPI', null);
+        }
+        try {
+            await rpc.invoke('pikkuVersionsUpdate', null);
         }
-        const localImports = allImports.map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`);
-        const externalImports = externalPackageBootstraps.map((packagePath) => `import '${packagePath}'`);
-        let externalPackagesRegistration = '';
-        if (Object.keys(usedExternalPackages).length > 0) {
-            externalPackagesRegistration = `
-// Register external package mappings
-import { pikkuState } from '@pikku/core'
-const externalPackages = pikkuState(null, 'rpc', 'externalPackages')
-${Object.entries(usedExternalPackages)
-                .map(([ns, pkg]) => `externalPackages.set('${ns}', '${pkg}')`)
-                .join('\n')}
-`;
-        }
-        const allBootstrapImports = [...localImports, ...externalImports]
-            .sort((a, b) => {
-            const aMeta = a.includes('meta');
-            const bMeta = b.includes('meta');
-            if (aMeta && !bMeta)
-                return -1;
-            if (!aMeta && bMeta)
-                return 1;
-            return 0;
-        })
-            .join('\n') + externalPackagesRegistration;
-        await writeFileInDir(logger, config.bootstrapFile, allBootstrapImports);
-        const state = await getInspectorState();
-        if (state.http?.meta) {
-            const httpRouteCount = Object.values(state.http.meta).reduce((sum, routes) => sum + Object.keys(routes).length, 0);
-            if (httpRouteCount > 0)
-                summary.set('httpRoutes', httpRouteCount);
-        }
-        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) {
-            const totalCommands = Object.values(state.cli.meta).reduce((sum, program) => sum + (program.commands?.length || 0), 0);
-            if (totalCommands > 0)
-                summary.set('cliCommands', totalCommands);
-        }
-        if (state.workflows?.meta) {
-            summary.set('workflows', Object.keys(state.workflows.meta).length);
-        }
-        if (state.forgeNodes?.meta) {
-            const forgeNodesCount = Object.keys(state.forgeNodes.meta).length;
-            if (forgeNodesCount > 0)
-                summary.set('forgeNodes', forgeNodesCount);
-        }
-        if (state.workflows?.graphMeta) {
-            const workflowGraphsCount = Object.keys(state.workflows.graphMeta).length;
-            if (workflowGraphsCount > 0)
-                summary.set('workflowGraphs', workflowGraphsCount);
-        }
-        if (!logger.isSilent()) {
-            console.log(summary.format());
-        }
-        if (logger.hasCriticalErrors()) {
-            process.exit(1);
+        catch {
+            logger.warn(`Run 'pikku init' to enable contract versioning.`);
         }
+        await rpc.invoke('pikkuBootstrap', { allImports });
+        await rpc.invoke('pikkuSummary', null);
     },
 });

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

@@ -1 +1 @@
-export declare const bootstrap: any;
+export declare const bootstrap: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;