@pikku/cli 0.10.2 → 0.11.1

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

@@ -0,0 +1,23 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+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));
+            return true;
+        }
+        return false;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating Public RPC Endpoint',
+            commandEnd: 'Generated Public RPC Endpoint',
+        }),
+    ],
+});

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

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

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

@@ -0,0 +1,23 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+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));
+            return true;
+        }
+        return false;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating Remote RPC Workers',
+            commandEnd: 'Generated Remote RPC Workers',
+        }),
+    ],
+});

package/dist/src/functions/wirings/rpc/serialize-public-rpc.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generate public RPC HTTP endpoint
+ */
+export declare const serializePublicRPC: (pathToPikkuTypes: string) => string;

package/dist/src/functions/wirings/rpc/serialize-public-rpc.js

@@ -0,0 +1,30 @@
+/**
+ * Generate public RPC HTTP endpoint
+ */
+export const serializePublicRPC = (pathToPikkuTypes) => {
+    return `/**
+ * Auto-generated public RPC HTTP endpoint
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
+
+/**
+ * Public RPC endpoint that invokes any exposed RPC by name
+ * This is used for public HTTP access to exposed server functions
+ */
+export const rpcCaller = pikkuSessionlessFunc<
+  { name: string, data?: any },
+  any
+>({
+  func: async ({ rpc }, { name, data }) => {
+    return await (rpc.invokeExposed as any)(name, data)
+  },
+})
+
+wireHTTP({
+  route: '/rpc',
+  method: 'post',
+  func: rpcCaller,
+})
+`;
+};

package/dist/src/functions/wirings/rpc/serialize-remote-rpc.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generate remote internal RPC queue worker and HTTP endpoint
+ */
+export declare const serializeRemoteRPC: (pathToPikkuTypes: string) => string;

package/dist/src/functions/wirings/rpc/serialize-remote-rpc.js

@@ -0,0 +1,30 @@
+/**
+ * Generate remote internal RPC queue worker and HTTP endpoint
+ */
+export const serializeRemoteRPC = (pathToPikkuTypes) => {
+    return `/**
+ * Auto-generated remote internal RPC queue worker and HTTP endpoint
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { pikkuSessionlessFunc, wireQueueWorker } from '${pathToPikkuTypes}'
+
+/**
+ * Generic remote RPC worker that invokes any internal RPC by name
+ * This is used for executing internal RPCs via a queue or HTTP (e.g., scheduled tasks, background jobs, internal services)
+ */
+export const pikkuRemoteInternalRPC = pikkuSessionlessFunc<
+  { rpcName: string, data?: any },
+  any
+>({
+  func: async ({ rpc }, { rpcName, data }) => {
+    return await (rpc.invoke as any)(rpcName, data)
+  },
+  internal: true,
+})
+
+wireQueueWorker({
+  queueName: 'pikku-remote-internal-rpc',
+  func: pikkuRemoteInternalRPC,
+})
+`;
+};

package/dist/src/functions/wirings/rpc/serialize-rpc-wrapper.js

@@ -53,13 +53,13 @@ export class PikkuRPC {
      * Invokes a remote procedure call on the server.
      * This is a generic method that routes to the appropriate server function
      * based on the function name and passes the provided data.
-     * 
+     *
      * @param name - The name of the server function to invoke
      * @param data - The data to pass to the server function
      * @returns A promise that resolves with the function's return value
      */
     invoke: RPCInvoke = async (name, data) => {
-       return await this.pikkuFetch.post('/rpc', { name, data })
+       return await this.pikkuFetch.post('/rpc' as any, { name, data }) as any
     }
 }
 

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

@@ -27,11 +27,18 @@ export type RPCInvoke = <Name extends keyof RPCMap>(
   }
 ) => Promise<RPCMap[Name]['output']>
 
