@pikku/cli 0.12.16 → 0.12.19

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

@@ -1,191 +1,7 @@
-import { existsSync } from 'fs';
 import { pikkuVoidFunc } from '#pikku';
-const scaffoldFiles = (config) => {
-    const files = [];
-    if (config.scaffold?.rpc && config.publicRpcFile)
-        files.push({ file: config.publicRpcFile, generator: 'pikkuPublicRPC' });
-    if (config.scaffold?.console && config.consoleFunctionsFile)
-        files.push({
-            file: config.consoleFunctionsFile,
-            generator: 'pikkuConsoleFunctions',
-        });
-    if (config.scaffold?.agent && config.publicAgentFile)
-        files.push({
-            file: config.publicAgentFile,
-            generator: 'pikkuPublicAgent',
-        });
-    return files;
-};
 export const all = pikkuVoidFunc({
     remote: true,
-    func: async ({ logger, config, getInspectorState }, _data, { rpc }) => {
-        const allImports = [];
-        let typesDeclarationFileExists = true;
-        if (!existsSync(config.outDir)) {
-            logger.debug(`• .pikku directory not found, running bootstrap first...`);
-            await getInspectorState(false, false, true);
-            await rpc.invoke('pikkuFunctionTypes', null);
-            await rpc.invoke('pikkuFunctionTypesSplit', null);
-            await rpc.invoke('pikkuHTTPTypes', null);
-            await rpc.invoke('pikkuChannelTypes', null);
-            await rpc.invoke('pikkuSchedulerTypes', null);
-            await rpc.invoke('pikkuQueueTypes', null);
-            await rpc.invoke('pikkuWorkflow', null);
-            await rpc.invoke('pikkuMCPTypes', null);
-            await rpc.invoke('pikkuAIAgentTypes', null);
-            await rpc.invoke('pikkuCLITypes', null);
-            await getInspectorState(true);
-        }
-        if (!existsSync(config.typesDeclarationFile)) {
-            typesDeclarationFileExists = false;
-        }
-        const missingScaffolds = scaffoldFiles(config).filter((s) => !existsSync(s.file));
-        if (missingScaffolds.length > 0) {
-            for (const { generator } of missingScaffolds) {
-                await rpc.invoke(generator, null);
-            }
-        }
-        await rpc.invoke('pikkuFunctionTypes', null);
-        if (!typesDeclarationFileExists || missingScaffolds.length > 0) {
-            logger.debug(`• Type file or scaffolds first created, inspecting again...`);
-            await getInspectorState(true);
-        }
-        await rpc.invoke('pikkuFunctionTypesSplit', null);
-        await rpc.invoke('pikkuTriggerTypes', null);
-        await rpc.invoke('pikkuAIAgentTypes', null);
-        if (!config.addon) {
-            await rpc.invoke('pikkuHTTPTypes', null);
-            await rpc.invoke('pikkuChannelTypes', null);
-            await rpc.invoke('pikkuSchedulerTypes', null);
-            await rpc.invoke('pikkuQueueTypes', null);
-            await rpc.invoke('pikkuMCPTypes', null);
-            await rpc.invoke('pikkuCLITypes', null);
-        }
-        const middleware = await rpc.invoke('pikkuMiddleware', null);
-        if (middleware) {
-            allImports.push(config.middlewareFile);
-        }
-        const permissions = await rpc.invoke('pikkuPermissions', null);
-        if (permissions) {
-            allImports.push(config.permissionsFile);
-        }
-        await rpc.invoke('pikkuServices', null);
-        const hasPackageFactories = await rpc.invoke('pikkuPackage', null);
-        if (hasPackageFactories) {
-            allImports.push(config.packageFile);
-        }
-        const hasInternalRPCs = await rpc.invoke('pikkuRPC', null);
-        const agents = await rpc.invoke('pikkuAIAgent', null);
-        if (agents) {
-            allImports.push(config.agentWiringMetaFile, config.agentWiringsFile);
-            if (config.scaffold?.agent) {
-                await rpc.invoke('pikkuPublicAgent', null);
-            }
-        }
-        await rpc.invoke('pikkuPublicRPC', null);
-        await rpc.invoke('pikkuConsoleFunctions', null);
-        await rpc.invoke('pikkuNodeTypes', null);
-        await rpc.invoke('pikkuSecretDefinitionTypes', null);
-        await rpc.invoke('pikkuSecrets', null);
-        await rpc.invoke('pikkuCredentials', null);
-        await rpc.invoke('pikkuVariableDefinitionTypes', null);
-        await rpc.invoke('pikkuVariables', null);
-        await rpc.invoke('pikkuAddonTypes', null);
-        if (hasInternalRPCs) {
-            allImports.push(config.rpcInternalWiringMetaFile);
-        }
-        if (agents || !config.addon) {
-            await getInspectorState(true);
-        }
-        const schemas = await rpc.invoke('pikkuSchemas', null);
-        if (schemas) {
-            allImports.push(`${config.schemaDirectory}/register.gen.ts`);
-        }
-        await rpc.invoke('pikkuRPCInternalMap', null);
-        await rpc.invoke('pikkuRPCExposedMap', null);
-        const workflows = await rpc.invoke('pikkuWorkflow', null);
-        let remoteRPC = false;
-        let workflowRoutes = false;
-        if (!config.addon) {
-            remoteRPC = await rpc.invoke('pikkuRemoteRPC', null);
-            if (workflows) {
-                workflowRoutes = await rpc.invoke('pikkuWorkflowRoutes', null);
-            }
-        }
-        if (workflows || remoteRPC || workflowRoutes) {
-            await getInspectorState(true);
-            await rpc.invoke('pikkuSchemas', null);
-        }
-        if (!config.addon) {
-            const http = await rpc.invoke('pikkuHTTP', null);
-            if (http) {
-                await rpc.invoke('pikkuHTTPMap', null);
-                await rpc.invoke('pikkuFetch', null);
-                await rpc.invoke('pikkuRPCClient', null);
-                allImports.push(config.httpWiringMetaFile, config.httpWiringsFile);
-            }
-            const scheduler = await rpc.invoke('pikkuScheduler', null);
-            if (scheduler) {
-                allImports.push(config.schedulersWiringMetaFile, config.schedulersWiringFile);
-            }
-            const triggers = await rpc.invoke('pikkuTrigger', null);
-            if (triggers) {
-                allImports.push(config.triggersWiringMetaFile, config.triggerSourcesMetaFile, config.triggersWiringFile);
-            }
-        }
-        const hasFunctionRegistrations = await rpc.invoke('pikkuFunctions', null);
-        allImports.push(config.functionsMetaFile);
-        if (hasFunctionRegistrations) {
-            allImports.push(config.functionsFile);
-        }
-        if (workflows) {
-            allImports.push(config.workflowsWiringFile);
-        }
-        if (!config.addon) {
-            const queues = await rpc.invoke('pikkuQueue', null);
-            if (queues) {
-                await rpc.invoke('pikkuQueueMap', null);
-                await rpc.invoke('pikkuQueueService', null);
-                allImports.push(config.queueWorkersWiringMetaFile, config.queueWorkersWiringFile);
-            }
-            const channels = await rpc.invoke('pikkuChannels', null);
-            if (channels) {
-                await rpc.invoke('pikkuChannelsMap', null);
-                await rpc.invoke('pikkuWebSocketTyped', null);
-                allImports.push(config.channelsWiringMetaFile, config.channelsWiringFile);
-            }
-            const gateways = await rpc.invoke('pikkuGateway', null);
-            if (gateways) {
-                allImports.push(config.gatewaysWiringFile);
-            }
-            const mcp = await rpc.invoke('pikkuMCP', null);
-            if (mcp) {
-                await rpc.invoke('pikkuMCPJSON', null);
-                allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile);
-            }
-            const cli = await rpc.invoke('pikkuCLI', null);
-            if (cli) {
-                await rpc.invoke('pikkuCLIEntry', null);
-                allImports.push(config.cliWiringMetaFile, config.cliWiringsFile);
-            }
-        }
-        await rpc.invoke('pikkuNodesMeta', null);
-        if (config.clientFiles?.nextBackendFile ||
-            config.clientFiles?.nextHTTPFile) {
-            await rpc.invoke('pikkuNext', null);
-        }
-        if (config.openAPI) {
-            logger.debug(`• OpenAPI requires a reinspection to pickup new generated types..`);
-            await getInspectorState(true);
-            await rpc.invoke('pikkuOpenAPI', null);
-        }
-        try {
-            await rpc.invoke('pikkuVersionsUpdate', null);
-        }
-        catch {
-            logger.warn(`Run 'pikku versions init' to enable contract versioning.`);
-        }
-        await rpc.invoke('pikkuBootstrap', { allImports });
-        await rpc.invoke('pikkuSummary', null);
+    func: async (services, _data, { rpc }) => {
+        await services.workflowService.runToCompletion('allWorkflow', {}, rpc);
     },
 });

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

