@pikku/cli 0.12.1 → 0.12.3

package/dist/src/functions/runtimes/websocket/pikku-command-websocket-typed.js

@@ -5,7 +5,8 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeWebsocketWrapper } from './serialize-websocket-wrapper.js';
 export const pikkuWebSocketTyped = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { websocketFile, channelsMapDeclarationFile, packageMappings } = config;
+        const websocketFile = config.clientFiles?.websocketFile;
+        const { channelsMapDeclarationFile, packageMappings } = config;
         // If websocketFile is not set, clean up any existing file and return
         if (!websocketFile) {
             logger.debug({

package/dist/src/functions/wirings/ai-agent/pikku-command-public-agent.js

@@ -3,13 +3,11 @@ 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 { serializePublicAgent } from './serialize-public-agent.js';
-import { join } from 'path';
 export const pikkuPublicAgent = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        if (config.agent?.publicAgentPath) {
-            const publicAgentPath = join(config.rootDir, config.agent.publicAgentPath);
-            const pathToPikkuTypes = getFileImportRelativePath(publicAgentPath, config.typesDeclarationFile, config.packageMappings);
-            await writeFileInDir(logger, publicAgentPath, serializePublicAgent(pathToPikkuTypes, config.agent.publicAgentRequireAuth ?? true));
+        if (config.scaffold?.agent) {
+            const pathToPikkuTypes = getFileImportRelativePath(config.publicAgentFile, config.typesDeclarationFile, config.packageMappings);
+            await writeFileInDir(logger, config.publicAgentFile, serializePublicAgent(pathToPikkuTypes, config.scaffold.agent === 'auth'));
             return true;
         }
         return false;

package/dist/src/functions/wirings/ai-agent/serialize-public-agent.js

@@ -40,6 +40,19 @@ export const agentApproveCaller = pikkuSessionlessFunc<
   },
 })
 
+export const agentResumeCaller = pikkuSessionlessFunc<
+  { agentName: string; runId: string; toolCallId: string; approved: boolean },
+  void
+>({
+  auth: ${authFlag},
+  func: async (_services, data, { rpc }) => {
+    await rpc.agent.resume(data.runId, {
+      toolCallId: data.toolCallId,
+      approved: data.approved,
+    })
+  },
+})
+
 export const agentRoutes = defineHTTPRoutes({
   auth: ${authFlag},
   tags: ['pikku:public'],
@@ -60,6 +73,12 @@ export const agentRoutes = defineHTTPRoutes({
       method: 'post',
       func: agentApproveCaller,
     },
+    agentResume: {
+      route: '/rpc/agent/:agentName/resume',
+      method: 'post',
+      sse: true,
+      func: agentResumeCaller,
+    },
   },
 })
 

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

@@ -6,7 +6,7 @@ export const pikkuChannelsMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const state = await getInspectorState();
         const { channelsMapDeclarationFile, packageMappings } = config;
-        const content = serializeTypedChannelsMap(logger, channelsMapDeclarationFile, packageMappings, state.functions.typesMap, state.functions.meta, state.channels.meta);
+        const content = serializeTypedChannelsMap(logger, channelsMapDeclarationFile, packageMappings, state.functions.typesMap, state.functions.meta, state.addonFunctions, state.channels.meta);
         await writeFileInDir(logger, channelsMapDeclarationFile, content);
     },
     middleware: [

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

@@ -2,4 +2,4 @@ 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;
+export declare const serializeTypedChannelsMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, addonFunctions: Record<string, FunctionsMeta>, channelsMeta: ChannelsMeta) => string;

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

@@ -1,7 +1,7 @@
 import { serializeImportMap } from '../../../utils/serialize-import-map.js';
