@pikku/cli 0.9.14 → 0.9.16-next.0

package/dist/.pikku/rpc/pikku-rpc-wirings-meta.internal.gen.js

@@ -0,0 +1,40 @@
+/**
+ * This file was generated by the @pikku/cli
+ */
+import { pikkuState } from '@pikku/core';
+pikkuState('rpc', 'meta', {
+    "all": "all",
+    "watch": "watch",
+    "pikkuNext": "pikkuNext",
+    "pikkuChannels": "pikkuChannels",
+    "pikkuChannelTypes": "pikkuChannelTypes",
+    "pikkuChannelsMap": "pikkuChannelsMap",
+    "pikkuWebSocketTyped": "pikkuWebSocketTyped",
+    "pikkuCLIEntry": "pikkuCLIEntry",
+    "pikkuCLITypes": "pikkuCLITypes",
+    "pikkuCLI": "pikkuCLI",
+    "pikkuFetch": "pikkuFetch",
+    "pikkuFunctionTypesSplit": "pikkuFunctionTypesSplit",
+    "pikkuFunctionTypes": "pikkuFunctionTypes",
+    "pikkuFunctions": "pikkuFunctions",
+    "pikkuServices": "pikkuServices",
+    "pikkuSchemas": "pikkuSchemas",
+    "pikkuMCPJSON": "pikkuMCPJSON",
+    "pikkuMCPTypes": "pikkuMCPTypes",
+    "pikkuMCP": "pikkuMCP",
+    "pikkuHTTPMap": "pikkuHTTPMap",
+    "pikkuHTTP": "pikkuHTTP",
+    "pikkuHTTPTypes": "pikkuHTTPTypes",
+    "pikkuOpenAPI": "pikkuOpenAPI",
+    "pikkuMiddleware": "pikkuMiddleware",
+    "pikkuRPCClient": "pikkuRPCClient",
+    "pikkuRPCInternalMap": "pikkuRPCInternalMap",
+    "pikkuRPCExposedMap": "pikkuRPCExposedMap",
+    "pikkuRPC": "pikkuRPC",
+    "pikkuQueueMap": "pikkuQueueMap",
+    "pikkuQueueService": "pikkuQueueService",
+    "pikkuQueueTypes": "pikkuQueueTypes",
+    "pikkuQueue": "pikkuQueue",
+    "pikkuSchedulerTypes": "pikkuSchedulerTypes",
+    "pikkuScheduler": "pikkuScheduler"
+});

package/dist/.pikku/scheduler/pikku-scheduler-types.gen.d.ts

@@ -0,0 +1,22 @@
+/**
+ * This file was generated by the @pikku/cli
+ */
+/**
+ * This file was generated by the @pikku/cli
+ * Scheduler-specific type definitions for tree-shaking optimization
+ */
+import { CoreScheduledTask } from '@pikku/core/scheduler';
+import type { PikkuFunctionConfig, PikkuMiddleware } from '../function/pikku-function-types.gen.js';
+/**
+ * Type definition for scheduled tasks that run at specified intervals.
+ * These are sessionless functions that execute based on cron expressions.
+ */
+type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void>, PikkuMiddleware>;
+/**
+ * Registers a scheduled task with the Pikku framework.
+ * Tasks run based on cron expressions and are sessionless.
+ *
+ * @param task - Scheduled task definition with cron expression and handler
+ */
+export declare const wireScheduler: (task: SchedulerWiring) => void;
+export {};

package/dist/.pikku/scheduler/pikku-scheduler-types.gen.js

@@ -0,0 +1,17 @@
+/**
+ * This file was generated by the @pikku/cli
+ */
+/**
+ * This file was generated by the @pikku/cli
+ * Scheduler-specific type definitions for tree-shaking optimization
+ */
+import { wireScheduler as wireSchedulerCore } from '@pikku/core/scheduler';
+/**
+ * Registers a scheduled task with the Pikku framework.
+ * Tasks run based on cron expressions and are sessionless.
+ *
+ * @param task - Scheduled task definition with cron expression and handler
+ */
+export const wireScheduler = (task) => {
+    wireSchedulerCore(task); // TODO
+};

package/dist/.pikku/schemas/register.gen.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/.pikku/schemas/register.gen.js

