@pikku/cli 0.11.3 → 0.12.1

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

@@ -1,21 +1,22 @@
 /**
  * Generates type definitions for WebSocket channel wirings
  */
-export const serializeChannelTypes = (functionTypesImportPath) => {
+export const serializeChannelTypes = (functionTypesImportPath, packageName) => {
+    const packageNameValue = packageName ? `'${packageName}'` : 'null';
     return `/**
-
  * Channel-specific type definitions for tree-shaking optimization
  */
 
-import { CoreChannel, wireChannel as wireChannelCore } from '@pikku/core/channel'
+import { CoreChannel, CorePikkuChannelMiddleware, CorePikkuChannelMiddlewareFactory, wireChannel as wireChannelCore, defineChannelRoutes as defineChannelRoutesCore, addChannelMiddleware as addChannelMiddlewareCore } from '@pikku/core/channel'
 import { AssertHTTPWiringParams } from '@pikku/core/http'
-import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
-import type { ZodLike, CorePermissionGroup } from '@pikku/core'
+import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware, Services } from '${functionTypesImportPath}'
+import type { CorePermissionGroup } from '@pikku/core'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 
 /**
- * Helper type to infer the output type from a Zod schema
+ * Helper type to infer the output type from a Standard Schema
  */
-type InferZodOutput<T> = T extends ZodLike<infer U> ? U : never
+type InferSchemaOutput<T> = T extends StandardSchemaV1<any, infer Output> ? Output : never
 
 /**
  * Type definition for WebSocket channels with typed data exchange.
@@ -70,20 +71,20 @@ export const pikkuChannelDisconnectionFunc = (
  * Configuration object for channel functions with Zod schema validation.
  */
 type PikkuChannelFuncConfigWithSchema<
-  InputSchema extends ZodLike,
-  OutputSchema extends ZodLike | undefined = undefined
+  InputSchema extends StandardSchemaV1,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
 > = {
   name?: string
   tags?: string[]
   expose?: boolean
-  internal?: boolean
+  remote?: boolean
   func: PikkuFunctionSessionless<
-    InferZodOutput<InputSchema>,
-    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    InferSchemaOutput<InputSchema>,
+    OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown,
     'channel' | 'session' | 'rpc'
   >
   auth?: boolean
-  permissions?: CorePermissionGroup<PikkuPermission<InferZodOutput<InputSchema>>>
+  permissions?: CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>>
   middleware?: PikkuMiddleware[]
   input: InputSchema
   output?: OutputSchema
@@ -121,11 +122,11 @@ type PikkuChannelFuncConfigWithSchema<
  * \`\`\`
  */
 export function pikkuChannelFunc<
-  InputSchema extends ZodLike,
-  OutputSchema extends ZodLike | undefined = undefined
+  InputSchema extends StandardSchemaV1,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
 >(
   config: PikkuChannelFuncConfigWithSchema<InputSchema, OutputSchema>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'channel' | 'session' | 'rpc'>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'channel' | 'session' | 'rpc'>
 export function pikkuChannelFunc<In, Out = unknown>(
   func:
     | PikkuFunctionSessionless<In, Out, 'channel' | 'session' | 'rpc'>
@@ -145,7 +146,36 @@ export function pikkuChannelFunc(func: any) {
 export const wireChannel = <ChannelData, Channel extends string>(
   channel: ChannelWiring<ChannelData, Channel> & AssertHTTPWiringParams<ChannelData, Channel>
 ) => {
-  wireChannelCore(channel as any) // TODO
+  wireChannelCore(channel as any)
+}
+
+/**
+ * Type-safe helper for defining channel message routes that can be composed.
+ * Returns the routes record as-is for use with wireChannel's onMessageWiring.
+ *
+ * @template T - Record of channel route handlers
+ * @param routes - The channel routes record
+ * @returns The same routes record (identity function for type safety)
+ */
+export function defineChannelRoutes<T extends Record<string, any>>(routes: T): T {
+  return defineChannelRoutesCore(routes)
 }
+
+export type PikkuChannelMiddleware<RequiredServices extends Services = Services, Event = unknown> = CorePikkuChannelMiddleware<RequiredServices, Event>
+
+export const pikkuChannelMiddleware = <RequiredServices extends Services = Services, Event = unknown>(
+  middleware: PikkuChannelMiddleware<RequiredServices, Event>
+): PikkuChannelMiddleware<RequiredServices, Event> => {
+  return middleware
+}
+
+export const pikkuChannelMiddlewareFactory = <In = any>(
+  factory: CorePikkuChannelMiddlewareFactory<In>
+): CorePikkuChannelMiddlewareFactory<In> => {
+  return factory
+}
+
+export const addChannelMiddleware = (tag: string, middleware: PikkuChannelMiddleware[]) =>
+  addChannelMiddlewareCore(tag, middleware, ${packageNameValue})
 `;
 };

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

@@ -1,4 +1,5 @@
-import { ChannelsMeta } from '@pikku/core/channel';
-import { TypesMap } from '@pikku/inspector';
-import { FunctionsMeta } from '@pikku/core';
-export declare const serializeTypedChannelsMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, channelsMeta: ChannelsMeta) => string;
+import type { ChannelsMeta } from '@pikku/core/channel';
+import type { TypesMap } from '@pikku/inspector';
+import type { FunctionsMeta } from '@pikku/core';
+import type { Logger } from '@pikku/core/services';
+export declare const serializeTypedChannelsMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, channelsMeta: ChannelsMeta) => string;

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

