@pikku/core 0.8.0 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -27,6 +27,7 @@
     "./queue": "./dist/events/queue/index.js",
     "./scheduler": "./dist/events/scheduler/index.js",
     "./rpc": "./dist/events/rpc/index.js",
+    "./mcp": "./dist/events/mcp/index.js",
     "./errors": "./dist/errors/index.js",
     "./services": "./dist/services/index.js",
     "./schema": "./dist/schema.js",

package/src/events/channel/channel-handler.ts

@@ -95,6 +95,9 @@ export const processMessageHandlers = (
     const permissions =
       typeof onMessage === 'function' ? {} : onMessage.permissions
 
+    const middleware =
+      typeof onMessage === 'function' ? [] : onMessage.middleware
+
     return await runPikkuFunc(pikkuFuncName, {
       getAllServices: () => ({
         ...services,
@@ -103,6 +106,7 @@ export const processMessageHandlers = (
       data,
       session,
       permissions,
+      middleware,
     })
   }
 

package/src/events/http/http-runner.test.ts

@@ -27,8 +27,6 @@ const setHTTPFunctionMap = (func: any) => {
       pikkuFuncName: 'pikku_func_name',
       route: 'test',
       method: 'get',
-      input: null,
-      output: null,
     },
   ])
   addFunction('pikku_func_name', { func })
@@ -56,7 +54,8 @@ describe('fetch', () => {
     response = new PikkuMockResponse()
 
     request.getData = async () => ({})
-    request.getHeader = () => 'application/json'
+    request.getHeader = (name: string) =>
+      name === 'content-type' ? 'application/json' : undefined
     response.setStatus = (status: number) => {}
     response.setJson = (json: JSONValue) => {}
   })

package/src/events/mcp/index.ts

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

package/src/events/mcp/mcp-endpoint-registry.test.d.ts

@@ -0,0 +1 @@
+export {}

package/src/events/mcp/mcp-endpoint-registry.test.ts

@@ -0,0 +1,389 @@
+import { test, describe, beforeEach } from 'node:test'
+import * as assert from 'assert'
+import { MCPEndpointRegistry } from './mcp-endpoint-registry.js'
+
+describe('MCPEndpointRegistry', () => {
+  let registry: MCPEndpointRegistry
+
+  beforeEach(() => {
+    registry = new MCPEndpointRegistry()
+  })
+
+  describe('constructor', () => {
+    test('should initialize with empty maps', () => {
+      assert.deepStrictEqual(registry.getTools(), [])
+      assert.deepStrictEqual(registry.getResources(), [])
+      assert.deepStrictEqual(registry.getPrompts(), [])
+    })
+  })
+
+  describe('loadFromMCPJson', () => {
+    test('should load tools from MCP JSON', async () => {
+      const mockData = {
+        tools: [
+          {
+            name: 'test-tool',
+            title: 'Test Tool',
+            description: 'A test tool',
+            parameters: { type: 'object' },
+            returns: { type: 'string' },
+            enabled: true,
+          },
+        ],
+      }
+
+      await registry.loadFromMCPJson(mockData)
+
+      const tools = registry.getTools()
+      assert.strictEqual(tools.length, 1)
+      assert.strictEqual(tools[0].name, 'test-tool')
+      assert.strictEqual(tools[0].title, 'Test Tool')
+      assert.strictEqual(tools[0].description, 'A test tool')
+      assert.deepStrictEqual(tools[0].inputSchema, { type: 'object' })
+      assert.deepStrictEqual(tools[0].outputSchema, { type: 'string' })
+      assert.strictEqual(tools[0].enabled, true)
+    })
+
+    test('should load resources from MCP JSON', async () => {
+      const mockData = {
+        resources: [
+          {
+            name: 'test-resource',
+            uri: 'file://test.txt',
+            description: 'A test resource',
+            parameters: { type: 'object' },
+            enabled: false,
+          },
+        ],
+      }
+
+      await registry.loadFromMCPJson(mockData)
+
+      const resources = registry.getResources()
+      assert.strictEqual(resources.length, 1)
+      assert.strictEqual(resources[0].title, 'test-resource')
+      assert.strictEqual(resources[0].uri, 'file://test.txt')
+      assert.strictEqual(resources[0].description, 'A test resource')
+      assert.deepStrictEqual(resources[0].inputSchema, { type: 'object' })
+      assert.strictEqual(resources[0].enabled, false)
+    })
+
+    test('should load prompts from MCP JSON', async () => {
+      const mockData = {
+        prompts: [
+          {
+            name: 'test-prompt',
+            description: 'A test prompt',
+            arguments: { type: 'object' },
+          },
+        ],
+      }
+
+      await registry.loadFromMCPJson(mockData)
+
+      const prompts = registry.getPrompts()
+      assert.strictEqual(prompts.length, 1)
+      assert.strictEqual(prompts[0].name, 'test-prompt')
+      assert.strictEqual(prompts[0].description, 'A test prompt')
+      assert.deepStrictEqual(prompts[0].inputSchema, { type: 'object' })
+      assert.strictEqual(prompts[0].enabled, true)
+    })
+
+    test('should handle tools with default enabled state', async () => {
+      const mockData = {
+        tools: [
+          {
+            name: 'default-tool',
+            title: 'Default Tool',
+            description: 'Tool with default enabled state',
+          },
+        ],
+      }
+
+      await registry.loadFromMCPJson(mockData)
+
+      const tools = registry.getTools()
+      assert.strictEqual(tools.length, 1)
+      assert.strictEqual(tools[0].enabled, true)
+    })
+
+    test('should handle empty arrays', async () => {
+      const mockData = {
+        tools: [],
+        resources: [],
+        prompts: [],
+      }
+
+      await registry.loadFromMCPJson(mockData)
+
+      assert.deepStrictEqual(registry.getTools(), [])
+      assert.deepStrictEqual(registry.getResources(), [])
+      assert.deepStrictEqual(registry.getPrompts(), [])
+    })
+
+    test('should handle missing arrays', async () => {
+      const mockData = {}
+
+      await registry.loadFromMCPJson(mockData)
+
+      assert.deepStrictEqual(registry.getTools(), [])
+      assert.deepStrictEqual(registry.getResources(), [])
+      assert.deepStrictEqual(registry.getPrompts(), [])
+    })
+
+    test('should handle empty object gracefully', async () => {
+      // Test with empty object
+      await registry.loadFromMCPJson({})
+      assert.deepStrictEqual(registry.getTools(), [])
+      assert.deepStrictEqual(registry.getResources(), [])
+      assert.deepStrictEqual(registry.getPrompts(), [])
+    })
+  })
+
+  describe('meta setters and getters', () => {
+    test('should set and check resource meta', () => {
+      const meta = {
+        'test-resource': {
+          uri: 'file://test.txt',
+          title: 'Test Resource',
+          description: 'Test description',
+          pikkuFuncName: 'testResource',
+          inputSchema: null,
+          outputSchema: null,
+          mimeType: 'text/plain',
+        },
+      }
+      registry.setResourcesMeta(meta)
+      assert.strictEqual(registry.hasResource('test-resource'), true)
+      assert.strictEqual(registry.hasResource('nonexistent'), false)
+    })
+
+    test('should set and check tool meta', () => {
+      const meta = {
+        'test-tool': {
+          name: 'test-tool',
+          title: 'Test Tool',
+          description: 'Test description',
+          pikkuFuncName: 'testTool',
+          inputSchema: null,
+          outputSchema: null,
+        },
+      }
+      registry.setToolsMeta(meta)
+      assert.strictEqual(registry.hasTool('test-tool'), true)
+      assert.strictEqual(registry.hasTool('nonexistent'), false)
+    })
+
+    test('should set and check prompt meta', () => {
+      const meta = {
+        'test-prompt': {
+          name: 'test-prompt',
+          description: 'Test Prompt',
+          pikkuFuncName: 'testPrompt',
+          inputSchema: null,
+          outputSchema: null,
+          arguments: [],
+        },
+      }
+      registry.setPromptsMeta(meta)
+      assert.strictEqual(registry.hasPrompt('test-prompt'), true)
+      assert.strictEqual(registry.hasPrompt('nonexistent'), false)
+    })
+  })
+
+  describe('individual item getters', () => {
+    beforeEach(async () => {
+      const mockData = {
+        tools: [
+          {
+            name: 'tool1',
+            title: 'Tool 1',
+            description: 'First tool',
+            enabled: true,
+          },
+        ],
+        resources: [
+          {
+            name: 'resource1',
+            uri: 'file://resource1.txt',
+            description: 'First resource',
+            enabled: true,
+          },
+        ],
+        prompts: [
+          {
+            name: 'prompt1',
+            description: 'First prompt',
+            enabled: true,
+          },
+        ],
+      }
+
+      await registry.loadFromMCPJson(mockData)
+    })
+
+    test('should get tool by name', () => {
+      const tool = registry.getTool('tool1')
+      assert.strictEqual(tool?.name, 'tool1')
+      assert.strictEqual(tool?.title, 'Tool 1')
+      assert.strictEqual(registry.getTool('nonexistent'), undefined)
+    })
+
+    test('should get resource by name', () => {
+      const resource = registry.getResource('resource1')
+      assert.strictEqual(resource?.title, 'resource1')
+      assert.strictEqual(resource?.uri, 'file://resource1.txt')
+      assert.strictEqual(registry.getResource('nonexistent'), undefined)
+    })
+
+    test('should get prompt by name', () => {
+      const prompt = registry.getPrompt('prompt1')
+      assert.strictEqual(prompt?.name, 'prompt1')
+      assert.strictEqual(prompt?.description, 'First prompt')
+      assert.strictEqual(registry.getPrompt('nonexistent'), undefined)
+    })
+  })
+
+  describe('getTools filters enabled tools', () => {
+    test('should only return enabled tools', async () => {
+      const mockData = {
+        tools: [
+          {
+            name: 'enabled-tool',
+            title: 'Enabled Tool',
+            description: 'This tool is enabled',
+            enabled: true,
+          },
+          {
+            name: 'disabled-tool',
+            title: 'Disabled Tool',
+            description: 'This tool is disabled',
+            enabled: false,
+          },
+        ],
+      }
+
+      await registry.loadFromMCPJson(mockData)
+
+      const tools = registry.getTools()
+      assert.strictEqual(tools.length, 1)
+      assert.strictEqual(tools[0].name, 'enabled-tool')
+    })
+  })
+
+  describe('enable/disable methods', () => {
+    beforeEach(async () => {
+      const mockData = {
+        tools: [
+          {
+            name: 'tool1',
+            title: 'Tool 1',
+            description: 'First tool',
+            enabled: true,
+          },
+          {
+            name: 'tool2',
+            title: 'Tool 2',
+            description: 'Second tool',
+            enabled: false,
+          },
+        ],
+        resources: [
+          {
+            name: 'resource1',
+            uri: 'file://resource1.txt',
+            description: 'First resource',
+            enabled: true,
+          },
+        ],
+        prompts: [
+          {
+            name: 'prompt1',
+            description: 'First prompt',
+            enabled: true,
+          },
+        ],
+      }
+
+      await registry.loadFromMCPJson(mockData)
+    })
+
+    test('should enable/disable tools and return change status', () => {
+      let changed = registry.enableTools({ tool1: false, tool2: true })
+      assert.strictEqual(changed, true)
+
+      const tool1 = registry.getTool('tool1')
+      const tool2 = registry.getTool('tool2')
+      assert.strictEqual(tool1?.enabled, false)
+      assert.strictEqual(tool2?.enabled, true)
+
+      changed = registry.enableTools({ tool1: false, tool2: true })
+      assert.strictEqual(changed, false)
+    })
+
+    test('should handle nonexistent tools', () => {
+      const changed = registry.enableTools({ nonexistent: true })
+      assert.strictEqual(changed, false)
+    })
+
+    test('should enable/disable prompts and return change status', () => {
+      let changed = registry.enablePrompts({ prompt1: false })
+      assert.strictEqual(changed, true)
+
+      const prompt1 = registry.getPrompt('prompt1')
+      assert.strictEqual(prompt1?.enabled, false)
+
+      changed = registry.enablePrompts({ prompt1: false })
+      assert.strictEqual(changed, false)
+    })
+
+    test('should handle nonexistent prompts', () => {
+      const changed = registry.enablePrompts({ nonexistent: true })
+      assert.strictEqual(changed, false)
+    })
+
+    test('should enable/disable resources', () => {
+      const changed = registry.enableResources({ resource1: false })
+      assert.strictEqual(changed, true)
+
+      const resource1 = registry.getResource('resource1')
+      assert.strictEqual(resource1?.enabled, false)
+    })
+  })
+
+  describe('edge cases', () => {
+    test('should handle null/undefined values in MCP JSON', async () => {
+      const mockData = {
+        tools: [
+          {
+            name: 'incomplete-tool',
+            title: null,
+            description: undefined,
+          },
+        ],
+      }
+
+      await registry.loadFromMCPJson(mockData)
+
+      const tools = registry.getTools()
+      assert.strictEqual(tools.length, 1)
+      assert.strictEqual(tools[0].name, 'incomplete-tool')
+      assert.strictEqual(tools[0].title, null)
+      assert.strictEqual(tools[0].description, undefined)
+    })
+
+    test('should handle non-array values for tools/resources/prompts', async () => {
+      const mockData = {
+        tools: 'not an array',
+        resources: null,
+        prompts: undefined,
+      }
+
+      await registry.loadFromMCPJson(mockData)
+
+      assert.deepStrictEqual(registry.getTools(), [])
+      assert.deepStrictEqual(registry.getResources(), [])
+      assert.deepStrictEqual(registry.getPrompts(), [])
+    })
+  })
+})

package/src/events/mcp/mcp-endpoint-registry.ts

@@ -0,0 +1,165 @@
+import { readFile } from 'fs/promises'
+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 class MCPEndpointRegistry {
+  private tools: Map<string, MCPToolEndpoint> = new Map()
+  private resources: Map<string, MCPResourceEndpoint> = new Map()
+  private prompts: Map<string, MCPPromptEndpoint> = new Map()
+  private resourcesMeta: MCPResourceMeta = {}
+  private toolsMeta: MCPToolMeta = {}
+  private promptsMeta: MCPPromptMeta = {}
+
+  async loadFromMCPJsonFile(mcpJsonPath: string): Promise<void> {
+    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: any): Promise<void> {
+    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: MCPResourceMeta): void {
+    this.resourcesMeta = meta
+  }
+
+  setToolsMeta(meta: MCPToolMeta): void {
+    this.toolsMeta = meta
+  }
+
+  setPromptsMeta(meta: MCPPromptMeta): void {
+    this.promptsMeta = meta
+  }
+
+  getTools(): MCPToolEndpoint[] {
+    return Array.from(this.tools.values()).filter((tool) => tool.enabled)
+  }
+
+  getResources(): MCPResourceEndpoint[] {
+    return Array.from(this.resources.values())
+  }
+
+  getPrompts(): MCPPromptEndpoint[] {
+    return Array.from(this.prompts.values())
+  }
+
+  getTool(name: string): MCPToolEndpoint | undefined {
+    return this.tools.get(name)
+  }
+
+  getResource(name: string): MCPResourceEndpoint | undefined {
+    return this.resources.get(name)
+  }
+
+  getPrompt(name: string): MCPPromptEndpoint | undefined {
+    return this.prompts.get(name)
+  }
+
+  hasResource(name: string): boolean {
+    return name in this.resourcesMeta
+  }
+
+  hasTool(name: string): boolean {
+    return name in this.toolsMeta
+  }
+
+  hasPrompt(name: string): boolean {
+    return name in this.promptsMeta
+  }
+
+  enableTools(tools: Record<any, boolean>): boolean {
+    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: Record<any, boolean>): boolean {
+    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: Record<any, boolean>): boolean {
+    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/src/events/queue/index.ts

@@ -14,5 +14,5 @@ export { validateWorkerConfig } from './validate-worker-config.js'
 export type { QueueConfigMapping } from './validate-worker-config.js'
 
 // Queue registration helper
-export { registerqueueWorkers } from './register-queue-helper.js'
+export { registerQueueWorkers } from './register-queue-helper.js'
 export type { QueueRegistrationCallback } from './register-queue-helper.js'

package/src/events/queue/register-queue-helper.ts

@@ -23,7 +23,7 @@ export type QueueRegistrationCallback<T = any> = (
  * @param logger - Optional logger for info/error messages
  * @returns Record of validation results by queue name
  */
-export async function registerqueueWorkers<T = any>(
+export async function registerQueueWorkers<T = any>(
   configMappings: QueueConfigMapping,
   logger: Logger,
   registerCallback: QueueRegistrationCallback<T>