@@ -0,0 +1,26 @@
+/**
+ * This file was generated by the @pikku/cli
+ */
+import { addSchema } from '@pikku/core/schema';
+import * as PikkuChannelsOutput from './schemas/PikkuChannelsOutput.schema.json' with { type: 'json' };
+addSchema('PikkuChannelsOutput', PikkuChannelsOutput);
+import * as PikkuCLIOutput from './schemas/PikkuCLIOutput.schema.json' with { type: 'json' };
+addSchema('PikkuCLIOutput', PikkuCLIOutput);
+import * as PikkuFunctionsOutput from './schemas/PikkuFunctionsOutput.schema.json' with { type: 'json' };
+addSchema('PikkuFunctionsOutput', PikkuFunctionsOutput);
+import * as PikkuSchemasOutput from './schemas/PikkuSchemasOutput.schema.json' with { type: 'json' };
+addSchema('PikkuSchemasOutput', PikkuSchemasOutput);
+import * as PikkuMCPOutput from './schemas/PikkuMCPOutput.schema.json' with { type: 'json' };
+addSchema('PikkuMCPOutput', PikkuMCPOutput);
+import * as PikkuHTTPOutput from './schemas/PikkuHTTPOutput.schema.json' with { type: 'json' };
+addSchema('PikkuHTTPOutput', PikkuHTTPOutput);
+import * as PikkuMiddlewareOutput from './schemas/PikkuMiddlewareOutput.schema.json' with { type: 'json' };
+addSchema('PikkuMiddlewareOutput', PikkuMiddlewareOutput);
+import * as PikkuRPCOutput from './schemas/PikkuRPCOutput.schema.json' with { type: 'json' };
+addSchema('PikkuRPCOutput', PikkuRPCOutput);
+import * as PikkuSchedulerOutput from './schemas/PikkuSchedulerOutput.schema.json' with { type: 'json' };
+addSchema('PikkuSchedulerOutput', PikkuSchedulerOutput);
+import * as PikkuQueueOutput from './schemas/PikkuQueueOutput.schema.json' with { type: 'json' };
+addSchema('PikkuQueueOutput', PikkuQueueOutput);
+import * as PikkuCLIConfig from './schemas/PikkuCLIConfig.schema.json' with { type: 'json' };
+addSchema('PikkuCLIConfig', PikkuCLIConfig);

package/dist/.pikku/schemas/schemas/PikkuCLIConfig.schema.json