@@ -1,6 +1,6 @@
 import { serializeImportMap } from '../../../utils/serialize-import-map.js';
-import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
-export const serializeTypedChannelsMap = (relativeToPath, packageMappings, typesMap, functionsMeta, channelsMeta) => {
+import { generateCustomTypes } from '@pikku/inspector';
+export const serializeTypedChannelsMap = (logger, relativeToPath, packageMappings, typesMap, functionsMeta, channelsMeta) => {
     const { channels, requiredTypes } = generateChannels(functionsMeta, channelsMeta);
     typesMap.customTypes.forEach(({ references }) => {
         for (const reference of references) {
@@ -9,7 +9,7 @@ export const serializeTypedChannelsMap = (relativeToPath, packageMappings, types
             }
         }
     });
-    const imports = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    const imports = serializeImportMap(logger, relativeToPath, packageMappings, typesMap, requiredTypes);
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
     return `/**
  * This provides the structure needed for TypeScript to be aware of channels
@@ -49,9 +49,9 @@ function generateChannels(functionsMeta, channelsMeta) {
             channelsObject[name] = { message: null, routes: {} };
         }
         if (message) {
-            const func = functionsMeta[message.pikkuFuncName];
+            const func = functionsMeta[message.pikkuFuncId];
             if (!func) {
-                throw new Error(`Function ${message.pikkuFuncName} not found in functionsMeta for channel ${name}`);
+                throw new Error(`Function ${message.pikkuFuncId} not found in functionsMeta for channel ${name}`);
             }
             const inputTypes = func.inputs || null;
             const outputTypes = func.outputs || null;
@@ -66,10 +66,10 @@ function generateChannels(functionsMeta, channelsMeta) {
             if (!channelsObject[name].routes[key]) {
                 channelsObject[name].routes[key] = {};
             }
-            for (const [method, { pikkuFuncName }] of Object.entries(route)) {
-                const func = functionsMeta[pikkuFuncName];
+            for (const [method, { pikkuFuncId }] of Object.entries(route)) {
+                const func = functionsMeta[pikkuFuncId];
                 if (!func) {
-                    throw new Error(`Function ${pikkuFuncName} not found in functionsMeta for channel ${name}, route ${key}, method ${method}`);
+                    throw new Error(`Function ${pikkuFuncId} not found in functionsMeta for channel ${name}, route ${key}, method ${method}`);
                 }
                 const inputTypes = func.inputs || null;
                 const outputTypes = func.outputs || null;

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

@@ -1 +1 @@
-export declare const pikkuCLIEntry: any;
+export declare const pikkuCLIEntry: 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/wirings/cli/pikku-command-cli-entry.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
@@ -15,7 +15,7 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
         // Check if CLI entrypoints are configured
         if (!config.cli?.entrypoints ||
             Object.keys(config.cli.entrypoints).length === 0) {
-            logger.info({
+            logger.debug({
                 message: 'No CLI entrypoints configured in config.cli.entrypoints, skipping CLI bootstrap generation',
                 type: 'skip',
             });
@@ -98,14 +98,10 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
                 // Get service factories for local mode
                 // Check for required types
                 checkRequiredTypes(visitState.filesAndMethodsErrors, {
-                    config: true,
                     singletonServicesFactory: true,
-                    wireServicesFactory: true,
                 });
                 const { pikkuConfigFactory, singletonServicesFactory, wireServicesFactory, } = visitState.filesAndMethods;
-                if (!pikkuConfigFactory ||
-                    !singletonServicesFactory ||
-                    !wireServicesFactory) {
+                if (!singletonServicesFactory) {
                     throw new Error('Required types not found');
                 }
                 const bootstrapCode = serializeLocalCLIBootstrap(programName, programMeta, bootstrapFile, config, pikkuConfigFactory, singletonServicesFactory, wireServicesFactory);

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

@@ -1 +1 @@
-export declare const pikkuCLITypes: any;
+export declare const pikkuCLITypes: 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/wirings/cli/pikku-command-cli-types.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 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';

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

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

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 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';
@@ -24,7 +24,7 @@ export const pikkuCLI = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, cliWiringMetaFile, `import { pikkuState } from '@pikku/core'\nimport { CLIMeta } from '@pikku/core/cli'\n${importStatement}\npikkuState(null, 'cli', 'meta', metaData as CLIMeta)`);
+        await writeFileInDir(logger, cliWiringMetaFile, `import { pikkuState } from '@pikku/core/internal'\nimport { CLIMeta } from '@pikku/core/cli'\n${importStatement}\npikkuState(null, 'cli', 'meta', metaData as CLIMeta)`);
         return true;
     },
     middleware: [

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

@@ -1,5 +1,5 @@
-import { CLIProgramMeta } from '@pikku/core/cli';
-import { Config } from '../../../../types/application-types.js';
+import type { CLIProgramMeta } from '@pikku/core/cli';
+import type { Config } from '../../../../types/application-types.js';
 /**
  * Collect all unique renderer names from CLI metadata (populated by inspector)
  */

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

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

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

@@ -12,9 +12,9 @@ export function serializeChannelCLI(programName, programMeta, channelFile, funct
         for (const [name, cmd] of Object.entries(commands)) {
             const fullPath = [...path, name];
             const commandKey = fullPath.join('.');
-            if (cmd.pikkuFuncName) {
+            if (cmd.pikkuFuncId) {
                 commandMap[commandKey] = {
-                    pikkuFuncName: cmd.pikkuFuncName,
+                    pikkuFuncId: cmd.pikkuFuncId,
                 };
             }
             // Recursively process subcommands
@@ -26,13 +26,13 @@ export function serializeChannelCLI(programName, programMeta, channelFile, funct
     collectCommands(programMeta.commands);
     // Generate imports from function file locations
     const funcNames = [
-        ...new Set(Object.values(commandMap).map((v) => v.pikkuFuncName)),
+        ...new Set(Object.values(commandMap).map((v) => v.pikkuFuncId)),
     ];
     const imports = funcNames
-        .map((pikkuFuncName) => {
-        const fileInfo = functionFiles.get(pikkuFuncName);
+        .map((pikkuFuncId) => {
+        const fileInfo = functionFiles.get(pikkuFuncId);
         if (!fileInfo) {
-            throw new Error(`Function not found in files map: ${pikkuFuncName}`);
+            throw new Error(`Function not found in files map: ${pikkuFuncId}`);
         }
         const importPath = getFileImportRelativePath(channelFile, fileInfo.path, packageMappings);
         return `import { ${fileInfo.exportedName} } from '${importPath}'`;
@@ -79,8 +79,8 @@ wireChannel({
   onMessageWiring: {
     command: {
 ${Object.entries(commandMap)
-        .map(([commandKey, { pikkuFuncName }]) => `      '${commandKey}': {
-        func: ${pikkuFuncName},
+        .map(([commandKey, { pikkuFuncId }]) => `      '${commandKey}': {
+        func: ${pikkuFuncId},
         middleware: [cliCloseOnComplete],
       }`)
         .join(',\n')}

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

@@ -7,7 +7,7 @@ export const serializeCLITypes = (functionTypesImportPath, userSessionTypeImport
  * CLI-specific type definitions for tree-shaking optimization
  */
 
-import { CoreCLI, wireCLI as wireCLICore, CorePikkuCLIRender, CoreCLICommandConfig } from '@pikku/core/cli'
+import { CoreCLI, wireCLI as wireCLICore, CorePikkuCLIRender, CoreCLICommandConfig, defineCLICommands as defineCLICommandsCore } from '@pikku/core/cli'
 import type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImportPath}'
 ${userSessionTypeImport}
 ${singletonServicesTypeImport}
@@ -91,5 +91,18 @@ export const pikkuCLICommand = <
 ): CoreCLICommandConfig<FuncConfig, PikkuMiddleware, PikkuCLIRender<any>, string> => {
   return config as any
 }
+
+/**
+ * Type-safe helper for defining CLI commands that can be composed and spread into wireCLI.
+ *
+ * @template T - Record of CLI command configurations
+ * @param commands - The CLI commands record
+ * @returns The same commands record (identity function for type safety)
+ */
+export const defineCLICommands = <T extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>, any>>>(
+  commands: T
+): T => {
+  return defineCLICommandsCore(commands as any) as T
+}
 `;
 };

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

@@ -1,14 +1,14 @@
-import { Config } from '../../../../types/application-types.js';
+import type { Config } from '../../../../types/application-types.js';
 /**
  * Serializes the local (in-program) CLI bootstrap code
  */
 export declare function serializeLocalCLIBootstrap(programName: string, _programMeta: any, bootstrapFile: string, config: Config, pikkuConfigFactory: {
     file: string;
     variable: string;
-}, singletonServicesFactory: {
+} | undefined, singletonServicesFactory: {
     file: string;
     variable: string;
-}, wireServicesFactory: {
+}, wireServicesFactory?: {
     file: string;
     variable: string;
 }): string;

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

@@ -4,30 +4,29 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
  */
 export function serializeLocalCLIBootstrap(programName, _programMeta, bootstrapFile, config, pikkuConfigFactory, singletonServicesFactory, wireServicesFactory) {
     const capitalizedName = programName.charAt(0).toUpperCase() + programName.slice(1).replace(/-/g, '');
-    // Get relative import paths
-    const pikkuConfigPath = getFileImportRelativePath(bootstrapFile, pikkuConfigFactory.file, config.packageMappings);
+    const pikkuConfigPath = pikkuConfigFactory
+        ? getFileImportRelativePath(bootstrapFile, pikkuConfigFactory.file, config.packageMappings)
+        : null;
     const singletonServicesPath = getFileImportRelativePath(bootstrapFile, singletonServicesFactory.file, config.packageMappings);
-    const wireServicesPath = getFileImportRelativePath(bootstrapFile, wireServicesFactory.file, config.packageMappings);
+    const wireServicesPath = wireServicesFactory
+        ? getFileImportRelativePath(bootstrapFile, wireServicesFactory.file, config.packageMappings)
+        : null;
     const cliBootstrapPath = getFileImportRelativePath(bootstrapFile, config.bootstrapFile, config.packageMappings);
     return `
 import { executeCLI, CLIError } from '@pikku/core/cli'
-import { ${pikkuConfigFactory.variable} as createConfig } from '${pikkuConfigPath}'
+${pikkuConfigFactory ? `import { ${pikkuConfigFactory.variable} as createConfig } from '${pikkuConfigPath}'` : ''}
 import { ${singletonServicesFactory.variable} as createSingletonServices } from '${singletonServicesPath}'
-import { ${wireServicesFactory.variable} as createWireServices } from '${wireServicesPath}'
+${wireServicesFactory ? `import { ${wireServicesFactory.variable} as createWireServices } from '${wireServicesPath}'` : ''}
 import '${cliBootstrapPath}'
 
-/**
- * ${capitalizedName} CLI function
- * Handles command line arguments and executes the appropriate function
- */
 export async function ${capitalizedName}CLI(args: string[]): Promise<void> {
   try {
     await executeCLI({
       programName: '${programName}',
       args: args || process.argv.slice(2),
-      createConfig,
+${pikkuConfigFactory ? '      createConfig,' : ''}
       createSingletonServices,
-      createWireServices,
+${wireServicesFactory ? '      createWireServices,' : ''}
     })
   } catch (error) {
     if (error instanceof CLIError) {

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

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

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

@@ -0,0 +1,24 @@
+import { pikkuSessionlessFunc } from '#pikku';
+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 { serializeConsoleFunctions } from './serialize-console-functions.js';
+import { join } from 'path';
+export const pikkuConsoleFunctions = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        if (config.console?.functionsPath) {
+            const consoleFunctionsPath = join(config.rootDir, config.console.functionsPath);
+            const pathToPikkuTypes = getFileImportRelativePath(consoleFunctionsPath, config.typesDeclarationFile, config.packageMappings);
+            const pathToAgentTypes = getFileImportRelativePath(consoleFunctionsPath, config.agentTypesFile, config.packageMappings);
+            await writeFileInDir(logger, consoleFunctionsPath, serializeConsoleFunctions(pathToPikkuTypes, pathToAgentTypes));
+            return true;
+        }
+        return false;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating Console functions',
+            commandEnd: 'Generated Console functions',
+        }),
+    ],
+});

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

