@pikku/core 0.12.14 → 0.12.15

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

@@ -3,7 +3,6 @@ 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';
-import { encryptJSON } from '../../crypto-utils.js';
 export class RPCNotFoundError extends PikkuError {
     rpcName;
     constructor(rpcName) {
@@ -95,17 +94,38 @@ export class ContextAwareRPCService {
                 }
                 : undefined,
         };
-        // Check if it's a namespaced function call (e.g., 'stripe:createCharge')
+        // Check addon namespace first (e.g. 'stripe:createCharge')
         if (funcName.includes(':')) {
-            return this.invokeAddonFunction(funcName, data, updatedWire);
+            try {
+                return await this.invokeAddonFunction(funcName, data, updatedWire);
+            }
+            catch (addonErr) {
+                if (!(addonErr instanceof RPCNotFoundError))
+                    throw addonErr;
+                // Not an addon — fall through to local lookup
+            }
+        }
+        // Try local function, then fall back to deployment service (remote)
+        try {
+            return await runPikkuFunc('rpc', funcName, getPikkuFunctionName(funcName), {
+                auth: this.options.requiresAuth,
+                singletonServices: this.services,
+                data: () => data,
+                wire: updatedWire,
+            });
+        }
+        catch (e) {
+            if (e instanceof RPCNotFoundError) {
+                // Fall back to deployment service (e.g. CF service binding, Lambda Invoke)
+                if (this.services.deploymentService) {
+                    const session = this.wire.getSession && typeof this.wire.getSession === 'function'
+                        ? await this.wire.getSession()
+                        : this.wire.session;
+                    return this.services.deploymentService.invoke(funcName, data, session, this.wire.traceId);
+                }
+            }
+            throw e;
         }
-        // Main package function
-        return runPikkuFunc('rpc', funcName, getPikkuFunctionName(funcName), {
-            auth: this.options.requiresAuth,
-            singletonServices: this.services,
-            data: () => data,
-            wire: updatedWire,
-        });
     }
     /**
      * Invoke a function from an addon package
@@ -117,16 +137,14 @@ export class ContextAwareRPCService {
         // Resolve namespace to package name
         const resolved = resolveNamespace(namespacedFunction);
         if (!resolved) {
-            throw new Error(`Unknown namespace in function reference: ${namespacedFunction}. ` +
-                `Make sure the package is registered in addons config.`);
+            throw new RPCNotFoundError(namespacedFunction);
         }
         // Get the function meta from the addon package
         // Addon packages use function meta, not RPC meta
         const addonFunctionMeta = pikkuState(resolved.package, 'function', 'meta');
         const funcMeta = addonFunctionMeta[resolved.function];
         if (!funcMeta) {
-            throw new Error(`Function '${resolved.function}' not found in package '${resolved.package}'. ` +
-                `Available functions: ${Object.keys(addonFunctionMeta).join(', ') || '(none)'}`);
+            throw new RPCNotFoundError(namespacedFunction);
         }
         const funcName = funcMeta.pikkuFuncId || resolved.function;
         const auth = resolved.addonConfig?.auth ?? this.options.requiresAuth;
@@ -162,12 +180,23 @@ export class ContextAwareRPCService {
         if (rpcName.includes(':')) {
             return this.invokeAddonFunction(rpcName, data, mergedWire);
         }
-        return runPikkuFunc('rpc', rpcName, getPikkuFunctionName(rpcName), {
-            auth: this.options.requiresAuth,
-            singletonServices: this.services,
-            data: () => data,
-            wire: mergedWire,
-        });
+        try {
+            return await runPikkuFunc('rpc', rpcName, getPikkuFunctionName(rpcName), {
+                auth: this.options.requiresAuth,
+                singletonServices: this.services,
+                data: () => data,
+                wire: mergedWire,
+            });
+        }
+        catch (e) {
+            if (e instanceof RPCNotFoundError && this.services.deploymentService) {
+                const session = this.wire.getSession && typeof this.wire.getSession === 'function'
+                    ? await this.wire.getSession()
+                    : this.wire.session;
+                return this.services.deploymentService.invoke(rpcName, data, session, this.wire.traceId);
+            }
+            throw e;
+        }
     }
     async startWorkflow(workflowName, input, options) {
         if (!this.services.workflowService) {
@@ -227,77 +256,14 @@ export class ContextAwareRPCService {
         };
     }
     async remote(funcName, data) {
-        let endpoint;
-        const headers = {
-            'Content-Type': 'application/json',
-        };
-        const colonIndex = funcName.indexOf(':');
-        if (colonIndex !== -1) {
-            const namespace = funcName.substring(0, colonIndex);
-            const addons = pikkuState(null, 'addons', 'packages');
-            const pkgConfig = addons.get(namespace);
-            endpoint = pkgConfig?.rpcEndpoint;
-        }
-        if (!endpoint && this.services.deploymentService) {
-            const deployments = await this.services.deploymentService.findFunction(funcName);
-            if (deployments.length > 0) {
-                endpoint = deployments[0].endpoint;
-            }
-        }
-        if (!endpoint) {
-            throw new Error(`No endpoint configured for remote RPC: ${funcName}. ` +
-                `Configure rpcEndpoint in addons config or set up a DeploymentService.`);
-        }
-        let secret;
-        if (this.services.secrets) {
-            try {
-                secret = await this.services.secrets.getSecret('PIKKU_REMOTE_SECRET');
-            }
-            catch { }
-        }
-        if (secret) {
-            if (!this.services.jwt) {
-                throw new Error('PIKKU_REMOTE_SECRET is set but JWT service is not available');
-            }
-            const session = this.wire.getSession && typeof this.wire.getSession === 'function'
-                ? await this.wire.getSession()
-                : this.wire.session;
-            const sessionEnc = session
-                ? await encryptJSON(secret, { session })
-                : undefined;
-            const token = await this.services.jwt.encode({ value: 5, unit: 'minute' }, {
-                aud: 'pikku-remote',
-                fn: funcName,
-                iat: Date.now(),
-                session: sessionEnc,
-            });
-            headers.Authorization = `Bearer ${token}`;
-        }
-        const url = `${endpoint}/rpc/${encodeURIComponent(funcName)}`;
-        const timeoutMs = 30_000;
-        const response = await fetch(url, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify({ data }),
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        if (!response.ok) {
-            let errorBody;
-            try {
-                errorBody = JSON.stringify(await response.json());
-            }
-            catch {
-                errorBody = await response.text();
-            }
-            throw new Error(`Remote RPC call failed: ${response.status} ${response.statusText}. ${errorBody}`);
-        }
-        try {
-            return (await response.json());
-        }
-        catch {
-            const text = await response.text();
-            throw new Error(`Remote RPC call returned non-JSON response: ${response.status} ${response.statusText}. ${text}`);
+        if (!this.services.deploymentService) {
+            throw new Error(`No DeploymentService configured for remote RPC: ${funcName}. ` +
+                `Set up a DeploymentService to enable remote function calls.`);
         }
+        const session = this.wire.getSession && typeof this.wire.getSession === 'function'
+            ? await this.wire.getSession()
+            : this.wire.session;
+        return this.services.deploymentService.invoke(funcName, data, session, this.wire.traceId);
     }
 }
 // RPC Service class for the global interface

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

@@ -4,7 +4,9 @@ import type { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../.
 export type RunScheduledTasksParams = {
     name: string;
     session?: CoreUserSession;
+    /** Pre-resolved trace ID */
+    traceId?: string;
 };
 export declare const wireScheduler: <PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunctionSessionless<void, void>>>(scheduledTask: CoreScheduledTask<PikkuFunctionConfig>) => void;