-import { generateCustomTypes } from '@pikku/inspector';
-export const serializeTypedChannelsMap = (logger, relativeToPath, packageMappings, typesMap, functionsMeta, channelsMeta) => {
-    const { channels, requiredTypes } = generateChannels(functionsMeta, channelsMeta);
+import { generateCustomTypes, resolveFunctionMeta } from '@pikku/inspector';
+export const serializeTypedChannelsMap = (logger, relativeToPath, packageMappings, typesMap, functionsMeta, addonFunctions, channelsMeta) => {
+    const { channels, requiredTypes } = generateChannels(functionsMeta, addonFunctions, channelsMeta);
     typesMap.customTypes.forEach(({ references }) => {
         for (const reference of references) {
             if (reference !== '__object' && !reference.startsWith('__object_')) {
@@ -40,7 +40,8 @@ export type ChannelWiringHandlerOf<
         : never;
 `;
 };
-function generateChannels(functionsMeta, channelsMeta) {
+function generateChannels(functionsMeta, addonFunctions, channelsMeta) {
+    const state = { functions: { meta: functionsMeta }, addonFunctions };
     const requiredTypes = new Set();
     const channelsObject = {};
     for (const meta of Object.values(channelsMeta)) {
@@ -49,7 +50,7 @@ function generateChannels(functionsMeta, channelsMeta) {
             channelsObject[name] = { message: null, routes: {} };
         }
         if (message) {
-            const func = functionsMeta[message.pikkuFuncId];
+            const func = resolveFunctionMeta(state, message.pikkuFuncId);
             if (!func) {
                 throw new Error(`Function ${message.pikkuFuncId} not found in functionsMeta for channel ${name}`);
             }
@@ -67,7 +68,7 @@ function generateChannels(functionsMeta, channelsMeta) {
                 channelsObject[name].routes[key] = {};
             }
             for (const [method, { pikkuFuncId }] of Object.entries(route)) {
-                const func = functionsMeta[pikkuFuncId];
+                const func = resolveFunctionMeta(state, pikkuFuncId);
                 if (!func) {
                     throw new Error(`Function ${pikkuFuncId} not found in functionsMeta for channel ${name}, route ${key}, method ${method}`);
                 }

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

@@ -47,7 +47,15 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
                     const channelClientPath = entrypointConfig.path;
                     const channelName = entrypointConfig.name;
                     const channelRoute = entrypointConfig.route;
-                    const channelWireFile = join(config.rootDir, channelWirePath);
+                    // Validate wirePath is not inside the output directory
+                    const resolvedWirePath = join(config.rootDir, channelWirePath);
+                    const resolvedOutDir = join(config.rootDir, config.outDir);
+                    if (resolvedWirePath.startsWith(resolvedOutDir)) {
+                        throw new Error(`CLI channel wirePath "${channelWirePath}" must not be inside the output directory "${config.outDir}". ` +
+                            `The wire file uses wireChannel() which must be in a source directory so the inspector can discover it. ` +
+                            `Move it to a source directory like "src/wirings/cli-channel.gen.ts".`);
+                    }
+                    const channelWireFile = resolvedWirePath;
                     const channelCode = serializeChannelCLI(programName, programMeta, channelWireFile, visitState.functions.files, config.packageMappings, config.channelsTypesFile, config.functionTypesFile, channelName, channelRoute);
                     await writeFileInDir(logger, channelWireFile, channelCode);
                     logger.debug(`Serialized CLI channel for ${programName}: ${channelWireFile}`);

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

@@ -15,6 +15,7 @@ export function serializeChannelCLI(programName, programMeta, channelFile, funct
             if (cmd.pikkuFuncId) {
                 commandMap[commandKey] = {
                     pikkuFuncId: cmd.pikkuFuncId,
+                    isAddon: !!cmd.packageName,
                 };
             }
             // Recursively process subcommands
@@ -24,20 +25,21 @@ export function serializeChannelCLI(programName, programMeta, channelFile, funct
         }
     };
     collectCommands(programMeta.commands);
-    // Generate imports from function file locations
-    const funcNames = [
+    const allFuncs = [
         ...new Set(Object.values(commandMap).map((v) => v.pikkuFuncId)),
     ];
-    const imports = funcNames
-        .map((pikkuFuncId) => {
+    const localFuncs = allFuncs.filter((id) => !Object.values(commandMap).find((v) => v.pikkuFuncId === id && v.isAddon));
+    const hasAddonFuncs = allFuncs.length > localFuncs.length;
+    const importLines = [];
+    for (const pikkuFuncId of localFuncs) {
         const fileInfo = functionFiles.get(pikkuFuncId);
         if (!fileInfo) {
             throw new Error(`Function not found in files map: ${pikkuFuncId}`);
         }
         const importPath = getFileImportRelativePath(channelFile, fileInfo.path, packageMappings);
-        return `import { ${fileInfo.exportedName} } from '${importPath}'`;
-    })
-        .join('\n');
+        importLines.push(`import { ${fileInfo.exportedName} } from '${importPath}'`);
+    }
+    const imports = importLines.join('\n');
     // Get relative path to channel types file
     const channelTypesPath = getFileImportRelativePath(channelFile, channelTypesFile, packageMappings);
     // Get relative path to function types file
@@ -46,7 +48,9 @@ export function serializeChannelCLI(programName, programMeta, channelFile, funct
  * WebSocket channel backend for '${programName}' CLI commands
  */
 import { wireChannel } from '${channelTypesPath}'
-import { pikkuMiddleware } from '${functionTypesPath}'
+import { pikkuMiddleware${hasAddonFuncs ? ', addon' : ''}, pikkuSessionlessFunc } from '${functionTypesPath}'
+import { generateCommandHelp } from '@pikku/core/cli'
+import { pikkuState } from '@pikku/core/internal'
 ${imports}
 
 // Middleware to close the channel after CLI command completes
@@ -61,7 +65,7 @@ const cliCloseOnComplete = pikkuMiddleware(async (_services, { channel }, next)
       }
     }, 200)
   }
-  
+
   try {
     const result = await next()
     closeChannel()
@@ -72,17 +76,36 @@ const cliCloseOnComplete = pikkuMiddleware(async (_services, { channel }, next)
   }
 })
 
+export const cliHelp = pikkuSessionlessFunc<{ args?: string[] }, { help: string }>({
+  auth: false,
+  func: async (_services, data: { args?: string[] }) => {
+    const cliMeta = pikkuState(null, 'cli', 'meta')
+    const commandPath = data?.args?.length ? data.args : []
+    const helpText = generateCommandHelp('${programName}', cliMeta as any, commandPath)
+    return { help: helpText }
+  },
+})
+
 wireChannel({
   name: '${finalChannelName}',
   route: '${finalChannelRoute}',
   auth: false,
   onMessageWiring: {
     command: {
+      '__help': {
+        func: cliHelp,
+        middleware: [cliCloseOnComplete],
+      },
 ${Object.entries(commandMap)
-        .map(([commandKey, { pikkuFuncId }]) => `      '${commandKey}': {
-        func: ${pikkuFuncId},
+        .map(([commandKey, { pikkuFuncId, isAddon }]) => {
+        const funcRef = isAddon
+            ? `addon('${pikkuFuncId}')`
+            : (functionFiles.get(pikkuFuncId)?.exportedName ?? pikkuFuncId);
+        return `      '${commandKey}': {
+        func: ${funcRef},
         middleware: [cliCloseOnComplete],
-      }`)
+      }`;
+    })
         .join(',\n')}
     }
   },

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

@@ -3,14 +3,12 @@ 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));
+        if (config.scaffold?.console) {
+            const pathToPikkuTypes = getFileImportRelativePath(config.consoleFunctionsFile, config.typesDeclarationFile, config.packageMappings);
+            const pathToAgentTypes = getFileImportRelativePath(config.consoleFunctionsFile, config.agentTypesFile, config.packageMappings);
+            await writeFileInDir(logger, config.consoleFunctionsFile, serializeConsoleFunctions(pathToPikkuTypes, pathToAgentTypes));
             return true;
         }
         return false;

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

@@ -5,10 +5,10 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeNodeTypes } from './serialize-node-types.js';
 export const pikkuNodeTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { nodeTypesFile, rpcInternalMapDeclarationFile, packageMappings, node, } = config;
+        const { nodeTypesFile, rpcInternalMapDeclarationFile, packageMappings, addon, } = config;
         let rpcMapImportPath = getFileImportRelativePath(nodeTypesFile, rpcInternalMapDeclarationFile, packageMappings);
         rpcMapImportPath = rpcMapImportPath.replace('.d.js', '.js');
-        const categories = node?.categories;
+        const categories = typeof addon === 'object' ? addon?.categories : undefined;
         const content = serializeNodeTypes(rpcMapImportPath, categories);
         await writeFileInDir(logger, nodeTypesFile, content);
     },

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

@@ -28,14 +28,16 @@ export const pikkuNodesMeta = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const state = await getInspectorState();
         const { nodes, secrets } = state;
-        const { nodesMetaJsonFile, node, rootDir } = config;
+        const { addonMetaJsonFile, addon, rootDir } = config;
+        const addonMeta = typeof addon === 'object' ? addon : undefined;
         const secretsMeta = validateAndBuildSecretDefinitionsMeta(secrets.definitions, state.schemaLookup);
         const hasNodes = Object.keys(nodes.meta).length > 0;
         const hasSecrets = secrets.definitions.length > 0;
-        if (!hasNodes && !hasSecrets) {
+        const hasPackageMeta = !!addonMeta?.icon || !!addonMeta?.displayName;
+        if (!hasNodes && !hasSecrets && !hasPackageMeta) {
             return undefined;
         }
-        const allowedCategories = node?.categories;
+        const allowedCategories = addonMeta?.categories;
         if (allowedCategories && allowedCategories.length > 0) {
             for (const [name, meta] of Object.entries(nodes.meta)) {
                 if (!allowedCategories.includes(meta.category)) {
@@ -49,23 +51,30 @@ export const pikkuNodesMeta = pikkuSessionlessFunc({
             const { icon: _icon, ...nodeMetaWithoutIcon } = meta;
             outputMeta[name] = nodeMetaWithoutIcon;
         }
-        const packageIcon = await loadIcon(node?.icon, rootDir, logger);
+        const packageIcon = await loadIcon(addonMeta?.icon, rootDir, logger);
         const metaData = {
             nodes: outputMeta,
             secrets: secretsMeta,
             package: {
-                displayName: node?.displayName,
-                description: node?.description,
+                displayName: addonMeta?.displayName,
+                description: addonMeta?.description,
                 icon: packageIcon,
-                categories: node?.categories,
+                categories: addonMeta?.categories,
             },
         };
-        if (nodesMetaJsonFile) {
+        if (addonMetaJsonFile && (config.scaffold?.console || config.addon)) {
             const minimalMeta = stripVerboseFields(metaData);
-            await writeFileInDir(logger, nodesMetaJsonFile, JSON.stringify(minimalMeta, null, 2), { ignoreModifyComment: true });
+            await writeFileInDir(logger, addonMetaJsonFile, 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 });
+                const verbosePath = addonMetaJsonFile.endsWith('.gen.json')
+                    ? addonMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json')
+                    : addonMetaJsonFile.replace(/(\.\w+)$/, '-verbose$1');
+                if (verbosePath === addonMetaJsonFile) {
+                    logger.warn(`Cannot derive verbose path from ${addonMetaJsonFile}, skipping verbose metadata`);
+                }
+                else {
+                    await writeFileInDir(logger, verbosePath, JSON.stringify(metaData, null, 2), { ignoreModifyComment: true });
+                }
             }
         }
         return true;

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

@@ -85,6 +85,6 @@ export const consoleRoutes = defineHTTPRoutes({
 })
 
 wireAddon({ name: 'console', package: '@pikku/addon-console' })
-wireHTTPRoutes({ baseRoute: '/api', routes: { console: consoleRoutes } })
+wireHTTPRoutes({ basePath: '/api', routes: { console: consoleRoutes } })
 `;
 };

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

@@ -21,7 +21,7 @@ export const pikkuFunctionTypesSplit = pikkuSessionlessFunc({
         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 { ${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.addonName, undefined, config.node?.categories);
+        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.addonName, undefined, typeof config.addon === 'object' ? config.addon?.categories : undefined);
         await writeFileInDir(logger, functionTypesFile, content);
     },
     middleware: [

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

@@ -61,18 +61,40 @@ export const pikkuAddonServices = <T extends Record<string, any>, ExistingServic
   func: (config: Config, services: ExistingServices) => Promise<T>
 ) => {
   return async (config: Config, existingServices?: Partial<SingletonServices>): Promise<RequiredSingletonServices> => {
-    const { logger, variables, secrets } = (existingServices ?? {}) as unknown as SingletonServices
+    const { logger, variables, secrets, schema } = (existingServices ?? {}) as unknown as SingletonServices
     const typedVariables = new TypedVariablesService(variables)
     const typedSecrets = new TypedSecretService(secrets)
     const result = await func(config, { ...existingServices, logger, variables: typedVariables, secrets: typedSecrets } as ExistingServices)
     return {
       config,
       logger,
+      schema,
       variables: typedVariables,
       secrets: typedSecrets,
       ...result,
     } as unknown as RequiredSingletonServices
   }
 }
+
+/**
+ * Creates a Pikku wire services factory for addon packages.
+ * Wire services are created per-request and have access to the HTTP request context.
+ *
+ * @param func - Wire services factory function that receives singleton services and the wire context
+ * @returns The wire services factory function
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createWireServices = pikkuAddonWireServices(async (services, wire) => {
+ *   const authHeader = wire.http?.request?.header('authorization')
+ *   return { myService: new MyService(authHeader) }
+ * })
+ * \`\`\`
+ */
+export const pikkuAddonWireServices = (
+  func: (services: SingletonServices, wire: any) => Promise<Record<string, any>>
+) => {
+  return func as any
+}
 `;
 };

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

@@ -15,6 +15,7 @@ export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeNam
 import { CorePikkuFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired } from '@pikku/core'
 import { pikkuState as __pikkuState, CreateWireServices } from '@pikku/core/internal'
 import { pikkuAuth as pikkuAuthCore } from '@pikku/core'
+import { PikkuError } from '@pikku/core/errors'
 import type { NodeType } from '@pikku/core/node'
 import type { StandardSchemaV1 } from '@standard-schema/spec'
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
@@ -229,6 +230,37 @@ export const pikkuPermissionFactory = <In = any>(
   return factory
 }
 
+/**
+ * A function that generates a human-readable description of a pending approval action.
+ * Used by AI agents to show meaningful approval prompts instead of raw tool arguments.
+ *
+ * @template In - The input type (same as the function it describes)
+ * @template RequiredServices - The services required for this description function
+ */
+export type PikkuApprovalDescription<In = unknown, RequiredServices extends Services = Services> = (
+  services: RequiredServices,
+  data: In
+) => Promise<string>
+
+/**
+ * Factory function for creating approval description functions with tree-shaking support.
+ *
+ * @example
+ * \`\`\`typescript
+ * export const deleteTodoApproval = pikkuApprovalDescription(
+ *   async ({ todoStore }, { id }) => {
+ *     const todo = await todoStore.get(id)
+ *     return \\\`Delete todo: "\${todo.title}"\\\`
+ *   }
+ * )
+ * \`\`\`
+ */
+export const pikkuApprovalDescription = <In = unknown, RequiredServices extends Services = Services>(
+  fn: PikkuApprovalDescription<In, RequiredServices>
+): PikkuApprovalDescription<In, RequiredServices> => {
+  return fn
+}
+
 /**
  * A sessionless API function that doesn't require user authentication.
  * Use this for public endpoints, health checks, or operations that don't need user context.
@@ -308,6 +340,8 @@ export type PikkuFunctionConfigWithSchema<
   expose?: boolean
   mcp?: boolean
   internal?: boolean
+  approvalRequired?: boolean
+  approvalDescription?: PikkuApprovalDescription<InferSchemaOutput<InputSchema>>
   func: PikkuFunction<
     InferSchemaOutput<InputSchema>,
     OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown,
@@ -323,6 +357,7 @@ export type PikkuFunctionConfigWithSchema<
   input: InputSchema
   output?: OutputSchema
   node?: NodeConfig
+  errors?: Array<typeof PikkuError>
 }
 
 /**
@@ -393,6 +428,8 @@ export type PikkuFunctionSessionlessConfigWithSchema<
   mcp?: boolean
   internal?: boolean
   remote?: boolean
+  approvalRequired?: boolean
+  approvalDescription?: PikkuApprovalDescription<InferSchemaOutput<InputSchema>>
   func: PikkuFunctionSessionless<
     InferSchemaOutput<InputSchema>,
     OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown,
@@ -404,6 +441,7 @@ export type PikkuFunctionSessionlessConfigWithSchema<
   input: InputSchema
   output?: OutputSchema
   node?: NodeConfig
+  errors?: Array<typeof PikkuError>
 }
 
 /**

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

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

@@ -0,0 +1,22 @@
+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';
+export const pikkuGateway = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { gatewaysWiringFile, packageMappings } = config;
+        const { gateways } = visitState;
+        if (Object.keys(gateways.meta).length === 0) {
+            return undefined;
+        }
+        await writeFileInDir(logger, gatewaysWiringFile, serializeFileImports('wireGateway', gatewaysWiringFile, gateways.files, packageMappings));
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding gateways',
+            commandEnd: 'Found gateways',
+        }),
+    ],
+});

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

@@ -5,7 +5,7 @@ import { serializeMCPJson } from '@pikku/inspector';
 export const pikkuMCPJSON = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const state = await getInspectorState();
-        const { mcpJsonFile } = config;
+        const mcpJsonFile = config.clientFiles?.mcpJsonFile;
         if (mcpJsonFile) {
             const mcpJson = serializeMCPJson(logger, state);
             await writeFileInDir(logger, mcpJsonFile, mcpJson, {

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

@@ -5,7 +5,8 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeQueueWrapper } from './serialize-queue-wrapper.js';
 export const pikkuQueueService = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { queueWiringsFile, queueMapDeclarationFile, packageMappings } = config;
+        const queueWiringsFile = config.clientFiles?.queueWiringsFile;
+        const { queueMapDeclarationFile, packageMappings } = config;
         // If queueWiringsFile is not set, clean up any existing file and return
         if (!queueWiringsFile) {
             logger.debug({

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

@@ -3,13 +3,11 @@ 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 { serializePublicRPC } from './serialize-public-rpc.js';
-import { join } from 'path';
 export const pikkuPublicRPC = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        if (config.rpc?.publicRpcPath) {
-            const publicRpcPath = join(config.rootDir, config.rpc.publicRpcPath);
-            const pathToPikkuTypes = getFileImportRelativePath(publicRpcPath, config.typesDeclarationFile, config.packageMappings);
-            await writeFileInDir(logger, publicRpcPath, serializePublicRPC(pathToPikkuTypes, config.rpc.publicRpcRequireAuth ?? true));
+        if (config.scaffold?.rpc) {
+            const pathToPikkuTypes = getFileImportRelativePath(config.publicRpcFile, config.typesDeclarationFile, config.packageMappings);
+            await writeFileInDir(logger, config.publicRpcFile, serializePublicRPC(pathToPikkuTypes, config.scaffold.rpc === 'auth'));
             return true;
         }
         return false;

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

@@ -3,13 +3,11 @@ 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 { serializeRemoteRPC } from './serialize-remote-rpc.js';
-import { join } from 'path';
 export const pikkuRemoteRPC = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        if (config.rpc?.remoteRpcWorkersPath) {
-            const remoteRpcPath = join(config.rootDir, config.rpc.remoteRpcWorkersPath);
-            const pathToPikkuTypes = getFileImportRelativePath(remoteRpcPath, config.typesDeclarationFile, config.packageMappings);
-            await writeFileInDir(logger, remoteRpcPath, serializeRemoteRPC(pathToPikkuTypes));
+        if (config.remoteRpcWorkersFile) {
+            const pathToPikkuTypes = getFileImportRelativePath(config.remoteRpcWorkersFile, config.typesDeclarationFile, config.packageMappings);
+            await writeFileInDir(logger, config.remoteRpcWorkersFile, serializeRemoteRPC(pathToPikkuTypes));
             return true;
         }
         return false;

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

@@ -5,7 +5,8 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeRPCWrapper } from './serialize-rpc-wrapper.js';
 export const pikkuRPCClient = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { rpcWiringsFile, rpcMapDeclarationFile, packageMappings } = config;
+        const rpcWiringsFile = config.clientFiles?.rpcWiringsFile;
+        const { rpcMapDeclarationFile, packageMappings } = config;
         // If rpcWiringsFile is not set, clean up any existing file and return
         if (!rpcWiringsFile) {
             logger.debug({

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

@@ -46,16 +46,9 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
         const workflowMapImportPath = getFileImportRelativePath(workflowTypesFile, workflowMapDeclarationFile, packageMappings);
         await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath, workflowMapImportPath));
         await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(logger, workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta, workflows.graphMeta));
-        if (config.workflows) {
-            if (config.workflows.singleQueue) {
-                const workflowPath = join(config.rootDir, config.workflows.path);
-                const pathToPikkuTypes = getFileImportRelativePath(workflowPath, typesDeclarationFile, packageMappings);
-                await writeFileInDir(logger, workflowPath, serializeWorkflowWorkers(pathToPikkuTypes));
-            }
-            else if (workflows.files.size > 0) {
-                logger.critical(ErrorCode.WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED, 'Multi-queue workflows are not supported when workflows.singleQueue is false. Please enable singleQueue in your configuration.');
-                return false;
-            }
+        if (config.scaffold?.workflow) {
+            const pathToPikkuTypes = getFileImportRelativePath(config.workflowWorkersFile, typesDeclarationFile, packageMappings);
+            await writeFileInDir(logger, config.workflowWorkersFile, serializeWorkflowWorkers(pathToPikkuTypes));
         }
         return hasWorkflows;
     },

package/dist/src/services.js

@@ -6,6 +6,7 @@ import { inspect, serializeInspectorState, deserializeInspectorState, filterInsp
 import { glob } from 'tinyglobby';
 import path from 'path';
 import { CLILoggerForwarder } from './services/cli-logger-forwarder.service.js';
+import { existsSync } from 'fs';
 import { readFile, writeFile } from 'fs/promises';
 import { loadManifest } from './utils/contract-versions.js';
 import { join } from 'path';
@@ -202,6 +203,17 @@ export const createSingletonServices = async (config) => {
                 ignore: config.ignoreFiles || [],
                 absolute: true,
             })))).flat();
+            const scaffoldFiles = [
+                config.consoleFunctionsFile,
+                config.publicRpcFile,
+                config.publicAgentFile,
+                config.workflowWorkersFile,
+            ];
+            for (const file of scaffoldFiles) {
+                if (file && !wiringFiles.includes(file) && existsSync(file)) {
+                    wiringFiles.push(file);
+                }
+            }
             const manifest = !setupOnly
                 ? ((await loadManifest(join(config.outDir, 'versions.json'))) ??
                     undefined)
@@ -209,7 +221,7 @@ export const createSingletonServices = async (config) => {
             unfilteredState = await inspect(logger, wiringFiles, {
                 setupOnly,
                 rootDir,
-                isAddon: config.addon,
+                isAddon: !!config.addon,
                 types: {
                     configFileType: config.configFile,
                     userSessionType: config.userSessionType,