@@ -3,16 +3,16 @@ export const bootstrap = pikkuVoidFunc({
     remote: true,
     func: async ({ logger, getInspectorState }, _data, { rpc }) => {
         await getInspectorState(false, false, true);
-        await rpc.invoke('pikkuFunctionTypes', null);
-        await rpc.invoke('pikkuFunctionTypesSplit', null);
-        await rpc.invoke('pikkuHTTPTypes', null);
-        await rpc.invoke('pikkuChannelTypes', null);
-        await rpc.invoke('pikkuSchedulerTypes', null);
-        await rpc.invoke('pikkuQueueTypes', null);
-        await rpc.invoke('pikkuWorkflow', null);
-        await rpc.invoke('pikkuMCPTypes', null);
-        await rpc.invoke('pikkuAIAgentTypes', null);
-        await rpc.invoke('pikkuCLITypes', null);
+        await rpc.invoke('pikkuFunctionTypes');
+        await rpc.invoke('pikkuFunctionTypesSplit');
+        await rpc.invoke('pikkuHTTPTypes');
+        await rpc.invoke('pikkuChannelTypes');
+        await rpc.invoke('pikkuSchedulerTypes');
+        await rpc.invoke('pikkuQueueTypes');
+        await rpc.invoke('pikkuWorkflow');
+        await rpc.invoke('pikkuMCPTypes');
+        await rpc.invoke('pikkuAIAgentTypes');
+        await rpc.invoke('pikkuCLITypes');
         if (logger.hasCriticalErrors()) {
             process.exit(1);
         }

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

@@ -88,7 +88,7 @@ export const consoleCommand = 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/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,6 +15,10 @@ 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 }
@@ -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)
+    })
   },
 })
 
@@ -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">;