@@ -0,0 +1 @@
+{ "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "additionalProperties": false, "properties": { "outDir": { "type": "string" }, "schemaDirectory": { "type": "string" }, "typesDeclarationFile": { "type": "string" }, "functionsFile": { "type": "string" }, "functionsMetaFile": { "type": "string" }, "functionsMetaMinFile": { "type": "string" }, "functionTypesFile": { "type": "string" }, "httpWiringsFile": { "type": "string" }, "httpWiringMetaFile": { "type": "string" }, "httpMapDeclarationFile": { "type": "string" }, "httpTypesFile": { "type": "string" }, "channelsWiringFile": { "type": "string" }, "channelsWiringMetaFile": { "type": "string" }, "channelsMapDeclarationFile": { "type": "string" }, "channelsTypesFile": { "type": "string" }, "rpcInternalWiringMetaFile": { "type": "string" }, "rpcInternalMapDeclarationFile": { "type": "string" }, "rpcMapDeclarationFile": { "type": "string" }, "schedulersWiringFile": { "type": "string" }, "schedulersWiringMetaFile": { "type": "string" }, "schedulersTypesFile": { "type": "string" }, "queueWorkersWiringFile": { "type": "string" }, "queueWorkersWiringMetaFile": { "type": "string" }, "queueMapDeclarationFile": { "type": "string" }, "queueTypesFile": { "type": "string" }, "mcpWiringsFile": { "type": "string" }, "mcpWiringsMetaFile": { "type": "string" }, "mcpTypesFile": { "type": "string" }, "cliWiringsFile": { "type": "string" }, "cliWiringMetaFile": { "type": "string" }, "cliBootstrapFile": { "type": "string" }, "cliTypesFile": { "type": "string" }, "servicesFile": { "type": "string" }, "middlewareFile": { "type": "string" }, "middlewareGroupsMetaFile": { "type": "string" }, "bootstrapFile": { "type": "string" }, "bootstrapFiles": { "type": "object", "properties": { "http": { "type": "string" }, "scheduler": { "type": "string" }, "channel": { "type": "string" }, "rpc": { "type": "string" }, "queue": { "type": "string" }, "mcp": { "type": "string" }, "cli": { "type": "string" } }, "required": ["http", "scheduler", "channel", "rpc", "queue", "mcp", "cli"], "additionalProperties": false }, "$schema": { "type": "string" }, "extends": { "type": "string" }, "rootDir": { "type": "string" }, "srcDirectories": { "type": "array", "items": { "type": "string" } }, "packageMappings": { "type": "object", "additionalProperties": { "type": "string" } }, "supportsImportAttributes": { "type": "boolean" }, "configFile": { "type": "string" }, "tags": { "type": "array", "items": { "type": "string" } }, "types": { "type": "array", "items": { "type": "string" } }, "configDir": { "type": "string" }, "tsconfig": { "type": "string" }, "nextBackendFile": { "type": "string" }, "nextHTTPFile": { "type": "string" }, "fetchFile": { "type": "string" }, "websocketFile": { "type": "string" }, "rpcWiringsFile": { "type": "string" }, "queueWiringsFile": { "type": "string" }, "mcpJsonFile": { "type": "string" }, "openAPI": { "type": "object", "properties": { "outputFile": { "type": "string" }, "additionalInfo": { "$ref": "#/definitions/OpenAPISpecInfo" } }, "required": ["outputFile", "additionalInfo"], "additionalProperties": false }, "cli": { "type": "object", "properties": { "entrypoints": { "type": "object", "additionalProperties": { "anyOf": [{ "type": "string" }, { "type": "object", "properties": { "type": { "type": "string", "const": "cli" }, "path": { "type": "string" } }, "required": ["type", "path"], "additionalProperties": false }, { "type": "object", "properties": { "type": { "type": "string", "const": "channel" }, "name": { "type": "string" }, "route": { "type": "string" }, "wirePath": { "type": "string" }, "path": { "type": "string" } }, "required": ["type", "wirePath"], "additionalProperties": false }, { "type": "array", "items": { "anyOf": [{ "type": "string" }, { "type": "object", "properties": { "type": { "type": "string", "const": "cli" }, "path": { "type": "string" } }, "required": ["type", "path"], "additionalProperties": false }, { "type": "object", "properties": { "type": { "type": "string", "const": "channel" }, "name": { "type": "string" }, "route": { "type": "string" }, "wirePath": { "type": "string" }, "path": { "type": "string" } }, "required": ["type", "wirePath"], "additionalProperties": false }] } }] } } }, "additionalProperties": false }, "middlewareServices": { "type": "array", "items": { "type": "string" } }, "schemasFromTypes": { "type": "array", "items": { "type": "string" } }, "filters": { "$ref": "#/definitions/InspectorFilters" } }, "required": ["bootstrapFile", "bootstrapFiles", "channelsMapDeclarationFile", "channelsTypesFile", "channelsWiringFile", "channelsWiringMetaFile", "cliBootstrapFile", "cliTypesFile", "cliWiringMetaFile", "cliWiringsFile", "configDir", "filters", "functionTypesFile", "functionsFile", "functionsMetaFile", "functionsMetaMinFile", "httpMapDeclarationFile", "httpTypesFile", "httpWiringMetaFile", "httpWiringsFile", "mcpTypesFile", "mcpWiringsFile", "mcpWiringsMetaFile", "middlewareFile", "middlewareGroupsMetaFile", "outDir", "packageMappings", "queueMapDeclarationFile", "queueTypesFile", "queueWorkersWiringFile", "queueWorkersWiringMetaFile", "rootDir", "rpcInternalMapDeclarationFile", "rpcInternalWiringMetaFile", "rpcMapDeclarationFile", "schedulersTypesFile", "schedulersWiringFile", "schedulersWiringMetaFile", "schemaDirectory", "servicesFile", "srcDirectories", "supportsImportAttributes", "tsconfig", "typesDeclarationFile"], "definitions": { "OpenAPISpecInfo": { "type": "object", "properties": { "info": { "type": "object", "properties": { "title": { "type": "string" }, "version": { "type": "string" }, "description": { "type": "string" }, "termsOfService": { "type": "string" }, "contact": { "type": "object", "properties": { "name": { "type": "string" }, "url": { "type": "string" }, "email": { "type": "string" } }, "additionalProperties": false }, "license": { "type": "object", "properties": { "name": { "type": "string" }, "url": { "type": "string" } }, "required": ["name"], "additionalProperties": false } }, "required": ["title", "version", "description"], "additionalProperties": false }, "servers": { "type": "array", "items": { "type": "object", "properties": { "url": { "type": "string" }, "description": { "type": "string" } }, "required": ["url"], "additionalProperties": false } }, "tags": { "type": "array", "items": { "type": "object", "properties": { "name": { "type": "string" }, "description": { "type": "string" } }, "required": ["name"], "additionalProperties": false } }, "externalDocs": { "type": "object", "properties": { "description": { "type": "string" }, "url": { "type": "string" } }, "required": ["url"], "additionalProperties": false }, "securitySchemes": { "type": "object" }, "security": { "type": "array", "items": { "type": "object", "additionalProperties": { "type": "array", "items": {} } } } }, "required": ["info", "servers"], "additionalProperties": false }, "InspectorFilters": { "type": "object", "properties": { "tags": { "type": "array", "items": { "type": "string" } }, "types": { "type": "array", "items": { "type": "string" } }, "directories": { "type": "array", "items": { "type": "string" } } }, "additionalProperties": false } } }

package/dist/.pikku/schemas/schemas/PikkuCLIOutput.schema.json

@@ -0,0 +1 @@
+{ "$schema": "http://json-schema.org/draft-07/schema#", "type": "boolean", "enum": [false, true], "definitions": {} }

package/dist/.pikku/schemas/schemas/PikkuChannelsOutput.schema.json

@@ -0,0 +1 @@
+{ "$schema": "http://json-schema.org/draft-07/schema#", "type": "boolean", "enum": [false, true], "description": "This provides the structure needed for typescript to be aware of RPCs and their return types", "definitions": {} }

package/dist/.pikku/schemas/schemas/PikkuFunctionsOutput.schema.json

@@ -0,0 +1 @@
+{ "$schema": "http://json-schema.org/draft-07/schema#", "type": "boolean", "enum": [false, true], "definitions": {} }

package/dist/.pikku/schemas/schemas/PikkuHTTPOutput.schema.json

@@ -0,0 +1 @@
+{ "$schema": "http://json-schema.org/draft-07/schema#", "type": "boolean", "enum": [false, true], "definitions": {} }

package/dist/.pikku/schemas/schemas/PikkuMCPOutput.schema.json

@@ -0,0 +1 @@
+{ "$schema": "http://json-schema.org/draft-07/schema#", "type": "boolean", "enum": [false, true], "definitions": {} }

package/dist/.pikku/schemas/schemas/PikkuMiddlewareOutput.schema.json

@@ -0,0 +1 @@
+{ "$schema": "http://json-schema.org/draft-07/schema#", "type": "boolean", "enum": [false, true], "definitions": {} }

package/dist/.pikku/schemas/schemas/PikkuQueueOutput.schema.json

@@ -0,0 +1 @@
+{ "$schema": "http://json-schema.org/draft-07/schema#", "type": "boolean", "enum": [false, true], "definitions": {} }

package/dist/.pikku/schemas/schemas/PikkuRPCOutput.schema.json

@@ -0,0 +1 @@
+{ "$schema": "http://json-schema.org/draft-07/schema#", "type": "boolean", "enum": [false, true], "definitions": {} }

package/dist/.pikku/schemas/schemas/PikkuSchedulerOutput.schema.json

@@ -0,0 +1 @@
+{ "$schema": "http://json-schema.org/draft-07/schema#", "type": "boolean", "enum": [false, true], "definitions": {} }

package/dist/.pikku/schemas/schemas/PikkuSchemasOutput.schema.json

@@ -0,0 +1 @@
+{ "$schema": "http://json-schema.org/draft-07/schema#", "type": "boolean", "enum": [false, true], "definitions": {} }

package/dist/bin/pikku.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+import '../.pikku/pikku-bootstrap.gen.js';

package/dist/bin/pikku.js

@@ -1,19 +1,37 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import { schemas } from './pikku-schemas.js';
-import { nextjs } from './pikku-nextjs.js';
-import { all } from './pikku-all.js';
-import { fetch } from './pikku-fetch.js';
-import { queue } from './pikku-queue-service.js';
-import { websocket } from './pikku-websocket.js';
-import { rpc } from './pikku-rpc.js';
+import { createConfig, createSingletonServices } from '../src/services.js';
+import { PikkuRPCService } from '@pikku/core';
+import '../.pikku/pikku-bootstrap.gen.js';
+import { LocalVariablesService } from '@pikku/core/services';
+const action = async (command, cliConfig) => {
+    const config = await createConfig(new LocalVariablesService(), cliConfig);
+    const services = await createSingletonServices(config);
+    const rpcWrapper = new PikkuRPCService();
+    const { rpc } = await rpcWrapper.injectRPCService(services, {}, false);
+    if (command === 'watch') {
+        await rpc.invoke('watch', null);
+    }
+    else {
+        await rpc.invoke('all', null);
+    }
+};
+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 session 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('--directories <directories...>', 'Which directories to filter by')
+        .option('-s | --silent', 'Silent mode - only show errors')
+        .action((c) => action(name, c));
+};
 const program = new Command('pikku');
 program.usage('[command]');
