@pikku/core 0.12.14 → 0.12.16

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

@@ -1,4 +1,4 @@
-import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js';
+import { NotFoundError } from '../../errors/errors.js';
 import { addFunction } from '../../function/function-runner.js';
 import { pikkuState, getSingletonServices } from '../../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../../schema.js';
@@ -12,9 +12,9 @@ export const wireChannel = (channel) => {
     const channelsMeta = pikkuState(null, 'channel', 'meta');
     const channelMeta = channelsMeta[channel.name];
     if (!channelMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for channel '${channel.name}'`);
+        console.warn(`[pikku] Skipping channel '${channel.name}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
-    pikkuState(null, 'channel', 'channels').set(channel.name, channel);
     // Register onConnect function if provided
     if (channel.onConnect && channelMeta.connect) {
         addFunction(channelMeta.connect.pikkuFuncId, channel.onConnect);

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

@@ -1,4 +1,4 @@
-import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js';
+import { NotFoundError } from '../../errors/errors.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
 import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
@@ -29,7 +29,8 @@ export const wireCLI = (cli) => {
     // Get the existing metadata that was generated during inspection
     const cliMeta = pikkuState(null, 'cli', 'meta') || {};
     if (!cliMeta.programs?.[cli.program]) {
-        throw new PikkuMissingMetaError(`CLI metadata not found for program '${cli.program}'`);
+        console.warn(`[pikku] Skipping CLI program '${cli.program}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     // Get existing programs state and add this program
     const programs = pikkuState(null, 'cli', 'programs') || {};
@@ -322,8 +323,9 @@ export async function executeCLI({ programName, args, createConfig, createSingle
         const config = createConfig
             ? await createConfig(new LocalVariablesService(), data)
             : {};
-        // Create services with config
+        // Create services with config and register in global state
         const singletonServices = await createSingletonServices(config);
+        pikkuState(null, 'package', 'singletonServices', singletonServices);
         // Execute the command
         await runCLICommand({
             program: programName,

package/dist/wirings/cli/command-parser.js

@@ -1,3 +1,7 @@
+/** Convert kebab-case to camelCase: "from-plan" → "fromPlan" */
+function toCamelCase(str) {
+    return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
 /**
  * Parses raw CLI arguments into structured data for a specific program
  */
@@ -81,11 +85,11 @@ export function parseCLIArguments(args, programName, allMeta) {
     while (currentIndex < args.length) {
         const arg = args[currentIndex];
         if (arg.startsWith('--')) {
-            // Long option
+            // Long option (--from-plan → fromPlan)
             const equalIndex = arg.indexOf('=');
             if (equalIndex > 0) {
                 // --option=value format
-                const key = arg.slice(2, equalIndex);
+                const key = toCamelCase(arg.slice(2, equalIndex));
                 const optionDef = availableOptions[key];
                 // Unknown options are allowed for forward compatibility
                 const value = arg.slice(equalIndex + 1);
@@ -93,7 +97,7 @@ export function parseCLIArguments(args, programName, allMeta) {
             }
             else {
                 // --option value format
-                const key = arg.slice(2);
+                const key = toCamelCase(arg.slice(2));
                 const optionDef = availableOptions[key];
                 // Unknown options are allowed for forward compatibility
                 if (optionDef && optionDef.array) {

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

@@ -136,4 +136,4 @@ export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest,
  * @param {RunHTTPWiringOptions} options - Options such as singleton services, session handling, and error configuration.
  * @returns {Promise<Out | void>} The output from the route handler or void if an error occurred.
  */
-export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, exposeErrors, generateRequestId, }?: RunHTTPWiringOptions) => Promise<Out | void>;
+export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, exposeErrors, generateRequestId, traceId: externalTraceId, }?: RunHTTPWiringOptions) => Promise<Out | void>;

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

@@ -1,4 +1,4 @@
-import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js';
+import { NotFoundError } from '../../errors/errors.js';
 import { closeWireServices, createWeakUID, isSerializable, } from '../../utils.js';
 import { getSingletonServices, getCreateWireServices, } from '../../pikku-state.js';
 import { PikkuSessionService } from '../../services/user-session-service.js';
@@ -112,7 +112,12 @@ export const wireHTTP = (httpWiring) => {
     const httpMeta = pikkuState(null, 'http', 'meta');
     const routeMeta = httpMeta[httpWiring.method][httpWiring.route];
     if (!routeMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for HTTP route '${httpWiring.method.toUpperCase()} ${httpWiring.route}'`);
+        // In deploy units with filtered metadata, wiring files may include
+        // routes for functions not in this unit. This happens when multiple
+        // wirings share a file — split them into separate files for better
+        // tree-shaking.
+        console.warn(`[pikku] Skipping HTTP route '${httpWiring.method.toUpperCase()} ${httpWiring.route}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     if (httpWiring.func) {
         addFunction(routeMeta.pikkuFuncId, httpWiring.func);
@@ -251,6 +256,7 @@ const executeRoute = async (services, matchedRoute, http, options) => {
         };
     }
     const wire = {
+        traceId: requestId,
         http,
         channel,
         session: userSession.get(),
@@ -345,19 +351,25 @@ export const pikkuFetch = async (request, params = {}) => {
  * @param {RunHTTPWiringOptions} options - Options such as singleton services, session handling, and error configuration.
  * @returns {Promise<Out | void>} The output from the route handler or void if an error occurred.
  */
-export const fetchData = async (request, response, { skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, exposeErrors = false, generateRequestId, } = {}) => {
+export const fetchData = async (request, response, { skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, exposeErrors = false, generateRequestId, traceId: externalTraceId, } = {}) => {
     const singletonServices = getSingletonServices();
     const createWireServices = getCreateWireServices();
     let wireServices;
     let result;
     // Combine the request and response into one wire object
     const pikkuRequest = request instanceof Request ? new PikkuFetchHTTPRequest(request) : request;
-    let requestId = null;
-    try {
-        requestId = pikkuRequest.header('x-request-id');
+    // Resolve traceId: external (e.g. CF-Ray) > x-request-id header > generated
+    let requestId = externalTraceId ?? null;
+    if (!requestId) {
+        try {
+            requestId = pikkuRequest.header('x-request-id');
+        }
+        catch { }
     }
-    catch { }
     requestId = requestId || generateRequestId?.() || createWeakUID();
+    // Scoped logger for HTTP runner internal logging (error handling, route matching)
+    // Functions/middleware receive singletonServices.logger directly for compatibility
+    const scopedLogger = singletonServices.logger.scope?.(requestId) ?? singletonServices.logger;
     const http = createHTTPWire(pikkuRequest, response);
     const apiType = http.request.method();
     const apiRoute = http.request.path();
@@ -375,7 +387,7 @@ export const fetchData = async (request, response, { skipUserSession = false, re
                 response.status(204).json(undefined);
                 return;
             }
-            singletonServices.logger.info({
+            scopedLogger.info({
                 message: 'Route not found',
                 apiRoute,
                 apiType,
@@ -395,7 +407,7 @@ export const fetchData = async (request, response, { skipUserSession = false, re
     catch (e) {
         if (matchedRoute?.route.sse) {
             // For SSE routes, send error through the stream since the response is already in stream mode
-            singletonServices.logger.error(e instanceof Error ? e.message : e);
+            scopedLogger.error(e instanceof Error ? e.message : e);
             try {
                 const errorResponse = getErrorResponse(e);
                 response.arrayBuffer(JSON.stringify({
@@ -405,12 +417,12 @@ export const fetchData = async (request, response, { skipUserSession = false, re
                 response.arrayBuffer(JSON.stringify({ type: 'done' }));
             }
             catch (streamErr) {
-                singletonServices.logger.error(`SSE error while sending error payload: ${streamErr instanceof Error ? streamErr.message : String(streamErr)}`);
+                scopedLogger.error(`SSE error while sending error payload: ${streamErr instanceof Error ? streamErr.message : String(streamErr)}`);
             }
             response.close?.();
         }
         else {
-            handleHTTPError(e, http, requestId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors, exposeErrors);
+            handleHTTPError(e, http, requestId, scopedLogger, logWarningsForStatusCodes, respondWith404, bubbleErrors, exposeErrors);
         }
     }
     finally {

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

@@ -17,6 +17,8 @@ export type RunHTTPWiringOptions = Partial<{
     bubbleErrors: boolean;
     exposeErrors: boolean;
     generateRequestId: () => string;
+    /** Pre-resolved trace ID (e.g. CF-Ray). Falls back to x-request-id header or generated ID. */
+    traceId: string;
 }>;
 /**
  * Represents the HTTP methods supported for API HTTP wirings.
@@ -165,6 +167,7 @@ export interface PikkuHTTPRequest<In = unknown> {
     query(): PikkuQuery;
 }
 export interface PikkuHTTPResponse<Out = unknown> {
+    readonly statusCode: number;
     status(code: number): this;
     cookie(name: string, value: string | null, options: SerializeOptions): this;
     header(name: string, value: string | string[]): this;

package/dist/wirings/http/pikku-fetch-http-response.d.ts

@@ -3,6 +3,7 @@ import type { SerializeOptions as CookieSerializeOptions } from 'cookie';
 export declare class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
     #private;
     setMode(mode: 'stream'): void;
+    get statusCode(): number;
     status(code: number): this;
     cookie(name: string, value: string, flags: CookieSerializeOptions): this;
     header(name: string, value: string | string[]): this;

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

@@ -13,6 +13,9 @@ export class PikkuFetchHTTPResponse {
             this.#body = this.createStream();
         }
     }
+    get statusCode() {
+        return this.#statusCode;
+    }
     status(code) {
         this.#statusCode = code;
         return this;

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

@@ -3,7 +3,7 @@ import { closeWireServices } from '../../utils.js';
 import { pikkuState, getSingletonServices, getCreateWireServices, } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { resolveNamespace } from '../rpc/rpc-runner.js';
-import { BadRequestError, NotFoundError, PikkuMissingMetaError, } from '../../errors/errors.js';
+import { BadRequestError, NotFoundError } from '../../errors/errors.js';
 import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
 export class MCPError extends Error {
     error;
@@ -18,7 +18,8 @@ export const wireMCPResource = (mcpResource) => {
     const resourcesMeta = pikkuState(null, 'mcp', 'resourcesMeta');
     const mcpResourceMeta = resourcesMeta[mcpResource.uri];
     if (!mcpResourceMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for MCP resource '${mcpResource.uri}'`);
+        console.warn(`[pikku] Skipping MCP resource '${mcpResource.uri}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     addFunction(mcpResourceMeta.pikkuFuncId, mcpResource.func);
     const resources = pikkuState(null, 'mcp', 'resources');
@@ -31,7 +32,8 @@ export const wireMCPPrompt = (mcpPrompt) => {
     const promptsMeta = pikkuState(null, 'mcp', 'promptsMeta');
     const mcpPromptMeta = promptsMeta[mcpPrompt.name];
     if (!mcpPromptMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for MCP prompt '${mcpPrompt.name}'`);
+        console.warn(`[pikku] Skipping MCP prompt '${mcpPrompt.name}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     addFunction(mcpPromptMeta.pikkuFuncId, mcpPrompt.func);
     const prompts = pikkuState(null, 'mcp', 'prompts');

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

@@ -80,7 +80,7 @@ export type CoreMCPResource<PikkuFunctionConfig = CorePikkuFunctionConfig<CorePi
 export type CoreMCPTool<PikkuFunctionConfig = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>>, PikkuPermission = CorePikkuPermission<any, any>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
     name: string;
     title?: string;
-    description: string;
+    description?: string;
     summary?: string;
     errors?: string[];
     func: PikkuFunctionConfig;

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

@@ -28,7 +28,9 @@ export declare function removeQueueWorker(name: string): Promise<void>;
 /**
  * Process a single queue job - this function is called by queue consumers
  */
-export declare function runQueueJob({ job, updateProgress, }: {
+export declare function runQueueJob({ job, updateProgress, traceId, }: {
     job: QueueJob;
     updateProgress?: (progress: number | string | object) => Promise<void>;
+    /** Pre-resolved trace ID (e.g. from queue message metadata) */
+    traceId?: string;
 }): Promise<void>;

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

@@ -36,7 +36,8 @@ export const wireQueueWorker = (queueWorker) => {
     const meta = pikkuState(null, 'queue', 'meta');
     const processorMeta = meta[queueWorker.name];
     if (!processorMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for queue worker '${queueWorker.name}'`);
+        console.warn(`[pikku] Skipping queue worker '${queueWorker.name}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     // Register the function with pikku
     addFunction(processorMeta.pikkuFuncId, {
@@ -70,10 +71,12 @@ export async function removeQueueWorker(name) {
 /**
  * Process a single queue job - this function is called by queue consumers
  */
-export async function runQueueJob({ job, updateProgress, }) {
+export async function runQueueJob({ job, updateProgress, traceId, }) {
     const singletonServices = getSingletonServices();
     const createWireServices = getCreateWireServices();
-    const logger = singletonServices.logger;
+    const resolvedTraceId = traceId ?? `q-${job.id}`;
+    const logger = singletonServices.logger.scope?.(resolvedTraceId) ??
+        singletonServices.logger;
     const meta = pikkuState(null, 'queue', 'meta');
     const processorMeta = meta[job.queueName];
     if (!processorMeta) {
@@ -105,6 +108,7 @@ export async function runQueueJob({ job, updateProgress, }) {
     try {
         logger.info(`Processing job ${job.id} in queue ${job.queueName}`);
         const wire = {
+            traceId: resolvedTraceId,
             queue,
         };
         // Execute the pikku function with the job data

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;
 }>;