@pikku/core 0.11.1 → 0.11.2

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

@@ -7,6 +7,7 @@ import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 import { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { httpRouter } from './routers/http-router.js';
+import { startWorkflowByHttpWire } from '../workflow/workflow-utils.js';
 /**
  * Registers HTTP middleware for a specific route pattern.
  *
@@ -36,8 +37,8 @@ import { httpRouter } from './routers/http-router.js';
  * ])
  * ```
  */
-export const addHTTPMiddleware = (pattern, middleware) => {
-    const httpGroups = pikkuState('middleware', 'httpGroup');
+export const addHTTPMiddleware = (pattern, middleware, packageName = null) => {
+    const httpGroups = pikkuState(packageName, 'middleware', 'httpGroup');
     httpGroups[pattern] = middleware;
     return middleware;
 };
@@ -70,8 +71,8 @@ export const addHTTPMiddleware = (pattern, middleware) => {
  * ])
  * ```
  */
-export const addHTTPPermission = (pattern, permissions) => {
-    const httpGroups = pikkuState('permissions', 'httpGroup');
+export const addHTTPPermission = (pattern, permissions, packageName = null) => {
+    const httpGroups = pikkuState(packageName, 'permissions', 'httpGroup');
     httpGroups[pattern] = permissions;
     return permissions;
 };
@@ -91,17 +92,19 @@ export const addHTTPPermission = (pattern, permissions) => {
  * @param {CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware>} httpWiring - The HTTP wiring configuration object.
  */
 export const wireHTTP = (httpWiring) => {
-    const httpMeta = pikkuState('http', 'meta');
+    const httpMeta = pikkuState(null, 'http', 'meta');
     const routeMeta = httpMeta[httpWiring.method][httpWiring.route];
     if (!routeMeta) {
         throw new Error('Route metadata not found');
     }
-    addFunction(routeMeta.pikkuFuncName, httpWiring.func);
-    const routes = pikkuState('http', 'routes');
+    if (httpWiring.func) {
+        addFunction(routeMeta.pikkuFuncName, httpWiring.func);
+    }
+    const routes = pikkuState(null, 'http', 'routes');
     if (!routes.has(httpWiring.method)) {
         routes.set(httpWiring.method, new Map());
     }
-    pikkuState('http', 'routes')
+    pikkuState(null, 'http', 'routes')
         .get(httpWiring.method)
         ?.set(httpWiring.route, httpWiring);
 };
@@ -119,10 +122,10 @@ export const wireHTTP = (httpWiring) => {
 const getMatchingRoute = (requestType, requestPath) => {
     const matchedPath = httpRouter.match(requestType.toLowerCase(), requestPath);
     if (matchedPath) {
-        const route = pikkuState('http', 'routes')
+        const route = pikkuState(null, 'http', 'routes')
             .get(requestType.toLowerCase())
             .get(matchedPath.route);
-        const meta = pikkuState('http', 'meta')[requestType.toLowerCase()][route.route];
+        const meta = pikkuState(null, 'http', 'meta')[requestType.toLowerCase()][route.route];
         return {
             matchedPath,
             params: matchedPath.params,
@@ -179,11 +182,11 @@ const executeRoute = async (services, matchedRoute, http, options) => {
     const userSession = new PikkuSessionService();
     const { params, route, meta } = matchedRoute;
     const { singletonServices, createWireServices, skipUserSession, requestId } = services;
+    // Attach URL parameters to the request object
+    http?.request?.setParams(params);
     const requiresSession = route.auth !== false;
     let wireServices;
     let result;
-    // Attach URL parameters to the request object
-    http?.request?.setParams(params);
     singletonServices.logger.info(`Matched route: ${route.route} | method: ${route.method.toUpperCase()} | auth: ${requiresSession.toString()}`);
     // Ensure session is available when required
     if (skipUserSession && requiresSession) {
@@ -218,6 +221,12 @@ const executeRoute = async (services, matchedRoute, http, options) => {
         };
     }
     const wire = { http, channel, session: userSession };
+    if (matchedRoute.meta.workflow === true) {
+        await startWorkflowByHttpWire(singletonServices, createWireServices, matchedRoute, wire);
+        return wireServices
+            ? { wireServices, result: http.response }
+            : { result: http.response };
+    }
     result = await runPikkuFunc('http', `${meta.method}:${meta.route}`, meta.pikkuFuncName, {
         singletonServices,
         createWireServices,

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

@@ -123,7 +123,19 @@ export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction exte
     tags?: string[];
     middleware?: PikkuMiddleware[];
     sse?: undefined;
-});
+}) | {
+    /** Route triggers a workflow matched by route/method from workflow wires.http */
+    route: R;
+    method: HTTPMethod;
+    workflow: true;
+    func?: undefined;
+    permissions?: undefined;
+    auth?: undefined;
+    tags?: undefined;
+    middleware?: undefined;
+    returnsJSON?: undefined;
+    sse?: boolean;
+};
 /**
  * Represents the input types for HTTP wiring metadata, including parameters, query, and body types.
  */
@@ -142,6 +154,7 @@ export type HTTPWiringMeta = CommonWireMeta & {
     query?: string[];
     inputTypes?: HTTPFunctionMetaInputTypes;
     sse?: true;
+    workflow?: true;
 };
 export type HTTPWiringsMeta = Record<HTTPMethod, Record<string, HTTPWiringMeta>>;
 export type HTTPFunctionsMeta = Array<{

package/dist/wirings/http/log-http-routes.js

@@ -4,7 +4,7 @@ import { pikkuState } from '../../pikku-state.js';
  * @param logger - A logger for logging information.
  */
 export const logRoutes = (logger) => {
-    const routesByType = pikkuState('http', 'routes');
+    const routesByType = pikkuState(null, 'http', 'routes');
     if (routesByType.size === 0) {
         logger.info('No routes added');
         return;

package/dist/wirings/http/routers/path-to-regex.js

@@ -10,8 +10,8 @@ export class PathToRegexRouter {
         this.isInitialized = false;
     }
     initialize() {
-        const routes = pikkuState('http', 'routes');
-        const channelRoutes = pikkuState('channel', 'channels');
+        const routes = pikkuState(null, 'http', 'routes');
+        const channelRoutes = pikkuState(null, 'channel', 'channels');
         // Helper function to compile routes for a given method
         const compileRoutesForMethod = (method, routeEntries) => {
             const methodCompiledRoutes = this.compiledRoutes.get(method) || new Map();

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

@@ -14,39 +14,39 @@ export class MCPError extends Error {
     }
 }
 export const wireMCPResource = (mcpResource) => {
-    const resourcesMeta = pikkuState('mcp', 'resourcesMeta');
+    const resourcesMeta = pikkuState(null, 'mcp', 'resourcesMeta');
     const mcpResourceMeta = resourcesMeta[mcpResource.uri];
     if (!mcpResourceMeta) {
         throw new Error(`MCP resource metadata not found for '${mcpResource.uri}'`);
     }
     addFunction(mcpResourceMeta.pikkuFuncName, mcpResource.func);
-    const resources = pikkuState('mcp', 'resources');
+    const resources = pikkuState(null, 'mcp', 'resources');
     if (resources.has(mcpResource.uri)) {
         throw new Error(`MCP resource already exists: ${mcpResource.uri}`);
     }
     resources.set(mcpResource.uri, mcpResource);
 };
 export const wireMCPTool = (mcpTool) => {
-    const toolsMeta = pikkuState('mcp', 'toolsMeta');
+    const toolsMeta = pikkuState(null, 'mcp', 'toolsMeta');
     const mcpToolMeta = toolsMeta[mcpTool.name];
     if (!mcpToolMeta) {
         throw new Error(`MCP tool metadata not found for '${mcpTool.name}'`);
     }
     addFunction(mcpToolMeta.pikkuFuncName, mcpTool.func);
-    const tools = pikkuState('mcp', 'tools');
+    const tools = pikkuState(null, 'mcp', 'tools');
     if (tools.has(mcpTool.name)) {
         throw new Error(`MCP tool already exists: ${mcpTool.name}`);
     }
     tools.set(mcpTool.name, mcpTool);
 };
 export const wireMCPPrompt = (mcpPrompt) => {
-    const promptsMeta = pikkuState('mcp', 'promptsMeta');
+    const promptsMeta = pikkuState(null, 'mcp', 'promptsMeta');
     const mcpPromptMeta = promptsMeta[mcpPrompt.name];
     if (!mcpPromptMeta) {
         throw new Error(`MCP prompt metadata not found for '${mcpPrompt.name}'`);
     }
     addFunction(mcpPromptMeta.pikkuFuncName, mcpPrompt.func);
-    const prompts = pikkuState('mcp', 'prompts');
+    const prompts = pikkuState(null, 'mcp', 'prompts');
     if (prompts.has(mcpPrompt.name)) {
         throw new Error(`MCP prompt already exists: ${mcpPrompt.name}`);
     }
@@ -56,8 +56,8 @@ export async function runMCPResource(request, params, uri) {
     let endpoint;
     let pikkuFuncName;
     let extractedParams = {};
-    const metas = pikkuState('mcp', 'resourcesMeta');
-    const endpoints = pikkuState('mcp', 'resources');
+    const metas = pikkuState(null, 'mcp', 'resourcesMeta');
+    const endpoints = pikkuState(null, 'mcp', 'resources');
     if (endpoints.has(uri)) {
         endpoint = endpoints.get(uri);
         pikkuFuncName = metas[uri]?.pikkuFuncName;
@@ -87,13 +87,13 @@ export async function runMCPResource(request, params, uri) {
     }, 'resource', uri, endpoint, pikkuFuncName, { ...params, mcp: { ...params.mcp, uri } });
 }
 export async function runMCPTool(request, params, name) {
-    const endpoint = pikkuState('mcp', 'tools').get(name);
-    const meta = pikkuState('mcp', 'toolsMeta')[name];
+    const endpoint = pikkuState(null, 'mcp', 'tools').get(name);
+    const meta = pikkuState(null, 'mcp', 'toolsMeta')[name];
     return await runMCPPikkuFunc(request, 'tool', name, endpoint, meta?.pikkuFuncName, params);
 }
 export async function runMCPPrompt(request, params, name) {
-    const endpoint = pikkuState('mcp', 'prompts').get(name);
-    const meta = pikkuState('mcp', 'promptsMeta')[name];
+    const endpoint = pikkuState(null, 'mcp', 'prompts').get(name);
+    const meta = pikkuState(null, 'mcp', 'promptsMeta')[name];
     return await runMCPPikkuFunc(request, 'prompt', name, endpoint, meta?.pikkuFuncName, params);
 }
 /**
@@ -120,13 +120,13 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { single
         // Get metadata for the MCP endpoint to access pre-resolved middleware
         let meta;
         if (type === 'resource') {
-            meta = pikkuState('mcp', 'resourcesMeta')[name];
+            meta = pikkuState(null, 'mcp', 'resourcesMeta')[name];
         }
         else if (type === 'tool') {
-            meta = pikkuState('mcp', 'toolsMeta')[name];
+            meta = pikkuState(null, 'mcp', 'toolsMeta')[name];
         }
         else if (type === 'prompt') {
-            meta = pikkuState('mcp', 'promptsMeta')[name];
+            meta = pikkuState(null, 'mcp', 'promptsMeta')[name];
         }
         const result = await runPikkuFunc('mcp', `${type}:${name}`, pikkuFuncName, {
             singletonServices,
@@ -173,20 +173,20 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { single
     }
 }
 export const getMCPTools = () => {
-    return pikkuState('mcp', 'tools');
+    return pikkuState(null, 'mcp', 'tools');
 };
 export const getMCPResources = () => {
-    return pikkuState('mcp', 'resources');
+    return pikkuState(null, 'mcp', 'resources');
 };
 export const getMCPResourcesMeta = () => {
-    return pikkuState('mcp', 'resourcesMeta');
+    return pikkuState(null, 'mcp', 'resourcesMeta');
 };
 export const getMCPToolsMeta = () => {
-    return pikkuState('mcp', 'toolsMeta');
+    return pikkuState(null, 'mcp', 'toolsMeta');
 };
 export const getMCPPrompts = () => {
-    return pikkuState('mcp', 'prompts');
+    return pikkuState(null, 'mcp', 'prompts');
 };
 export const getMCPPromptsMeta = () => {
-    return pikkuState('mcp', 'promptsMeta');
+    return pikkuState(null, 'mcp', 'promptsMeta');
 };

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

@@ -32,7 +32,7 @@ export class QueueJobDiscardedError extends PikkuError {
  */
 export const wireQueueWorker = (queueWorker) => {
     // Get processor metadata
-    const meta = pikkuState('queue', 'meta');
+    const meta = pikkuState(null, 'queue', 'meta');
     const processorMeta = meta[queueWorker.queueName];
     if (!processorMeta) {
         throw new Error(`Queue processor metadata not found for '${queueWorker.queueName}'. Make sure to run the CLI to generate metadata.`);
@@ -46,20 +46,20 @@ export const wireQueueWorker = (queueWorker) => {
         tags: queueWorker.func.tags,
     });
     // Store processor definition in state - runtime adapters will pick this up
-    const registrations = pikkuState('queue', 'registrations');
+    const registrations = pikkuState(null, 'queue', 'registrations');
     registrations.set(queueWorker.queueName, queueWorker);
 };
 /**
  * Get all registered queue processors
  */
 export function getQueueWorkers() {
-    return pikkuState('queue', 'registrations');
+    return pikkuState(null, 'queue', 'registrations');
 }
 /**
  * Stop and remove a queue processor
  */
 export async function removeQueueWorker(name) {
-    const registrations = pikkuState('queue', 'registrations');
+    const registrations = pikkuState(null, 'queue', 'registrations');
     const registration = registrations.get(name);
     if (!registration) {
         throw new QueueWorkerNotFoundError(name);
@@ -71,13 +71,13 @@ export async function removeQueueWorker(name) {
  */
 export async function runQueueJob({ singletonServices, createWireServices, job, updateProgress, }) {
     const logger = singletonServices.logger;
-    const meta = pikkuState('queue', 'meta');
+    const meta = pikkuState(null, 'queue', 'meta');
     const processorMeta = meta[job.queueName];
     if (!processorMeta) {
         throw new Error(`Processor metadata not found for: ${job.queueName}`);
     }
     // Get the queue worker registration to access middleware
-    const registrations = pikkuState('queue', 'registrations');
+    const registrations = pikkuState(null, 'queue', 'registrations');
     const queueWorker = registrations.get(job.queueName);
     if (!queueWorker) {
         throw new Error(`Queue worker registration not found for: ${job.queueName}`);

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

@@ -1,2 +1,2 @@
-export { initialize, PikkuRPCService, rpcService } from './rpc-runner.js';
+export { PikkuRPCService, rpcService } from './rpc-runner.js';
 export type { PikkuRPC, RPCMeta } from './rpc-types.js';

package/dist/wirings/rpc/index.js

@@ -1 +1 @@
-export { initialize, PikkuRPCService, rpcService } from './rpc-runner.js';
+export { PikkuRPCService, rpcService } from './rpc-runner.js';

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

@@ -1,26 +1,27 @@
 import { CoreServices, PikkuWire } from '../../types/core.types.js';
 import { PikkuRPC } from './rpc-types.js';
-type RPCServiceConfig = {
-    coerceDataFromSchema: boolean;
-};
 export declare class ContextAwareRPCService {
     private services;
     private wire;
     private options;
     constructor(services: CoreServices, wire: PikkuWire, options: {
-        coerceDataFromSchema?: boolean;
         requiresAuth?: boolean;
     });
     rpcExposed(funcName: string, data: any): Promise<any>;
     rpc<In = any, Out = any>(funcName: string, data: In): Promise<Out>;
+    /**
+     * Invoke a function from an external package
+     * External packages register their functions in pikkuState under their package name.
+     * The function is executed using the parent services (shared singleton services).
+     * @private
+     */
+    private invokeExternalPackageFunction;
     rpcWithWire<In = any, Out = any>(rpcName: string, data: In, wire: PikkuWire): Promise<Out>;
     startWorkflow<In = any>(workflowName: string, input: In): Promise<{
         runId: string;
     }>;
 }
 export declare class PikkuRPCService<Services extends CoreServices, TypedRPC = PikkuRPC> {
-    private config?;
-    initialize(config: RPCServiceConfig): void;
     getContextRPCService(services: Services, wire: PikkuWire, requiresAuth?: boolean | undefined, depth?: number): TypedRPC;
 }
 export declare const rpcService: PikkuRPCService<import("../../types/core.types.js").CoreSingletonServices<{
@@ -28,5 +29,3 @@ export declare const rpcService: PikkuRPCService<import("../../types/core.types.
     secrets?: {};
     workflow?: import("../workflow/workflow.types.js").WorkflowServiceConfig;
 }>, PikkuRPC>;
-export declare const initialize: (config: RPCServiceConfig) => void;
-export {};

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

@@ -1,8 +1,29 @@
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
 import { ForbiddenError } from '../../errors/errors.js';
+/**
+ * Resolve a namespaced function reference to package and function names
+ * Uses pikkuState to look up the namespace -> package mapping
+ */
+const resolveNamespace = (namespacedFunction) => {
+    const colonIndex = namespacedFunction.indexOf(':');
+    if (colonIndex === -1) {
+        return null;
+    }
+    const namespace = namespacedFunction.substring(0, colonIndex);
+    const functionName = namespacedFunction.substring(colonIndex + 1);
+    const externalPackages = pikkuState(null, 'rpc', 'externalPackages');
+    const packageName = externalPackages.get(namespace);
+    if (!packageName) {
+        return null;
+    }
+    return {
+        package: packageName,
+        function: functionName,
+    };
+};
 const getPikkuFunctionName = (rpcName) => {
-    const rpc = pikkuState('rpc', 'meta');
+    const rpc = pikkuState(null, 'rpc', 'meta');
     const rpcMeta = rpc[rpcName];
     if (!rpcMeta) {
         throw new Error(`RPC function not found: ${rpcName}`);
@@ -20,7 +41,7 @@ export class ContextAwareRPCService {
         this.options = options;
     }
     async rpcExposed(funcName, data) {
-        const functionMeta = pikkuState('function', 'meta')[funcName];
+        const functionMeta = pikkuState(null, 'function', 'meta')[funcName];
         if (!functionMeta) {
             throw new Error(`Function not found: ${funcName}`);
         }
@@ -41,16 +62,54 @@ export class ContextAwareRPCService {
                 }
                 : undefined,
         };
+        // Check if it's a namespaced function call (e.g., 'stripe:createCharge')
+        if (funcName.includes(':')) {
+            return this.invokeExternalPackageFunction(funcName, data, updatedWire);
+        }
+        // Main package function
         return runPikkuFunc('rpc', funcName, getPikkuFunctionName(funcName), {
             auth: this.options.requiresAuth,
             // TODO: this is a hack since services have already been created
             // but is valid since we don't want to keep creating new wire services
             singletonServices: this.services,
             data: () => data,
-            coerceDataFromSchema: this.options.coerceDataFromSchema,
             wire: updatedWire,
         });
     }
+    /**
+     * Invoke a function from an external package
+     * External packages register their functions in pikkuState under their package name.
+     * The function is executed using the parent services (shared singleton services).
+     * @private
+     */
+    async invokeExternalPackageFunction(namespacedFunction, data, wire) {
+        // 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 externalPackages config.`);
+        }
+        // Get the function meta from the external package
+        // External packages use function meta, not RPC meta
+        const externalFunctionMeta = pikkuState(resolved.package, 'function', 'meta');
+        const funcMeta = externalFunctionMeta[resolved.function];
+        if (!funcMeta) {
+            throw new Error(`Function '${resolved.function}' not found in package '${resolved.package}'. ` +
+                `Available functions: ${Object.keys(externalFunctionMeta).join(', ') || '(none)'}`);
+        }
+        const funcName = funcMeta.pikkuFuncName || resolved.function;
+        // Execute the function using runPikkuFunc with the external package's state
+        // We use the parent services (this.services) since external packages share services
+        // Pass the function's tags so tag-based middleware/permissions are applied
+        return runPikkuFunc('rpc', namespacedFunction, funcName, {
+            auth: this.options.requiresAuth,
+            singletonServices: this.services,
+            data: () => data,
+            wire,
+            packageName: resolved.package,
+            tags: funcMeta.tags,
+        });
+    }
     async rpcWithWire(rpcName, data, wire) {
         const rpcDepth = this.wire.rpc?.depth || 0;
         const mergedWire = {
@@ -68,7 +127,6 @@ export class ContextAwareRPCService {
             auth: this.options.requiresAuth,
             singletonServices: this.services,
             data: () => data,
-            coerceDataFromSchema: this.options.coerceDataFromSchema,
             wire: mergedWire,
         });
     }