@@ -0,0 +1 @@
+export declare const pikkuNodeTypes: 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/wirings/console/pikku-command-node-types.js

@@ -0,0 +1,21 @@
+import { pikkuSessionlessFunc } from '#pikku';
+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 { serializeNodeTypes } from './serialize-node-types.js';
+export const pikkuNodeTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { nodeTypesFile, rpcInternalMapDeclarationFile, packageMappings, node, } = config;
+        let rpcMapImportPath = getFileImportRelativePath(nodeTypesFile, rpcInternalMapDeclarationFile, packageMappings);
+        rpcMapImportPath = rpcMapImportPath.replace('.d.js', '.js');
+        const categories = node?.categories;
+        const content = serializeNodeTypes(rpcMapImportPath, categories);
+        await writeFileInDir(logger, nodeTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating Node types',
+            commandEnd: 'Created Node types',
+        }),
+    ],
+});

package/dist/src/functions/wirings/console/pikku-command-nodes-meta.d.ts

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

package/dist/src/functions/wirings/console/pikku-command-nodes-meta.js

@@ -0,0 +1,79 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { ErrorCode } from '@pikku/inspector';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { readFile } from 'fs/promises';
+import { join, isAbsolute } from 'path';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { validateAndBuildSecretDefinitionsMeta } from '@pikku/core/secret';
+const loadIcon = async (iconPath, rootDir, logger) => {
+    if (!iconPath)
+        return undefined;
+    const fullPath = isAbsolute(iconPath) ? iconPath : join(rootDir, iconPath);
+    try {
+        const content = await readFile(fullPath, 'utf-8');
+        const trimmed = content.trim();
+        if (!trimmed.startsWith('<svg') && !trimmed.startsWith('<?xml')) {
+            logger.warn(`Icon file is not a valid SVG: ${fullPath}`);
+            return undefined;
+        }
+        return trimmed.replace(/<\?xml[^?]*\?>\s*/g, '').trim();
+    }
+    catch {
+        logger.warn(`Could not load icon: ${fullPath}`);
+        return undefined;
+    }
+};
+export const pikkuNodesMeta = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const state = await getInspectorState();
+        const { nodes, secrets } = state;
+        const { nodesMetaJsonFile, node, rootDir } = config;
+        const secretsMeta = validateAndBuildSecretDefinitionsMeta(secrets.definitions, state.schemaLookup);
+        const hasNodes = Object.keys(nodes.meta).length > 0;
+        const hasSecrets = secrets.definitions.length > 0;
+        if (!hasNodes && !hasSecrets) {
+            return undefined;
+        }
+        const allowedCategories = node?.categories;
+        if (allowedCategories && allowedCategories.length > 0) {
+            for (const [name, meta] of Object.entries(nodes.meta)) {
+                if (!allowedCategories.includes(meta.category)) {
+                    logger.critical(ErrorCode.INVALID_VALUE, `Node '${name}' has invalid category '${meta.category}'. ` +
+                        `Allowed categories: ${allowedCategories.join(', ')}`);
+                }
+            }
+        }
+        const outputMeta = {};
+        for (const [name, meta] of Object.entries(nodes.meta)) {
+            const { icon: _icon, ...nodeMetaWithoutIcon } = meta;
+            outputMeta[name] = nodeMetaWithoutIcon;
+        }
+        const packageIcon = await loadIcon(node?.icon, rootDir, logger);
+        const metaData = {
+            nodes: outputMeta,
+            secrets: secretsMeta,
+            package: {
+                displayName: node?.displayName,
+                description: node?.description,
+                icon: packageIcon,
+                categories: node?.categories,
+            },
+        };
+        if (nodesMetaJsonFile) {
+            const minimalMeta = stripVerboseFields(metaData);
+            await writeFileInDir(logger, nodesMetaJsonFile, JSON.stringify(minimalMeta, null, 2), { ignoreModifyComment: true });
+            if (hasVerboseFields(metaData)) {
+                const verbosePath = nodesMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+                await writeFileInDir(logger, verbosePath, JSON.stringify(metaData, null, 2), { ignoreModifyComment: true });
+            }
+        }
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating nodes metadata',
+            commandEnd: 'Generated nodes metadata',
+        }),
+    ],
+});

