@pikku/cli 0.11.1 → 0.11.3

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

@@ -2,15 +2,29 @@ import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 export const pikkuCLI = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const { cliWiringsFile, cliWiringMetaFile, packageMappings } = config;
+        const { cliWiringsFile, cliWiringMetaFile, cliWiringMetaJsonFile, packageMappings, schema, } = config;
         const { cli } = visitState;
         // Generate CLI wirings file
         await writeFileInDir(logger, cliWiringsFile, serializeFileImports('wireCLI', cliWiringsFile, cli.files, packageMappings));
-        // Generate CLI metadata file
-        await writeFileInDir(logger, cliWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('cli', 'meta', ${JSON.stringify(cli.meta, null, 2)})`);
+        // Write minimal JSON (runtime-only fields)
+        const minimalMeta = stripVerboseFields(cli.meta);
+        await writeFileInDir(logger, cliWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(cli.meta)) {
+            const verbosePath = cliWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(cli.meta, null, 2));
+        }
+        const jsonImportPath = getFileImportRelativePath(cliWiringMetaFile, cliWiringMetaJsonFile, packageMappings);
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        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)`);
         return true;
     },
     middleware: [

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

@@ -50,7 +50,7 @@ import { pikkuMiddleware } from '${functionTypesPath}'
 ${imports}
 
 // Middleware to close the channel after CLI command completes
-const cliCloseOnComplete = pikkuMiddleware(async (services, { channel }, next) => {
+const cliCloseOnComplete = pikkuMiddleware(async (_services, { channel }, next) => {
   const closeChannel = () => {
     setTimeout(async () => {
       try {

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

@@ -50,7 +50,7 @@ export const pikkuCLIRender = <Data, RequiredServices extends SingletonServices
  * CLI command configuration with project-specific types.
  * Uses CoreCLICommandConfig from @pikku/core with local middleware and render types.
  */
-type CLICommandConfig<Func extends PikkuFunctionConfig<In, Out>, In = any, Out = any, Params extends string = string> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>, Params>
+type CLICommandConfig<Func extends PikkuFunctionConfig<In, Out, 'cli' | 'rpc' | 'session'>, In = any, Out = any, Params extends string = string> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>, Params>
 
 /**
  * Type definition for CLI applications with commands and global options.
@@ -84,7 +84,7 @@ export const wireCLI = <Commands extends Record<string, CoreCLICommandConfig<any
  * @returns CLI command configuration with inferred types
  */
 export const pikkuCLICommand = <
-  FuncConfig extends PikkuFunctionConfig<any, any>,
+  FuncConfig extends PikkuFunctionConfig<any, any, 'cli' | 'rpc' | 'session'>,
   Params extends string
 >(
   config: CLICommandConfig<FuncConfig, any, any, Params>

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

@@ -8,7 +8,7 @@ export declare function serializeLocalCLIBootstrap(programName: string, _program
 }, singletonServicesFactory: {
     file: string;
     variable: string;
-}, sessionServicesFactory: {
+}, wireServicesFactory: {
     file: string;
     variable: string;
 }): string;

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

@@ -2,18 +2,18 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 /**
  * Serializes the local (in-program) CLI bootstrap code
  */
-export function serializeLocalCLIBootstrap(programName, _programMeta, bootstrapFile, config, pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory) {
+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 singletonServicesPath = getFileImportRelativePath(bootstrapFile, singletonServicesFactory.file, config.packageMappings);
-    const sessionServicesPath = getFileImportRelativePath(bootstrapFile, sessionServicesFactory.file, config.packageMappings);
+    const wireServicesPath = getFileImportRelativePath(bootstrapFile, wireServicesFactory.file, config.packageMappings);
     const cliBootstrapPath = getFileImportRelativePath(bootstrapFile, config.bootstrapFile, config.packageMappings);
     return `
 import { executeCLI, CLIError } from '@pikku/core/cli'
 import { ${pikkuConfigFactory.variable} as createConfig } from '${pikkuConfigPath}'
 import { ${singletonServicesFactory.variable} as createSingletonServices } from '${singletonServicesPath}'
-import { ${sessionServicesFactory.variable} as createSessionServices } from '${sessionServicesPath}'
+import { ${wireServicesFactory.variable} as createWireServices } from '${wireServicesPath}'
 import '${cliBootstrapPath}'
 
 /**
@@ -27,7 +27,7 @@ export async function ${capitalizedName}CLI(args: string[]): Promise<void> {
       args: args || process.argv.slice(2),
       createConfig,
       createSingletonServices,
-      createSessionServices,
+      createWireServices,
     })
   } catch (error) {
     if (error instanceof CLIError) {

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

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

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

@@ -0,0 +1,90 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+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';
+/**
+ * Load and sanitize an SVG icon file.
+ * Returns the SVG content as a string, or undefined if not found.
+ */
+const loadIcon = async (iconPath, rootDir, logger) => {
+    if (!iconPath)
+        return undefined;
+    // Resolve the full path to the icon
+    const fullPath = isAbsolute(iconPath) ? iconPath : join(rootDir, iconPath);
+    try {
+        const content = await readFile(fullPath, 'utf-8');
+        // Basic SVG validation - must start with <svg
+        const trimmed = content.trim();
+        if (!trimmed.startsWith('<svg') && !trimmed.startsWith('<?xml')) {
+            logger.warn(`Icon file is not a valid SVG: ${fullPath}`);
+            return undefined;
+        }
+        // Return the sanitized SVG (remove XML declaration if present)
+        return trimmed.replace(/<\?xml[^?]*\?>\s*/g, '').trim();
+    }
+    catch (e) {
+        logger.warn(`Could not load icon: ${fullPath}`);
+        return undefined;
+    }
+};
+export const pikkuForgeNodes = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { forgeNodes, forgeCredentials } = await getInspectorState();
+        const { forgeNodesMetaJsonFile, forge, rootDir } = config;
+        const hasNodes = Object.keys(forgeNodes.meta).length > 0;
+        const hasCredentials = Object.keys(forgeCredentials.meta).length > 0;
+        // Only generate if there are forge nodes or credentials
+        if (!hasNodes && !hasCredentials) {
+            return undefined;
+        }
+        // Validate categories if configured
+        const allowedCategories = forge?.node?.categories;
+        if (allowedCategories && allowedCategories.length > 0) {
+            for (const [name, meta] of Object.entries(forgeNodes.meta)) {
+                if (!allowedCategories.includes(meta.category)) {
+                    logger.critical(ErrorCode.INVALID_VALUE, `Forge node '${name}' has invalid category '${meta.category}'. ` +
+                        `Allowed categories: ${allowedCategories.join(', ')}`);
+                }
+            }
+        }
+        // Build the output metadata - remove per-node icon field
+        const outputMeta = {};
+        for (const [name, meta] of Object.entries(forgeNodes.meta)) {
+            // Remove icon from node meta - only package-level icon is used
+            const { icon: _icon, ...nodeMetaWithoutIcon } = meta;
+            outputMeta[name] = nodeMetaWithoutIcon;
+        }
+        // Load package-level icon
+        const packageIcon = await loadIcon(forge?.node?.icon, rootDir, logger);
+        const metaData = {
+            nodes: outputMeta,
+            credentials: forgeCredentials.meta,
+            package: {
+                displayName: forge?.node?.displayName,
+                description: forge?.node?.description,
+                icon: packageIcon,
+                categories: forge?.node?.categories,
+            },
+        };
+        if (forgeNodesMetaJsonFile) {
+            // Write minimal JSON (runtime-only fields)
+            const minimalMeta = stripVerboseFields(metaData);
+            await writeFileInDir(logger, forgeNodesMetaJsonFile, JSON.stringify(minimalMeta, null, 2), { ignoreModifyComment: true });
+            // Write verbose JSON only if it has additional fields
+            if (hasVerboseFields(metaData)) {
+                const verbosePath = forgeNodesMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+                await writeFileInDir(logger, verbosePath, JSON.stringify(metaData, null, 2), { ignoreModifyComment: true });
+            }
+        }
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating Forge nodes metadata',
+            commandEnd: 'Generated Forge nodes metadata',
+        }),
+    ],
+});

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

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

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

@@ -0,0 +1,26 @@
+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 { serializeForgeTypes } from './serialize-forge-types.js';
+export const pikkuForgeTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { forgeTypesFile, rpcInternalMapDeclarationFile, packageMappings, forge, } = config;
+        // Get the import path for the RPC map declaration file
+        // The declaration file ends in .d.ts, but we need to import from .js
+        // getFileImportRelativePath converts .ts -> .js, so .d.ts -> .d.js
+        // We need to remove the extra .d extension
+        let rpcMapImportPath = getFileImportRelativePath(forgeTypesFile, rpcInternalMapDeclarationFile, packageMappings);
+        // Fix: .d.ts files should be imported as .js (TypeScript resolves types from .d.ts)
+        rpcMapImportPath = rpcMapImportPath.replace('.d.js', '.js');
+        const categories = forge?.node?.categories;
+        const content = serializeForgeTypes(rpcMapImportPath, categories);
+        await writeFileInDir(logger, forgeTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating Forge types',
+            commandEnd: 'Created Forge types',
+        }),
+    ],
+});

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

@@ -0,0 +1,4 @@
+/**
+ * Generates type definitions for Forge wirings with typed category and RPC validation
+ */
+export declare const serializeForgeTypes: (rpcMapImportPath: string, categories: string[] | undefined) => string;

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

@@ -0,0 +1,90 @@
+/**
+ * Generates type definitions for Forge wirings with typed category and RPC validation
+ */
+export const serializeForgeTypes = (rpcMapImportPath, categories) => {
+    // Generate category union type - 'never' if no categories configured
+    const categoryType = categories?.length
+        ? categories.map((c) => `'${c}'`).join(' | ')
+        : 'never';
+    return `/**
+ * Forge-specific type definitions for typed wireForgeNode and wireForgeCredential
+ */
+
+import { wireForgeNode as wireForgeNodeCore, wireForgeCredential as wireForgeCredentialCore } from '@pikku/core/forge-node'
+import type { CoreForgeNode, CoreForgeCredential } from '@pikku/core/forge-node'
+import type { FlattenedRPCMap } from '${rpcMapImportPath}'
+
+/**
+ * Valid category values for forge nodes.
+ * ${categories?.length ? `Configured categories: ${categories.join(', ')}` : 'No categories configured - wireForgeNode cannot be used until forge.node.categories is defined in pikku.config.json.'}
+ */
+export type ForgeCategory = ${categoryType}
+
+/**
+ * Valid RPC names that can be used with forge nodes.
+ * These are derived from the FlattenedRPCMap which includes both local and external package RPCs.
+ */
+export type ForgeRPCName = keyof FlattenedRPCMap
+
+/**
+ * Typed forge node configuration.
+ * Validates that category and rpc are valid values.
+ */
+export type TypedForgeNode = Omit<CoreForgeNode, 'category' | 'rpc'> & {
+  /** Grouping category (validated against forge.node.categories in config) */
+  category: ForgeCategory
+  /** RPC name to call when node executes (must be a valid RPC name) */
+  rpc: ForgeRPCName
+}
+
+/**
+ * Registers a Forge node with validated category and RPC.
+ *
+ * @param config - Forge node configuration with typed category and rpc
+ *
+ * @example
+ * \`\`\`typescript
+ * wireForgeNode({
+ *   name: 'send-email',
+ *   displayName: 'Send Email',
+ *   category: 'Communication', // Must be in forge.node.categories
+ *   type: 'action',
+ *   rpc: 'sendEmail', // Must be a valid RPC name
+ *   description: 'Sends an email to a recipient'
+ * })
+ * \`\`\`
+ */
+export const wireForgeNode = (config: TypedForgeNode): void => {
+  wireForgeNodeCore(config as CoreForgeNode)
+}
+
+/**
+ * Registers a Forge credential definition.
+ * Credentials define secrets/API keys required by the package.
+ *
+ * @template T - Zod schema type for the credential structure
+ * @param config - Forge credential configuration
+ *
+ * @example
+ * \`\`\`typescript
+ * import { z } from 'zod'
+ *
+ * const apiCredentials = z.object({
+ *   apiKey: z.string().describe('API key for authentication'),
+ *   apiSecret: z.string().describe('API secret')
+ * })
+ *
+ * wireForgeCredential({
+ *   name: 'example-api',
+ *   displayName: 'Example API Credentials',
+ *   description: 'Credentials for the example external API',
+ *   secretId: 'EXAMPLE_API_CREDENTIALS',
+ *   schema: apiCredentials
+ * })
+ * \`\`\`
+ */
+export const wireForgeCredential = <T>(config: CoreForgeCredential<T>): void => {
+  wireForgeCredentialCore(config)
+}
+`;
+};

package/dist/src/functions/wirings/functions/pikku-command-function-types-split.js

@@ -11,17 +11,17 @@ export const pikkuFunctionTypesSplit = pikkuSessionlessFunc({
         // Check for required types
         checkRequiredTypes(visitState.filesAndMethodsErrors, {
             userSessionType: true,
-            sessionServiceType: true,
+            wireServiceType: true,
             singletonServicesType: true,
         });
-        const { userSessionType, sessionServicesType, singletonServicesType, pikkuConfigType, } = visitState.filesAndMethods;
-        if (!userSessionType || !sessionServicesType || !singletonServicesType) {
+        const { userSessionType, wireServicesType, singletonServicesType, pikkuConfigType, } = visitState.filesAndMethods;
+        if (!userSessionType || !wireServicesType || !singletonServicesType) {
             throw new Error('Required types not found');
         }
         const configTypeImport = pikkuConfigType
             ? `import type { ${pikkuConfigType.type} } from '${getFileImportRelativePath(functionTypesFile, pikkuConfigType.typePath, packageMappings)}'`
             : '// Config type not found, will use fallback';
-        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, sessionServicesType.typePath, packageMappings)}'`, sessionServicesType.type, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`, `import type { RequiredSingletonServices, RequiredSessionServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`, configTypeImport);
+        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, wireServicesType.typePath, packageMappings)}'`, wireServicesType.type, `import type { TypedPikkuRPC, FlattenedRPCMap } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`, `import type { RequiredSingletonServices, RequiredWireServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`, configTypeImport, config.externalPackageName);
         await writeFileInDir(logger, functionTypesFile, content);
     },
     middleware: [

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

@@ -5,8 +5,13 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializePikkuTypesHub } from './serialize-pikku-types-hub.js';
 export const pikkuFunctionTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, } = config;
-        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getFileImportRelativePath(typesFile, httpTypesFile, packageMappings), getFileImportRelativePath(typesFile, channelsTypesFile, packageMappings), getFileImportRelativePath(typesFile, schedulersTypesFile, packageMappings), getFileImportRelativePath(typesFile, queueTypesFile, packageMappings), getFileImportRelativePath(typesFile, mcpTypesFile, packageMappings), getFileImportRelativePath(typesFile, cliTypesFile, packageMappings));
+        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, forgeTypesFile, } = config;
+        const getImportPath = (file) => config.externalPackage
+            ? null
+            : getFileImportRelativePath(typesFile, file, packageMappings);
+        // Forge types are included for external packages (they need wireForgeNode/wireForgeCredential)
+        const getForgeImportPath = (file) => getFileImportRelativePath(typesFile, file, packageMappings);
+        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getImportPath(httpTypesFile), getImportPath(channelsTypesFile), getImportPath(schedulersTypesFile), getImportPath(queueTypesFile), getImportPath(mcpTypesFile), getImportPath(cliTypesFile), getForgeImportPath(forgeTypesFile));
         await writeFileInDir(logger, typesFile, content);
     },
     middleware: [

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

@@ -1,21 +1,46 @@
 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 { generateRuntimeMeta, serializeFunctionImports, } from './serialize-function-imports.js';
+import { serializeFunctionImports } from './serialize-function-imports.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 export const pikkuFunctions = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { functions, rpc } = await getInspectorState();
-        const { functionsMetaFile, functionsMetaMinFile, functionsFile, packageMappings, } = config;
-        // Generate full metadata
-        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
-        // Generate minimal metadata (runtime)
-        const runtimeMeta = generateRuntimeMeta(functions.meta);
-        await writeFileInDir(logger, functionsMetaMinFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(runtimeMeta, null, 2)})`);
+        const { functionsMetaFile, functionsMetaJsonFile, functionsFile, packageMappings, schema, } = config;
+        // Write minimal JSON (runtime-only fields)
+        const minimalMeta = stripVerboseFields(functions.meta);
+        await writeFileInDir(logger, functionsMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(functions.meta)) {
+            const verbosePath = functionsMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(functions.meta, null, 2));
+        }
+        const jsonImportPath = getFileImportRelativePath(functionsMetaFile, functionsMetaJsonFile, packageMappings);
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        const importStatement = supportsImportAttributes
+            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+            : `import metaData from '${jsonImportPath}'`;
+        const packageName = config.externalPackageName
+            ? `'${config.externalPackageName}'`
+            : 'null';
+        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState, FunctionsMeta } from '@pikku/core'\n${importStatement}\npikkuState(${packageName}, 'function', 'meta', metaData as FunctionsMeta)`);
+        // For external packages, register ALL functions (they'll be invoked by consumers)
+        // For main packages, only register functions that are invoked via internal RPCs
+        const isExternalPackage = !!config.externalPackageName;
         const hasRPCs = rpc.exposedFiles.size > 0 || rpc.internalFiles.size > 0;
-        if (hasRPCs) {
-            await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, rpc.internalFiles, functions.meta, packageMappings));
+        const hasFunctions = functions.files.size > 0;
+        const shouldGenerateFunctionsFile = isExternalPackage
+            ? hasFunctions
+            : hasRPCs;
+        if (shouldGenerateFunctionsFile) {
+            // For external packages, use all function files; for main packages, use internal RPC files
+            const filesToRegister = isExternalPackage
+                ? functions.files
+                : rpc.internalFiles;
+            await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, filesToRegister, functions.meta, packageMappings, config.externalPackageName));
         }