@@ -81,15 +139,9 @@ export class ContextAwareRPCService {
 }
 // RPC Service class for the global interface
 export class PikkuRPCService {
-    config;
-    // Initialize the RPC service with configuration
-    initialize(config) {
-        this.config = config;
-    }
     // Convenience function for initializing
     getContextRPCService(services, wire, requiresAuth, depth = 0) {
         const serviceRPC = new ContextAwareRPCService(services, wire, {
-            coerceDataFromSchema: this.config?.coerceDataFromSchema,
             requiresAuth,
         });
         return {
@@ -104,7 +156,3 @@ export class PikkuRPCService {
 }
 // Create a singleton instance
 export const rpcService = new PikkuRPCService();
-// Convenience function for initializing
-export const initialize = (config) => {
-    rpcService.initialize(config);
-};

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

@@ -15,3 +15,10 @@ export interface RPCHandler<Input, Output> {
     input: Input;
     output: Output;
 }
+/**
+ * Resolved function reference from namespace
+ */
+export interface ResolvedFunction {
+    package: string;
+    function: string;
+}

package/dist/wirings/scheduler/log-schedulers.js

@@ -4,7 +4,7 @@ import { pikkuState } from '../../pikku-state.js';
  * @param logger - A logger for logging information.
  */
 export const logSchedulers = (logger) => {
-    const scheduledTasks = pikkuState('scheduler', 'tasks');
+    const scheduledTasks = pikkuState(null, 'scheduler', 'tasks');
     if (scheduledTasks.size === 0) {
         logger.info('No scheduled tasks added');
         return;

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

@@ -4,7 +4,7 @@ import { pikkuState } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { PikkuSessionService } from '../../services/user-session-service.js';
 export const wireScheduler = (scheduledTask) => {
-    const meta = pikkuState('scheduler', 'meta');
+    const meta = pikkuState(null, 'scheduler', 'meta');
     const taskMeta = meta[scheduledTask.name];
     if (!taskMeta) {
         throw new Error('Task metadata not found');
@@ -16,7 +16,7 @@ export const wireScheduler = (scheduledTask) => {
         middleware: scheduledTask.func.middleware,
         tags: scheduledTask.func.tags,
     });
-    const tasks = pikkuState('scheduler', 'tasks');
+    const tasks = pikkuState(null, 'scheduler', 'tasks');
     if (tasks.has(scheduledTask.name)) {
         throw new Error(`Scheduled task already exists: ${scheduledTask.name}`);
     }
@@ -35,8 +35,8 @@ class ScheduledTaskSkippedError extends PikkuError {
 }
 export async function runScheduledTask({ name, session, singletonServices, createWireServices, }) {
     let wireServices;
-    const task = pikkuState('scheduler', 'tasks').get(name);
-    const meta = pikkuState('scheduler', 'meta')[name];
+    const task = pikkuState(null, 'scheduler', 'tasks').get(name);
+    const meta = pikkuState(null, 'scheduler', 'meta')[name];
     const userSession = new PikkuSessionService();
     if (session) {
         userSession.set(session);
@@ -86,5 +86,5 @@ export async function runScheduledTask({ name, session, singletonServices, creat
     }
 }
 export const getScheduledTasks = () => {
-    return pikkuState('scheduler', 'tasks');
+    return pikkuState(null, 'scheduler', 'tasks');
 };

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

@@ -0,0 +1,2 @@
+export * from './trigger.types.js';
+export * from './trigger-runner.js';

package/dist/wirings/trigger/index.js

@@ -0,0 +1,2 @@
+export * from './trigger.types.js';
+export * from './trigger-runner.js';

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

@@ -0,0 +1,29 @@
+import type { CoreSingletonServices } from '../../types/core.types.js';
+import type { CoreTrigger, TriggerInstance } from './trigger.types.js';
+import type { CorePikkuTriggerFunctionConfig } from '../../function/functions.types.js';
+/**
+ * Registers a trigger with the Pikku framework.
+ * The trigger will be available for setup via setupTrigger.
+ */
+export declare const wireTrigger: <TConfig = unknown, TOutput = unknown, TriggerFunctionConfig extends CorePikkuTriggerFunctionConfig<TConfig, TOutput> = CorePikkuTriggerFunctionConfig<TConfig, TOutput>>(trigger: CoreTrigger<TConfig, TOutput, TriggerFunctionConfig>) => void;
+/**
+ * Parameters for setting up a trigger
+ */
+export type SetupTriggerParams<TOutput = unknown> = {
+    name: string;
+    singletonServices: CoreSingletonServices;
+    onTrigger: (data: TOutput) => void | Promise<void>;
+};
+/**
+ * Sets up a registered trigger and starts listening for events.
+ * Returns a TriggerInstance with a teardown function.
+ */
+export declare function setupTrigger<TOutput = unknown>({ name, singletonServices, onTrigger, }: SetupTriggerParams<TOutput>): Promise<TriggerInstance>;
+/**
+ * Gets all registered triggers
+ */
+export declare const getRegisteredTriggers: () => Map<string, CoreTrigger<unknown, unknown, CorePikkuTriggerFunctionConfig<unknown, unknown>>>;
+/**
+ * Gets trigger metadata
+ */
+export declare const getTriggerMeta: () => import("./trigger.types.js").TriggerMeta;

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

@@ -0,0 +1,57 @@
+import { pikkuState } from '../../pikku-state.js';
+/**
+ * Registers a trigger with the Pikku framework.
+ * The trigger will be available for setup via setupTrigger.
+ */
+export const wireTrigger = (trigger) => {
+    const meta = pikkuState(null, 'trigger', 'meta');
+    const triggerMeta = meta[trigger.name];
+    if (!triggerMeta) {
+        throw new Error(`Trigger metadata not found: ${trigger.name}`);
+    }
+    const triggers = pikkuState(null, 'trigger', 'triggers');
+    if (triggers.has(trigger.name)) {
+        throw new Error(`Trigger already exists: ${trigger.name}`);
+    }
+    triggers.set(trigger.name, trigger);
+};
+/**
+ * Sets up a registered trigger and starts listening for events.
+ * Returns a TriggerInstance with a teardown function.
+ */
+export async function setupTrigger({ name, singletonServices, onTrigger, }) {
+    const trigger = pikkuState(null, 'trigger', 'triggers').get(name);
+    const meta = pikkuState(null, 'trigger', 'meta')[name];
+    if (!trigger) {
+        throw new Error(`Trigger not found: ${name}`);
+    }
+    if (!meta) {
+        throw new Error(`Trigger metadata not found: ${name}`);
+    }
+    const wire = {
+        trigger: {
+            trigger: (data) => {
+                singletonServices.logger.info(`Trigger fired: ${name}`);
+                onTrigger(data);
+            },
+        },
+    };
+    singletonServices.logger.info(`Setting up trigger: ${name}`);
+    const teardown = await trigger.func.func(singletonServices, trigger.config, wire);
+    return {
+        name,
+        teardown,
+    };
+}
+/**
+ * Gets all registered triggers
+ */
+export const getRegisteredTriggers = () => {
+    return pikkuState(null, 'trigger', 'triggers');
+};
+/**
+ * Gets trigger metadata
+ */
+export const getTriggerMeta = () => {
+    return pikkuState(null, 'trigger', 'meta');
+};