package/dist/src/functions/wirings/console/serialize-console-functions.d.ts

@@ -0,0 +1 @@
+export declare const serializeConsoleFunctions: (pathToPikkuTypes: string, _pathToAgentTypes: string) => string;

package/dist/src/functions/wirings/console/serialize-console-functions.js

@@ -0,0 +1,90 @@
+export const serializeConsoleFunctions = (pathToPikkuTypes, _pathToAgentTypes) => {
+    return `import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes, addon, wireAddon } from '${pathToPikkuTypes}'
+
+export const pikkuConsoleSetSecret = pikkuSessionlessFunc<{
+  secretId: string
+  value: unknown
+}, {
+  success: boolean
+}>({
+  description: 'Set the value of a secret',
+  expose: true,
+  auth: false,
+  func: async ({ secrets }, { secretId, value }) => {
+    await secrets.setSecretJSON(secretId, value)
+    return { success: true }
+  },
+})
+
+export const pikkuConsoleGetVariable = pikkuSessionlessFunc<
+  { variableId: string },
+  { exists: boolean; value: unknown | null }
+>({
+  description: 'Get the current value of a variable',
+  expose: true,
+  auth: false,
+  func: async ({ variables }, { variableId }) => {
+    const exists = await variables.has(variableId)
+    if (!exists) {
+      return { exists: false, value: null }
+    }
+    try {
+      const value = await variables.getJSON(variableId)
+      return { exists: true, value }
+    } catch {
+      const value = await variables.get(variableId)
+      return { exists: true, value }
+    }
+  },
+})
+
+export const pikkuConsoleSetVariable = pikkuSessionlessFunc<
+  { variableId: string; value: unknown },
+  { success: boolean }
+>({
+  description: 'Set the value of a variable',
+  expose: true,
+  auth: false,
+  func: async ({ variables }, { variableId, value }) => {
+    if (typeof value === 'string') {
+      await variables.set(variableId, value)
+    } else {
+      await variables.setJSON(variableId, value)
+    }
+    return { success: true }
+  },
+})
+
+export const pikkuConsoleGetSecret = pikkuSessionlessFunc<
+  { secretId: string },
+  { exists: boolean; value: unknown | null }
+>({
+  description: 'Get the current value of a secret',
+  expose: true,
+  auth: false,
+  func: async ({ secrets }, { secretId }) => {
+    const exists = await secrets.hasSecret(secretId)
+    if (!exists) {
+      return { exists: false, value: null }
+    }
+    const value = await secrets.getSecretJSON(secretId)
+    return { exists: true, value }
+  },
+})
+
+export const consoleRoutes = defineHTTPRoutes({
+  auth: false,
+  routes: {
+    workflowRunStream: {
+      route: '/workflow-run/:runId/stream',
+      method: 'get',
+      sse: true,
+      func: addon('console:streamWorkflowRun'),
+    },
+  },
+})
+
+wireAddon({ name: 'console', package: '@pikku/addon-console' })
+wireHTTPRoutes({ baseRoute: '/api', routes: { console: consoleRoutes } })
+`;
+};

package/dist/src/functions/wirings/console/serialize-node-types.d.ts

@@ -0,0 +1 @@
+export declare const serializeNodeTypes: (rpcMapImportPath: string, categories: string[] | undefined) => string;

package/dist/src/functions/wirings/console/serialize-node-types.js

@@ -0,0 +1,11 @@
+export const serializeNodeTypes = (rpcMapImportPath, categories) => {
+    const categoryType = categories?.length
+        ? categories.map((c) => `'${c}'`).join(' | ')
+        : 'never';
+    return `import type { FlattenedRPCMap } from '${rpcMapImportPath}'
+
+export type NodeCategory = ${categoryType}
+
+export type NodeRPCName = keyof FlattenedRPCMap
+`;
+};

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

@@ -0,0 +1 @@
+export declare const pikkuAddonTypes: 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>;