@pikku/cli 0.11.0 → 0.11.2

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

@@ -15,7 +15,7 @@ import type { PikkuFunctionConfig } from '${functionTypesImportPath}'
  * @template In - Input type for the queue job
  * @template Out - Output type for the queue job
  */
-type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionConfig<In, Out>>
+type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionConfig<In, Out, 'session' | 'rpc'>>
 
 /**
  * Registers a queue worker with the Pikku framework.

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

@@ -1,12 +1,19 @@
 import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const pikkuRPC = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { rpc } = await getInspectorState();
-        const { rpcInternalWiringMetaFile } = config;
+        const { rpcInternalWiringMetaFile, rpcInternalWiringMetaJsonFile, packageMappings, schema, } = config;
         if (rpc.internalFiles.size > 0) {
-            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.internalMeta, null, 2)})`);
+            await writeFileInDir(logger, rpcInternalWiringMetaJsonFile, JSON.stringify(rpc.internalMeta, null, 2));
+            const jsonImportPath = getFileImportRelativePath(rpcInternalWiringMetaFile, rpcInternalWiringMetaJsonFile, packageMappings);
+            const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+            const importStatement = supportsImportAttributes
+                ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+                : `import metaData from '${jsonImportPath}'`;
+            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core'\n${importStatement}\npikkuState('rpc', 'meta', metaData as Record<string, string>)`);
             return true;
         }
         return false;

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

@@ -13,16 +13,23 @@ import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
  * This is used for public HTTP access to exposed server functions
  */
 export const rpcCaller = pikkuSessionlessFunc<
