@pikku/cli 0.11.2 → 0.12.0

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

@@ -1,203 +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 all command functions directly
-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 { pikkuWorkflowTypes } from '../wirings/workflow/pikku-command-workflow-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 { pikkuWorkflowMap } from '../wirings/workflow/pikku-command-workflow-map.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 { 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);
-        // This is needed since the wireHTTP function will add the routes to the visitState
+        await rpc.invoke('pikkuFunctionTypes', null);
         if (!typesDeclarationFileExists) {
             logger.debug(`• Type file first created, inspecting again...`);
             await getInspectorState(true);
         }
-        // Generate wiring-specific type files for tree-shaking
-        await pikkuFunctionTypesSplit.func(services, null, wire);
-        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 pikkuWorkflowTypes.func(services, null, wire);
-        await pikkuMCPTypes.func(services, null, wire);
-        await pikkuCLITypes.func(services, null, wire);
-        const hasFunctionRegistrations = await pikkuFunctions.func(services, wire, null);
-        // Generate and register middleware
-        const middleware = await pikkuMiddleware.func(services, null, wire);
-        // Middleware must be imported before functions meta to ensure registration happens first
+        await rpc.invoke('pikkuFunctionTypesSplit', null);
+        await rpc.invoke('pikkuTriggerTypes', null);
+        await rpc.invoke('pikkuAIAgentTypes', null);
+        if (!config.externalPackage) {
+            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);
         }
-        // Generate and register permissions
-        const permissions = await pikkuPermissions.func(services, null, wire);
-        // Permissions must be imported before functions meta to ensure registration happens first
+        const permissions = await rpc.invoke('pikkuPermissions', null);
         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 pikkuServices.func(services, null, wire);
-        // Generate service metadata JSON files for AI consumption
-        await pikkuServiceMetadata.func(services, null, wire);
-        const hasInternalRPCs = await pikkuRPC.func(services, null, wire);
-        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 rpc.invoke('pikkuServices', null);
+        const hasPackageFactories = await rpc.invoke('pikkuPackage', null);
+        if (hasPackageFactories) {
+            allImports.push(config.packageFile);
+        }
+        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 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('pikkuExternalTypes', null);
         if (hasInternalRPCs) {
             allImports.push(config.rpcInternalWiringMetaFile);
         }
-        const schemas = await pikkuSchemas.func(services, null, wire);
+        if (agents || !config.externalPackage) {
+            await getInspectorState(true);
+        }
+        const schemas = await rpc.invoke('pikkuSchemas', null);
         if (schemas) {
             allImports.push(`${config.schemaDirectory}/register.gen.ts`);
         }
-        // Generate HTTP
-        const http = await pikkuHTTP.func(services, null, wire);
-        if (http) {
-            await pikkuHTTPMap.func(services, null, wire);
-            await pikkuFetch.func(services, null, wire);
-            allImports.push(config.httpWiringMetaFile, config.httpWiringsFile);
-        }
-        // Generate Scheduler
-        const scheduler = await pikkuScheduler.func(services, null, wire);
-        if (scheduler) {
-            allImports.push(config.schedulersWiringMetaFile, config.schedulersWiringFile);
-        }
-        // Generate Workflows
-        const workflows = await pikkuWorkflow.func(services, null, wire);
-        // Generate Remote RPC Workers (must be before queue discovery so wireQueueWorker calls are picked up)
-        const remoteRPC = await pikkuRemoteRPC.func(services, null, wire);
-        // Reinspect to pick up generated workflow workers and remote RPC workers BEFORE generating maps
+        await rpc.invoke('pikkuRPCInternalMap', null);
+        await rpc.invoke('pikkuRPCExposedMap', null);
+        if (!config.externalPackage) {
+            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);
+            }
+            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 rpc.invoke('pikkuWorkflow', null);
+        let remoteRPC = false;
+        if (!config.externalPackage) {
+            remoteRPC = await rpc.invoke('pikkuRemoteRPC', null);
+        }
         if (workflows || remoteRPC) {
             await getInspectorState(true);
+            await rpc.invoke('pikkuSchemas', null);
         }