-all(program);
-schemas(program);
-nextjs(program);
-websocket(program);
-rpc(program);
-fetch(program);
-queue(program);
+all(program, 'all', 'Generate all pikku wirings and files');
+all(program, 'watch', 'Watch for changes in pikku files');
 program.parse(process.argv);

package/dist/src/cli.wiring.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/cli.wiring.js

@@ -0,0 +1,75 @@
+// 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 { 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'
+// import { pikkuNext } from './functions/runtimes/nextjs/pikku-command-nextjs.js'
+// import { pikkuCLICommand, wireCLI } from '../.pikku/cli/pikku-cli-types.gen.js'
+// import { all } from './functions/commands/all.js'
+// import { defaultCLIRenderer } from './services.js'
+export {};
+// wireCLI({
+//   program: 'pikku',
+//   description:
+//     'Pikku CLI - Code generation tool for type-safe backend development',
+//   render: defaultCLIRenderer,
+//   options: {
+//     config: {
+//       description: 'Path to pikku.config.json file',
+//       short: 'c',
+//     },
+//     logLevel: {
+//       description: 'Set log level',
+//       default: 'info',
+//       short: 'l',
+//     },
+//   },
+//   commands: {
+//     all: pikkuCLICommand({
+//       func: all,
+//       description: 'Generate all Pikku files (types, schemas, wirings, etc.)',
+//       options: {
+//         tags: {
+//           description: 'Filter functions by tags (comma-separated)',
+//           short: 't',
+//         },
+//         types: {
+//           description: 'Filter functions by types (comma-separated)',
+//         },
+//         directories: {
+//           description: 'Filter functions by directories (comma-separated)',
+//           short: 'd',
+//         },
+//       },
+//     }),
+//     schemas: pikkuCLICommand({
+//       func: pikkuSchemas,
+//       description: 'Generate JSON schemas for function input/output types',
+//     }),
+//     fetch: pikkuCLICommand({
+//       func: pikkuFetch,
+//       description: 'Generate type-safe HTTP fetch client',
+//     }),
+//     websocket: pikkuCLICommand({
+//       func: pikkuWebSocketTyped,
+//       description: 'Generate type-safe WebSocket client',
+//     }),
+//     rpc: pikkuCLICommand({
+//       func: pikkuRPCClient,
+//       description: 'Generate RPC client wrappers',
+//     }),
+//     'queue-service': pikkuCLICommand({
+//       func: pikkuQueueService,
+//       description: 'Generate queue service wrapper',
+//     }),
+//     openapi: pikkuCLICommand({
+//       func: pikkuOpenAPI,
+//       description: 'Generate OpenAPI specification from HTTP routes',
+//     }),
+//     nextjs: pikkuCLICommand({
+//       func: pikkuNext,
+//       description: 'Generate Next.js backend and HTTP wrappers',
+//     }),
+//   },
+// })

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

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

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

