@pikku/cli 0.12.2 → 0.12.4

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 && config.scaffold?.console) {
+        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/services.js

@@ -221,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,

package/dist/src/utils/file-import-path.js

@@ -30,8 +30,11 @@ export const getFileImportRelativePath = (from, to, packageMappings) => {
     const fromAbsolutePath = resolve(dirname(from));
     // Check if both files are in the same package directory
     // If so, skip packageMappings to use relative paths
+    // Skip '.' key — it matches any dot character in paths and is too generic for substring matching
     let inSamePackage = false;
     for (const [path] of Object.entries(packageMappings)) {
+        if (path === '.')
+            continue;
         if (absolutePath.includes(path) && fromAbsolutePath.includes(path)) {
             inSamePackage = true;
             break;
@@ -39,10 +42,10 @@ export const getFileImportRelativePath = (from, to, packageMappings) => {
     }
     // Only apply packageMappings if files are not in the same package
     if (!inSamePackage) {
-        // let usesPackageName = false
         for (const [path, packageName] of Object.entries(packageMappings)) {
+            if (path === '.')
+                continue;
             if (absolutePath.includes(path)) {
-                // usesPackageName = true
                 // Use string slicing instead of regex to avoid ReDoS and ensure correct behavior
                 const pathIndex = absolutePath.indexOf(path);
                 filePath = packageName + absolutePath.slice(pathIndex + path.length);

package/dist/src/utils/openapi/codegen.d.ts

@@ -14,6 +14,7 @@ interface AddonVars {
 interface CodegenFlags {
     oauth: boolean;
     secret: boolean;
+    mcp?: boolean;
 }
 export declare function generateAddonFromOpenAPI(spec: ParsedSpec, vars: AddonVars, flags: CodegenFlags): Record<string, string>;
 export {};