-        if (workflows) {
-            await pikkuWorkflowMap.func(services, null, wire);
-            allImports.push(config.workflowsWiringMetaFile, config.workflowsWiringFile);
-        }
-        // Generate Queues
-        const queues = await pikkuQueue.func(services, null, wire);
-        if (queues) {
-            await pikkuQueueMap.func(services, null, wire);
-            await pikkuQueueService.func(services, null, wire);
-            allImports.push(config.queueWorkersWiringMetaFile, config.queueWorkersWiringFile);
-        }
-        // Generate Channels
-        const channels = await pikkuChannels.func(services, null, wire);
-        if (channels) {
-            await pikkuChannelsMap.func(services, null, wire);
-            await pikkuWebSocketTyped.func(services, null, wire);
-            allImports.push(config.channelsWiringMetaFile, config.channelsWiringFile);
-        }
-        // Generate MCP
-        const mcp = await pikkuMCP.func(services, null, wire);
-        if (mcp) {
-            await pikkuMCPJSON.func(services, null, wire);
-            allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile);
-        }
-        // Generate CLI
-        const cli = await pikkuCLI.func(services, null, wire);
-        if (cli) {
-            await pikkuCLIEntry.func(services, null, wire);
-            allImports.push(config.cliWiringMetaFile, config.cliWiringsFile);
+        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 rpc.invoke('pikkuQueue', null);
+            if (queues) {
+                await rpc.invoke('pikkuQueueMap', null);
+                await rpc.invoke('pikkuQueueService', null);
+                allImports.push(config.queueWorkersWiringMetaFile, config.queueWorkersWiringFile);
+            }
+            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);
+            }
+            const mcp = await rpc.invoke('pikkuMCP', null);
+            if (mcp) {
+                await rpc.invoke('pikkuMCPJSON', null);
+                allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile);
+            }
+            const cli = await rpc.invoke('pikkuCLI', null);
+            if (cli) {
+                await rpc.invoke('pikkuCLIEntry', null);
+                allImports.push(config.cliWiringMetaFile, config.cliWiringsFile);
+            }
+        }
+        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);
-        }
-        // 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'));
-        // Get final inspector state and collect stats for summary
-        const state = await getInspectorState();
-        if (state.http?.meta)
-            summary.set('httpRoutes', Object.keys(state.http.meta).length);
-        if (state.channels?.meta)
-            summary.set('channels', Object.keys(state.channels.meta).length);
-        if (state.scheduledTasks?.meta)
-            summary.set('scheduledTasks', Object.keys(state.scheduledTasks.meta).length);
-        if (state.queueWorkers?.meta)
-            summary.set('queueWorkers', Object.keys(state.queueWorkers.meta).length);
-        if (state.mcpEndpoints) {
-            const mcpTotal = Object.keys(state.mcpEndpoints.toolsMeta || {}).length +
-                Object.keys(state.mcpEndpoints.resourcesMeta || {}).length +
-                Object.keys(state.mcpEndpoints.promptsMeta || {}).length;
-            if (mcpTotal > 0)
-                summary.set('mcpEndpoints', mcpTotal);
-        }
-        if (state.cli?.meta) {
-            // Count total CLI commands across all programs
-            const totalCommands = Object.values(state.cli.meta).reduce((sum, program) => sum + (program.commands?.length || 0), 0);
-            if (totalCommands > 0)
-                summary.set('cliCommands', totalCommands);
-        }
-        if (state.workflows?.meta) {
-            summary.set('workflows', Object.keys(state.workflows.meta).length);
-        }
-        // Display summary (unless in silent mode)
-        if (!logger.isSilent()) {
-            console.log(summary.format());
-        }
-        // Check for critical errors and exit if any were logged
-        if (logger.hasCriticalErrors()) {
-            process.exit(1);
+            await rpc.invoke('pikkuOpenAPI', null);
+        }
+        try {
+            await rpc.invoke('pikkuVersionsUpdate', null);
+        }
+        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>;

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

