@pikku/cli 0.12.20 → 0.12.22

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

@@ -5,13 +5,17 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeWorkflowTypes } from './serialize-workflow-types.js';
 import { serializeWorkflowRegistration } from './serialize-workflow-registration.js';
 import { serializeWorkflowMap } from './serialize-workflow-map.js';
+import { serializeWorkflowBootstrapMap } from './serialize-workflow-bootstrap-map.js';
 import { serializeWorkflowMeta } from './serialize-workflow-meta.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 import { join } from 'path';
 export const pikkuWorkflow = pikkuSessionlessFunc({
-    func: async ({ logger, config, getInspectorState }) => {
-        const visitState = await getInspectorState();
+    func: async ({ logger, config, getInspectorState }, input) => {
+        const bootstrap = input?.bootstrap === true;
+        const visitState = bootstrap
+            ? await getInspectorState(false, true, false)
+            : await getInspectorState();
         const { workflowsWiringFile, workflowsWiringMetaFile, workflowMetaDir, workflowMapDeclarationFile, workflowTypesFile, functionTypesFile, packageMappings, schema, } = config;
         const { workflows, functions: functionState } = visitState;
         const { typesMap } = functionState;
@@ -24,7 +28,15 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
         const hasRelevantWorkflows = allWorkflowNames.length > 0;
         const hasWorkflows = hasRelevantWorkflows;
         if (hasWorkflows) {
-            const hasWorkflowState = visitState.serviceAggregation.allSingletonServices.includes('workflowService');
+            const singletonServices = visitState.serviceAggregation.allSingletonServices.length > 0
+                ? visitState.serviceAggregation.allSingletonServices
+                : visitState.typesLookup?.get('SingletonServices')?.[0]
+                    ? visitState.typesLookup
+                        .get('SingletonServices')[0]
+                        .getProperties()
+                        .map((symbol) => symbol.getName())
+                    : [];
+            const hasWorkflowState = singletonServices.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');
@@ -50,7 +62,9 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
         const rpcMapImportPath = getFileImportRelativePath(workflowTypesFile, config.rpcInternalMapDeclarationFile, packageMappings);
         const workflowMapImportPath = getFileImportRelativePath(workflowTypesFile, workflowMapDeclarationFile, packageMappings);
         await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath, workflowMapImportPath));
-        await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(logger, workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta, workflows.graphMeta, visitState.rpc?.wireAddonDeclarations));
+        await writeFileInDir(logger, workflowMapDeclarationFile, bootstrap
+            ? serializeWorkflowBootstrapMap(workflows.meta, workflows.graphMeta)
+            : serializeWorkflowMap(logger, workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta, workflows.graphMeta, visitState.rpc?.wireAddonDeclarations));
         return hasWorkflows;
     },
     middleware: [

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

@@ -0,0 +1,3 @@
+import type { WorkflowsMeta } from '@pikku/core/workflow';
+import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph';
+export declare const serializeWorkflowBootstrapMap: (workflowsMeta: WorkflowsMeta, graphMeta: SerializedWorkflowGraphs) => string;

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

@@ -0,0 +1,40 @@
+export const serializeWorkflowBootstrapMap = (workflowsMeta, graphMeta) => {
+    const workflowEntries = Object.keys(workflowsMeta)
+        .sort()
+        .map((workflowName) => `  readonly '${workflowName}': WorkflowHandler<unknown, unknown>,`)
+        .join('\n');
+    const graphEntries = Object.entries(graphMeta)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([graphName, graph]) => {
+        const nodeEntries = Object.keys(graph.nodes)
+            .sort()
+            .map((nodeId) => `    readonly '${nodeId}': GraphNodeHandler<unknown>,`)
+            .join('\n');
+        return `  readonly '${graphName}': {\n${nodeEntries}\n  },`;
+    })
+        .join('\n');
+    return `/**
+ * Bootstrap-safe workflow type map.
+ * Full input/output types are populated by the later \`pikku all\` pass.
+ */
+
+interface WorkflowHandler<I, O> {
+  input: I;
+  output: O;
+}
+
+interface GraphNodeHandler<I> {
+  input: I;
+}
+
+export type WorkflowMap = {
+${workflowEntries}
+};
+
+export type GraphsMap = {
+${graphEntries}
+};
+
+export type FlattenedWorkflowMap = WorkflowMap
+`;
+};

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

@@ -23,8 +23,13 @@ export const workflowStarter = pikkuSessionlessFunc<
   { workflowName: string; data?: unknown },
   { runId: string }
 >({
+  tags: ['pikku'],
   auth: ${authFlag},
-  func: async (_services, { workflowName, data }, { rpc }) => {
+  // workflowService is destructured (even though we delegate via rpc) so the
+  // analyzer assigns workflow-state capability to this unit — without it,
+  // rpc.startWorkflow() runs against a container missing workflowService.
+  func: async ({ workflowService }, { workflowName, data }, { rpc }) => {
+    assertWorkflowService(workflowService)
     return await rpc.startWorkflow(workflowName as any, (data ?? {}) as any)
   },
 })
@@ -33,6 +38,7 @@ export const workflowRunner = pikkuSessionlessFunc<
   { workflowName: string; data?: unknown },
   unknown
 >({
+  tags: ['pikku'],
   auth: ${authFlag},
   func: async ({ workflowService }, { workflowName, data }, { rpc }) => {
     assertWorkflowService(workflowService)
@@ -44,6 +50,7 @@ export const workflowStatusChecker = pikkuSessionlessFunc<
   { workflowName: string; runId: string },
   WorkflowRunStatus
 >({
+  tags: ['pikku'],
   auth: ${authFlag},
   func: async ({ workflowService }, { runId }) => {
     assertWorkflowService(workflowService)
@@ -61,6 +68,7 @@ export const workflowStatusStream = pikkuSessionlessFunc<
   { workflowName: string; runId: string },
   unknown
 >({
+  tags: ['pikku'],
   auth: ${authFlag},
   func: async ({ workflowRunService }, { runId }, { channel }) => {
     assertWorkflowRunService(workflowRunService)
@@ -68,6 +76,7 @@ export const workflowStatusStream = pikkuSessionlessFunc<
 
     const terminalStatuses = new Set(['completed', 'failed', 'cancelled'])
     let lastHash = ''
+    let initSent = false
 
     const poll = async () => {
       const run = await workflowRunService.getRun(runId)
@@ -78,6 +87,26 @@ export const workflowStatusStream = pikkuSessionlessFunc<
 
       const steps = await workflowRunService.getRunSteps(runId)
 
+      if (!initSent && run.deterministic) {
+        const statusByStep = new Map(
+          steps.map((s: { stepName: string; status: string }) => [
+            s.stepName,
+            s.status,
+          ])
+        )
+        channel.send({
+          type: 'init',
+          deterministic: true,
+          steps: (run.plannedSteps ?? []).map(
+            (s: { stepName: string }) => ({
+              stepName: s.stepName,
+              status: statusByStep.get(s.stepName) ?? 'pending',
+            })
+          ),
+        })
+        initSent = true
+      }
+
       const hash = JSON.stringify({
         s: run.status,
         steps: steps.map((s: { stepName: string; status: string }) => [s.stepName, s.status]),
@@ -126,6 +155,7 @@ export const workflowStatusStreamFull = pikkuSessionlessFunc<
   { workflowName: string; runId: string },
   unknown
 >({
+  tags: ['pikku'],
   auth: ${authFlag},
   func: async ({ workflowRunService }, { runId }, { channel }) => {
     assertWorkflowRunService(workflowRunService)
@@ -133,6 +163,7 @@ export const workflowStatusStreamFull = pikkuSessionlessFunc<
 
     const terminalStatuses = new Set(['completed', 'failed', 'cancelled'])
     let lastHash = ''
+    let initSent = false
 
     const poll = async () => {
       const run = await workflowRunService.getRun(runId)
@@ -143,6 +174,26 @@ export const workflowStatusStreamFull = pikkuSessionlessFunc<
 
       const steps = await workflowRunService.getRunSteps(runId)
 
+      if (!initSent && run.deterministic) {
+        const statusByStep = new Map(
+          steps.map((s: { stepName: string; status: string }) => [
+            s.stepName,
+            s.status,
+          ])
+        )
+        channel.send({
+          type: 'init',
+          deterministic: true,
+          steps: (run.plannedSteps ?? []).map(
+            (s: { stepName: string }) => ({
+              stepName: s.stepName,
+              status: statusByStep.get(s.stepName) ?? 'pending',
+            })
+          ),
+        })
+        initSent = true
+      }
+
       const hash = JSON.stringify({
         s: run.status,
         o: run.output,
@@ -192,7 +243,10 @@ export const graphStarter = pikkuSessionlessFunc<
   { runId: string }
 >({
   auth: ${authFlag},
-  func: async (_services, { workflowName, nodeId, data }, { rpc }) => {
+  // See workflowStarter — destructure workflowService so the analyzer
+  // assigns workflow-state capability to this unit.
+  func: async ({ workflowService }, { workflowName, nodeId, data }, { rpc }) => {
+    assertWorkflowService(workflowService)
     return await rpc.startWorkflow(workflowName as any, (data ?? {}) as any, { startNode: nodeId })
   },
 })

package/dist/src/functions/workflows/all.workflow.js

@@ -14,6 +14,11 @@ const scaffoldFiles = (config) => {
             file: config.publicAgentFile,
             generator: 'pikkuPublicAgent',
         });
+    if (config.scaffold?.events && config.eventsChannelFile)
+        files.push({
+            file: config.eventsChannelFile,
+            generator: 'pikkuEventsScaffold',
+        });
     return files;
 };
 export const allWorkflow = pikkuWorkflowComplexFunc({
@@ -23,20 +28,30 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         let typesDeclarationFileExists = true;
         if (!existsSync(config.outDir)) {
             logger.debug(`• .pikku directory not found, running bootstrap first...`);
-            await workflow.do('Bootstrap inspect', async () => getInspectorState(false, false, true));
+            await workflow.do('Bootstrap inspect', async () => getInspectorState(false, true, true));
+            await workflow.do('Bootstrap function types split', 'pikkuFunctionTypesSplit', null);
             await workflow.do('Bootstrap function types', 'pikkuFunctionTypes', null);
+            await workflow.do('Bootstrap addon types', 'pikkuAddonTypes', {
+                bootstrap: true,
+            });
             await Promise.all([
-                workflow.do('Bootstrap function types split', 'pikkuFunctionTypesSplit', null),
                 workflow.do('Bootstrap HTTP types', 'pikkuHTTPTypes', null),
                 workflow.do('Bootstrap channel types', 'pikkuChannelTypes', null),
                 workflow.do('Bootstrap scheduler types', 'pikkuSchedulerTypes', null),
                 workflow.do('Bootstrap queue types', 'pikkuQueueTypes', null),
-                workflow.do('Bootstrap workflow', 'pikkuWorkflow', null),
+                workflow.do('Bootstrap workflow', 'pikkuWorkflow', {
+                    bootstrap: true,
+                }),
+                workflow.do('Bootstrap Trigger types', 'pikkuTriggerTypes', null),
                 workflow.do('Bootstrap MCP types', 'pikkuMCPTypes', null),
                 workflow.do('Bootstrap AI agent types', 'pikkuAIAgentTypes', null),
-                workflow.do('Bootstrap CLI types', 'pikkuCLITypes', null),
             ]);
-            await workflow.do('Bootstrap re-inspect', async () => getInspectorState(true));
+            await workflow.do('Bootstrap Node types', 'pikkuNodeTypes', null);
+            await workflow.do('Bootstrap Secret definition types', 'pikkuSecretDefinitionTypes', null);
+            await workflow.do('Bootstrap CLI types', 'pikkuCLITypes', {
+                bootstrap: true,
+            });
+            await workflow.do('Bootstrap re-inspect', async () => getInspectorState(true, true));
         }
         if (!existsSync(config.typesDeclarationFile)) {
             typesDeclarationFileExists = false;
@@ -59,9 +74,13 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
             workflow.do('AI agent types', 'pikkuAIAgentTypes', null),
         ];
         if (!config.addon) {
-            typeGenerators.push(workflow.do('HTTP types', 'pikkuHTTPTypes', null), workflow.do('Channel types', 'pikkuChannelTypes', null), workflow.do('Scheduler types', 'pikkuSchedulerTypes', null), workflow.do('Queue types', 'pikkuQueueTypes', null), workflow.do('MCP types', 'pikkuMCPTypes', null), workflow.do('CLI types', 'pikkuCLITypes', null));
+            typeGenerators.push(workflow.do('HTTP types', 'pikkuHTTPTypes', null), workflow.do('Channel types', 'pikkuChannelTypes', null), workflow.do('Scheduler types', 'pikkuSchedulerTypes', null), workflow.do('Queue types', 'pikkuQueueTypes', null), workflow.do('MCP types', 'pikkuMCPTypes', null));
         }
         await Promise.all(typeGenerators);
+        await workflow.do('Node types', 'pikkuNodeTypes', null);
+        if (!config.addon) {
+            await workflow.do('CLI types', 'pikkuCLITypes', null);
+        }
         const [middleware, permissions] = await Promise.all([
             workflow.do('Middleware', 'pikkuMiddleware', null),
             workflow.do('Permissions', 'pikkuPermissions', null),
@@ -91,7 +110,7 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         await Promise.all([
             workflow.do('Public RPC', 'pikkuPublicRPC', null),
             workflow.do('Console functions', 'pikkuConsoleFunctions', null),
-            workflow.do('Node types', 'pikkuNodeTypes', null),
+            workflow.do('Events scaffold', 'pikkuEventsScaffold', null),
             workflow.do('Secret definition types', 'pikkuSecretDefinitionTypes', null),
             workflow.do('Secrets', 'pikkuSecrets', null),
             workflow.do('Credentials', 'pikkuCredentials', null),
@@ -128,7 +147,7 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         }
         if (!config.addon) {
             const [http, scheduler, triggers] = await Promise.all([
-                workflow.do('HTTP', 'pikkuHTTP', null),
+                workflow.do('HTTP', 'pikkuCommandHTTP', null),
                 workflow.do('Scheduler', 'pikkuScheduler', null),
                 workflow.do('Trigger', 'pikkuTrigger', null),
             ]);
@@ -138,6 +157,8 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
                     workflow.do('Fetch', 'pikkuFetch', null),
                     workflow.do('RPC client', 'pikkuRPCClient', null),
                     workflow.do('React query', 'pikkuReactQuery', null),
+                    workflow.do('TanStack Start', 'pikkuTanStackStart', null),
+                    workflow.do('Realtime client', 'pikkuRealtime', null),
                 ]);
                 allImports.push(config.httpWiringMetaFile, config.httpWiringsFile);
             }
@@ -158,15 +179,15 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         }
         if (!config.addon) {
             const [queues, channels, gateways, mcp, cli] = await Promise.all([
-                workflow.do('Queue', 'pikkuQueue', null),
-                workflow.do('Channels', 'pikkuChannels', null),
+                workflow.do('Queue', 'pikkuCommandQueue', null),
+                workflow.do('Channels', 'pikkuCommandChannels', null),
                 workflow.do('Gateway', 'pikkuGateway', null),
                 workflow.do('MCP', 'pikkuMCP', null),
                 workflow.do('CLI', 'pikkuCLI', null),
             ]);
             if (queues) {
                 await Promise.all([
-                    workflow.do('Queue map', 'pikkuQueueMap', null),
+                    workflow.do('Queue map', 'pikkuCommandQueueMap', null),
                     workflow.do('Queue service', 'pikkuQueueService', null),
                 ]);
                 allImports.push(config.queueWorkersWiringMetaFile, config.queueWorkersWiringFile);
@@ -186,8 +207,20 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
                 allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile);
             }
             if (cli) {
-                await workflow.do('CLI entry', 'pikkuCLIEntry', null);
+                const cliChannelGenerated = await workflow.do('CLI entry', 'pikkuCLIEntry', null);
                 allImports.push(config.cliWiringMetaFile, config.cliWiringsFile);
+                if (cliChannelGenerated) {
+                    await workflow.do('Re-inspect after CLI channel', async () => getInspectorState(true));
+                    const cliChannels = await workflow.do('Channels after CLI', 'pikkuCommandChannels', null);
+                    await workflow.do('Functions after CLI', 'pikkuFunctions', null);
+                    await workflow.do('Schemas after CLI', 'pikkuSchemas', null);
+                    if (cliChannels) {
+                        await workflow.do('Channels map after CLI', 'pikkuChannelsMap', null);
+                        if (!channels) {
+                            allImports.push(config.channelsWiringMetaFile, config.channelsWiringFile);
+                        }
+                    }
+                }
             }
         }
         await workflow.do('Nodes meta', 'pikkuNodesMeta', null);

package/dist/src/scaffold/rpc-remote.gen.d.ts

@@ -1,10 +1,10 @@
 export declare const remoteRPCHandler: import("../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
     rpcName: string;
     data?: unknown;
-}, unknown, "session" | "rpc", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+}, unknown, "rpc" | "session", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
     rpcName: string;
     data?: unknown;
-}, unknown, "session" | "rpc", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
+}, unknown, "rpc" | "session", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
     rpcName: string;
     data?: unknown;
-}, unknown, "session" | "rpc", import("../../types/application-types.js").Services>, undefined, undefined>;
+}, unknown, "rpc" | "session", import("../../types/application-types.js").Services>, undefined, undefined>;

package/dist/src/scaffold/rpc-remote.gen.js

@@ -1,18 +1,23 @@
 /**
- * This file was generated by @pikku/cli@0.12.20
+ * This file was generated by @pikku/cli@0.12.22
  */
 /**
  * Auto-generated remote internal RPC queue worker and HTTP endpoint
  * Do not edit manually - regenerate with 'npx pikku'
  */
-import { pikkuSessionlessFunc, wireHTTP } from '../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc, wireHTTP, wireQueueWorker } from '../../.pikku/pikku-types.gen.js';
 import { pikkuRemoteAuthMiddleware } from '@pikku/core/middleware';
 export const remoteRPCHandler = pikkuSessionlessFunc({
+    tags: ['pikku'],
     func: async (_services, { rpcName, data }, { rpc }) => {
         return await rpc.invoke(rpcName, data);
     },
     remote: true,
 });
+wireQueueWorker({
+    name: 'pikku-remote-internal-rpc',
+    func: remoteRPCHandler,
+});
 wireHTTP({
     route: '/remote/rpc/:rpcName',
     method: 'post',

package/dist/src/scaffold/workflow-routes.gen.d.ts

@@ -4,37 +4,37 @@ export declare const workflowStarter: import("../../.pikku/pikku-types.gen.js").
     data?: unknown;
 }, {
     runId: string;
-}, "session" | "rpc", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+}, "rpc" | "session", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
     workflowName: string;
     data?: unknown;
 }, {
     runId: string;
-}, "session" | "rpc", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
+}, "rpc" | "session", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
     workflowName: string;
     data?: unknown;
 }, {
     runId: string;
-}, "session" | "rpc", import("../../types/application-types.js").Services>, undefined, undefined>;
+}, "rpc" | "session", import("../../types/application-types.js").Services>, undefined, undefined>;
 export declare const workflowRunner: import("../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
     workflowName: string;
     data?: unknown;
-}, unknown, "session" | "rpc", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+}, unknown, "rpc" | "session", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
     workflowName: string;
     data?: unknown;
-}, unknown, "session" | "rpc", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
+}, unknown, "rpc" | "session", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
     workflowName: string;
     data?: unknown;
-}, unknown, "session" | "rpc", import("../../types/application-types.js").Services>, undefined, undefined>;
+}, unknown, "rpc" | "session", import("../../types/application-types.js").Services>, undefined, undefined>;
 export declare const workflowStatusChecker: import("../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
     workflowName: string;
     runId: string;
-}, WorkflowRunStatus, "session" | "rpc", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+}, WorkflowRunStatus, "rpc" | "session", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
     workflowName: string;
     runId: string;
-}, WorkflowRunStatus, "session" | "rpc", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
+}, WorkflowRunStatus, "rpc" | "session", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
     workflowName: string;
     runId: string;
-}, WorkflowRunStatus, "session" | "rpc", import("../../types/application-types.js").Services>, undefined, undefined>;
+}, WorkflowRunStatus, "rpc" | "session", import("../../types/application-types.js").Services>, undefined, undefined>;
 /**
  * Minimal workflow status stream — sends step names and statuses only.
  * Use this for user-facing frontends where internal details should not be exposed.
@@ -42,13 +42,13 @@ export declare const workflowStatusChecker: import("../../.pikku/pikku-types.gen
 export declare const workflowStatusStream: import("../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
     workflowName: string;
     runId: string;
-}, unknown, "session" | "rpc", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+}, unknown, "rpc" | "session", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
     workflowName: string;
     runId: string;
-}, unknown, "session" | "rpc", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
+}, unknown, "rpc" | "session", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
     workflowName: string;
     runId: string;
-}, unknown, "session" | "rpc", import("../../types/application-types.js").Services>, undefined, undefined>;
+}, unknown, "rpc" | "session", import("../../types/application-types.js").Services>, undefined, undefined>;
 /**
  * Full workflow status stream — includes output, error, and child run IDs.
  * Use this for admin consoles and internal tooling.
@@ -56,29 +56,29 @@ export declare const workflowStatusStream: import("../../.pikku/pikku-types.gen.
 export declare const workflowStatusStreamFull: import("../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
     workflowName: string;
     runId: string;
-}, unknown, "session" | "rpc", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+}, unknown, "rpc" | "session", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
     workflowName: string;
     runId: string;
-}, unknown, "session" | "rpc", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
+}, unknown, "rpc" | "session", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
     workflowName: string;
     runId: string;
-}, unknown, "session" | "rpc", import("../../types/application-types.js").Services>, undefined, undefined>;
+}, unknown, "rpc" | "session", import("../../types/application-types.js").Services>, undefined, undefined>;
 export declare const graphStarter: import("../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
     workflowName: string;
     nodeId: string;
     data?: unknown;
 }, {
     runId: string;
-}, "session" | "rpc", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+}, "rpc" | "session", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
     workflowName: string;
     nodeId: string;
     data?: unknown;
 }, {
     runId: string;
-}, "session" | "rpc", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
+}, "rpc" | "session", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
     workflowName: string;
     nodeId: string;
     data?: unknown;
 }, {
     runId: string;
-}, "session" | "rpc", import("../../types/application-types.js").Services>, undefined, undefined>;
+}, "rpc" | "session", import("../../types/application-types.js").Services>, undefined, undefined>;

package/dist/src/scaffold/workflow-routes.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.20
+ * This file was generated by @pikku/cli@0.12.21
  */
 /**
  * Workflow HTTP catch-all routes
@@ -50,6 +50,7 @@ export const workflowStatusStream = pikkuSessionlessFunc({
             return;
         const terminalStatuses = new Set(['completed', 'failed', 'cancelled']);
         let lastHash = '';
+        let initSent = false;
         const poll = async () => {
             const run = await workflowRunService.getRun(runId);
             if (!run) {
@@ -57,6 +58,21 @@ export const workflowStatusStream = pikkuSessionlessFunc({
                 return false;
             }
             const steps = await workflowRunService.getRunSteps(runId);
+            if (!initSent && run.deterministic) {
+                const statusByStep = new Map(steps.map((s) => [
+                    s.stepName,
+                    s.status,
+                ]));
+                channel.send({
+                    type: 'init',
+                    deterministic: true,
+                    steps: (run.plannedSteps ?? []).map((s) => ({
+                        stepName: s.stepName,
+                        status: statusByStep.get(s.stepName) ?? 'pending',
+                    })),
+                });
+                initSent = true;
+            }
             const hash = JSON.stringify({
                 s: run.status,
                 steps: steps.map((s) => [s.stepName, s.status]),
@@ -105,6 +121,7 @@ export const workflowStatusStreamFull = pikkuSessionlessFunc({
             return;
         const terminalStatuses = new Set(['completed', 'failed', 'cancelled']);
         let lastHash = '';
+        let initSent = false;
         const poll = async () => {
             const run = await workflowRunService.getRun(runId);
             if (!run) {
@@ -112,6 +129,21 @@ export const workflowStatusStreamFull = pikkuSessionlessFunc({
                 return false;
             }
             const steps = await workflowRunService.getRunSteps(runId);
+            if (!initSent && run.deterministic) {
+                const statusByStep = new Map(steps.map((s) => [
+                    s.stepName,
+                    s.status,
+                ]));
+                channel.send({
+                    type: 'init',
+                    deterministic: true,
+                    steps: (run.plannedSteps ?? []).map((s) => ({
+                        stepName: s.stepName,
+                        status: statusByStep.get(s.stepName) ?? 'pending',
+                    })),
+                });
+                initSent = true;
+            }
             const hash = JSON.stringify({
                 s: run.status,
                 o: run.output,

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

@@ -1,29 +1,48 @@
 import type { Logger } from '@pikku/core/services';
 import { LogLevel } from '@pikku/core/services';
 import type { ErrorCode } from '@pikku/inspector';
+export type CLIOutputMode = 'text' | 'json';
 export declare class CLILogger implements Logger {
     private silent;
     private level;
     private criticalErrors;
+    private outputMode;
+    private jsonFlushHookRegistered;
     constructor({ logLogo, silent, }: {
         logLogo: boolean;
         silent?: boolean;
     });
     setLevel(level: LogLevel): void;
     setSilent(silent: boolean): void;
+    setOutputMode(mode: CLIOutputMode): void;
+    getOutputMode(): CLIOutputMode;
     isSilent(): boolean;
+    private normalizeMessage;
+    private writeJSONLine;
+    private ensureJSONFlushHook;
+    flushJSONBuffer(): void;
+    private emit;
     info(message: string | {
         message: string;
         type?: string;
+        data?: Record<string, unknown>;
+    }): void;
+    error(message: string | Error | {
+        message: string;
+        type?: string;
+        data?: Record<string, unknown>;
+    }): void;
+    warn(message: string | {
+        message: string;
+        type?: string;
+        data?: Record<string, unknown>;
     }): void;
-    error(message: string): void;
-    warn(message: string): void;
     debug(message: string | {
         message: string;
         type?: string;
+        data?: Record<string, unknown>;
     }): void;
     critical(code: ErrorCode, message: string): void;
     hasCriticalErrors(): boolean;
     logLogo(): void;
-    private primary;
 }