-  { name: string, data?: any },
+  { rpcName: string, data?: any },
   any
 >({
-  func: async ({ rpc }, { name, data }) => {
-    return await (rpc.invokeExposed as any)(name, data)
+  func: async (services, { rpcName, data }, { rpc }) => {
+    return await (rpc.invokeExposed as any)(rpcName, data)
   },
 })
 
 wireHTTP({
-  route: '/rpc',
+  route: "/rpc/:rpcName",
+  method: "options",
+  auth: false,
+  func: pikkuSessionlessFunc<{ rpcName: string }>(async () => void 0),
+});
+
+wireHTTP({
+  route: '/rpc/:rpcName',
   method: 'post',
   func: rpcCaller,
 })

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

@@ -16,7 +16,7 @@ export const pikkuRemoteInternalRPC = pikkuSessionlessFunc<
   { rpcName: string, data?: any },
   any
 >({
-  func: async ({ rpc }, { rpcName, data }) => {
+  func: async (_services, { rpcName, data }, { rpc }) => {
     return await (rpc.invoke as any)(rpcName, data)
   },
   internal: true,

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

@@ -54,12 +54,12 @@ export class PikkuRPC {
      * 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 rpcName - 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' as any, { name, data }) as any
+    invoke: RPCInvoke = async (rpcName, data) => {
+       return await this.pikkuFetch.post(\`/rpc/\${rpcName}\` as any, { rpcName, data }) as any
     }
 }
 

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

@@ -2,13 +2,16 @@ import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-import { serializeSchedulerMeta } from './serialize-scheduler-meta.js';
+import { serializeSchedulerMeta, serializeSchedulerMetaTS, } from './serialize-scheduler-meta.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const pikkuScheduler = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const { schedulersWiringFile, schedulersWiringMetaFile, packageMappings } = config;
+        const { schedulersWiringFile, schedulersWiringMetaFile, schedulersWiringMetaJsonFile, packageMappings, schema, } = config;
         const { scheduledTasks } = visitState;
-        await writeFileInDir(logger, schedulersWiringMetaFile, serializeSchedulerMeta(scheduledTasks.meta));
+        await writeFileInDir(logger, schedulersWiringMetaJsonFile, JSON.stringify(serializeSchedulerMeta(scheduledTasks.meta), null, 2));
+        const jsonImportPath = getFileImportRelativePath(schedulersWiringMetaFile, schedulersWiringMetaJsonFile, packageMappings);
+        await writeFileInDir(logger, schedulersWiringMetaFile, serializeSchedulerMetaTS(scheduledTasks.meta, jsonImportPath, schema?.supportsImportAttributes ?? false));
         await writeFileInDir(logger, schedulersWiringFile, serializeFileImports('addScheduledTasks', schedulersWiringFile, scheduledTasks.files, packageMappings));
         return true;
     },

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

@@ -1,2 +1,3 @@
 import { ScheduledTasksMeta } from '@pikku/core/scheduler';
-export declare const serializeSchedulerMeta: (scheduledTasksMeta: ScheduledTasksMeta) => string;
+export declare const serializeSchedulerMeta: (scheduledTasksMeta: ScheduledTasksMeta) => ScheduledTasksMeta;
+export declare const serializeSchedulerMetaTS: (scheduledTasksMeta: ScheduledTasksMeta, jsonImportPath: string, supportsImportAttributes: any) => string;

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

@@ -1,7 +1,17 @@
 export const serializeSchedulerMeta = (scheduledTasksMeta) => {
+    return scheduledTasksMeta;
+};
+export const serializeSchedulerMetaTS = (scheduledTasksMeta, jsonImportPath, supportsImportAttributes) => {
+    const importStatement = supportsImportAttributes
+        ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+        : `import metaData from '${jsonImportPath}'`;
     const serializedOutput = [];
     serializedOutput.push("import { pikkuState } from '@pikku/core'");
-    serializedOutput.push(`pikkuState('scheduler', 'meta', ${JSON.stringify(scheduledTasksMeta, null, 2)})`);
+    serializedOutput.push("import { ScheduledTasksMeta } from '@pikku/core/scheduler'");
+    serializedOutput.push(importStatement);
+    serializedOutput.push('');
+    serializedOutput.push("pikkuState('scheduler', 'meta', metaData as ScheduledTasksMeta)");
+    serializedOutput.push('');
     const scheduledTasksMetaValues = Object.values(scheduledTasksMeta);
     if (scheduledTasksMetaValues.length > 0) {
         serializedOutput.push(`export type ScheduledTaskNames = '${scheduledTasksMetaValues.map((s) => s.name).join("' | '")}'`);

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

@@ -13,7 +13,7 @@ import type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImport
  * Type definition for scheduled tasks that run at specified intervals.
  * These are sessionless functions that execute based on cron expressions.
  */
-type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void>, PikkuMiddleware>
+type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void, 'session' | 'rpc'>, PikkuMiddleware>
 
 /**
  * Registers a scheduled task with the Pikku framework.

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

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

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

@@ -0,0 +1,22 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { writeAllServiceMetadata } from '@pikku/inspector';
+export const pikkuServiceMetadata = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const state = await getInspectorState();
+        // Only write service metadata if there are services to document
+        if (state.serviceMetadata && state.serviceMetadata.length > 0) {
+            writeAllServiceMetadata(state.serviceMetadata, config.outDir);
+            logger.debug(`• Wrote ${state.serviceMetadata.length} service metadata files`);
+        }
+        else {
+            logger.debug('• No service metadata to write');
+        }
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating service metadata',
+            commandEnd: 'Generated service metadata',
+        }),
+    ],
+});

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

@@ -6,6 +6,8 @@ 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));
+        // Get RPC map import path
+        const rpcMapImportPath = getFileImportRelativePath(workflowTypesFile, config.rpcInternalMapDeclarationFile, packageMappings);
+        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath));
     },
 });

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

@@ -1,18 +1,18 @@
 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 { serializeWorkflowMeta, serializeWorkflowMetaTS, } 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 { serializeWorkflowWirings } from './serialize-workflow-wirings.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 { workflowsWiringFile, workflowsWiringMetaFile, workflowsWiringMetaJsonFile, workflowMapDeclarationFile, workflowTypesFile, functionTypesFile, typesDeclarationFile, packageMappings, schema, } = config;
         const { workflows, functions: functionState } = visitState;
         const { typesMap } = functionState;
         // Validate that workflowService service is configured if workflows are defined
@@ -24,13 +24,17 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
                 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));
+        await writeFileInDir(logger, workflowsWiringMetaJsonFile, JSON.stringify(serializeWorkflowMeta(workflows.meta), null, 2));
+        const jsonImportPath = getFileImportRelativePath(workflowsWiringMetaFile, workflowsWiringMetaJsonFile, packageMappings);
+        // Write workflow metadata TypeScript file that imports JSON
+        await writeFileInDir(logger, workflowsWiringMetaFile, serializeWorkflowMetaTS(workflows.meta, jsonImportPath, schema?.supportsImportAttributes ?? false));
+        // Write workflow wirings (imports and addWorkflow calls)
+        await writeFileInDir(logger, workflowsWiringFile, serializeWorkflowWirings(workflowsWiringFile, workflows.files, packageMappings));
         // Write workflow types
         const functionTypesImportPath = getFileImportRelativePath(workflowTypesFile, functionTypesFile, packageMappings);
-        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath));
+        // Get RPC map import path
+        const rpcMapImportPath = getFileImportRelativePath(workflowTypesFile, config.rpcInternalMapDeclarationFile, packageMappings);
+        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath));
         // Write workflow map (type-safe client API)
         await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta));
         if (config.workflows) {

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

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

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

@@ -1,7 +1,17 @@
 export const serializeWorkflowMeta = (workflowsMeta) => {
+    return workflowsMeta;
+};
+export const serializeWorkflowMetaTS = (workflowsMeta, jsonImportPath, supportsImportAttributes) => {
+    const importStatement = supportsImportAttributes
+        ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+        : `import metaData from '${jsonImportPath}'`;
     const serializedOutput = [];
     serializedOutput.push("import { pikkuState } from '@pikku/core'");
-    serializedOutput.push(`pikkuState('workflows', 'meta', ${JSON.stringify(workflowsMeta, null, 2)})`);
+    serializedOutput.push("import { WorkflowsMeta } from '@pikku/core/workflow'");
+    serializedOutput.push(importStatement);
+    serializedOutput.push('');
+    serializedOutput.push("pikkuState('workflows', 'meta', metaData as WorkflowsMeta)");
+    serializedOutput.push('');
     const workflowsMetaValues = Object.values(workflowsMeta);
     if (workflowsMetaValues.length > 0) {
         serializedOutput.push(`export type WorkflowNames = '${workflowsMetaValues.map((w) => w.workflowName).join("' | '")}'`);

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

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

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

@@ -1,30 +1,20 @@
 /**
  * Generates type definitions for workflow wirings
  */
-export const serializeWorkflowTypes = (functionTypesImportPath) => {
+export const serializeWorkflowTypes = (functionTypesImportPath, rpcMapImportPath) => {
     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'
+import { PikkuWorkflowWire, WorkflowStepOptions } from '@pikku/core/workflow'
+import type { PikkuFunctionSessionless, PikkuFunctionConfig } from '${functionTypesImportPath}'
+import type { RPCMap } from '${rpcMapImportPath}'
 
 /**
- * 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
+ * Typed workflow wire with RPC awareness
  * Provides type-safe workflow.do() for RPC steps
  */
-export interface TypedWorkflow extends PikkuWorkflowInteraction {
+export interface TypedWorkflow extends PikkuWorkflowWire {
   /**
    * Execute a workflow step with RPC invocation (typed based on available RPCs)
    * @template K - RPC name from the RPC map
@@ -49,25 +39,23 @@ export interface TypedWorkflow extends PikkuWorkflowInteraction {
 
 /**
  * Workflow function type with typed workflow service
- * Includes the workflow interaction object with typed RPC methods
+ * Includes the workflow wire object with typed RPC methods
  */
 export type PikkuFunctionWorkflow<
   In = unknown,
   Out = never
-> = CorePikkuFunctionSessionless<
+> = PikkuFunctionSessionless<
   In,
   Out,
-  null,
-  SingletonServices & {
-    rpc: TypedPikkuRPC
-    workflow: TypedWorkflow
-  },
-  UserSession
+  'workflow'
 >
 
 /**
  * Creates a workflow function with typed input and output.
- * Workflow functions have access to the workflow interaction object for step execution.
+ * Workflow functions have access to the workflow wire object for step execution.
+ *
+ * This is the permissive mode - workflows that don't conform to simple DSL will fall back
+ * to basic extraction with a warning.
  *
  * @template In - Input type for the workflow
  * @template Out - Output type for the workflow
@@ -77,19 +65,36 @@ export type PikkuFunctionWorkflow<
 export const pikkuWorkflowFunc = <In, Out = unknown>(
   func:
     | PikkuFunctionWorkflow<In, Out>
-    | CorePikkuFunctionConfig<PikkuFunctionWorkflow<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+    | PikkuFunctionConfig<In, Out, 'workflow', PikkuFunctionWorkflow<In, Out>>
 ) => {
   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.
+ * Creates a simple workflow function with typed input and output.
+ * Simple workflows must conform to the restricted DSL for static analysis.
+ *
+ * This is the strict mode - workflows that don't conform to simple DSL will cause
+ * a critical error during inspection.
  *
- * @param workflow - Workflow definition with name, execution mode, and handler function
+ * Constraints:
+ * - Must use only workflow.do() with RPC form (no inline functions)
+ * - Only if/else, for..of, and Promise.all(array.map()) control flow allowed
+ * - Step names must be unique (except across mutually exclusive branches)
+ * - All workflow calls must be awaited
+ *
+ * @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 wireWorkflow = (workflow: WorkflowWiring) => {
-  wireWorkflowCore(workflow as any)
+export const pikkuSimpleWorkflowFunc = <In, Out = unknown>(
+  func:
+    | PikkuFunctionWorkflow<In, Out>
+    | PikkuFunctionConfig<In, Out, 'workflow', PikkuFunctionWorkflow<In, Out>>
+) => {
+  return typeof func === 'function' ? { func } : func
 }
+
 `;
 };

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

@@ -0,0 +1,8 @@
+/**
+ * Generate workflow registration wirings
+ * Imports all workflow functions and calls addWorkflow for each
+ */
+export declare const serializeWorkflowWirings: (outputPath: string, workflowFiles: Map<string, {
+    path: string;
+    exportedName: string;
+}>, packageMappings?: Record<string, string>) => string;

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

@@ -0,0 +1,30 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+/**
+ * Generate workflow registration wirings
+ * Imports all workflow functions and calls addWorkflow for each
+ */
+export const serializeWorkflowWirings = (outputPath, workflowFiles, packageMappings = {}) => {
+    const imports = [];
+    const registrations = [];
+    // Sort by pikkuFuncName for consistent output
+    const sortedWorkflows = Array.from(workflowFiles.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+    // Generate imports
+    for (const [, { path, exportedName }] of sortedWorkflows) {
+        const importPath = getFileImportRelativePath(outputPath, path, packageMappings);
+        imports.push(`import { ${exportedName} } from '${importPath}'`);
+    }
+    // Generate addWorkflow calls
+    for (const [pikkuFuncName, { exportedName }] of sortedWorkflows) {
+        registrations.push(`addWorkflow('${pikkuFuncName}', ${exportedName})`);
+    }
+    // Only import addWorkflow if there are workflows to register
+    const addWorkflowImport = sortedWorkflows.length > 0
+        ? `import { addWorkflow } from '@pikku/core/workflow'\n\n`
+        : '';
+    return `/**
+ * Auto-generated workflow registrations
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+${addWorkflowImport}${imports.join('\n')}${imports.length > 0 ? '\n\n' : ''}${registrations.join('\n')}
+`;
+};

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

@@ -22,7 +22,7 @@ export const pikkuWorkflowWorker = pikkuSessionlessFunc<
   WorkflowStepInput,
   void
 >({
-  func: async ({ workflowService, rpc }, { runId, stepName, rpcName, data }) => {
+  func: async ({ workflowService }, { runId, stepName, rpcName, data }, { rpc }) => {
     await workflowService!.executeWorkflowStep(runId, stepName, rpcName, data, rpc)
   }
 })
@@ -31,7 +31,7 @@ export const pikkuWorkflowOrchestrator = pikkuSessionlessFunc<
   { runId: string },
   void
 >({
-  func: async ({ workflowService, rpc }, { runId }) => {
+  func: async ({ workflowService }, { runId }, { rpc }) => {
     await workflowService!.orchestrateWorkflow(runId, rpc)
   }
 })

package/dist/src/middleware/log-command-info-and-time.d.ts

@@ -1,6 +1,6 @@
 import type { Services } from '../../types/application-types.js';
-import type { PikkuInteraction } from '@pikku/core';
-type PikkuMiddleware = (services: Services, interaction: PikkuInteraction, next: () => Promise<void>) => Promise<void>;
+import type { PikkuWire } from '@pikku/core';
+type PikkuMiddleware = (services: Services, wire: PikkuWire, next: () => Promise<void>) => Promise<void>;
 export interface LogCommandInfoOptions {
     commandStart: string;
     commandEnd: string;

package/dist/src/middleware/log-command-info-and-time.js

@@ -3,13 +3,10 @@
  * Uses debug level so it only shows with --verbose flag
  */
 export const logCommandInfoAndTime = ({ commandStart, commandEnd, }) => {
-    return async ({ logger }, _interaction, next) => {
-        // Log start (debug level - only shows with --verbose)
+    return async ({ logger }, _wire, next) => {
         const start = Date.now();
         logger.debug(`• ${commandStart}...`);
-        // Execute the function
         await next();
-        // Log completion (debug level - only shows with --verbose)
         logger.debug({
             type: 'success',
             message: `✓ ${commandEnd} in ${Date.now() - start}ms.`,

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,12 +15,18 @@ 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) {
-            this.logger.error(messageOrObj);
+            this.logger.error(messageOrObj.toString());
             message = messageOrObj.message;
         }
         else if (typeof messageOrObj === 'object') {

package/dist/src/services.d.ts

@@ -1,20 +1,15 @@
 import type { Config, Services, SingletonServices, UserSession } from '../types/application-types.js';
-import { CreateConfig, CreateSessionServices, CreateSingletonServices } from '@pikku/core';
+import { CreateConfig, CreateWireServices, CreateSingletonServices } from '@pikku/core';
 import { PikkuCLIConfig } from '../types/config.js';
 import { ForwardedLogMessage } from './services/cli-logger-forwarder.service.js';
 /**
  * Default CLI renderer that logs output using the logger
  */
 export declare const defaultCLIRenderer: import("@pikku/core").CorePikkuCLIRender<ForwardedLogMessage, SingletonServices, import("@pikku/core").CoreUserSession>;
-/**
- * Client-safe CLI renderer that outputs to console (no service dependencies)
- * This renderer can be used in CLI-over-channel clients
- */
-export declare const clientCLIRenderer: import("@pikku/core").CorePikkuCLIRender<ForwardedLogMessage, import("@pikku/core").CoreServices, import("@pikku/core").CoreUserSession>;
 export declare const createConfig: CreateConfig<Config, [PikkuCLIConfig]>;
 /**
  * Singleton services factory for the Pikku CLI
  * This function creates the singleton services used by the CLI and is created once on start.
  */
 export declare const createSingletonServices: CreateSingletonServices<Config, SingletonServices>;
-export declare const createSessionServices: CreateSessionServices<SingletonServices, Services, UserSession>;
+export declare const createWireServices: CreateWireServices<SingletonServices, Services, UserSession>;

package/dist/src/services.js

@@ -70,15 +70,17 @@ export const defaultCLIRenderer = pikkuCLIRender(({ logger }, data) => {
         logger[data.level]({ message: data.message, type: data.type });
     }
 });
-/**
- * Client-safe CLI renderer that outputs to console (no service dependencies)
- * This renderer can be used in CLI-over-channel clients
- */
-export const clientCLIRenderer = pikkuCLIRender(({ logger }, data) => {
-    if (data) {
-        logger[data.level]?.({ message: data.message, type: data.type });
-    }
-});
+// /**
+//  * Client-safe CLI renderer that outputs to console (no service dependencies)
+//  * This renderer can be used in CLI-over-channel clients
+//  */
+// export const clientCLIRenderer = pikkuCLIRender<ForwardedLogMessage>(
+//   ({ logger }, data) => {
+//     if (data) {
+//       logger[data.level]?.({ message: data.message, type: data.type } as any)
+//     }
+//   }
+// )
 export const createConfig = async (_variablesService, data) => {
     // Determine log level based on CLI flags with precedence:
     // --silent > --loglevel > --verbose > --info > default (warn)
@@ -155,7 +157,7 @@ export const createSingletonServices = async (config) => {
                     type: 'CoreUserSession',
                     typePath: corePackagePath,
                 },
-                sessionServicesType: {
+                wireServicesType: {
                     file: corePackagePath,
                     variable: 'CoreServices',
                     type: 'CoreServices',
@@ -188,7 +190,7 @@ export const createSingletonServices = async (config) => {
                     configFileType: config.configFile,
                     userSessionType: config.userSessionType,
                     singletonServicesFactoryType: config.singletonServicesFactoryType,
-                    sessionServicesFactoryType: config.sessionServicesFactoryType,
+                    wireServicesFactoryType: config.wireServicesFactoryType,
                 },
             });
             // Save unfiltered inspector state to file if stateOutput is provided
@@ -216,7 +218,7 @@ export const createSingletonServices = async (config) => {
         getInspectorState,
     };
 };
-export const createSessionServices = async ({ logger }, { cli, channel }) => {
+export const createWireServices = async ({ logger }, { cli, channel }) => {
     const vChannel = cli ? cli.channel : channel;
     if (!vChannel) {
         throw new Error('No channel provided for CLI services');

package/dist/src/utils/check-required-types.d.ts

@@ -1,10 +1,10 @@
 import { FilesAndMethodsErrors } from '@pikku/inspector';
 export type RequiredTypes = Partial<{
     config: boolean;
-    sessionServiceType: boolean;
+    wireServiceType: boolean;
     singletonServicesType: boolean;
     userSessionType: boolean;
     singletonServicesFactory: boolean;
-    sessionServicesFactory: boolean;
+    wireServicesFactory: boolean;
 }>;
 export declare const checkRequiredTypes: (errors: FilesAndMethodsErrors, requires?: RequiredTypes) => void;

package/dist/src/utils/check-required-types.js

@@ -13,7 +13,7 @@ export const checkRequiredTypes = (errors, requires = {}) => {
         }
         if (requires.config && message.includes('CoreConfig'))
             return true;
-        if (requires.sessionServiceType && message.includes('CoreServices'))
+        if (requires.wireServiceType && message.includes('CoreServices'))
             return true;
         if (requires.singletonServicesType &&
             message.includes('CoreSingletonServices'))
@@ -23,8 +23,7 @@ export const checkRequiredTypes = (errors, requires = {}) => {
         if (requires.singletonServicesFactory &&
             message.includes('CreateSingletonServices'))
             return true;
-        if (requires.sessionServicesFactory &&
-            message.includes('CreateSessionServices'))
+        if (requires.wireServicesFactory && message.includes('CreateWireServices'))
             return true;
         return false;
     });