@@ -1,34 +1,18 @@
-import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js';
-// Import command functions directly
-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 { pikkuWorkflowTypes } from '../wirings/workflow/pikku-command-workflow-types.js';
-import { pikkuMCPTypes } from '../wirings/mcp/pikku-command-mcp-types.js';
-import { pikkuCLITypes } from '../wirings/cli/pikku-command-cli-types.js';
+import { pikkuVoidFunc } from '#pikku';
 export const bootstrap = pikkuVoidFunc({
-    func: async ({ logger, config, getInspectorState }) => {
-        const wire = {};
-        const services = { logger, config, getInspectorState };
-        // Initialize inspector state in bootstrap mode with core types only
-        // This allows bootstrap to run immediately without inspecting the codebase
-        // All subsequent RPC commands will use this cached state
+    remote: true,
+    func: async ({ logger, getInspectorState }, _data, { rpc }) => {
         await getInspectorState(false, false, true);
-        await pikkuFunctionTypes.func(services, null, wire);
-        // Generate wiring-specific type files for tree-shaking
-        // These use the bootstrap mode state with core types
-        await pikkuFunctionTypesSplit.func(services, null, wire);
-        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 pikkuWorkflowTypes.func(services, null, wire);
-        await pikkuMCPTypes.func(services, null, wire);
-        await pikkuCLITypes.func(services, null, wire);
-        // Check for critical errors and exit if any were logged
+        await rpc.invoke('pikkuFunctionTypes', null);
+        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('pikkuWorkflow', null);
+        await rpc.invoke('pikkuMCPTypes', null);
+        await rpc.invoke('pikkuAIAgentTypes', null);
+        await rpc.invoke('pikkuCLITypes', null);
         if (logger.hasCriticalErrors()) {
             process.exit(1);
         }

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

@@ -0,0 +1,7 @@
+export declare const consoleCommand: import("#pikku").PikkuFunctionConfig<{
+    port?: string;
+}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+    port?: string;
+}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    port?: string;
+}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -0,0 +1,106 @@
+import { createServer } from 'http';
+import { readFile, stat } from 'fs/promises';
+import { join, extname } from 'path';
+import { fileURLToPath } from 'url';
+import { pikkuSessionlessFunc } from '#pikku';
+import chokidar from 'chokidar';
+import open from 'open';
+const MIME_TYPES = {
+    '.html': 'text/html',
+    '.js': 'application/javascript',
+    '.css': 'text/css',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.webmanifest': 'application/manifest+json',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.map': 'application/json',
+};
+export const consoleCommand = pikkuSessionlessFunc({
+    remote: true,
+    func: async ({ logger, config }, { port }, { rpc }) => {
+        const consoleDir = join(fileURLToPath(import.meta.url), '..', '..', '..', '..', '..', 'console-app');
+        const resolvedPort = parseInt(port || '51442', 10);
+        try {
+            await stat(consoleDir);
+        }
+        catch {
+            logger.error('Console app not found. Please rebuild @pikku/cli with the console app bundled.');
+            return;
+        }
+        const server = createServer(async (req, res) => {
+            const url = new URL(req.url || '/', `http://localhost:${resolvedPort}`);
+            let filePath = join(consoleDir, url.pathname);
+            try {
+                const fileStat = await stat(filePath);
+                if (fileStat.isDirectory()) {
+                    filePath = join(filePath, 'index.html');
+                }
+            }
+            catch {
+                filePath = join(consoleDir, 'index.html');
+            }
+            try {
+                const content = await readFile(filePath);
+                const ext = extname(filePath);
+                const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+                res.writeHead(200, { 'Content-Type': contentType });
+                res.end(content);
+            }
+            catch {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('Not Found');
+            }
+        });
+        server.listen(resolvedPort, () => {
+            logger.info(`Pikku Console running at http://localhost:${resolvedPort}`);
+            open(`http://localhost:${resolvedPort}`);
+        });
+        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) {
+                        console.error(err);
+                        logger.error('Error running watch');
+                    }
+                };
+                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);
+        await new Promise(() => { });
+    },
+});

package/dist/src/functions/commands/pikku-command-bootstrap.d.ts