@@ -0,0 +1,104 @@
+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);
+        }
+        // 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'));
+    },
+});

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,11 +1,14 @@
-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, bootstrapFiles, } = config;
+        const visitState = await getInspectorState();
         if (!nextBackendFile && !nextHTTPFile) {
             throw new Error('nextBackendFile or nextHTTPFile is required in pikku config for nextJS');
         }
@@ -13,11 +16,18 @@ export const pikkuNext = async (logger, { nextBackendFile, nextHTTPFile, httpMap
             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)}'`;
@@ -32,5 +42,14 @@ 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',
+            skipCondition: ({ config }) => config.nextBackendFile === undefined &&
+                config.nextHTTPFile === undefined,
+            skipMessage: 'nextjs outfile is not defined',
+        }),
+    ],
+});

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,24 @@
+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',
+            skipCondition: async ({ getInspectorState }) => {
+                const visitState = await getInspectorState();
+                return visitState.channels.files.size === 0;
+            },
+            skipMessage: 'none found',
+        }),
+    ],
+});

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,21 @@
+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',
+            skipCondition: false,
+            skipMessage: '',
+        }),
+    ],
+});

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,23 @@
+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',
+            skipCondition: async ({ getInspectorState }) => {
+                const state = await getInspectorState();
+                return state.channels.files.size === 0;
+            },
+            skipMessage: 'none found',
+        }),
+    ],
+});

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

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