@pikku/cli 0.12.17 → 0.12.20

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

@@ -0,0 +1,187 @@
+import { createServer } from 'http';
+import { join, resolve } from 'path';
+import { Readable } from 'stream';
+import { pikkuSessionlessFunc } from '#pikku';
+import chokidar from 'chokidar';
+import { pikkuDevReloader } from '@pikku/core/dev';
+import { ConsoleLogger, InMemoryQueueService, InMemoryWorkflowService, InMemoryTriggerService, InMemoryAIRunStateService, } from '@pikku/core/services';
+import { stopSingletonServices } from '@pikku/core';
+import { pikkuState } from '@pikku/core/internal';
+import { fetchData, PikkuFetchHTTPResponse, logRoutes, } from '@pikku/core/http';
+import { compileAllSchemas } from '@pikku/core/schema';
+import { pikkuWebsocketHandler } from '@pikku/ws';
+import { WebSocketServer } from 'ws';
+import { InMemorySchedulerService } from '@pikku/schedule';
+function incomingMessageToRequest(req) {
+    const url = new URL(req.url || '/', 'http://localhost');
+    const method = req.method ? req.method.toUpperCase() : 'GET';
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (value) {
+            headers.set(key, Array.isArray(value) ? value.join(', ') : value);
+        }
+    }
+    let body = null;
+    if (method !== 'GET' && method !== 'HEAD') {
+        body = Readable.toWeb(req);
+    }
+    return new Request(url.toString(), {
+        method,
+        headers,
+        body,
+        // @ts-ignore - duplex is needed for streaming body in Node.js
+        duplex: 'half',
+    });
+}
+async function writeResponse(nodeRes, webResponse) {
+    const headers = {};
+    webResponse.headers.forEach((value, name) => {
+        const lower = name.toLowerCase();
+        if (lower === 'set-cookie') {
+            const existing = headers[lower];
+            if (Array.isArray(existing)) {
+                existing.push(value);
+            }
+            else {
+                headers[lower] = [value];
+            }
+        }
+        else {
+            headers[lower] = value;
+        }
+    });
+    nodeRes.writeHead(webResponse.status, headers);
+    if (webResponse.body) {
+        const reader = webResponse.body.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                nodeRes.write(value);
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    nodeRes.end();
+}
+export const dev = pikkuSessionlessFunc({
+    remote: true,
+    func: async ({ logger, config, getInspectorState }, { port, watch, hmr }, { rpc }) => {
+        const resolvedPort = parseInt(port || '3000', 10);
+        const hostname = 'localhost';
+        const enableWatch = watch !== false;
+        const enableHmr = hmr !== false;
+        await rpc.invoke('all');
+        const inspectorState = await getInspectorState(true);
+        const { pikkuConfigFactory, singletonServicesFactory } = inspectorState.filesAndMethods;
+        if (!pikkuConfigFactory || !singletonServicesFactory) {
+            logger.error('createConfig and createSingletonServices must be defined in your project');
+            return;
+        }
+        const pikkuDir = resolve(config.rootDir, config.outDir);
+        const bootstrapPath = join(pikkuDir, 'pikku-bootstrap.gen.js');
+        await import(bootstrapPath);
+        const configModule = await import(pikkuConfigFactory.file);
+        const servicesModule = await import(singletonServicesFactory.file);
+        const userCreateConfig = configModule[pikkuConfigFactory.variable];
+        const userCreateSingletonServices = servicesModule[singletonServicesFactory.variable];
+        const userConfig = await userCreateConfig();
+        const schedulerService = new InMemorySchedulerService();
+        const inMemoryServices = {
+            logger: new ConsoleLogger(),
+            schedulerService,
+            queueService: new InMemoryQueueService(),
+            workflowService: new InMemoryWorkflowService(),
+            triggerService: new InMemoryTriggerService(),
+            aiRunStateService: new InMemoryAIRunStateService(),
+        };
+        const singletonServices = await userCreateSingletonServices(userConfig, inMemoryServices);
+        pikkuState(null, 'package', 'singletonServices', singletonServices);
+        compileAllSchemas(logger);
+        logRoutes(logger);
+        const server = createServer(async (req, res) => {
+            const request = incomingMessageToRequest(req);
+            const pikkuResponse = new PikkuFetchHTTPResponse();
+            await fetchData(request, pikkuResponse, { respondWith404: true });
+            const response = pikkuResponse.toResponse();
+            await writeResponse(res, response);
+        });
+        const wss = new WebSocketServer({ noServer: true });
+        pikkuWebsocketHandler({ server, wss, logger });
+        await schedulerService.start();
+        await new Promise((resolve) => {
+            server.listen(resolvedPort, hostname, () => {
+                logger.info(`Dev server running at http://${hostname}:${resolvedPort}`);
+                resolve();
+            });
+        });
+        let configWatcher;
+        let watcher;
+        process.once('SIGINT', async () => {
+            logger.info('Stopping dev server...');
+            try {
+                await stopSingletonServices();
+                await configWatcher?.close();
+                await watcher?.close();
+                await new Promise((resolve, reject) => wss.close((err) => (err ? reject(err) : resolve())));
+                await new Promise((resolve, reject) => server.close((err) => (err ? reject(err) : resolve())));
+            }
+            finally {
+                process.exit(0);
+            }
+        });
+        if (enableHmr) {
+            await pikkuDevReloader({
+                srcDirectories: config.srcDirectories,
+                logger,
+            });
+        }
+        if (enableWatch) {
+            const genIgnore = /\.gen\.tsx?$/;
+            configWatcher = chokidar.watch(config.srcDirectories, {
+                ignoreInitial: true,
+                ignored: genIgnore,
+            });
+            const generatorWatcher = () => {
+                watcher?.close();
+                logger.info(`• Watching directories: \n  - ${config.srcDirectories.join('\n  - ')}`);
+                watcher = chokidar.watch(config.srcDirectories, {
+                    ignoreInitial: true,
+                    ignored: genIgnore,
+                });
+                watcher.on('ready', async () => {
+                    const handle = async () => {
+                        try {
+                            const start = Date.now();
+                            await rpc.invoke('all');
+                            logger.info({
+                                message: `✓ Generated in ${Date.now() - start}ms`,
+                                type: 'timing',
+                            });
+                        }
+                        catch (err) {
+                            logger.error(`Error running watch: ${err}`);
+                        }
+                    };
+                    await handle();
+                    let timeout;
+                    const deduped = (_file) => {
+                        if (timeout) {
+                            clearTimeout(timeout);
+                        }
+                        timeout = setTimeout(handle, 10);
+                    };
+                    watcher?.on('change', deduped);
+                    watcher?.on('add', deduped);
+                    watcher?.on('unlink', deduped);
+                });
+            };
+            configWatcher.on('ready', generatorWatcher);
+            configWatcher.on('change', generatorWatcher);
+        }
+        await new Promise(() => { });
+    },
+});

package/dist/src/functions/commands/versions-update.js

@@ -7,12 +7,16 @@ export const pikkuVersionsUpdate = pikkuSessionlessFunc({
         const manifestPath = join(config.rootDir, 'versions.pikku.json');
         const visitState = await getInspectorState();
         if (!visitState.manifest.initial) {
-            throw new Error(`Version manifest not found at ${manifestPath}. Run 'pikku versions init' to create one.`);
+            logger.warn(`Run 'pikku versions init' to enable contract versioning.`);
+            return;
         }
         const immutabilityErrors = visitState.manifest.errors.filter((e) => e.code === ErrorCode.FUNCTION_VERSION_MODIFIED);
         if (immutabilityErrors.length > 0) {
-            const messages = immutabilityErrors.map((e) => `[${e.code}] ${e.message}`);
-            throw new Error(messages.join('\n'));
+            for (const e of immutabilityErrors) {
+                logger.warn(`[${e.code}] ${e.message}`);
+            }
+            logger.warn(`Contract drift detected — version manifest not updated. Run 'pikku versions check' to inspect, or bump versions via code and re-run.`);
+            return;
         }
         await saveManifest(manifestPath, visitState.manifest.current);
         logger.debug(`Version manifest updated at ${manifestPath}`);

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

@@ -26,7 +26,7 @@ export const watch = pikkuSessionlessFunc({
                 const handle = async () => {
                     try {
                         const start = Date.now();
-                        await rpc.invoke('all', null);
+                        await rpc.invoke('all');
                         logger.info({
                             message: `✓ Generated in ${Date.now() - start}ms`,
                             type: 'timing',

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

@@ -0,0 +1 @@
+export declare const pikkuReactQuery: 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/wirings/rpc/pikku-command-react-query.js

@@ -0,0 +1,33 @@
+import { pikkuSessionlessFunc } from '#pikku';
+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 { serializeReactQueryHooks } from './serialize-react-query-hooks.js';
+export const pikkuReactQuery = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const reactQueryFile = config.clientFiles?.reactQueryFile;
+        const { rpcMapDeclarationFile, workflowMapDeclarationFile, packageMappings, } = config;
+        if (!reactQueryFile) {
+            logger.debug({
+                message: "Skipping generating React Query hooks since reactQueryFile isn't set in the pikku config.",
+                type: 'skip',
+            });
+            return;
+        }
+        const { workflows } = await getInspectorState();
+        const hasWorkflows = Object.keys(workflows?.meta ?? {}).length > 0;
+        const rpcMapPath = getFileImportRelativePath(reactQueryFile, rpcMapDeclarationFile, packageMappings);
+        let workflowMapPath;
+        if (hasWorkflows) {
+            workflowMapPath = getFileImportRelativePath(reactQueryFile, workflowMapDeclarationFile, packageMappings);
+        }
+        const content = serializeReactQueryHooks(rpcMapPath, workflowMapPath);
+        await writeFileInDir(logger, reactQueryFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating React Query hooks',
+            commandEnd: 'Generated React Query hooks',
+        }),
+    ],
+});

package/dist/src/functions/wirings/rpc/serialize-react-query-hooks.d.ts

@@ -0,0 +1 @@
+export declare const serializeReactQueryHooks: (rpcMapPath: string, workflowMapPath?: string) => string;

package/dist/src/functions/wirings/rpc/serialize-react-query-hooks.js

@@ -0,0 +1,108 @@
+export const serializeReactQueryHooks = (rpcMapPath, workflowMapPath) => {
+    const workflowImport = workflowMapPath
+        ? `\nimport type { FlattenedWorkflowMap } from '${workflowMapPath}'`
+        : '';
+    const workflowHooks = workflowMapPath
+        ? `
+export const useRunWorkflow = <Name extends keyof FlattenedWorkflowMap>(
+  name: Name,
+  options?: Omit<UseMutationOptions<FlattenedWorkflowMap[Name]['output'], Error, FlattenedWorkflowMap[Name]['input']>, 'mutationFn'>
+) => {
+  const rpc = usePikkuRPC<{ runWorkflow: <N extends keyof FlattenedWorkflowMap>(name: N, input: FlattenedWorkflowMap[N]['input']) => Promise<FlattenedWorkflowMap[N]['output']> }>()
+  return useMutation<FlattenedWorkflowMap[Name]['output'], Error, FlattenedWorkflowMap[Name]['input']>({
+    mutationFn: (input) => rpc.runWorkflow(name, input),
+    ...options,
+  })
+}
+
+export const useStartWorkflow = <Name extends keyof FlattenedWorkflowMap>(
+  name: Name,
+  options?: Omit<UseMutationOptions<{ runId: string }, Error, FlattenedWorkflowMap[Name]['input']>, 'mutationFn'>
+) => {
+  const rpc = usePikkuRPC<{ startWorkflow: <N extends keyof FlattenedWorkflowMap>(name: N, input: FlattenedWorkflowMap[N]['input']) => Promise<{ runId: string }> }>()
+  return useMutation<{ runId: string }, Error, FlattenedWorkflowMap[Name]['input']>({
+    mutationFn: (input) => rpc.startWorkflow(name, input),
+    ...options,
+  })
+}
+
+type WorkflowRunStatus = {
+  id: string
+  status: 'running' | 'suspended' | 'completed' | 'failed' | 'cancelled'
+  output?: unknown
+  error?: { message?: string }
+}
+
+export const useWorkflowStatus = (
+  workflowName: keyof FlattenedWorkflowMap & string,
+  runId?: string,
+  options?: Omit<UseQueryOptions<WorkflowRunStatus, Error>, 'queryKey' | 'queryFn' | 'enabled'>
+) => {
+  const rpc = usePikkuRPC<{ workflowStatus: (name: string, runId: string) => Promise<WorkflowRunStatus> }>()
+  return useQuery<WorkflowRunStatus, Error>({
+    queryKey: ['workflowStatus', workflowName, runId],
+    queryFn: () => {
+      if (!runId) throw new Error('runId is required')
+      return rpc.workflowStatus(workflowName, runId)
+    },
+    enabled: !!runId,
+    ...options,
+  })
+}
+`
+        : '';
+    return `import { useQuery, useInfiniteQuery, useMutation, type UseQueryOptions, type UseInfiniteQueryOptions, type UseMutationOptions, type InfiniteData } from '@tanstack/react-query'
+import { usePikkuRPC } from '@pikku/react'
+import type { FlattenedRPCMap } from '${rpcMapPath}'${workflowImport}
+
+type RPCInvoke = <Name extends keyof FlattenedRPCMap>(name: Name, data: FlattenedRPCMap[Name]['input']) => Promise<FlattenedRPCMap[Name]['output']>
+
+export const usePikkuQuery = <Name extends keyof FlattenedRPCMap>(
+  name: Name,
+  data: FlattenedRPCMap[Name]['input'],
+  options?: Omit<UseQueryOptions<FlattenedRPCMap[Name]['output'], Error>, 'queryKey' | 'queryFn'>
+) => {
+  const rpc = usePikkuRPC<{ invoke: RPCInvoke }>()
+  return useQuery<FlattenedRPCMap[Name]['output'], Error>({
+    queryKey: [name, data],
+    queryFn: () => rpc.invoke(name, data),
+    ...options,
+  })
+}
+
+export const usePikkuMutation = <Name extends keyof FlattenedRPCMap>(
+  name: Name,
+  options?: Omit<UseMutationOptions<FlattenedRPCMap[Name]['output'], Error, FlattenedRPCMap[Name]['input']>, 'mutationFn'>
+) => {
+  const rpc = usePikkuRPC<{ invoke: RPCInvoke }>()
+  return useMutation<FlattenedRPCMap[Name]['output'], Error, FlattenedRPCMap[Name]['input']>({
+    mutationFn: (data) => rpc.invoke(name, data),
+    ...options,
+  })
+}
+
+type PaginatedKeys = {
+  [K in keyof FlattenedRPCMap]: FlattenedRPCMap[K]['output'] extends { nextCursor?: string | null } ? K : never
+}[keyof FlattenedRPCMap]
+
+type InfiniteOpts<Name extends PaginatedKeys> = Omit<
+  UseInfiniteQueryOptions<FlattenedRPCMap[Name]['output'], Error, InfiniteData<FlattenedRPCMap[Name]['output'], string | undefined>, readonly unknown[], string | undefined>,
+  'queryKey' | 'queryFn' | 'getNextPageParam' | 'initialPageParam'
+>
+
+export const usePikkuInfiniteQuery = <Name extends PaginatedKeys>(
+  name: Name,
+  data: Omit<FlattenedRPCMap[Name]['input'], 'nextCursor'>,
+  options?: InfiniteOpts<Name>
+) => {
+  const rpc = usePikkuRPC<{ invoke: RPCInvoke }>()
+  return useInfiniteQuery({
+    queryKey: [name, data] as const,
+    queryFn: ({ pageParam }: { pageParam: string | undefined }) => rpc.invoke(name, { ...data, nextCursor: pageParam } as FlattenedRPCMap[Name]['input']),
+    initialPageParam: undefined as string | undefined,
+    getNextPageParam: (lastPage: FlattenedRPCMap[Name]['output']) => (lastPage as { nextCursor?: string }).nextCursor ?? undefined,
+    ...options,
+  })
+}
+${workflowHooks}`;
+};

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

@@ -59,9 +59,9 @@ export class PikkuRPC {
      * @param data - The data to pass to the server function
      * @returns A promise that resolves with the function's return value
      */
-    invoke: RPCInvoke = async (rpcName, data) => {
-       return await this.pikkuFetch.post(\`${globalHTTPPrefix}/rpc/\${String(rpcName)}\` as never, { rpcName: String(rpcName), data }) as any
-    }
+    invoke = ((rpcName: string, data?: unknown) => {
+       return this.pikkuFetch.post(\`${globalHTTPPrefix}/rpc/\${String(rpcName)}\` as never, { rpcName: String(rpcName), data }) as any
+    }) as RPCInvoke
 
     /**
      * Starts a workflow by name with the given input.

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

@@ -41,13 +41,15 @@ ${addonImports}
 ${mergedRPCMap}
 
 export type RPCInvoke = <Name extends keyof FlattenedRPCMap>(
-  name: Name,
-  data: FlattenedRPCMap[Name]['input']
+  ...args: FlattenedRPCMap[Name]['input'] extends void | null
+    ? [name: Name]
+    : [name: Name, data: FlattenedRPCMap[Name]['input']]
 ) => Promise<FlattenedRPCMap[Name]['output']>
 
 export type RPCRemote = <Name extends keyof FlattenedRPCMap>(
-  name: Name,
-  data: FlattenedRPCMap[Name]['input']
+  ...args: FlattenedRPCMap[Name]['input'] extends void | null
+    ? [name: Name]
+    : [name: Name, data: FlattenedRPCMap[Name]['input']]
 ) => Promise<FlattenedRPCMap[Name]['output']>
 
 ${workflowMapPath ? `import type { FlattenedWorkflowMap } from '${workflowMapPath}'` : `type FlattenedWorkflowMap = {}`}

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

@@ -15,13 +15,17 @@ function assertWorkflowService(workflowService: unknown): asserts workflowServic
   if (!workflowService) throw new MissingServiceError('workflowService is required')
 }
 
+function assertWorkflowRunService(workflowRunService: unknown): asserts workflowRunService {
+  if (!workflowRunService) throw new MissingServiceError('workflowRunService is required')
+}
+
 export const workflowStarter = pikkuSessionlessFunc<
   { workflowName: string; data?: unknown },
   { runId: string }
 >({
   auth: ${authFlag},
   func: async (_services, { workflowName, data }, { rpc }) => {
-    return await rpc.startWorkflow(workflowName as any, data ?? {})
+    return await rpc.startWorkflow(workflowName as any, (data ?? {}) as any)
   },
 })
 
@@ -49,48 +53,137 @@ export const workflowStatusChecker = pikkuSessionlessFunc<
   },
 })
 
+/**
+ * Minimal workflow status stream — sends step names and statuses only.
+ * Use this for user-facing frontends where internal details should not be exposed.
+ */
 export const workflowStatusStream = pikkuSessionlessFunc<
   { workflowName: string; runId: string },
-  WorkflowRunStatus
+  unknown
 >({
   auth: ${authFlag},
-  func: async ({ workflowService }, { runId }, { channel }) => {
-    assertWorkflowService(workflowService)
+  func: async ({ workflowRunService }, { runId }, { channel }) => {
+    assertWorkflowRunService(workflowRunService)
+    if (!channel) return
+
     const terminalStatuses = new Set(['completed', 'failed', 'cancelled'])
-    const pollIntervalMs = 1000
-    const maxWaitMs = 300_000
+    let lastHash = ''
 
-    const startTime = Date.now()
-    let lastStatusJson = ''
+    const poll = async () => {
+      const run = await workflowRunService.getRun(runId)
+      if (!run) {
+        channel.close()
+        return false
+      }
 
-    while (Date.now() - startTime < maxWaitMs) {
-      const status = await workflowService.getRunStatus(runId)
-      if (!status) throw new Error(\`Run not found: \${runId}\`)
+      const steps = await workflowRunService.getRunSteps(runId)
 
-      const statusJson = JSON.stringify(status)
-      if (statusJson !== lastStatusJson) {
-        lastStatusJson = statusJson
-        if (channel) {
-          channel.send(status)
-        }
+      const hash = JSON.stringify({
+        s: run.status,
+        steps: steps.map((s: { stepName: string; status: string }) => [s.stepName, s.status]),
+      })
+
+      if (hash !== lastHash) {
+        lastHash = hash
+        channel.send({
+          type: 'update',
+          status: run.status,
+          steps: steps.map((s: { stepName: string; status: string }) => ({
+            stepName: s.stepName,
+            status: s.status,
+          })),
+        })
+      }
+
+      if (terminalStatuses.has(run.status)) {
+        channel.send({ type: 'done' })
+        channel.close()
+        return false
       }
+      return true
+    }
+
+    const shouldContinue = await poll()
+    if (!shouldContinue) return
 
-      if (terminalStatuses.has(status.status)) {
-        if (channel) {
-          channel.close()
+    await new Promise<void>((resolve) => {
+      const interval = setInterval(async () => {
+        const cont = await poll()
+        if (!cont) {
+          clearInterval(interval)
+          resolve()
         }
-        return status
+      }, 500)
+    })
+  },
+})
+
+/**
+ * Full workflow status stream — includes output, error, and child run IDs.
+ * Use this for admin consoles and internal tooling.
+ */
+export const workflowStatusStreamFull = pikkuSessionlessFunc<
+  { workflowName: string; runId: string },
+  unknown
+>({
+  auth: ${authFlag},
+  func: async ({ workflowRunService }, { runId }, { channel }) => {
+    assertWorkflowRunService(workflowRunService)
+    if (!channel) return
+
+    const terminalStatuses = new Set(['completed', 'failed', 'cancelled'])
+    let lastHash = ''
+
+    const poll = async () => {
+      const run = await workflowRunService.getRun(runId)
+      if (!run) {
+        channel.close()
+        return false
       }
 
-      await new Promise((r) => setTimeout(r, pollIntervalMs))
-    }
+      const steps = await workflowRunService.getRunSteps(runId)
+
+      const hash = JSON.stringify({
+        s: run.status,
+        o: run.output,
+        steps: steps.map((s: { stepName: string; status: string }) => [s.stepName, s.status]),
+      })
 
-    // Timeout — return last known status
-    const finalStatus = await workflowService.getRunStatus(runId)
-    if (channel) {
-      channel.close()
+      if (hash !== lastHash) {
+        lastHash = hash
+        channel.send({
+          type: 'update',
+          status: run.status,
+          output: run.output,
+          error: run.error,
+          steps: steps.map((s: { stepName: string; status: string; childRunId?: string }) => ({
+            stepName: s.stepName,
+            status: s.status,
+            ...(s.childRunId ? { childRunId: s.childRunId } : {}),
+          })),
+        })
+      }
+
+      if (terminalStatuses.has(run.status)) {
+        channel.send({ type: 'done' })
+        channel.close()
+        return false
+      }
+      return true
     }
-    return finalStatus as WorkflowRunStatus
+
+    const shouldContinue = await poll()
+    if (!shouldContinue) return
+
+    await new Promise<void>((resolve) => {
+      const interval = setInterval(async () => {
+        const cont = await poll()
+        if (!cont) {
+          clearInterval(interval)
+          resolve()
+        }
+      }, 500)
+    })
   },
 })
 
@@ -100,7 +193,7 @@ export const graphStarter = pikkuSessionlessFunc<
 >({
   auth: ${authFlag},
   func: async (_services, { workflowName, nodeId, data }, { rpc }) => {
-    return await rpc.startWorkflow(workflowName as any, data ?? {}, { startNode: nodeId })
+    return await rpc.startWorkflow(workflowName as any, (data ?? {}) as any, { startNode: nodeId })
   },
 })
 
@@ -128,6 +221,12 @@ wireHTTPRoutes({
       sse: true,
       func: workflowStatusStream,
     },
+    workflowStatusStreamFull: {
+      route: '/workflow/:workflowName/status/:runId/stream/full',
+      method: 'get',
+      sse: true,
+      func: workflowStatusStreamFull,
+    },
     graphStart: {
       route: '/workflow/:workflowName/graph/:nodeId',
       method: 'post',

package/dist/src/functions/workflows/all.workflow.d.ts

@@ -0,0 +1 @@
+export declare const allWorkflow: import("../../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<void, void, "workflow">;