@@ -0,0 +1,4 @@
+export type BootstrapInput = {
+    allImports: string[];
+};
+export declare const pikkuBootstrap: import("#pikku").PikkuFunctionConfig<BootstrapInput, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<BootstrapInput, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<BootstrapInput, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/pikku-command-bootstrap.js

@@ -0,0 +1,67 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { getFileImportRelativePath } from '../../utils/file-import-path.js';
+import { writeFileInDir } from '../../utils/file-writer.js';
+export const pikkuBootstrap = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }, { allImports }) => {
+        const stateBeforeBootstrap = await getInspectorState();
+        const externalPackageBootstraps = [];
+        const usedExternalPackages = {};
+        if (config.externalPackages) {
+            for (const [namespace, externalPkg] of Object.entries(config.externalPackages)) {
+                const isUsed = stateBeforeBootstrap.rpc?.usedExternalPackages?.has(namespace);
+                if (isUsed || externalPkg.forceInclude) {
+                    const packageName = externalPkg.package;
+                    const packageBootstrap = `${packageName}/.pikku/pikku-bootstrap.gen.js`;
+                    externalPackageBootstraps.push(packageBootstrap);
+                    usedExternalPackages[namespace] = {
+                        package: packageName,
+                        rpcEndpoint: externalPkg.rpcEndpoint,
+                    };
+                    logger.debug(`• External package ${externalPkg.forceInclude && !isUsed ? 'force-included' : 'detected'}: ${namespace} (${packageName})`);
+                }
+            }
+        }
+        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, cfg]) => {
+                const rpcEndpointPart = cfg.rpcEndpoint
+                    ? `, rpcEndpoint: '${cfg.rpcEndpoint}'`
+                    : '';
+                return `externalPackages.set('${ns}', { package: '${cfg.package}'${rpcEndpointPart} })`;
+            })
+                .join('\n')}
+`;
+        }
+        const packageNameArg = config.externalPackageName
+            ? `'${config.externalPackageName}'`
+            : 'null';
+        const metaDirRegistration = `import { pikkuState as __pikkuState } from '@pikku/core'
+try {
+  const { fileURLToPath: __fileURLToPath } = await import('url')
+  const { dirname: __dirname } = await import('path')
+  __pikkuState(${packageNameArg}, 'package', 'metaDir', __dirname(__fileURLToPath(import.meta.url)))
+} catch {}
+`;
+        const allBootstrapImports = metaDirRegistration +
+            [...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);
+    },
+});

package/dist/src/functions/commands/pikku-command-summary.d.ts

@@ -0,0 +1 @@
+export declare const pikkuSummary: 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/pikku-command-summary.js

@@ -0,0 +1,55 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { CommandSummary } from '../../utils/command-summary.js';
+export const pikkuSummary = pikkuSessionlessFunc({
+    func: async ({ logger, getInspectorState }) => {
+        const summary = new CommandSummary('all');
+        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.triggers?.meta) {
+            const triggerCount = Object.keys(state.triggers.meta).length;
+            if (triggerCount > 0)
+                summary.set('triggers', triggerCount);
+        }
+        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.nodes?.meta) {
+            const nodesCount = Object.keys(state.nodes.meta).length;
+            if (nodesCount > 0)
+                summary.set('nodes', nodesCount);
+        }
+        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());
+        }
+    },
+});

package/dist/src/functions/commands/versions-check.d.ts

@@ -0,0 +1 @@
+export declare const pikkuVersionsCheck: 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/versions-check.js

@@ -0,0 +1,17 @@
+import { join } from 'path';
+import { pikkuSessionlessFunc } from '#pikku';
+import { ErrorCode } from '@pikku/inspector';
+export const pikkuVersionsCheck = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        if (!visitState.manifest.initial) {
+            const manifestPath = join(config.outDir, 'versions.json');
+            throw new Error(`[${ErrorCode.MANIFEST_MISSING}] Version manifest not found at ${manifestPath}. Run 'pikku init' to create one.`);
+        }
+        if (visitState.manifest.errors.length > 0) {
+            const messages = visitState.manifest.errors.map((e) => `[${e.code}] ${e.message}`);
+            throw new Error(messages.join('\n'));
+        }
+        logger.info('Version manifest check passed.');
+    },
+});