@pikku/core 0.7.8 → 0.8.1

package/CHANGELOG.md

@@ -1,4 +1,29 @@
-## 0.7.0
+## 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
+- **Queue System**: Added queue support with runners and workers
+- **RPC (Remote Procedure Calls)**: Added typed RPC calls inside functions with local and remote support
+- **Middleware Runner**: Added middleware runner to functions for enhanced request processing
+- **Multiple Bootstrap Files**: Added support for different transport bootstrap files
+- **Middleware Runner**: Run middleware on any function
 
 ## 0.7.8
 

package/dist/errors/error-handler.d.ts

@@ -15,6 +15,7 @@ export declare class PikkuError extends Error {
 export interface ErrorDetails {
     status: number;
     message: string;
+    mcpCode?: number;
 }
 /**
  * Adds an error to the API errors map.
@@ -35,4 +36,5 @@ export declare const addErrors: (errors: Array<[error: any, details: ErrorDetail
 export declare const getErrorResponse: (error: Error) => {
     status: number;
     message: string;
+    mcpCode?: number;
 } | undefined;

package/dist/errors/errors.js

@@ -10,6 +10,7 @@ export class BadRequestError extends PikkuError {
 }
 addError(BadRequestError, {
     status: 400,
+    mcpCode: -32600,
     message: 'The server cannot or will not process the request due to client error (e.g., malformed request syntax).',
 });
 /**
@@ -81,6 +82,7 @@ export class NotFoundError extends PikkuError {
  */
 addError(NotFoundError, {
     status: 404,
+    mcpCode: -32601,
     message: 'The server cannot find the requested resource.',
 });
 /**

package/dist/{channel → events/channel}/channel-handler.d.ts

@@ -1,3 +1,3 @@
-import { CoreServices, CoreUserSession } from '../types/core.types.js';
+import { CoreServices, CoreUserSession } from '../../types/core.types.js';
 import { CoreAPIChannel, PikkuChannelHandler } from './channel.types.js';
 export declare const processMessageHandlers: (services: CoreServices, session: CoreUserSession | undefined, channelConfig: CoreAPIChannel<any, any>, channelHandler: PikkuChannelHandler) => (rawData: any) => Promise<unknown>;

package/dist/{channel → events/channel}/channel-handler.js

@@ -1,5 +1,5 @@
-import { pikkuState } from '../pikku-state.js';
-import { runPikkuFunc } from '../function/function-runner.js';
+import { pikkuState } from '../../pikku-state.js';
+import { runPikkuFunc } from '../../function/function-runner.js';
 const getRouteMeta = (channelName, routingProperty, routerValue) => {
     const channelMeta = pikkuState('channel', 'meta')[channelName];
     if (!channelMeta) {
@@ -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/{channel → events/channel}/channel-runner.d.ts

@@ -1,4 +1,4 @@
-import { UserSessionService } from '../services/user-session-service.js';
+import { UserSessionService } from '../../services/user-session-service.js';
 import { ChannelMeta, CoreAPIChannel, RunChannelOptions, RunChannelParams } from './channel.types.js';
 /**
  * Adds a channel and registers all functions referenced in it using the

package/dist/{channel → events/channel}/channel-runner.js

@@ -1,7 +1,7 @@
-import { NotFoundError } from '../errors/errors.js';
-import { addFunction } from '../function/function-runner.js';
-import { pikkuState } from '../pikku-state.js';
-import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
+import { NotFoundError } from '../../errors/errors.js';
+import { addFunction } from '../../function/function-runner.js';
+import { pikkuState } from '../../pikku-state.js';
+import { coerceTopLevelDataFromSchema, validateSchema } from '../../schema.js';
 import { match } from 'path-to-regexp';
 /**
  * Adds a channel and registers all functions referenced in it using the

package/dist/{channel → events/channel}/channel-store.d.ts

@@ -1,4 +1,4 @@
-import { CoreUserSession } from '../types/core.types.js';
+import { CoreUserSession } from '../../types/core.types.js';
 export type Channel<ChannelType = unknown, OpeningData = unknown> = {
     channelId: string;
     channelName: string;

package/dist/{channel → events/channel}/channel.types.d.ts

@@ -1,7 +1,7 @@
-import { PikkuError } from '../errors/error-handler.js';
+import { PikkuError } from '../../errors/error-handler.js';
 import { HTTPFunctionMetaInputTypes, PikkuHTTPRequest, PikkuHTTPResponse } from '../http/http.types.js';
-import { APIDocs, CoreSingletonServices, CreateSessionServices, PikkuMiddleware } from '../types/core.types.js';
-import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission } from '../function/functions.types.js';
+import { APIDocs, CoreSingletonServices, CreateSessionServices, PikkuMiddleware } from '../../types/core.types.js';
+import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission } from '../../function/functions.types.js';
 export type RunChannelOptions = Partial<{
     skipUserSession: boolean;
     respondWith404: boolean;

package/dist/{channel → events/channel}/local/local-channel-runner.js

@@ -1,12 +1,12 @@
 import { openChannel } from '../channel-runner.js';
 import { createHTTPInteraction } from '../../http/http-runner.js';
-import { closeSessionServices } from '../../utils.js';
+import { closeSessionServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
-import { handleError } from '../../handle-error.js';
-import { runMiddleware } from '../../middleware-runner.js';
-import { PikkuUserSessionService } from '../../services/user-session-service.js';
-import { runPikkuFuncDirectly } from '../../function/function-runner.js';
+import { handleHTTPError } from '../../../handle-error.js';
+import { runMiddleware } from '../../../middleware-runner.js';
+import { PikkuUserSessionService } from '../../../services/user-session-service.js';
+import { runPikkuFuncDirectly } from '../../../function/function-runner.js';
 import { rpcService } from '../../rpc/rpc-runner.js';
 export const runLocalChannel = async ({ singletonServices, channelId, request, response, route, createSessionServices, skipUserSession = false, respondWith404 = true, coerceDataFromSchema = true, logWarningsForStatusCodes = [], bubbleErrors = false, }) => {
     let sessionServices;
@@ -58,7 +58,7 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
             channelHandler.registerOnMessage(processMessageHandlers(allServices, session, channelConfig, channelHandler));
         }
         catch (e) {
-            handleError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+            handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
         }
         finally {
             if (sessionServices) {

package/dist/{channel → events/channel}/log-channels.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from '../services/index.js';
+import { Logger } from '../../services/index.js';
 /**
  * Logs all the loaded channels.
  * @param logger - A logger for logging information.

package/dist/{channel → events/channel}/log-channels.js

@@ -1,4 +1,4 @@
-import { pikkuState } from '../pikku-state.js';
+import { pikkuState } from '../../pikku-state.js';
 /**
  * Logs all the loaded channels.
  * @param logger - A logger for logging information.

package/dist/{channel → events/channel}/serverless/serverless-channel-runner.js

@@ -1,13 +1,13 @@
-import { closeSessionServices } from '../../utils.js';
+import { closeSessionServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { openChannel } from '../channel-runner.js';
 import { createHTTPInteraction } from '../../http/http-runner.js';
-import { handleError } from '../../handle-error.js';
-import { PikkuUserSessionService } from '../../services/user-session-service.js';
-import { runMiddleware } from '../../middleware-runner.js';
-import { pikkuState } from '../../pikku-state.js';
+import { handleHTTPError } from '../../../handle-error.js';
+import { PikkuUserSessionService } from '../../../services/user-session-service.js';
+import { runMiddleware } from '../../../middleware-runner.js';
+import { pikkuState } from '../../../pikku-state.js';
 import { PikkuFetchHTTPRequest } from '../../http/pikku-fetch-http-request.js';
-import { runPikkuFuncDirectly } from '../../function/function-runner.js';
+import { runPikkuFuncDirectly } from '../../../function/function-runner.js';
 const getVariablesForChannel = ({ channelId, channelName, channelHandlerFactory, openingData, }) => {
     const channels = pikkuState('channel', 'channels');
     const channelConfig = channels[channelName];
@@ -65,7 +65,7 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
             http?.response?.status(101);
         }
         catch (e) {
-            handleError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+            handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
         }
         finally {
             if (sessionServices) {

package/dist/{http → events/http}/http-runner.d.ts

@@ -1,5 +1,5 @@
 import { CoreHTTPFunctionRoute, RunRouteOptions, RunRouteParams, PikkuHTTP, PikkuHTTPRequest, PikkuHTTPResponse } from './http.types.js';
-import { PikkuMiddleware } from '../types/core.types.js';
+import { PikkuMiddleware } from '../../types/core.types.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 /**
  * Registers middleware either globally or for a specific route.

package/dist/{http → events/http}/http-runner.js

@@ -1,13 +1,13 @@
 import { match } from 'path-to-regexp';
-import { MissingSessionError, NotFoundError } from '../errors/errors.js';
-import { closeSessionServices, createWeakUID, isSerializable, } from '../utils.js';
-import { PikkuUserSessionService, } from '../services/user-session-service.js';
-import { runMiddleware } from '../middleware-runner.js';
-import { handleError } from '../handle-error.js';
-import { pikkuState } from '../pikku-state.js';
+import { MissingSessionError, NotFoundError } from '../../errors/errors.js';
+import { closeSessionServices, createWeakUID, isSerializable, } from '../../utils.js';
+import { PikkuUserSessionService, } from '../../services/user-session-service.js';
+import { runMiddleware } from '../../middleware-runner.js';
+import { handleHTTPError } from '../../handle-error.js';
+import { pikkuState } from '../../pikku-state.js';
 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 { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { rpcService } from '../rpc/rpc-runner.js';
 /**
  * Registers middleware either globally or for a specific route.
@@ -342,7 +342,7 @@ export const fetchData = async (request, response, { singletonServices, createSe
     }
     catch (e) {
         // Handle errors and, depending on configuration, bubble them up or respond with an error
-        handleError(e, http, requestId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+        handleHTTPError(e, http, requestId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
     }
     finally {
         // Clean up any session-specific services created during processing

package/dist/{http → events/http}/http.types.d.ts

@@ -1,7 +1,7 @@
 import type { SerializeOptions } from 'cookie';
-import type { PikkuError } from '../errors/error-handler.js';
-import type { APIDocs, CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices, PikkuMiddleware } from '../types/core.types.js';
-import type { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission, CorePermissionGroup } from '../function/functions.types.js';
+import type { PikkuError } from '../../errors/error-handler.js';
+import type { APIDocs, CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices, PikkuMiddleware } from '../../types/core.types.js';
+import type { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission, CorePermissionGroup } from '../../function/functions.types.js';
 type ExtractRouteParams<S extends string> = S extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractRouteParams<`/${Rest}`> : S extends `${string}:${infer Param}` ? Param : never;
 export type AssertRouteParams<In, Route extends string> = ExtractRouteParams<Route> extends keyof In ? unknown : ['Error: Route parameters', ExtractRouteParams<Route>, 'not in', keyof In];
 export type RunRouteOptions = Partial<{

package/dist/{http → events/http}/index.d.ts

@@ -1,6 +1,5 @@
 export * from './pikku-fetch-http-request.js';
 export * from './pikku-fetch-http-response.js';
-export * from './incomingmessage-to-request-convertor.js';
 export * from './log-http-routes.js';
 export { fetch, fetchData, addHTTPRoute } from './http-runner.js';
 export type * from './http.types.js';

package/dist/{http → events/http}/index.js

@@ -1,5 +1,4 @@
 export * from './pikku-fetch-http-request.js';
 export * from './pikku-fetch-http-response.js';
-export * from './incomingmessage-to-request-convertor.js';
 export * from './log-http-routes.js';
 export { fetch, fetchData, addHTTPRoute } from './http-runner.js';

package/dist/{http → events/http}/log-http-routes.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from '../services/index.js';
+import { Logger } from '../../services/index.js';
 /**
  * Logs all the loaded routes.
  * @param logger - A logger for logging information.

package/dist/{http → events/http}/log-http-routes.js

@@ -1,4 +1,4 @@
-import { pikkuState } from '../pikku-state.js';
+import { pikkuState } from '../../pikku-state.js';
 /**
  * Logs all the loaded routes.
  * @param logger - A logger for logging information.

package/dist/{http → events/http}/pikku-fetch-http-request.js

@@ -1,6 +1,6 @@
 import { parse as parseQuery } from 'picoquery';
 import { parse as parseCookie } from 'cookie';
-import { UnprocessableContentError } from '../errors/errors.js';
+import { UnprocessableContentError } from '../../errors/errors.js';
 /**
  * Abstract class representing a pikku request.
  * @template In - The type of the request body.

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

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

package/dist/events/mcp/index.js

@@ -0,0 +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/mcp/mcp-runner.d.ts

@@ -0,0 +1,30 @@
+import type { CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices } from '../../types/core.types.js';
+import type { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, JsonRpcRequest, JsonRpcResponse, JsonRpcErrorResponse, PikkuMCP } from './mcp.types.js';
+import type { CoreAPIFunctionSessionless } from '../../function/functions.types.js';
+export declare class MCPError extends Error {
+    readonly error: JsonRpcErrorResponse;
+    constructor(error: JsonRpcErrorResponse);
+}
+export type RunMCPEndpointParams<Tools extends string = any> = {
+    session?: CoreUserSession;
+    singletonServices: CoreSingletonServices;
+    mcp?: PikkuMCP<Tools>;
+    createSessionServices?: CreateSessionServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
+};
+export type JsonRpcError = {
+    code: number;
+    message: string;
+    data?: any;
+};
+export declare const addMCPResource: <APIFunction extends CoreAPIFunctionSessionless<any, any>>(mcpResource: CoreMCPResource<APIFunction>) => void;
+export declare const addMCPTool: <APIFunction extends CoreAPIFunctionSessionless<any, any>>(mcpTool: CoreMCPTool<APIFunction>) => void;
+export declare const addMCPPrompt: <APIFunction extends CoreAPIFunctionSessionless<any, any>>(mcpPrompt: CoreMCPPrompt<APIFunction>) => void;
+export declare function runMCPResource(request: JsonRpcRequest, params: RunMCPEndpointParams, uri: string): Promise<JsonRpcResponse>;
+export declare function runMCPTool(request: JsonRpcRequest, params: RunMCPEndpointParams, name: string): Promise<JsonRpcResponse>;
+export declare function runMCPPrompt(request: JsonRpcRequest, params: RunMCPEndpointParams, name: string): Promise<JsonRpcResponse>;
+export declare const getMCPTools: () => Map<string, CoreMCPTool>;
+export declare const getMCPResources: () => Map<string, CoreMCPResource>;
+export declare const getMCPResourcesMeta: () => import("./mcp.types.js").MCPResourceMeta;
+export declare const getMCPToolsMeta: () => import("./mcp.types.js").MCPToolMeta;
+export declare const getMCPPrompts: () => Map<string, CoreMCPPrompt>;
+export declare const getMCPPromptsMeta: () => import("./mcp.types.js").MCPPromptMeta;