@pikku/core 0.8.0 → 0.8.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## 0.8.0
 
+## 0.8.1
+
+### Patch Changes
+
+- 3261090: refactor: moving mcp endpoints into core
+- 7c592b8: feat: support for required services and improved service configuration
+
+  This release includes several enhancements to service management and configuration:
+
+  - Added support for required services configuration
+  - Improved service discovery and registration
+  - Added typed RPC clients for service communication
+  - Updated middleware to run per function
+
+- 30a082f: refactor: moving service implementations out of pikku/core since they aren't all edge compatible
+
 ### Major Features
 
 - **Model Context Protocol (MCP) Support**: Added MCP implementation with resources, tools, and prompts

package/dist/events/channel/channel-handler.js

@@ -46,6 +46,7 @@ export const processMessageHandlers = (services, session, channelConfig, channel
         }
         const { pikkuFuncName } = getRouteMeta(channelConfig.name, routingProperty, routerValue);
         const permissions = typeof onMessage === 'function' ? {} : onMessage.permissions;
+        const middleware = typeof onMessage === 'function' ? [] : onMessage.middleware;
         return await runPikkuFunc(pikkuFuncName, {
             getAllServices: () => ({
                 ...services,
@@ -54,6 +55,7 @@ export const processMessageHandlers = (services, session, channelConfig, channel
             data,
             session,
             permissions,
+            middleware,
         });
     };
     const onMessage = async (rawData) => {

package/dist/events/mcp/index.d.ts

@@ -1,2 +1,3 @@
 export * from './mcp.types.js';
 export * from './mcp-runner.js';
+export * from './mcp-endpoint-registry.js';

package/dist/events/mcp/index.js

@@ -1,2 +1,3 @@
 export * from './mcp.types.js';
 export * from './mcp-runner.js';
+export * from './mcp-endpoint-registry.js';

package/dist/events/mcp/mcp-endpoint-registry.d.ts

@@ -0,0 +1,48 @@
+import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core';
+export interface MCPToolEndpoint {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema?: any;
+    outputSchema?: any;
+    enabled: boolean;
+}
+export interface MCPResourceEndpoint {
+    uri: string;
+    title: string;
+    description: string;
+    inputSchema?: any;
+    mimeType?: string;
+    enabled: boolean;
+}
+export interface MCPPromptEndpoint {
+    name: string;
+    description: string;
+    inputSchema?: any;
+    enabled: boolean;
+}
+export declare class MCPEndpointRegistry {
+    private tools;
+    private resources;
+    private prompts;
+    private resourcesMeta;
+    private toolsMeta;
+    private promptsMeta;
+    loadFromMCPJsonFile(mcpJsonPath: string): Promise<void>;
+    loadFromMCPJson(mcpData: any): Promise<void>;
+    setResourcesMeta(meta: MCPResourceMeta): void;
+    setToolsMeta(meta: MCPToolMeta): void;
+    setPromptsMeta(meta: MCPPromptMeta): void;
+    getTools(): MCPToolEndpoint[];
+    getResources(): MCPResourceEndpoint[];
+    getPrompts(): MCPPromptEndpoint[];
+    getTool(name: string): MCPToolEndpoint | undefined;
+    getResource(name: string): MCPResourceEndpoint | undefined;
+    getPrompt(name: string): MCPPromptEndpoint | undefined;
+    hasResource(name: string): boolean;
+    hasTool(name: string): boolean;
+    hasPrompt(name: string): boolean;
+    enableTools(tools: Record<any, boolean>): boolean;
+    enablePrompts(prompts: Record<any, boolean>): boolean;
+    enableResources(resources: Record<any, boolean>): boolean;
+}

package/dist/events/mcp/mcp-endpoint-registry.js

@@ -0,0 +1,122 @@
+import { readFile } from 'fs/promises';
+export class MCPEndpointRegistry {
+    tools = new Map();
+    resources = new Map();
+    prompts = new Map();
+    resourcesMeta = {};
+    toolsMeta = {};
+    promptsMeta = {};
+    async loadFromMCPJsonFile(mcpJsonPath) {
+        try {
+            const mcpJsonContent = await readFile(mcpJsonPath, 'utf-8');
+            await this.loadFromMCPJson(JSON.parse(mcpJsonContent));
+        }
+        catch (error) {
+            throw new Error(`Failed to load MCP JSON from ${mcpJsonPath}: ${error}`);
+        }
+    }
+    async loadFromMCPJson(mcpData) {
+        if (mcpData.tools && Array.isArray(mcpData.tools)) {
+            for (const tool of mcpData.tools) {
+                this.tools.set(tool.name, {
+                    name: tool.name,
+                    title: tool.title,
+                    description: tool.description,
+                    inputSchema: tool.parameters,
+                    outputSchema: tool.returns,
+                    enabled: tool.enabled !== undefined ? tool.enabled : true,
+                });
+            }
+        }
+        if (mcpData.resources && Array.isArray(mcpData.resources)) {
+            for (const resource of mcpData.resources) {
+                this.resources.set(resource.name, {
+                    title: resource.name,
+                    uri: resource.uri,
+                    description: resource.description,
+                    inputSchema: resource.parameters,
+                    enabled: resource.enabled !== undefined ? resource.enabled : true,
+                });
+            }
+        }
+        if (mcpData.prompts && Array.isArray(mcpData.prompts)) {
+            for (const prompt of mcpData.prompts) {
+                this.prompts.set(prompt.name, {
+                    name: prompt.name,
+                    description: prompt.description,
+                    inputSchema: prompt.arguments,
+                    enabled: prompt.enabled !== undefined ? prompt.enabled : true,
+                });
+            }
+        }
+    }
+    setResourcesMeta(meta) {
+        this.resourcesMeta = meta;
+    }
+    setToolsMeta(meta) {
+        this.toolsMeta = meta;
+    }
+    setPromptsMeta(meta) {
+        this.promptsMeta = meta;
+    }
+    getTools() {
+        return Array.from(this.tools.values()).filter((tool) => tool.enabled);
+    }
+    getResources() {
+        return Array.from(this.resources.values());
+    }
+    getPrompts() {
+        return Array.from(this.prompts.values());
+    }
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    getResource(name) {
+        return this.resources.get(name);
+    }
+    getPrompt(name) {
+        return this.prompts.get(name);
+    }
+    hasResource(name) {
+        return name in this.resourcesMeta;
+    }
+    hasTool(name) {
+        return name in this.toolsMeta;
+    }
+    hasPrompt(name) {
+        return name in this.promptsMeta;
+    }
+    enableTools(tools) {
+        let changed = false;
+        for (const [name, enabled] of Object.entries(tools)) {
+            const tool = this.tools.get(name);
+            if (tool && tool.enabled !== enabled) {
+                tool.enabled = enabled;
+                changed = true;
+            }
+        }
+        return changed;
+    }
+    enablePrompts(prompts) {
+        let changed = false;
+        for (const [name, enabled] of Object.entries(prompts)) {
+            const prompt = this.prompts.get(name);
+            if (prompt && prompt.enabled !== enabled) {
+                prompt.enabled = enabled;
+                changed = true;
+            }
+        }
+        return changed;
+    }
+    enableResources(resources) {
+        let changed = false;
+        for (const [name, enabled] of Object.entries(resources)) {
+            const resource = this.resources.get(name);
+            if (resource && resource.enabled !== enabled) {
+                resource.enabled = enabled;
+                changed = true;
+            }
+        }
+        return changed;
+    }
+}

package/dist/events/queue/index.d.ts

@@ -2,5 +2,5 @@ export type * from './queue.types.js';
 export { addQueueWorker, runQueueJob, getQueueWorkers, removeQueueWorker, } from './queue-runner.js';
 export { validateWorkerConfig } from './validate-worker-config.js';
 export type { QueueConfigMapping } from './validate-worker-config.js';
-export { registerqueueWorkers } from './register-queue-helper.js';
+export { registerQueueWorkers } from './register-queue-helper.js';
 export type { QueueRegistrationCallback } from './register-queue-helper.js';

package/dist/events/queue/index.js

@@ -3,4 +3,4 @@ export { addQueueWorker, runQueueJob, getQueueWorkers, removeQueueWorker, } from
 // Configuration validation
 export { validateWorkerConfig } from './validate-worker-config.js';
 // Queue registration helper
-export { registerqueueWorkers } from './register-queue-helper.js';
+export { registerQueueWorkers } from './register-queue-helper.js';

package/dist/events/queue/register-queue-helper.d.ts

@@ -14,4 +14,4 @@ export type QueueRegistrationCallback<T = any> = (queueName: string, processor:
  * @param logger - Optional logger for info/error messages
  * @returns Record of validation results by queue name
  */
-export declare function registerqueueWorkers<T = any>(configMappings: QueueConfigMapping, logger: Logger, registerCallback: QueueRegistrationCallback<T>): Promise<Record<string, ConfigValidationResult[]>>;
+export declare function registerQueueWorkers<T = any>(configMappings: QueueConfigMapping, logger: Logger, registerCallback: QueueRegistrationCallback<T>): Promise<Record<string, ConfigValidationResult[]>>;

package/dist/events/queue/register-queue-helper.js

@@ -9,7 +9,7 @@ import { validateWorkerConfig, } from './validate-worker-config.js';
  * @param logger - Optional logger for info/error messages
  * @returns Record of validation results by queue name
  */
-export async function registerqueueWorkers(configMappings, logger, registerCallback) {
+export async function registerQueueWorkers(configMappings, logger, registerCallback) {
     const configValidation = {};
     const queueWorkers = getQueueWorkers();
     for (const [queueName, processor] of queueWorkers) {

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

@@ -6,16 +6,13 @@ export declare class PikkuRPCService {
     private config?;
     initialize(config: RPCServiceConfig): void;
     injectRPCService(coreServices: CoreServices, depth?: number): {
-        jwt?: import("../../index.js").JWTService;
         schema?: import("../../index.js").SchemaService;
         config: {
             logLevel?: import("../../index.js").LogLevel;
             secrets?: {};
         };
         logger: import("../../index.js").Logger;
-        variables: import("../../index.js").VariablesService;
-        eventHub?: import("../channel/eventhub-service.js").EventHubService<unknown>;
-        secrets?: import("../../index.js").SecretService;
+        variables: import("../../services/variables-service.js").VariablesService;
         http?: import("../http/http.types.js").PikkuHTTP;
         mcp?: import("../mcp/mcp.types.js").PikkuMCP;
         rpc?: import("./rpc-types.js").PikkuRPC;

package/dist/function/function-runner.d.ts

@@ -1,11 +1,12 @@
-import { CoreServices, CoreUserSession } from '../types/core.types.js';
+import { CoreServices, CoreUserSession, PikkuFunctionMiddleware } from '../types/core.types.js';
 import { CorePermissionGroup, CorePikkuFunctionConfig } from './functions.types.js';
 export declare const addFunction: (funcName: string, funcConfig: CorePikkuFunctionConfig<any, any>) => void;
 export declare const runPikkuFuncDirectly: <In, Out>(funcName: string, allServices: CoreServices, data: In, session?: CoreUserSession) => Promise<Out>;
-export declare const runPikkuFunc: <In = any, Out = any>(funcName: string, { getAllServices, data, session, permissions: transportPermissions, coerceDataFromSchema, }: {
+export declare const runPikkuFunc: <In = any, Out = any>(funcName: string, { getAllServices, data, session, permissions: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, }: {
     getAllServices: () => Promise<CoreServices> | CoreServices;
     data: In;
     session?: CoreUserSession;
     permissions?: CorePermissionGroup;
+    middleware?: PikkuFunctionMiddleware[];
     coerceDataFromSchema?: boolean;
 }) => Promise<Out>;

package/dist/function/function-runner.js

@@ -3,42 +3,6 @@ import { runMiddleware } from '../middleware-runner.js';
 import { verifyPermissions } from '../permissions.js';
 import { pikkuState } from '../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
-// Permission merging function
-function mergePermissions(logger, funcName, funcPermissions, transportPermissions) {
-    if (!funcPermissions && !transportPermissions) {
-        return undefined;
-    }
-    if (!funcPermissions) {
-        return transportPermissions;
-    }
-    if (!transportPermissions) {
-        return funcPermissions;
-    }
-    // Start with a copy of function permissions
-    const mergedPermissions = { ...funcPermissions };
-    // Merge in transport permissions
-    for (const [key, transportValue] of Object.entries(transportPermissions)) {
-        if (key in mergedPermissions) {
-            // For permission arrays, concatenate and deduplicate values
-            if (Array.isArray(mergedPermissions[key]) &&
-                Array.isArray(transportValue)) {
-                mergedPermissions[key] = [
-                    ...new Set([...mergedPermissions[key], ...transportValue]),
-                ];
-            }
-            // For other types, warn about conflict and use the more restrictive (transport-level) value
-            else {
-                logger.warn(`Permission conflict on key "${key}" for function "${funcName}". Using transport-level permission.`);
-                mergedPermissions[key] = transportValue;
-            }
-        }
-        else {
-            // If key doesn't exist in function permissions, add it
-            mergedPermissions[key] = transportValue;
-        }
-    }
-    return mergedPermissions;
-}
 export const addFunction = (funcName, funcConfig) => {
     pikkuState('function', 'functions').set(funcName, funcConfig);
 };
@@ -49,7 +13,7 @@ export const runPikkuFuncDirectly = async (funcName, allServices, data, session)
     }
     return (await funcConfig.func(allServices, data, session));
 };
-export const runPikkuFunc = async (funcName, { getAllServices, data, session, permissions: transportPermissions, coerceDataFromSchema, }) => {
+export const runPikkuFunc = async (funcName, { getAllServices, data, session, permissions: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, }) => {
     const funcConfig = pikkuState('function', 'functions').get(funcName);
     if (!funcConfig) {
         throw new Error(`Function not found: ${funcName}`);
@@ -71,18 +35,22 @@ export const runPikkuFunc = async (funcName, { getAllServices, data, session, pe
             coerceTopLevelDataFromSchema(schemaName, data);
         }
     }
-    // Execute permission checks
-    const mergedPermissions = mergePermissions(allServices.logger, funcName, funcConfig.permissions, transportPermissions);
-    const permissioned = await verifyPermissions(mergedPermissions, allServices, data, session);
+    let permissioned = true;
+    if (funcConfig.permissions) {
+        permissioned = await verifyPermissions(funcConfig.permissions, allServices, data, session);
+    }
+    if (!permissioned && transportPermissions) {
+        permissioned = await verifyPermissions(transportPermissions, allServices, data, session);
+    }
     if (permissioned === false) {
         throw new ForbiddenError('Permission denied');
     }
-    if (funcConfig.middleware) {
+    if (transportMiddleware || funcConfig.middleware) {
         return (await runMiddleware(allServices, {
             http: allServices.http,
             mcp: allServices.mcp,
             rpc: allServices.rpc,
-        }, funcConfig.middleware, async () => await funcConfig.func(allServices, data, session)));
+        }, [...(transportMiddleware || []), ...(funcConfig.middleware || [])], async () => await funcConfig.func(allServices, data, session)));
     }
     return (await funcConfig.func(allServices, data, session));
 };

package/dist/index.d.ts

@@ -5,7 +5,11 @@ export * from './types/core.types.js';
 export * from './function/index.js';
 export * from './pikku-request.js';
 export * from './pikku-response.js';
-export * from './services/index.js';
+export * from './services/logger.js';
+export * from './services/schema-service.js';
+export * from './services/jwt-service.js';
+export * from './services/secret-service.js';
+export * from './services/user-session-service.js';
 export * from './events/http/index.js';
 export * from './events/channel/index.js';
 export * from './events/scheduler/index.js';

package/dist/index.js

@@ -5,7 +5,11 @@ export * from './types/core.types.js';
 export * from './function/index.js';
 export * from './pikku-request.js';
 export * from './pikku-response.js';
-export * from './services/index.js';
+export * from './services/logger.js';
+export * from './services/schema-service.js';
+export * from './services/jwt-service.js';
+export * from './services/secret-service.js';
+export * from './services/user-session-service.js';
 export * from './events/http/index.js';
 export * from './events/channel/index.js';
 export * from './events/scheduler/index.js';

package/dist/services/index.d.ts

@@ -4,11 +4,11 @@
 export * from './content-service.js';
 export * from './jwt-service.js';
 export * from './logger.js';
-export * from './logger-console.js';
 export * from './secret-service.js';
 export * from './variables-service.js';
 export * from './schema-service.js';
 export * from './user-session-service.js';
-export * from './local-content.js';
 export * from './local-secrets.js';
 export * from './local-variables.js';
+export * from './logger-console.js';
+export * from './local-content.js';

package/dist/services/index.js

@@ -5,12 +5,12 @@
 export * from './content-service.js';
 export * from './jwt-service.js';
 export * from './logger.js';
-export * from './logger-console.js';
 export * from './secret-service.js';
 export * from './variables-service.js';
 export * from './schema-service.js';
 export * from './user-session-service.js';
-export * from './local-content.js';
 // Local implementations
 export * from './local-secrets.js';
 export * from './local-variables.js';
+export * from './logger-console.js';
+export * from './local-content.js';

package/dist/services/jwt-service.d.ts

@@ -1,4 +1,4 @@
-import { RelativeTimeInput } from '../time-utils.js';
+import type { RelativeTimeInput } from '../time-utils.js';
 /**
  * Interface for handling JSON Web Tokens (JWT).
  */

package/dist/types/core.types.d.ts

@@ -1,17 +1,14 @@
 import type { Logger, LogLevel } from '../services/logger.js';
 import { VariablesService } from '../services/variables-service.js';
-import { EventHubService } from '../events/channel/eventhub-service.js';
 import { SchemaService } from '../services/schema-service.js';
 import { PikkuHTTP } from '../events/http/http.types.js';
 import { UserSessionService } from '../services/user-session-service.js';
-import { JWTService } from '../services/jwt-service.js';
-import { SecretService } from '../services/secret-service.js';
 import { PikkuChannel } from '../events/channel/channel.types.js';
 import { PikkuRPC } from '../events/rpc/rpc-types.js';
 import { PikkuMCP } from '../events/mcp/mcp.types.js';
 export declare enum PikkuEventTypes {
     http = "http",
-    scheduled = "scheduled",
+    scheduler = "scheduler",
     channel = "channel",
     rpc = "rpc",
     queue = "queue",
@@ -72,8 +69,6 @@ export interface CoreUserSession {
  * Interface for core singleton services provided by Pikku.
  */
 export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
-    /** JWT Service */
-    jwt?: JWTService;
     /** The schema library used to validate data */
     schema?: SchemaService;
     /** The core configuration for the application. */
@@ -82,10 +77,6 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     logger: Logger;
     /** The variable service to be used */
     variables: VariablesService;
-    /** The subscription service that is passed to streams */
-    eventHub?: EventHubService<unknown>;
-    /** SecretServce  */
-    secrets?: SecretService;
 }
 /**
  * Represents different forms of interaction within Pikku and the outside world.

package/dist/types/core.types.js

@@ -1,7 +1,7 @@
 export var PikkuEventTypes;
 (function (PikkuEventTypes) {
     PikkuEventTypes["http"] = "http";
-    PikkuEventTypes["scheduled"] = "scheduled";
+    PikkuEventTypes["scheduler"] = "scheduler";
     PikkuEventTypes["channel"] = "channel";
     PikkuEventTypes["rpc"] = "rpc";
     PikkuEventTypes["queue"] = "queue";