@pikku/core 0.12.19 → 0.12.21

package/dist/wirings/http/http-runner.js

@@ -239,8 +239,10 @@ const executeRoute = async (services, matchedRoute, http, options) => {
         response.setMode('stream');
         response.header('Content-Type', 'text/event-stream');
         response.header('Cache-Control', 'no-cache');
+        let sseState;
+        const channelId = createWeakUID();
         channel = {
-            channelId: requestId,
+            channelId,
             openingData: await data(),
             send: (data) => {
                 response.arrayBuffer(isSerializable(data) ? JSON.stringify(data) : data);
@@ -253,7 +255,36 @@ const executeRoute = async (services, matchedRoute, http, options) => {
                 response.close?.();
             },
             state: 'open',
+            setState: (s) => {
+                sseState = s;
+            },
+            getState: () => sseState,
+            clearState: () => {
+                sseState = undefined;
+            },
         };
+        // Register the SSE channel with the eventHub (if present) so that
+        // eventHub.publish() can deliver messages to SSE subscribers.
+        // The channel handler wraps the SSE channel to match PikkuChannelHandler.
+        if (singletonServices.eventHub?.onChannelOpened) {
+            const channelRef = channel;
+            const channelHandler = {
+                getChannel: () => channelRef,
+                send: (data, isBinary) => {
+                    if (isBinary)
+                        channelRef.sendBinary(data);
+                    else
+                        channelRef.send(data);
+                },
+                sendBinary: (data) => channelRef.sendBinary(data),
+            };
+            singletonServices.eventHub.onChannelOpened(channelHandler);
+            const originalClose = channel.close;
+            channel.close = () => {
+                singletonServices.eventHub.onChannelClosed(channelId);
+                originalClose();
+            };
+        }
     }
     const wire = {
         traceId: requestId,
@@ -264,22 +295,45 @@ const executeRoute = async (services, matchedRoute, http, options) => {
         getSession: () => userSession.get(),
         hasSessionChanged: () => userSession.sessionChanged,
     };
-    result = await runPikkuFunc('http', `${meta.method}:${meta.route}`, meta.pikkuFuncId, {
-        singletonServices,
-        createWireServices,
-        auth: route.auth !== false,
-        data,
-        inheritedMiddleware: meta.middleware,
-        wireMiddleware: route.middleware,
-        inheritedPermissions: meta.permissions,
-        wirePermissions: route.permissions,
-        coerceDataFromSchema: options.coerceDataFromSchema,
-        tags: route.tags,
-        wire,
-        sessionService: userSession,
-        packageName: meta.packageName,
-    });
-    if (!matchedRoute.route.sse) {
+    try {
+        result = await runPikkuFunc('http', `${meta.method}:${meta.route}`, meta.pikkuFuncId, {
+            singletonServices,
+            createWireServices,
+            auth: route.auth !== false,
+            data,
+            inheritedMiddleware: meta.middleware,
+            wireMiddleware: route.middleware,
+            inheritedPermissions: meta.permissions,
+            wirePermissions: route.permissions,
+            coerceDataFromSchema: options.coerceDataFromSchema,
+            tags: route.tags,
+            wire,
+            sessionService: userSession,
+            packageName: meta.packageName,
+        });
+    }
+    catch (e) {
+        if (matchedRoute.route.sse) {
+            singletonServices.logger.error(e instanceof Error ? e.message : e);
+            try {
+                const errorResponse = getErrorResponse(e);
+                http?.response?.arrayBuffer(JSON.stringify({
+                    type: 'error',
+                    errorText: errorResponse?.message ?? 'Internal server error',
+                }));
+                http?.response?.arrayBuffer(JSON.stringify({ type: 'done' }));
+            }
+            catch { }
+            channel?.close();
+            return wireServices ? { result, wireServices } : { result };
+        }
+        throw e;
+    }
+    if (matchedRoute.route.sse) {
+        // Flush headers after middleware has run so CORS/auth headers are included
+        http?.response?.flushHeaders?.();
+    }
+    else {
         if (result instanceof Response) {
             await applyWebResponse(http.response, result);
         }
@@ -405,25 +459,7 @@ export const fetchData = async (request, response, { skipUserSession = false, re
         return result;
     }
     catch (e) {
-        if (matchedRoute?.route.sse) {
-            // For SSE routes, send error through the stream since the response is already in stream mode
-            scopedLogger.error(e instanceof Error ? e.message : e);
-            try {
-                const errorResponse = getErrorResponse(e);
-                response.arrayBuffer(JSON.stringify({
-                    type: 'error',
-                    errorText: errorResponse?.message ?? 'Internal server error',
-                }));
-                response.arrayBuffer(JSON.stringify({ type: 'done' }));
-            }
-            catch (streamErr) {
-                scopedLogger.error(`SSE error while sending error payload: ${streamErr instanceof Error ? streamErr.message : String(streamErr)}`);
-            }
-            response.close?.();
-        }
-        else {
-            handleHTTPError(e, http, requestId, scopedLogger, logWarningsForStatusCodes, respondWith404, bubbleErrors, exposeErrors);
-        }
+        handleHTTPError(e, http, requestId, scopedLogger, logWarningsForStatusCodes, respondWith404, bubbleErrors, exposeErrors);
     }
     finally {
         // Clean up any session-specific services created during processing

package/dist/wirings/http/http.types.d.ts

@@ -177,6 +177,7 @@ export interface PikkuHTTPResponse<Out = unknown> {
     redirect(location: string, status?: number): this;
     close?: () => void;
     setMode?: (mode: 'stream') => void;
+    flushHeaders?: () => void;
 }
 /**
  * Single route configuration - supports all wireHTTP options

package/dist/wirings/http/pikku-fetch-http-request.js

@@ -89,7 +89,9 @@ export class PikkuFetchHTTPRequest {
         const merged = {};
         for (const part of parts) {
             for (const [key, value] of Object.entries(part)) {
-                if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+                if (key === '__proto__' ||
+                    key === 'constructor' ||
+                    key === 'prototype') {
                     continue;
                 }
                 if (key in merged && !valuesAreEquivalent(merged[key], value)) {

package/dist/wirings/http/web-request.js

@@ -57,17 +57,46 @@ export function toWebRequest(req, baseUrl) {
     });
 }
 const SKIP_RESPONSE_HEADERS = new Set(['content-length', 'transfer-encoding']);
+function collectSetCookieHeaders(webResponse) {
+    const seen = new Set();
+    const values = [];
+    const add = (cookie) => {
+        if (!cookie || seen.has(cookie)) {
+            return;
+        }
+        seen.add(cookie);
+        values.push(cookie);
+    };
+    const headersWithGetSetCookie = webResponse.headers;
+    if (typeof headersWithGetSetCookie.getSetCookie === 'function') {
+        for (const cookie of headersWithGetSetCookie.getSetCookie()) {
+            add(cookie);
+        }
+    }
+    else {
+        webResponse.headers.forEach((value, name) => {
+            if (name.toLowerCase() === 'set-cookie') {
+                add(value);
+            }
+        });
+    }
+    return values;
+}
 /**
  * Applies a Web API Response to a PikkuHTTPResponse.
  * Copies status, headers (including Set-Cookie), redirects, and body.
  */
 export async function applyWebResponse(res, webResponse) {
     res.status(webResponse.status);
+    const setCookieValues = collectSetCookieHeaders(webResponse);
     webResponse.headers.forEach((value, name) => {
         const lower = name.toLowerCase();
         if (SKIP_RESPONSE_HEADERS.has(lower)) {
             return;
         }
+        if (lower === 'set-cookie') {
+            return;
+        }
         if (lower === 'location') {
             res.redirect(value, webResponse.status);
         }
@@ -75,6 +104,9 @@ export async function applyWebResponse(res, webResponse) {
             res.header(name, value);
         }
     });
+    if (setCookieValues.length > 0) {
+        res.header('Set-Cookie', setCookieValues);
+    }
     const body = await webResponse.text();
     if (body) {
         if (res.send) {

package/dist/wirings/rpc/rpc-runner.d.ts

@@ -18,10 +18,11 @@ export declare class ContextAwareRPCService {
     private services;
     private wire;
     private options;
+    private packageName;
     constructor(services: CoreServices, wire: PikkuWire, options: {
         requiresAuth?: boolean;
         sessionService?: SessionService<CoreUserSession>;
-    });
+    }, packageName?: string | null);
     rpcExposed(funcName: string, data: any): Promise<any>;
     rpc<In = any, Out = any>(funcName: string, data: In): Promise<Out>;
     /**
@@ -96,7 +97,7 @@ export declare class PikkuRPCService<Services extends CoreServices, TypedRPC = P
     getContextRPCService(services: Services, wire: PikkuWire, requiresAuthOrOptions?: boolean | {
         requiresAuth?: boolean;
         sessionService?: SessionService<CoreUserSession>;
-    } | undefined, depth?: number): TypedRPC;
+    } | undefined, depth?: number, packageName?: string | null): TypedRPC;
 }
 export declare const rpcService: PikkuRPCService<import("../../types/core.types.js").CoreSingletonServices<{
     logLevel?: import("../../services/logger.js").LogLevel;

package/dist/wirings/rpc/rpc-runner.js

@@ -1,6 +1,5 @@
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
-import { ForbiddenError } from '../../errors/errors.js';
 import { PikkuError, addError } from '../../errors/error-handler.js';
 import { parseVersionedId } from '../../version.js';
 export class RPCNotFoundError extends PikkuError {
@@ -39,7 +38,22 @@ export const resolveNamespace = (namespacedFunction) => {
         addonConfig: pkgConfig,
     };
 };
-const getPikkuFunctionName = (rpcName) => {
+/**
+ * Resolve a bare (non-namespaced) RPC name to its pikkuFuncId, preferring
+ * the caller's addon package when provided. Returns the function name plus
+ * the package scope that resolved it (null = root), so callers can thread
+ * the scope into runPikkuFunc without a second lookup.
+ */
+const resolvePikkuFunction = (rpcName, packageName = null) => {
+    // Addon-scoped calls: try the caller's package function meta first.
+    // (RPC meta only lives in root; addon functions are registered under their package.)
+    if (packageName) {
+        const pkgFunctions = pikkuState(packageName, 'function', 'meta');
+        const pkgMeta = pkgFunctions?.[rpcName];
+        if (pkgMeta) {
+            return { pikkuFuncId: pkgMeta.pikkuFuncId || rpcName, packageName };
+        }
+    }
     const rpc = pikkuState(null, 'rpc', 'meta');
     let rpcMeta = rpc[rpcName];
     if (!rpcMeta) {
@@ -48,20 +62,32 @@ const getPikkuFunctionName = (rpcName) => {
             rpcMeta = rpc[baseName];
         }
     }
+    if (!rpcMeta) {
+        const rootFunctions = pikkuState(null, 'function', 'meta');
+        const rootFunctionMeta = rootFunctions?.[rpcName];
+        if (rootFunctionMeta) {
+            return {
+                pikkuFuncId: rootFunctionMeta.pikkuFuncId || rpcName,
+                packageName: null,
+            };
+        }
+    }
     if (!rpcMeta) {
         throw new RPCNotFoundError(rpcName);
     }
-    return rpcMeta;
+    return { pikkuFuncId: rpcMeta, packageName: null };
 };
 // Context-aware RPC client for use within services
 export class ContextAwareRPCService {
     services;
     wire;
     options;
-    constructor(services, wire, options) {
+    packageName;
+    constructor(services, wire, options, packageName = null) {
         this.services = services;
         this.wire = wire;
         this.options = options;
+        this.packageName = packageName;
     }
     async rpcExposed(funcName, data) {
         let functionMeta;
@@ -72,13 +98,14 @@ export class ContextAwareRPCService {
             }
         }
         else {
-            functionMeta = pikkuState(null, 'function', 'meta')[funcName];
+            const resolved = resolvePikkuFunction(funcName, this.packageName);
+            functionMeta = pikkuState(resolved.packageName, 'function', 'meta')[resolved.pikkuFuncId];
         }
         if (!functionMeta) {
             throw new RPCNotFoundError(funcName);
         }
         if (!functionMeta.expose) {
-            throw new ForbiddenError();
+            throw new RPCNotFoundError(funcName);
         }
         return await this.rpc(funcName, data);
     }
@@ -105,13 +132,18 @@ export class ContextAwareRPCService {
                 // Not an addon — fall through to local lookup
             }
         }
-        // Try local function, then fall back to deployment service (remote)
+        // Bare name: resolve via caller's package scope first (if any), then root.
+        // Note: intra-addon bare calls do NOT re-apply the addon's external
+        // addonConfig.auth/tags — those gates are only applied on the external
+        // 'namespace:func' boundary via invokeAddonFunction.
         try {
-            return await runPikkuFunc('rpc', funcName, getPikkuFunctionName(funcName), {
+            const resolved = resolvePikkuFunction(funcName, this.packageName);
+            return await runPikkuFunc('rpc', funcName, resolved.pikkuFuncId, {
                 auth: this.options.requiresAuth,
                 singletonServices: this.services,
                 data: () => data,
                 wire: updatedWire,
+                packageName: resolved.packageName,
             });
         }
         catch (e) {
@@ -181,11 +213,13 @@ export class ContextAwareRPCService {
             return this.invokeAddonFunction(rpcName, data, mergedWire);
         }
         try {
-            return await runPikkuFunc('rpc', rpcName, getPikkuFunctionName(rpcName), {
+            const resolved = resolvePikkuFunction(rpcName, this.packageName);
+            return await runPikkuFunc('rpc', rpcName, resolved.pikkuFuncId, {
                 auth: this.options.requiresAuth,
                 singletonServices: this.services,
                 data: () => data,
                 wire: mergedWire,
+                packageName: resolved.packageName,
             });
         }
         catch (e) {
@@ -269,12 +303,12 @@ export class ContextAwareRPCService {
 // RPC Service class for the global interface
 export class PikkuRPCService {
     // Convenience function for initializing
-    getContextRPCService(services, wire, requiresAuthOrOptions, depth = 0) {
+    getContextRPCService(services, wire, requiresAuthOrOptions, depth = 0, packageName = null) {
         const options = typeof requiresAuthOrOptions === 'object' &&
             requiresAuthOrOptions !== null
             ? requiresAuthOrOptions
             : { requiresAuth: requiresAuthOrOptions };
-        const serviceRPC = new ContextAwareRPCService(services, wire, options);
+        const serviceRPC = new ContextAwareRPCService(services, wire, options, packageName);
         return {
             depth,
             global: false,

package/dist/wirings/workflow/graph/graph-node.d.ts

@@ -26,6 +26,10 @@ export interface GraphNodeDef<RPCMap extends Record<string, RPCHandler>, NodeIds
     next?: NextConfig<NodeIds>;
     /** Error handling - node(s) to execute on error */
     onError?: NodeIds | NodeIds[];
+    /** Maximum retry attempts allowed (excludes the initial attempt) */
+    retries?: number;
+    /** Delay between retries — milliseconds, duration string, or 'exponential' */
+    retryDelay?: string | number;
 }
 /**
  * Helper to create a type-safe graph definition with RPC autocomplete.
@@ -87,6 +91,8 @@ type GraphNodeConfigMap<FuncMap extends Record<string, string>, RPCMap extends R
         next?: NextConfig<Extract<keyof FuncMap, string>>;
         input?: (ref: <N extends Extract<keyof FuncMap, string>, P extends keyof ComputeNodeOutputs<FuncMap, RPCMap>[N] & string>(nodeId: N, path: P) => TypedRef<ComputeNodeOutputs<FuncMap, RPCMap>[N][P]>) => InputWithRefs<ComputeNodeInputs<FuncMap, RPCMap>[K]>;
         onError?: Extract<keyof FuncMap, string> | Extract<keyof FuncMap, string>[];
+        retries?: number;
+        retryDelay?: string | number;
     };
 };
 /**
@@ -113,5 +119,7 @@ export declare function graph<NodeIds extends string = string>(nodes: Record<Nod
     next?: NextConfig<NodeIds>;
     input?: (ref: (nodeId: NodeIds, path: string) => RefValue) => Record<string, unknown>;
     onError?: NodeIds | NodeIds[];
+    retries?: number;
+    retryDelay?: string | number;
 }>): Record<NodeIds, GraphNodeConfig<NodeIds>>;
 export {};

package/dist/wirings/workflow/graph/graph-node.js

@@ -20,6 +20,8 @@ export function createGraph() {
                 input: def?.input,
                 next: def?.next,
                 onError: def?.onError,
+                retries: def?.retries,
+                retryDelay: def?.retryDelay,
             };
         }
         return result;
@@ -52,6 +54,8 @@ export function graph(nodes) {
             input: def.input,
             next: def.next,
             onError: def.onError,
+            retries: def.retries,
+            retryDelay: def.retryDelay,
         };
     }
     return result;

package/dist/wirings/workflow/graph/graph-runner.js

@@ -257,11 +257,13 @@ function areDependenciesSatisfied(node, completedNodeIds) {
     const deps = extractReferencedNodeIds(node.input).filter((id) => !IGNORED_REFS.has(id));
     return deps.every((dep) => completedNodeIds.has(dep));
 }
-async function queueGraphNode(workflowService, runId, _graphName, nodeId, rpcName, input) {
-    await workflowService.insertStepState(runId, nodeId, rpcName, input, {
-        retries: 0,
-    });
-    await workflowService.queueStepWorker(runId, nodeId, rpcName, input);
+async function queueGraphNode(workflowService, runId, _graphName, nodeId, rpcName, input, nodeConfig) {
+    const stepOptions = {
+        retries: nodeConfig?.retries ?? 0,
+        retryDelay: nodeConfig?.retryDelay,
+    };
+    await workflowService.insertStepState(runId, nodeId, rpcName, input, stepOptions);
+    await workflowService.queueStepWorker(runId, nodeId, rpcName, input, stepOptions);
 }
 export async function continueGraph(workflowService, runId, graphName, overrideMeta) {
     const meta = overrideMeta ?? getWorkflowMeta(graphName);
@@ -332,7 +334,7 @@ export async function continueGraph(workflowService, runId, graphName, overrideM
         const fetchedResults = await workflowService.getNodeResults(runId, referencedNodeIds);
         const nodeResults = { trigger: triggerInput, ...fetchedResults };
         const resolvedInput = resolveSerializedInput(node.input, nodeResults);
-        await queueGraphNode(workflowService, runId, graphName, nodeId, node.rpcName, resolvedInput);
+        await queueGraphNode(workflowService, runId, graphName, nodeId, node.rpcName, resolvedInput, node);
     }
 }
 export async function executeGraphStep(workflowService, rpcService, runId, stepId, nodeId, rpcName, data, graphName) {
@@ -410,7 +412,7 @@ export async function executeGraphStep(workflowService, rpcService, runId, stepI
                 for (const errorNodeId of errorNodes) {
                     const errorNode = meta.nodes[errorNodeId];
                     if (errorNode) {
-                        await queueGraphNode(workflowService, runId, graphName, errorNodeId, errorNode.rpcName, { error: { message: error.message } });
+                        await queueGraphNode(workflowService, runId, graphName, errorNodeId, errorNode.rpcName, { error: { message: error.message } }, errorNode);
                     }
                 }
                 throw error;
@@ -430,7 +432,7 @@ async function executeGraphNodeInline(workflowService, rpcService, runId, graphN
     if (!node)
         return;
     const rpcName = node.rpcName;
-    const stepState = await workflowService.insertStepState(runId, nodeId, rpcName, input, { retries: 3 });
+    const stepState = await workflowService.insertStepState(runId, nodeId, rpcName, input, { retries: node.retries ?? 0, retryDelay: node.retryDelay });
     await workflowService.setStepRunning(stepState.stepId);
     const wireState = {};
     const graphWire = {
@@ -486,7 +488,7 @@ async function executeGraphNodeInline(workflowService, rpcService, runId, graphN
                 message: `RPC '${rpcName}' not found. Deploy the missing function and resume.`,
                 code: 'RPC_NOT_FOUND',
             });
-            return;
+            throw new WorkflowSuspendedException(runId, 'RPC_NOT_FOUND');
         }
         await workflowService.setStepError(stepState.stepId, error);
         if (node?.onError) {
@@ -627,7 +629,7 @@ export async function runWorkflowGraph(workflowService, graphName, triggerInput,
             const resolvedInput = node.input && Object.keys(node.input).length > 0
                 ? resolveSerializedInput(node.input, triggerNodeResults)
                 : triggerInput;
-            await queueGraphNode(workflowService, runId, graphName, nodeId, node.rpcName, resolvedInput);
+            await queueGraphNode(workflowService, runId, graphName, nodeId, node.rpcName, resolvedInput, node);
         }
         if (inline) {
             workflowService.unregisterInlineRun(runId);

package/dist/wirings/workflow/graph/workflow-graph.types.d.ts

@@ -45,6 +45,10 @@ export interface GraphNodeConfig<NodeIds extends string = string> {
     next?: NextConfig<NodeIds>;
     /** Error routing - node(s) to execute on error */
     onError?: NodeIds | NodeIds[];
+    /** Maximum retry attempts allowed (excludes the initial attempt) */
+    retries?: number;
+    /** Delay between retries — milliseconds, duration string, or 'exponential' */
+    retryDelay?: string | number;
 }
 /**
  * Graph wire context - available to functions running in a workflow graph

package/dist/wirings/workflow/index.d.ts

@@ -8,5 +8,5 @@ export { pikkuWorkflowGraph, type PikkuWorkflowGraphConfig, type PikkuWorkflowGr
 export { validateWorkflowWiring, computeEntryNodeIds, } from './graph/graph-validation.js';
 export { pikkuWorkflowWorkerFunc, pikkuWorkflowOrchestratorFunc, pikkuWorkflowSleeperFunc, } from './workflow-queue-workers.js';
 export type { WorkflowStepInput as WorkflowStepQueueInput, PikkuWorkflowOrchestratorInput, PikkuWorkflowSleeperInput, } from './workflow-queue-workers.js';
-export type { WorkflowService, WorkflowServiceConfig, WorkflowPlannedStep, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, StepStatus, WorkflowRun, WorkflowRunStatus, StepState, WorkflowRunService, CoreWorkflow, PikkuWorkflow, ContextVariable, WorkflowContext, WorkflowsMeta, WorkflowRuntimeMeta, WorkflowsRuntimeMeta, WorkflowStepInput, WorkflowOrchestratorInput, WorkflowSleeperInput, } from './workflow.types.js';
+export type { WorkflowService, WorkflowServiceConfig, WorkflowPlannedStep, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, StepStatus, WorkflowRun, WorkflowRunStatus, StepState, WorkflowRunService, WorkflowRunMirror, CoreWorkflow, PikkuWorkflow, ContextVariable, WorkflowContext, WorkflowsMeta, WorkflowRuntimeMeta, WorkflowsRuntimeMeta, WorkflowStepInput, WorkflowOrchestratorInput, WorkflowSleeperInput, } from './workflow.types.js';
 export type { WorkflowStepOptions, WorkflowWireDoRPC, WorkflowWireDoInline, WorkflowWireSleep, WorkflowWireSuspend, InputSource, OutputBinding, RpcStepMeta, SimpleCondition, Condition, BranchCase, BranchStepMeta, ParallelGroupStepMeta, FanoutStepMeta, ReturnStepMeta, InlineStepMeta, SleepStepMeta, CancelStepMeta, SetStepMeta, SwitchCaseMeta, SwitchStepMeta, FilterStepMeta, ArrayPredicateStepMeta, WorkflowStepMeta, WorkflowStepWire, PikkuWorkflowWire, } from './workflow.types.js';