-        return hasRPCs;
+        return shouldGenerateFunctionsFile;
     },
     middleware: [
         logCommandInfoAndTime({

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

@@ -1,2 +1,2 @@
-export declare const serializeServicesMap: (allSingletonServices: string[], allSessionServices: string[], requiredServices: Set<string>, forceRequiredServices: string[] | undefined, servicesImport: string, sessionServicesImport: string) => string;
+export declare const serializeServicesMap: (allSingletonServices: string[], allWireServices: string[], requiredServices: Set<string>, forceRequiredServices: string[] | undefined, servicesImport: string, wireServicesImport: string) => string;
 export declare const pikkuServices: any;

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

@@ -3,7 +3,7 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-export const serializeServicesMap = (allSingletonServices, allSessionServices, requiredServices, forceRequiredServices = [], servicesImport, sessionServicesImport) => {
+export const serializeServicesMap = (allSingletonServices, allWireServices, requiredServices, forceRequiredServices = [], servicesImport, wireServicesImport) => {
     // Use pre-aggregated services from inspector state
     // This includes services from:
     // - Wired functions (HTTP, channels, queues, schedulers, MCP, CLI, RPC)
@@ -11,7 +11,7 @@ export const serializeServicesMap = (allSingletonServices, allSessionServices, r
     // - Permissions used by wired functions
     // - Session factories
     const usedServices = new Set(requiredServices);
-    // Internal services that are created internally by the framework (PikkuInteraction)
+    // Internal services that are created internally by the framework (PikkuWire)
     // These should not appear in the services maps
     const internalServices = new Set([
         'rpc',
@@ -30,31 +30,31 @@ export const serializeServicesMap = (allSingletonServices, allSessionServices, r
         }
     });
     // Services that are always required internally by the framework
-    const defaultServices = ['config', 'logger', 'variables', 'schema'];
+    const defaultServices = ['config', 'logger', 'variables', 'schema', 'secrets'];
     defaultServices.forEach((service) => usedServices.add(service));
     // Create singleton services map: all singleton services with true/false based on usage
     const singletonServicesMap = {};
     allSingletonServices.forEach((service) => {
         singletonServicesMap[service] = usedServices.has(service);
     });
-    // Create session services map: all session services with true/false based on usage
-    // Exclude internal framework services (PikkuInteraction)
-    const sessionServicesMap = {};
-    allSessionServices.forEach((service) => {
+    // Create wire services map: all wire services with true/false based on usage
+    // Exclude internal framework services (PikkuWire)
+    const wireServicesMap = {};
+    allWireServices.forEach((service) => {
         if (!internalServices.has(service)) {
-            sessionServicesMap[service] = usedServices.has(service);
+            wireServicesMap[service] = usedServices.has(service);
         }
     });
     // Get all required service names (those marked as true)
     const requiredSingletonServiceNames = Object.keys(singletonServicesMap)
         .filter((key) => singletonServicesMap[key])
         .sort();
-    const requiredSessionServiceNames = Object.keys(sessionServicesMap)
-        .filter((key) => sessionServicesMap[key])
+    const requiredWireServiceNames = Object.keys(wireServicesMap)
+        .filter((key) => wireServicesMap[key])
         .sort();
     const code = [
         servicesImport,
-        sessionServicesImport,
+        wireServicesImport,
         '',
         '// Singleton services map: true if required, false if available but unused',
         'export const requiredSingletonServices = {',
@@ -63,11 +63,11 @@ export const serializeServicesMap = (allSingletonServices, allSessionServices, r
             .map((service) => `  '${service}': ${singletonServicesMap[service]},`),
         '} as const',
         '',
-        '// Session services map: true if required, false if available but unused',
-        'export const requiredSessionServices = {',
-        ...Object.keys(sessionServicesMap)
+        '// Wire services map: true if required, false if available but unused',
+        'export const requiredWireServices = {',
+        ...Object.keys(wireServicesMap)
             .sort()
-            .map((service) => `  '${service}': ${sessionServicesMap[service]},`),
+            .map((service) => `  '${service}': ${wireServicesMap[service]},`),
         '} as const',
         '',
         '// Type exports',
@@ -75,9 +75,9 @@ export const serializeServicesMap = (allSingletonServices, allSessionServices, r
             ? `export type RequiredSingletonServices = Pick<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
             : 'export type RequiredSingletonServices = Partial<SingletonServices>',
         '',
-        requiredSessionServiceNames.length > 0
-            ? `export type RequiredSessionServices = Pick<Services, ${requiredSessionServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<Services, ${requiredSessionServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
-            : 'export type RequiredSessionServices = Partial<Services>',
+        requiredWireServiceNames.length > 0
+            ? `export type RequiredWireServices = Pick<Services, ${requiredWireServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<Services, ${requiredWireServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
+            : 'export type RequiredWireServices = Partial<Services>',
         '',
     ].join('\n');
     return code;
@@ -87,16 +87,16 @@ export const pikkuServices = pikkuSessionlessFunc({
         const visitState = await getInspectorState();
         // Check for required types
         checkRequiredTypes(visitState.filesAndMethodsErrors, {
-            sessionServiceType: true,
+            wireServiceType: true,
             singletonServicesType: true,
         });
-        const { sessionServicesType, singletonServicesType } = visitState.filesAndMethods;
-        if (!sessionServicesType || !singletonServicesType) {
-            throw new Error('Required types not found: sessionServicesType or singletonServicesType');
+        const { wireServicesType, singletonServicesType } = visitState.filesAndMethods;
+        if (!wireServicesType || !singletonServicesType) {
+            throw new Error('Required types not found: wireServicesType or singletonServicesType');
         }
         const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, singletonServicesType.typePath, config.packageMappings)}'`;
-        const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, sessionServicesType.typePath, config.packageMappings)}'`;
-        const servicesCode = serializeServicesMap(visitState.serviceAggregation.allSingletonServices, visitState.serviceAggregation.allSessionServices, visitState.serviceAggregation.requiredServices, config.forceRequiredServices, servicesImport, sessionServicesImport);
+        const wireServicesImport = `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, wireServicesType.typePath, config.packageMappings)}'`;
+        const servicesCode = serializeServicesMap(visitState.serviceAggregation.allSingletonServices, visitState.serviceAggregation.allWireServices, visitState.serviceAggregation.requiredServices, config.forceRequiredServices, servicesImport, wireServicesImport);
         await writeFileInDir(logger, config.servicesFile, servicesCode);
     },
     middleware: [

package/dist/src/functions/wirings/functions/pikku-function-types.js

@@ -5,8 +5,8 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializePikkuTypesHub } from './serialize-pikku-types-hub.js';
 export const pikkuFunctionTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, } = config;
-        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getFileImportRelativePath(typesFile, httpTypesFile, packageMappings), getFileImportRelativePath(typesFile, channelsTypesFile, packageMappings), getFileImportRelativePath(typesFile, schedulersTypesFile, packageMappings), getFileImportRelativePath(typesFile, queueTypesFile, packageMappings), getFileImportRelativePath(typesFile, mcpTypesFile, packageMappings), getFileImportRelativePath(typesFile, cliTypesFile, packageMappings));
+        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, forgeTypesFile, } = config;
+        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getFileImportRelativePath(typesFile, httpTypesFile, packageMappings), getFileImportRelativePath(typesFile, channelsTypesFile, packageMappings), getFileImportRelativePath(typesFile, schedulersTypesFile, packageMappings), getFileImportRelativePath(typesFile, queueTypesFile, packageMappings), getFileImportRelativePath(typesFile, mcpTypesFile, packageMappings), getFileImportRelativePath(typesFile, cliTypesFile, packageMappings), getFileImportRelativePath(typesFile, forgeTypesFile, packageMappings));
         await writeFileInDir(logger, typesFile, content);
     },
     middleware: [

package/dist/src/functions/wirings/functions/schemas.d.ts

@@ -1,4 +1,4 @@
 /**
- * Generate JSON schemas from TypeScript types
+ * Generate JSON schemas from TypeScript types and Zod schemas
  */
 export declare const pikkuSchemas: any;

package/dist/src/functions/wirings/functions/schemas.js

@@ -1,14 +1,15 @@
 import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
-import { saveSchemas, generateSchemas, } from '../../../utils/schema-generator.js';
+import { saveSchemas, generateSchemas, generateZodSchemas, } from '../../../utils/schema-generator.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 /**
- * Generate JSON schemas from TypeScript types
+ * Generate JSON schemas from TypeScript types and Zod schemas
  */
 export const pikkuSchemas = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const schemas = await generateSchemas(logger, config.tsconfig, visitState.functions.typesMap, visitState.functions.meta, visitState.http.meta, config.schemasFromTypes, config.schema?.additionalProperties);
-        await saveSchemas(logger, config.schemaDirectory, schemas, visitState.functions.typesMap, visitState.functions.meta, config.schemasFromTypes, config.schema?.supportsImportAttributes);
+        const schemas = await generateSchemas(logger, config.tsconfig, visitState.functions.typesMap, visitState.functions.meta, visitState.http.meta, config.schemasFromTypes, config.schema?.additionalProperties, visitState.zodLookup);
+        const zodSchemas = await generateZodSchemas(logger, visitState.zodLookup, visitState.functions.typesMap);
+        await saveSchemas(logger, config.schemaDirectory, { ...schemas, ...zodSchemas }, visitState.functions.typesMap, visitState.functions.meta, config.schema?.supportsImportAttributes || true, config.schemasFromTypes, visitState.zodLookup, config.externalPackageName || null);
         return true;
     },
     middleware: [

package/dist/src/functions/wirings/functions/serialize-function-imports.d.ts

@@ -2,5 +2,7 @@ import { FunctionsMeta, FunctionsRuntimeMeta } from '@pikku/core';
 export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
     path: string;
     exportedName: string;
-}>, functionsMeta: FunctionsMeta, packageMappings?: Record<string, string>) => string;
+}>, functionsMeta: FunctionsMeta, packageMappings?: Record<string, string>, 
+/** Package name for external packages (e.g., '@pikku/templates-function-external') */
+externalPackageName?: string) => string;
 export declare const generateRuntimeMeta: (functions: FunctionsMeta) => FunctionsRuntimeMeta;