+// Import WorkflowMap for workflow typing
+import type { WorkflowMap } from '../workflow/pikku-workflow-map.gen.js'
+
 export type TypedPikkuRPC = {
   depth: number;
   global: boolean;
   invoke: RPCInvoke;
-  invokeExposed: (name: string, data: any) => Promise<any> 
+  invokeExposed: (name: string, data: any) => Promise<any>;
+  startWorkflow: <Name extends keyof WorkflowMap>(
+    name: Name,
+    input: WorkflowMap[Name]['input']
+  ) => Promise<{ runId: string }>;
 }
   `;
 };
@@ -47,8 +54,25 @@ function generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes) {
         const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
         const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
         // Store the input and output types for RPCHandler
-        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
-        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
+        // Use 'any' for types not in typesMap (e.g., inline types in generated workflow workers)
+        let inputType = 'null';
+        if (input) {
+            try {
+                inputType = typesMap.getTypeMeta(input).uniqueName;
+            }
+            catch {
+                inputType = 'any';
+            }
+        }
+        let outputType = 'null';
+        if (output) {
+            try {
+                outputType = typesMap.getTypeMeta(output).uniqueName;
+            }
+            catch {
+                outputType = 'any';
+            }
+        }
         requiredTypes.add(inputType);
         requiredTypes.add(outputType);
         // Add RPC entry

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

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

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

@@ -0,0 +1,12 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { serializeWorkflowMap } from './serialize-workflow-map.js';
+export const pikkuWorkflowMap = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { workflowMapDeclarationFile, packageMappings } = config;
+        const { workflows, functions: functionState } = visitState;
+        const { typesMap } = functionState;
+        await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta));
+    },
+});

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

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

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

@@ -0,0 +1,11 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { serializeWorkflowTypes } from './serialize-workflow-types.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+export const pikkuWorkflowTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { workflowTypesFile, functionTypesFile, packageMappings } = config;
+        const functionTypesImportPath = getFileImportRelativePath(workflowTypesFile, functionTypesFile, packageMappings);
+        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath));
+    },
+});

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

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

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

@@ -0,0 +1,55 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { ErrorCode } from '@pikku/inspector';
+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 { serializeWorkflowMeta } from './serialize-workflow-meta.js';
+import { serializeWorkflowTypes } from './serialize-workflow-types.js';
+import { serializeWorkflowMap } from './serialize-workflow-map.js';
+import { serializeWorkflowWorkers } from './serialize-workflow-workers.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { join } from 'path';
+export const pikkuWorkflow = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { workflowsWiringFile, workflowsWiringMetaFile, workflowMapDeclarationFile, workflowTypesFile, functionTypesFile, typesDeclarationFile, packageMappings, } = config;
+        const { workflows, functions: functionState } = visitState;
+        const { typesMap } = functionState;
+        // Validate that workflowService service is configured if workflows are defined
+        const hasWorkflows = Object.keys(workflows.meta).length > 0;
+        if (hasWorkflows) {
+            const hasWorkflowState = visitState.serviceAggregation.allSingletonServices.includes('workflowService');
+            if (!hasWorkflowState) {
+                logger.critical(ErrorCode.WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED, 'Workflows detected but workflowService service not configured. Please add workflowService to your singleton services');
+                throw new Error('WorkflowState service not configured but workflows are defined');
+            }
+        }
+        // Write workflow metadata
+        await writeFileInDir(logger, workflowsWiringMetaFile, serializeWorkflowMeta(workflows.meta));
+        // Write workflow wirings (imports)
+        await writeFileInDir(logger, workflowsWiringFile, serializeFileImports('wireWorkflow', workflowsWiringFile, workflows.files, packageMappings));
+        // Write workflow types
+        const functionTypesImportPath = getFileImportRelativePath(workflowTypesFile, functionTypesFile, packageMappings);
+        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath));
+        // Write workflow map (type-safe client API)
+        await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta));
+        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;
+            }
+        }
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding Workflows',
+            commandEnd: 'Found Workflows',
+        }),
+    ],
+});

package/dist/src/functions/wirings/workflow/serialize-workflow-map.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowsMeta } from '@pikku/core/workflow';
+import { TypesMap } from '@pikku/inspector';
+import { FunctionsMeta } from '@pikku/core';
+export declare const serializeWorkflowMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, workflowsMeta: WorkflowsMeta) => string;

package/dist/src/functions/wirings/workflow/serialize-workflow-map.js

@@ -0,0 +1,79 @@
+import { serializeImportMap } from '../../../utils/serialize-import-map.js';
+import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
+export const serializeWorkflowMap = (relativeToPath, packageMappings, typesMap, functionsMeta, workflowsMeta) => {
+    const requiredTypes = new Set();
+    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
+    const serializedWorkflows = generateWorkflows(workflowsMeta, functionsMeta, typesMap, requiredTypes);
+    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    return `/**
+ * This provides the structure needed for TypeScript to be aware of workflows and their input/output types
+ */
+
+${serializedImportMap}
+${serializedCustomTypes}
+
+interface WorkflowHandler<I, O> {
+    input: I;
+    output: O;
+}
+
+${serializedWorkflows}
+
+/**
+ * Type-safe workflow client API
+ */
+export type WorkflowClient<Name extends keyof WorkflowMap> = {
+  /**
+   * Start a new workflow run
+   */
+  start: (input: WorkflowMap[Name]['input']) => Promise<{ runId: string }>;
+
+  /**
+   * Get a workflow run by ID
+   */
+  getRun: <output extends keyof WorkflowMap[Name]>(runId: string) => Promise<WorkflowMap[Name][output]>;
+
+  /**
+   * Cancel a running workflow
+   */
+  cancelRun: (runId: string) => Promise<boolean>;
+}
+
+/**
+ * Map of all registered workflows with type-safe client APIs
+ */
+export type TypedWorkflowClients = {
+  [Name in keyof WorkflowMap]: WorkflowClient<Name>;
+}
+  `;
+};
+function generateWorkflows(workflowsMeta, functionsMeta, typesMap, requiredTypes) {
+    // Initialize an object to collect workflows
+    const workflowsObj = {};
+    // Iterate through workflow metadata
+    for (const [workflowName, { pikkuFuncName }] of Object.entries(workflowsMeta)) {
+        const functionMeta = functionsMeta[pikkuFuncName];
+        if (!functionMeta) {
+            throw new Error(`Function ${workflowName} not found in functionsMeta. Please check your configuration.`);
+        }
+        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
+        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
+        // Store the input and output types for WorkflowHandler
+        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'void';
+        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'void';
+        requiredTypes.add(inputType);
+        requiredTypes.add(outputType);
+        // Add workflow entry
+        workflowsObj[workflowName] = {
+            inputType,
+            outputType,
+        };
+    }
+    // Build the Workflows object as a string
+    let workflowsStr = 'export type WorkflowMap = {\n';
+    for (const [workflowName, handler] of Object.entries(workflowsObj)) {
+        workflowsStr += `  readonly '${workflowName}': WorkflowHandler<${handler.inputType}, ${handler.outputType}>,\n`;
+    }
+    workflowsStr += '};\n';
+    return workflowsStr;
+}

package/dist/src/functions/wirings/workflow/serialize-workflow-meta.d.ts

@@ -0,0 +1,2 @@
+import { WorkflowsMeta } from '@pikku/core/workflow';
+export declare const serializeWorkflowMeta: (workflowsMeta: WorkflowsMeta) => string;

package/dist/src/functions/wirings/workflow/serialize-workflow-meta.js

@@ -0,0 +1,10 @@
+export const serializeWorkflowMeta = (workflowsMeta) => {
+    const serializedOutput = [];
+    serializedOutput.push("import { pikkuState } from '@pikku/core'");
+    serializedOutput.push(`pikkuState('workflows', 'meta', ${JSON.stringify(workflowsMeta, null, 2)})`);
+    const workflowsMetaValues = Object.values(workflowsMeta);
+    if (workflowsMetaValues.length > 0) {
+        serializedOutput.push(`export type WorkflowNames = '${workflowsMetaValues.map((w) => w.workflowName).join("' | '")}'`);
+    }
+    return serializedOutput.join('\n');
+};

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

@@ -0,0 +1,4 @@
+/**
+ * Generates type definitions for workflow wirings
+ */
+export declare const serializeWorkflowTypes: (functionTypesImportPath: string) => string;

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

@@ -0,0 +1,95 @@
+/**
+ * Generates type definitions for workflow wirings
+ */
+export const serializeWorkflowTypes = (functionTypesImportPath) => {
+    return `/**
+ * Workflow-specific type definitions for tree-shaking optimization
+ */
+
+import { CoreWorkflow, wireWorkflow as wireWorkflowCore, PikkuWorkflowInteraction, WorkflowStepOptions } from '@pikku/core/workflow'
+import { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '@pikku/core'
+import type { PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
+import type { UserSession, SingletonServices } from '../../types/application-types.d.js'
+import type { TypedPikkuRPC, RPCMap } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js'
+
+/**
+ * Type definition for workflows that orchestrate multi-step processes.
+ * Workflows support both inline and remote execution modes with step caching.
+ */
+type WorkflowWiring = CoreWorkflow<
+  CorePikkuFunctionConfig<PikkuFunctionWorkflow<any, any>, PikkuPermission<any>, PikkuMiddleware>
+>
+
+/**
+ * Typed workflow interaction with RPC awareness
+ * Provides type-safe workflow.do() for RPC steps
+ */
+export interface TypedWorkflow extends PikkuWorkflowInteraction {
+  /**
+   * Execute a workflow step with RPC invocation (typed based on available RPCs)
+   * @template K - RPC name from the RPC map
+   */
+  do<K extends keyof RPCMap>(
+    stepName: string,
+    rpcName: K,
+    data: RPCMap[K]['input'],
+    options?: WorkflowStepOptions
+  ): Promise<RPCMap[K]['output']>
+
+  /**
+   * Execute a workflow step with inline function
+   * @template T - Return type of the inline function
+   */
+  do<T>(
+    stepName: string,
+    fn: () => T | Promise<T>,
+    options?: WorkflowStepOptions
+  ): Promise<T>
+}
+
+/**
+ * Workflow function type with typed workflow service
+ * Includes the workflow interaction object with typed RPC methods
+ */
+export type PikkuFunctionWorkflow<
+  In = unknown,
+  Out = never
+> = CorePikkuFunctionSessionless<
+  In,
+  Out,
+  null,
+  SingletonServices & {
+    rpc: TypedPikkuRPC
+    workflow: TypedWorkflow
+  },
+  UserSession
+>
+
+/**
+ * Creates a workflow function with typed input and output.
+ * Workflow functions have access to the workflow interaction object for step execution.
+ *
+ * @template In - Input type for the workflow
+ * @template Out - Output type for the workflow
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ */
+export const pikkuWorkflowFunc = <In, Out = unknown>(
+  func:
+    | PikkuFunctionWorkflow<In, Out>
+    | CorePikkuFunctionConfig<PikkuFunctionWorkflow<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Registers a workflow with the Pikku framework.
+ * Workflows can run in 'inline' (synchronous) or 'remote' (queue-based) execution modes.
+ *
+ * @param workflow - Workflow definition with name, execution mode, and handler function
+ */
+export const wireWorkflow = (workflow: WorkflowWiring) => {
+  wireWorkflowCore(workflow as any)
+}
+`;
+};

package/dist/src/functions/wirings/workflow/serialize-workflow-workers.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generate queue workers and RPC functions for workflow steps and orchestrator
+ */
+export declare const serializeWorkflowWorkers: (pathToPikkuTypes: string) => string;

package/dist/src/functions/wirings/workflow/serialize-workflow-workers.js

@@ -0,0 +1,60 @@
+/**
+ * Generate queue workers and RPC functions for workflow steps and orchestrator
+ */
+export const serializeWorkflowWorkers = (pathToPikkuTypes) => {
+    return `/**
+ * Auto-generated workflow queue workers and RPC functions
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { pikkuSessionlessFunc, wireQueueWorker } from '${pathToPikkuTypes}'
+
+/**
+ * Worker input types for generated queue workers
+ */
+export type WorkflowStepInput = {
+  runId: string
+  stepName: string
+  rpcName: string
+  data: any
+}
+
+export const pikkuWorkflowWorker = pikkuSessionlessFunc<
+  WorkflowStepInput,
+  void
+>({
+  func: async ({ workflowService, rpc }, { runId, stepName, rpcName, data }) => {
+    await workflowService!.executeWorkflowStep(runId, stepName, rpcName, data, rpc)
+  }
+})
+
+export const pikkuWorkflowOrchestrator = pikkuSessionlessFunc<
+  { runId: string },
+  void
+>({
+  func: async ({ workflowService, rpc }, { runId }) => {
+    await workflowService!.orchestrateWorkflow(runId, rpc)
+  }
+})
+
+export const pikkuWorkflowSleeper = pikkuSessionlessFunc<
+  { runId: string, stepId: string },
+  void
+>({
+  func: async ({ workflowService }, { runId, stepId }) => {
+    await workflowService!.executeWorkflowSleep(runId, stepId)
+  },
+  name: 'pikkuWorkflowStepSleeper',
+  internal: true,
+})
+
+wireQueueWorker({
+  queueName: 'pikku-workflow-step-worker',
+  func: pikkuWorkflowWorker,
+})
+
+wireQueueWorker({
+  queueName: 'pikku-workflow-orchestrator',
+  func: pikkuWorkflowOrchestrator,
+})
+`;
+};

package/dist/src/services/cli-logger-forwarder.service.d.ts

@@ -17,8 +17,11 @@ export declare class CLILoggerForwarder implements Logger {
     private logger;
     private channel;
     private level;
+    private silent;
     constructor(logger: Logger, channel: PikkuChannel<unknown, any>);
     setLevel(level: LogLevel): void;
+    setSilent(silent: boolean): void;
+    isSilent(): boolean;
     private log;
     info(messageOrObj: string | Record<string, any>, ..._meta: any[]): void;
     error(messageOrObj: string | Record<string, any> | Error, ..._meta: any[]): void;

package/dist/src/services/cli-logger-forwarder.service.js

@@ -7,6 +7,7 @@ export class CLILoggerForwarder {
     logger;
     channel;
     level = LogLevel.info;
+    silent = false;
     constructor(logger, channel) {
         this.logger = logger;
         this.channel = channel;
@@ -14,8 +15,14 @@ export class CLILoggerForwarder {
     setLevel(level) {
         this.level = level;
     }
+    setSilent(silent) {
+        this.silent = silent;
+    }
+    isSilent() {
+        return this.silent;
+    }
     log(level, logLevel, messageOrObj, type) {
-        if (this.level > logLevel)
+        if (this.level > logLevel || this.silent)
             return;
         let message;
         if (messageOrObj instanceof Error) {
@@ -53,7 +60,7 @@ export class CLILoggerForwarder {
         this.log('trace', LogLevel.trace, message);
     }
     critical(code, message) {
-        const url = `https://pikku.dev/docs/cli-errors/${code.toLowerCase()}`;
+        const url = `https://pikku.dev/docs/pikku-cli/errors/${code.toLowerCase()}`;
         const formattedMessage = `[${code}] ${message}\n  → ${url}`;
         this.error(formattedMessage);
     }

package/dist/src/services/cli-logger.service.js

@@ -8,7 +8,7 @@ const logo = `
 | |    | |  _ (|  _ (|  _ (| |_| |
 |_|    |_|_| _)_| _)____/
 `;
-const BASE_ERROR_URL = 'https://pikku.dev/errors';
+const BASE_ERROR_URL = 'https://pikku.dev/docs/pikku-cli/errors';
 export class CLILogger {
     silent;
     level = LogLevel.warn; // default to warn level

package/dist/src/utils/command-summary.d.ts

@@ -6,6 +6,7 @@ export interface CommandSummaryStats {
     queueWorkers?: number;
     mcpEndpoints?: number;
     cliCommands?: number;
+    workflows?: number;
     [key: string]: number | undefined;
 }
 /**

package/dist/src/utils/command-summary.js

@@ -44,18 +44,19 @@ export class CommandSummary {
         lines.push(chalk.green(`\npikku ${this.commandName} (completed in ${elapsed}ms)`));
         // Stats
         const statLabels = {
-            httpRoutes: 'HTTP routes',
-            channels: 'WebSocket channels',
-            functions: 'functions',
-            scheduledTasks: 'scheduled tasks',
-            queueWorkers: 'queue workers',
-            mcpEndpoints: 'MCP endpoints',
-            cliCommands: 'CLI commands',
+            httpRoutes: 'HTTP route',
+            channels: 'WebSocket channel',
+            functions: 'Function',
+            scheduledTasks: 'Scheduled task',
+            queueWorkers: 'Queue worker',
+            mcpEndpoints: 'MCP endpoint',
+            cliCommands: 'CLI command',
+            workflows: 'Workflow',
         };
         for (const [key, label] of Object.entries(statLabels)) {
             const value = this.stats[key];
             if (value !== undefined && value > 0) {
-                lines.push(chalk.gray(`  • ${value} ${label}`));
+                lines.push(chalk.gray(`  • ${value} ${label}${value > 1 ? 's' : ''}`));
             }
         }
         // If no stats, show a simple completion message