@pikku/cli 0.12.0 → 0.12.2

package/dist/.pikku/workflow/pikku-workflow-wirings-meta.gen.js

@@ -1,6 +1,6 @@
 /**
- * This file was generated by @pikku/cli@0.12.0
+ * This file was generated by @pikku/cli@0.12.2
  */
-import { pikkuState } from '@pikku/core';
+import { pikkuState } from '@pikku/core/internal';
 const workflowsMeta = {};
 pikkuState(null, 'workflows', 'meta', workflowsMeta);

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.d.ts

@@ -1,4 +1,4 @@
 export {};
 /**
- * This file was generated by @pikku/cli@0.12.0
+ * This file was generated by @pikku/cli@0.12.2
  */

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.js

@@ -1,4 +1,4 @@
 export {};
 /**
- * This file was generated by @pikku/cli@0.12.0
+ * This file was generated by @pikku/cli@0.12.2
  */

package/dist/src/cli.wiring.js

@@ -12,6 +12,14 @@ import { watch } from './functions/commands/watch.js';
 import { consoleCommand } from './functions/commands/console.js';
 import { pikkuVersionsInit } from './functions/commands/versions-init.js';
 import { pikkuVersionsCheck } from './functions/commands/versions-check.js';
+import { pikkuVersionsUpdate } from './functions/commands/versions-update.js';
+import { pikkuNewFunction } from './functions/commands/new-function.js';
+import { pikkuNewWiring } from './functions/commands/new-wiring.js';
+import { pikkuNewMiddleware } from './functions/commands/new-middleware.js';
+import { pikkuNewPermission } from './functions/commands/new-permission.js';
+import { pikkuNewAddon } from './functions/commands/new-addon.js';
+import { pikkuInfoFunctions, pikkuInfoTags, pikkuInfoMiddleware, pikkuInfoPermissions, } from './functions/commands/info.js';
+import { enableRpc, enableConsole, enableAgent, enableWorkflow, } from './functions/commands/enable.js';
 // import { clientCLIRenderer } from './services.js'
 wireCLI({
     program: 'pikku',
@@ -119,18 +127,237 @@ wireCLI({
             func: pikkuNext,
             description: 'Generate Next.js backend and HTTP wrappers',
         }),
-        init: pikkuCLICommand({
-            func: pikkuVersionsInit,
-            description: 'Initialize project',
+        enable: {
+            description: 'Enable Pikku features',
+            subcommands: {
+                rpc: pikkuCLICommand({
+                    func: enableRpc,
+                    description: 'Enable public RPC endpoint',
+                    options: {
+                        'no-auth': {
+                            description: 'Disable auth requirement',
+                            default: false,
+                        },
+                    },
+                }),
+                console: pikkuCLICommand({
+                    func: enableConsole,
+                    description: 'Enable console functions',
+                    options: {
+                        'no-auth': {
+                            description: 'Disable auth requirement',
+                            default: false,
+                        },
+                    },
+                }),
+                agent: pikkuCLICommand({
+                    func: enableAgent,
+                    description: 'Enable public agent endpoints',
+                    options: {
+                        'no-auth': {
+                            description: 'Disable auth requirement',
+                            default: false,
+                        },
+                    },
+                }),
+                workflow: pikkuCLICommand({
+                    func: enableWorkflow,
+                    description: 'Enable workflow workers',
+                    options: {
+                        'no-auth': {
+                            description: 'Disable auth requirement',
+                            default: false,
+                        },
+                    },
+                }),
+            },
+        },
+        new: {
+            description: 'Scaffold new functions and wirings',
+            subcommands: {
+                function: pikkuCLICommand({
+                    func: pikkuNewFunction,
+                    description: 'Create a new Pikku function file',
+                    parameters: '<name>',
+                    options: {
+                        type: {
+                            description: 'Function type: func, sessionless (default), or void',
+                            short: 't',
+                            default: 'sessionless',
+                        },
+                    },
+                }),
+                wiring: pikkuCLICommand({
+                    func: pikkuNewWiring,
+                    description: 'Create a new wiring file',
+                    parameters: '<name>',
+                    options: {
+                        type: {
+                            description: 'Wiring type: http (default), channel, scheduler, queue, mcp, cli, or trigger',
+                            short: 't',
+                            default: 'http',
+                        },
+                    },
+                }),
+                middleware: pikkuCLICommand({
+                    func: pikkuNewMiddleware,
+                    description: 'Create a new middleware file',
+                    parameters: '<name>',
+                    options: {
+                        type: {
+                            description: 'Middleware type: simple (default) or factory',
+                            short: 't',
+                            default: 'simple',
+                        },
+                    },
+                }),
+                permission: pikkuCLICommand({
+                    func: pikkuNewPermission,
+                    description: 'Create a new permission file',
+                    parameters: '<name>',
+                    options: {
+                        type: {
+                            description: 'Permission type: simple (default) or factory',
+                            short: 't',
+                            default: 'simple',
+                        },
+                    },
+                }),
+                addon: pikkuCLICommand({
+                    func: pikkuNewAddon,
+                    description: 'Scaffold a new addon package',
+                    parameters: '<name>',
+                    options: {
+                        displayName: {
+                            description: 'Human-readable display name (defaults to PascalCase of name)',
+                        },
+                        description: {
+                            description: 'Package description (defaults to "{displayName} integration for Pikku")',
+                        },
+                        category: {
+                            description: 'Forge category (defaults to "General")',
+                            default: 'General',
+                        },
+                        dir: {
+                            description: 'Override output directory (defaults to scaffold.addonDir or cwd)',
+                            short: 'd',
+                        },
+                        secret: {
+                            description: 'Include secret schema file',
+                            default: false,
+                        },
+                        variable: {
+                            description: 'Include variable definition file',
+                            default: false,
+                        },
+                        oauth: {
+                            description: 'Include OAuth2 credential wiring and OAuth2Client-based API service',
+                            default: false,
+                        },
+                        test: {
+                            description: 'Include test harness (default: true)',
+                            default: true,
+                        },
+                        openapi: {
+                            description: 'Path to OpenAPI YAML/JSON spec to generate functions from',
+                        },
+                    },
+                }),
+            },
+        },
+        versions: {
+            description: 'Manage function contract versions',
+            subcommands: {
+                init: pikkuCLICommand({
+                    func: pikkuVersionsInit,
+                    description: 'Initialize the version manifest (versions.json)',
+                    options: {
+                        force: {
+                            description: 'Overwrite existing manifest',
+                        },
+                    },
+                }),
+                check: pikkuCLICommand({
+                    func: pikkuVersionsCheck,
+                    description: 'Validate function contracts against the version manifest',
+                }),
+                update: pikkuCLICommand({
+                    func: pikkuVersionsUpdate,
+                    description: 'Update the version manifest with current contract hashes',
+                }),
+            },
+        },
+        info: pikkuCLICommand({
+            func: pikkuInfoFunctions,
+            description: 'Show information about Pikku project resources',
             options: {
-                force: {
-                    description: 'Overwrite existing manifest',
+                limit: {
+                    description: 'Maximum number of rows to display',
+                    default: '50',
+                },
+                verbose: {
+                    description: 'Show additional details (file paths, services, etc.)',
+                    default: false,
                 },
             },
-        }),
-        'versions-check': pikkuCLICommand({
-            func: pikkuVersionsCheck,
-            description: 'Validate function contracts against the version manifest',
+            subcommands: {
+                functions: pikkuCLICommand({
+                    func: pikkuInfoFunctions,
+                    description: 'List all registered functions',
+                    options: {
+                        limit: {
+                            description: 'Maximum number of rows to display',
+                            default: '50',
+                        },
+                        verbose: {
+                            description: 'Show additional details (type, middleware, file)',
+                            default: false,
+                        },
+                    },
+                }),
+                tags: pikkuCLICommand({
+                    func: pikkuInfoTags,
+                    description: 'List all tags with associated functions, middleware, and permissions',
+                    options: {
+                        limit: {
+                            description: 'Maximum number of rows to display',
+                            default: '50',
+                        },
+                        verbose: {
+                            description: 'Show names instead of counts',
+                            default: false,
+                        },
+                    },
+                }),
+                middleware: pikkuCLICommand({
+                    func: pikkuInfoMiddleware,
+                    description: 'List all middleware definitions',
+                    options: {
+                        limit: {
+                            description: 'Maximum number of rows to display',
+                            default: '50',
+                        },
+                        verbose: {
+                            description: 'Show additional details (sourceFile, services)',
+                            default: false,
+                        },
+                    },
+                }),
+                permissions: pikkuCLICommand({
+                    func: pikkuInfoPermissions,
+                    description: 'List all permission definitions',
+                    options: {
+                        limit: {
+                            description: 'Maximum number of rows to display',
+                            default: '50',
+                        },
+                        verbose: {
+                            description: 'Show additional details (sourceFile, services)',
+                            default: false,
+                        },
+                    },
+                }),
+            },
         }),
     },
 });

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

@@ -16,7 +16,7 @@ export const all = pikkuVoidFunc({
         await rpc.invoke('pikkuFunctionTypesSplit', null);
         await rpc.invoke('pikkuTriggerTypes', null);
         await rpc.invoke('pikkuAIAgentTypes', null);
-        if (!config.externalPackage) {
+        if (!config.addon) {
             await rpc.invoke('pikkuHTTPTypes', null);
             await rpc.invoke('pikkuChannelTypes', null);
             await rpc.invoke('pikkuSchedulerTypes', null);
@@ -41,7 +41,7 @@ export const all = pikkuVoidFunc({
         const agents = await rpc.invoke('pikkuAIAgent', null);
         if (agents) {
             allImports.push(config.agentWiringMetaFile, config.agentWiringsFile);
-            if (config.agent?.publicAgentPath) {
+            if (config.scaffold?.agent) {
                 await rpc.invoke('pikkuPublicAgent', null);
             }
         }
@@ -53,11 +53,11 @@ export const all = pikkuVoidFunc({
         await rpc.invoke('pikkuSecrets', null);
         await rpc.invoke('pikkuVariableDefinitionTypes', null);
         await rpc.invoke('pikkuVariables', null);
-        await rpc.invoke('pikkuExternalTypes', null);
+        await rpc.invoke('pikkuAddonTypes', null);
         if (hasInternalRPCs) {
             allImports.push(config.rpcInternalWiringMetaFile);
         }
-        if (agents || !config.externalPackage) {
+        if (agents || !config.addon) {
             await getInspectorState(true);
         }
         const schemas = await rpc.invoke('pikkuSchemas', null);
@@ -66,7 +66,7 @@ export const all = pikkuVoidFunc({
         }
         await rpc.invoke('pikkuRPCInternalMap', null);
         await rpc.invoke('pikkuRPCExposedMap', null);
-        if (!config.externalPackage) {
+        if (!config.addon) {
             const http = await rpc.invoke('pikkuHTTP', null);
             if (http) {
                 await rpc.invoke('pikkuHTTPMap', null);
@@ -84,7 +84,7 @@ export const all = pikkuVoidFunc({
         }
         const workflows = await rpc.invoke('pikkuWorkflow', null);
         let remoteRPC = false;
-        if (!config.externalPackage) {
+        if (!config.addon) {
             remoteRPC = await rpc.invoke('pikkuRemoteRPC', null);
         }
         if (workflows || remoteRPC) {
@@ -99,7 +99,7 @@ export const all = pikkuVoidFunc({
         if (workflows) {
             allImports.push(config.workflowsWiringFile);
         }
-        if (!config.externalPackage) {
+        if (!config.addon) {
             const queues = await rpc.invoke('pikkuQueue', null);
             if (queues) {
                 await rpc.invoke('pikkuQueueMap', null);
@@ -112,6 +112,10 @@ export const all = pikkuVoidFunc({
                 await rpc.invoke('pikkuWebSocketTyped', null);
                 allImports.push(config.channelsWiringMetaFile, config.channelsWiringFile);
             }
+            const gateways = await rpc.invoke('pikkuGateway', null);
+            if (gateways) {
+                allImports.push(config.gatewaysWiringFile);
+            }
             const mcp = await rpc.invoke('pikkuMCP', null);
             if (mcp) {
                 await rpc.invoke('pikkuMCPJSON', null);
@@ -124,7 +128,8 @@ export const all = pikkuVoidFunc({
             }
         }
         await rpc.invoke('pikkuNodesMeta', null);
-        if (config.nextBackendFile || config.nextHTTPFile) {
+        if (config.clientFiles?.nextBackendFile ||
+            config.clientFiles?.nextHTTPFile) {
             await rpc.invoke('pikkuNext', null);
         }
         if (config.openAPI) {

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

@@ -0,0 +1,4 @@
+export declare const enableRpc: 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>;
+export declare const enableConsole: 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>;
+export declare const enableAgent: 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>;
+export declare const enableWorkflow: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -0,0 +1,39 @@
+import { readFile, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { pikkuVoidFunc } from '#pikku';
+const FEATURE_DEFAULTS = {
+    rpc: 'auth',
+    agent: 'auth',
+    console: 'no-auth',
+    workflow: 'auth',
+};
+async function enableFeature(feature, logger, config, data) {
+    const noAuth = data?.['no-auth'] ?? false;
+    const configPath = join(config.configDir, 'pikku.config.json');
+    const raw = await readFile(configPath, 'utf-8');
+    const json = JSON.parse(raw);
+    if (!json.scaffold) {
+        json.scaffold = {};
+    }
+    if (!json.scaffold.pikkuDir) {
+        json.scaffold.pikkuDir = 'pikku';
+    }
+    const value = noAuth
+        ? 'no-auth'
+        : FEATURE_DEFAULTS[feature];
+    json.scaffold[feature] = value;
+    await writeFile(configPath, JSON.stringify(json, null, 2) + '\n', 'utf-8');
+    logger.info(`Enabled scaffold.${feature} = '${value}' in ${configPath}`);
+}
+export const enableRpc = pikkuVoidFunc({
+    func: async ({ logger, config }, data) => enableFeature('rpc', logger, config, data),
+});
+export const enableConsole = pikkuVoidFunc({
+    func: async ({ logger, config }, data) => enableFeature('console', logger, config, data),
+});
+export const enableAgent = pikkuVoidFunc({
+    func: async ({ logger, config }, data) => enableFeature('agent', logger, config, data),
+});
+export const enableWorkflow = pikkuVoidFunc({
+    func: async ({ logger, config }, data) => enableFeature('workflow', logger, config, data),
+});

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

@@ -0,0 +1,9 @@
+type InfoInput = {
+    limit?: string;
+    verbose?: boolean;
+};
+export declare const pikkuInfoFunctions: import("#pikku").PikkuFunctionConfig<InfoInput, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuInfoTags: import("#pikku").PikkuFunctionConfig<InfoInput, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuInfoMiddleware: import("#pikku").PikkuFunctionConfig<InfoInput, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuInfoPermissions: import("#pikku").PikkuFunctionConfig<InfoInput, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export {};