-export declare function runScheduledTask({ name, session, }: RunScheduledTasksParams): Promise<void>;
+export declare function runScheduledTask({ name, session, traceId, }: RunScheduledTasksParams): Promise<void>;
 export declare const getScheduledTasks: () => Map<string, CoreScheduledTask>;

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

@@ -1,5 +1,4 @@
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js';
-import { PikkuMissingMetaError } from '../../errors/errors.js';
 import { getSingletonServices, getCreateWireServices, pikkuState, } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
@@ -7,7 +6,8 @@ export const wireScheduler = (scheduledTask) => {
     const meta = pikkuState(null, 'scheduler', 'meta');
     const taskMeta = meta[scheduledTask.name];
     if (!taskMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for scheduled task '${scheduledTask.name}'`);
+        console.warn(`[pikku] Skipping scheduled task '${scheduledTask.name}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     addFunction(taskMeta.pikkuFuncId, {
         func: scheduledTask.func.func,
@@ -33,9 +33,12 @@ class ScheduledTaskSkippedError extends PikkuError {
         this.name = 'ScheduledTaskSkippedError';
     }
 }
-export async function runScheduledTask({ name, session, }) {
+export async function runScheduledTask({ name, session, traceId, }) {
     const singletonServices = getSingletonServices();
     const createWireServices = getCreateWireServices();
+    const resolvedTraceId = traceId ?? `cron-${name}-${Date.now()}`;
+    const scopedLogger = singletonServices.logger.scope?.(resolvedTraceId) ??
+        singletonServices.logger;
     const task = pikkuState(null, 'scheduler', 'tasks').get(name);
     const meta = pikkuState(null, 'scheduler', 'meta')[name];
     const userSession = new PikkuSessionService();
@@ -50,6 +53,7 @@ export async function runScheduledTask({ name, session, }) {
     }
     // Create the scheduled task wire object
     const wire = {
+        traceId: resolvedTraceId,
         scheduledTask: {
             name,
             schedule: task.schedule,
@@ -61,7 +65,7 @@ export async function runScheduledTask({ name, session, }) {
         ...createMiddlewareSessionWireProps(userSession),
     };
     try {
-        singletonServices.logger.info(`Running schedule task: ${name} | schedule: ${task.schedule}`);
+        scopedLogger.info(`Running schedule task: ${name} | schedule: ${task.schedule}`);
         await runPikkuFunc('scheduler', meta.name, meta.pikkuFuncId, {
             singletonServices,
             createWireServices,
@@ -78,7 +82,7 @@ export async function runScheduledTask({ name, session, }) {
     catch (e) {
         const errorResponse = getErrorResponse(e);
         if (errorResponse != null) {
-            singletonServices.logger.error(e);
+            scopedLogger.error(e);
         }
         throw e;
     }

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

@@ -10,7 +10,8 @@ export const wireTrigger = (trigger) => {
     const meta = pikkuState(null, 'trigger', 'meta');
     const triggerMeta = meta[trigger.name];
     if (!triggerMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for trigger '${trigger.name}'`);
+        console.warn(`[pikku] Skipping trigger '${trigger.name}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     addFunction(triggerMeta.pikkuFuncId, trigger.func);
     const triggers = pikkuState(null, 'trigger', 'triggers');
@@ -25,7 +26,8 @@ export const wireTriggerSource = (source) => {
     const sourceMeta = pikkuState(null, 'trigger', 'sourceMeta');
     const triggerSourceMeta = sourceMeta[source.name];
     if (!triggerSourceMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for trigger source '${source.name}'`);
+        console.warn(`[pikku] Skipping trigger source '${source.name}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     const triggerSources = pikkuState(null, 'trigger', 'triggerSources');
     if (triggerSources.has(source.name)) {

package/dist/wirings/workflow/dsl/workflow-runner.d.ts

@@ -2,4 +2,4 @@
  * Add a workflow to the system
  * This is called by the generated workflow wirings
  */
-export declare const addWorkflow: (workflowName: string, workflowFunc: any) => void;
+export declare const addWorkflow: (workflowName: string, workflowFunc: any, packageName?: string | null) => void;

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

@@ -1,23 +1,20 @@
 import { pikkuState } from '../../../pikku-state.js';
 import { addFunction } from '../../../function/function-runner.js';
-import { PikkuMissingMetaError } from '../../../errors/errors.js';
 /**
  * Add a workflow to the system
  * This is called by the generated workflow wirings
  */
-export const addWorkflow = (workflowName, workflowFunc) => {
-    // Get workflow metadata from inspector
-    const meta = pikkuState(null, 'workflows', 'meta');
+export const addWorkflow = (workflowName, workflowFunc, packageName = null) => {
+    const meta = pikkuState(packageName, 'workflows', 'meta');
     const workflowMeta = meta[workflowName];
     if (!workflowMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for workflow '${workflowName}'`);
+        console.warn(`[pikku] Skipping workflow '${workflowName}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
-    // Store workflow definition in state
-    const registrations = pikkuState(null, 'workflows', 'registrations');
+    const registrations = pikkuState(packageName, 'workflows', 'registrations');
     registrations.set(workflowName, {
         name: workflowName,
         func: workflowFunc,
     });
-    // Register the function with pikku
-    addFunction(workflowMeta.pikkuFuncId, workflowFunc);
+    addFunction(workflowMeta.pikkuFuncId, workflowFunc, packageName);
 };

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

@@ -11,6 +11,6 @@ export declare function continueGraph(workflowService: PikkuWorkflowService, run
 export declare function executeGraphStep(workflowService: PikkuWorkflowService, rpcService: any, runId: string, stepId: string, nodeId: string, rpcName: string, data: any, graphName: string): Promise<any>;
 export declare function onGraphNodeComplete(workflowService: PikkuWorkflowService, runId: string, graphName: string): Promise<void>;
 export declare function runFromMeta(workflowService: PikkuWorkflowService, runId: string, meta: WorkflowRuntimeMeta, _rpcService: any): Promise<void>;
-export declare function runWorkflowGraph(workflowService: PikkuWorkflowService, graphName: string, triggerInput: any, rpcService?: any, inline?: boolean, startNode?: string, wire?: WorkflowRunWire): Promise<{
+export declare function runWorkflowGraph(workflowService: PikkuWorkflowService, graphName: string, triggerInput: any, rpcService?: any, inline?: boolean, startNode?: string, wire?: WorkflowRunWire, overrideMeta?: WorkflowRuntimeMeta): Promise<{
     runId: string;
 }>;

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

@@ -90,8 +90,22 @@ function isTemplate(value) {
         typeof value.$template === 'object');
 }
 function getWorkflowMeta(name) {
-    const meta = pikkuState(null, 'workflows', 'meta');
-    return meta[name];
+    const rootMeta = pikkuState(null, 'workflows', 'meta');
+    if (rootMeta[name])
+        return rootMeta[name];
+    const colonIndex = name.indexOf(':');
+    if (colonIndex !== -1) {
+        const namespace = name.substring(0, colonIndex);
+        const localName = name.substring(colonIndex + 1);
+        const addons = pikkuState(null, 'addons', 'packages');
+        const pkgConfig = addons?.get(namespace);
+        if (pkgConfig) {
+            const addonMeta = pikkuState(pkgConfig.package, 'workflows', 'meta');
+            if (addonMeta?.[localName])
+                return addonMeta[localName];
+        }
+    }
+    return undefined;
 }
 function resolveNextFromConfig(next, branchKey) {
     if (!next)
@@ -543,8 +557,8 @@ async function continueGraphInline(workflowService, rpcService, runId, graphName
         }));
     }
 }
-export async function runWorkflowGraph(workflowService, graphName, triggerInput, rpcService, inline, startNode, wire) {
-    const meta = getWorkflowMeta(graphName);
+export async function runWorkflowGraph(workflowService, graphName, triggerInput, rpcService, inline, startNode, wire, overrideMeta) {
+    const meta = overrideMeta ?? getWorkflowMeta(graphName);
     if (!meta?.nodes) {
         throw new Error(`Workflow graph '${graphName}' not found`);
     }

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

@@ -5,6 +5,8 @@ export { PikkuWorkflowService, WorkflowCancelledException, WorkflowSuspendedExce
 export { addWorkflow } from './dsl/workflow-runner.js';
 export { template, type TemplateString } from './graph/template.js';
 export { pikkuWorkflowGraph, type PikkuWorkflowGraphConfig, type PikkuWorkflowGraphResult, } from './graph/wire-workflow-graph.js';
-export { workflow, workflowStart, workflowStatus, graphStart, } from './workflow-helpers.js';
-export type { WorkflowService, WorkflowServiceConfig, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, StepStatus, WorkflowRun, StepState, WorkflowRunService, CoreWorkflow, PikkuWorkflow, ContextVariable, WorkflowContext, WorkflowsMeta, WorkflowRuntimeMeta, WorkflowsRuntimeMeta, WorkflowStepInput, WorkflowOrchestratorInput, WorkflowSleeperInput, } from './workflow.types.js';
+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, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, StepStatus, WorkflowRun, WorkflowRunStatus, StepState, WorkflowRunService, 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';

package/dist/wirings/workflow/index.js

@@ -7,5 +7,7 @@ export { addWorkflow } from './dsl/workflow-runner.js';
 // Graph helpers (template, pikkuWorkflowGraph)
 export { template } from './graph/template.js';
 export { pikkuWorkflowGraph, } from './graph/wire-workflow-graph.js';
-// Workflow helpers (runtime factories for HTTP handlers)
-export { workflow, workflowStart, workflowStatus, graphStart, } from './workflow-helpers.js';
+// Graph validation and dynamic workflow utilities
+export { validateWorkflowWiring, computeEntryNodeIds, } from './graph/graph-validation.js';
+// Queue worker functions (registered by codegen, executed at runtime)
+export { pikkuWorkflowWorkerFunc, pikkuWorkflowOrchestratorFunc, pikkuWorkflowSleeperFunc, } from './workflow-queue-workers.js';

package/dist/wirings/workflow/pikku-workflow-service.d.ts

@@ -1,5 +1,5 @@
 import type { SerializedError } from '../../types/core.types.js';
-import type { PikkuWorkflowWire, StepState, WorkflowRun, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from './workflow.types.js';
+import type { PikkuWorkflowWire, StepState, WorkflowRun, WorkflowRunStatus, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from './workflow.types.js';
 import type { WorkflowService } from '../../services/workflow-service.js';
 import { PikkuError } from '../../errors/error-handler.js';
 /**
@@ -69,6 +69,11 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      * @returns Workflow run or null if not found
      */
     abstract getRun(id: string): Promise<WorkflowRun | null>;
+    /**
+     * Get minimal workflow run status with step summaries.
+     * Used by the public API — the console addon provides the full verbose view.
+     */
+    getRunStatus(id: string): Promise<WorkflowRunStatus | null>;
     /**
      * Get workflow run history (all step attempts in chronological order)
      * @param runId - Run ID
@@ -219,7 +224,7 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      * Resume a paused workflow by triggering the orchestrator
      * @param runId - Run ID
      */
-    resumeWorkflow(runId: string): Promise<void>;
+    resumeWorkflow(runId: string, workflowName?: string): Promise<void>;
     queueStepWorker(runId: string, stepName: string, rpcName: string, data: any): Promise<void>;
     /**
      * Execute a workflow sleep step completion
@@ -232,7 +237,7 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      * @param runId - Run ID
      * @param retryDelay - Delay in milliseconds or duration string (optional)
      */
-    protected scheduleOrchestratorRetry(runId: string, retryDelay?: number | string): Promise<void>;
+    protected scheduleOrchestratorRetry(runId: string, retryDelay?: number | string, workflowName?: string): Promise<void>;
     /**
      * Start a new workflow run
      * Automatically detects workflow type (DSL or graph) from meta and executes accordingly
@@ -269,7 +274,14 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
     private sleepStep;
     private getSuspendStepName;
     private suspendStep;
-    createWorkflowWire(name: string, runId: string, rpcService: any): PikkuWorkflowWire;
+    createWorkflowWire(name: string, runId: string, rpcService: any, addonNamespace?: string | null): PikkuWorkflowWire;
     private verifyStepName;
     private getConfig;
+    /**
+     * Get the orchestrator queue name for a specific workflow.
+     * Checks queue meta for a per-workflow queue first (e.g. wf-orchestrator-{name}),
+     * falls back to the shared orchestrator queue.
+     */
+    protected getOrchestratorQueueName(workflowName?: string): string;
+    protected getStepWorkerQueueName(rpcName?: string): string;
 }