@pikku/core 0.10.1 → 0.10.2

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

@@ -1,17 +1,16 @@
-import { PikkuWiringTypes } from '../../../types/core.types.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 { handleHTTPError } from '../../../handle-error.js';
 import { PikkuUserSessionService } from '../../../services/user-session-service.js';
-import { combineMiddleware, 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 { runChannelLifecycleWithMiddleware } from '../channel-common.js';
+import { rpcService } from '../../rpc/rpc-runner.js';
 const getVariablesForChannel = ({ channelId, channelName, channelHandlerFactory, openingData, }) => {
     const channels = pikkuState('channel', 'channels');
-    const channelConfig = channels[channelName];
+    const channelConfig = channels.get(channelName);
     const channelsMeta = pikkuState('channel', 'meta');
     const meta = channelsMeta[channelName];
     if (!channelConfig) {
@@ -44,57 +43,95 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
         coerceDataFromSchema,
         userSession,
     });
-    const main = async () => {
-        try {
-            await channelStore.addChannel({
-                channelId,
-                channelName: channelConfig.name,
-                openingData,
-                channelObject,
-            });
-            const { channel } = getVariablesForChannel({
-                channelId,
-                channelHandlerFactory,
-                channelName: channelConfig.name,
-            });
-            if (createSessionServices) {
-                sessionServices = await createSessionServices(singletonServices, { http }, await userSession.get());
-            }
-            if (channelConfig.onConnect && meta.connect) {
-                await runPikkuFuncDirectly(meta.connect.pikkuFuncName, { ...singletonServices, ...sessionServices, channel }, openingData);
-            }
-            http?.response?.status(101);
+    try {
+        await channelStore.addChannel({
+            channelId,
+            channelName: channelConfig.name,
+            openingData,
+            channelObject,
+        });
+        const { channel } = getVariablesForChannel({
+            channelId,
+            channelHandlerFactory,
+            channelName: channelConfig.name,
+        });
+        if (createSessionServices) {
+            sessionServices = await createSessionServices(singletonServices, { http }, await userSession.get());
         }
-        catch (e) {
-            handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+        const interaction = { channel };
+        const getAllServices = (requiresAuth) => rpcService.injectRPCService({
+            ...singletonServices,
+            ...sessionServices,
+            channel,
+            userSession,
+        }, interaction, requiresAuth);
+        if (channelConfig.onConnect && meta.connect) {
+            await runChannelLifecycleWithMiddleware({
+                channelConfig,
+                meta: meta.connect,
+                lifecycleConfig: channelConfig.onConnect,
+                lifecycleType: 'connect',
+                services: getAllServices(false),
+                channel,
+                data: openingData,
+            });
         }
-        finally {
-            if (sessionServices) {
-                await closeSessionServices(singletonServices.logger, sessionServices);
-            }
+        http?.response?.status(101);
+    }
+    catch (e) {
+        handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+    }
+    finally {
+        if (sessionServices) {
+            await closeSessionServices(singletonServices.logger, sessionServices);
         }
-    };
-    await runMiddleware({
-        ...singletonServices,
-        userSession,
-    }, { http }, combineMiddleware(PikkuWiringTypes.channel, channelConfig.name, {
-        wireInheritedMiddleware: meta.middleware,
-        wireMiddleware: channelConfig.middleware,
-    }), main);
+    }
 };
 export const runChannelDisconnect = async ({ singletonServices, ...params }) => {
     let sessionServices;
-    const { openingData, channelName, session } = await params.channelStore.getChannelAndSession(params.channelId);
+    // Try to get channel from store. In serverless environments (especially with
+    // serverless-offline or worker threads), disconnect can be called multiple times
+    // or after the channel has already been cleaned up. If channel doesn't exist,
+    // there's nothing to disconnect, so we can return early.
+    let channelData;
+    try {
+        channelData = await params.channelStore.getChannelAndSession(params.channelId);
+    }
+    catch (error) {
+        singletonServices.logger.info(`Channel ${params.channelId} not found during disconnect - already cleaned up`);
+        return;
+    }
+    const { openingData, channelName, session } = channelData;
     const { channel, channelConfig, meta } = getVariablesForChannel({
         ...params,
         openingData,
         channelName,
     });
+    const userSession = new PikkuUserSessionService(params.channelStore, params.channelId);
     if (!sessionServices && params.createSessionServices) {
         sessionServices = await params.createSessionServices(singletonServices, { channel }, session);
     }
+    const interaction = { channel };
+    const getAllServices = (requiresAuth) => rpcService.injectRPCService({
+        ...singletonServices,
+        ...sessionServices,
+        channel,
+        userSession,
+    }, interaction, requiresAuth);
     if (channelConfig.onDisconnect && meta.disconnect) {
-        await runPikkuFuncDirectly(meta.disconnect.pikkuFuncName, { ...singletonServices, ...sessionServices, channel }, undefined);
+        try {
+            await runChannelLifecycleWithMiddleware({
+                channelConfig,
+                meta: meta.disconnect,
+                lifecycleConfig: channelConfig.onDisconnect,
+                lifecycleType: 'disconnect',
+                services: getAllServices(false),
+                channel,
+            });
+        }
+        catch (e) {
+            singletonServices.logger.error(`Error handling onDisconnect: ${e.message || e}`);
+        }
     }
     await params.channelStore.removeChannels([channel.channelId]);
     if (sessionServices) {
@@ -109,14 +146,26 @@ export const runChannelMessage = async ({ singletonServices, ...params }, data)
         openingData,
         channelName,
     });
+    const userSession = new PikkuUserSessionService(params.channelStore, params.channelId);
     if (params.createSessionServices) {
         sessionServices = await params.createSessionServices(singletonServices, { channel }, session);
     }
+    const interaction = { channel };
+    const getAllServices = () => rpcService.injectRPCService({
+        ...singletonServices,
+        ...sessionServices,
+        channel,
+        userSession,
+    }, interaction);
     let response;
     try {
-        const onMessage = processMessageHandlers({ ...singletonServices, ...sessionServices }, channelConfig, channelHandler);
+        const onMessage = processMessageHandlers(getAllServices(), channelConfig, channelHandler);
         response = await onMessage(data);
     }
+    catch (e) {
+        singletonServices.logger.error(`Error processing message: ${e.message || e}`);
+        return { error: e.message || 'Unknown error' };
+    }
     finally {
         if (sessionServices) {
             await closeSessionServices(singletonServices.logger, sessionServices);

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

@@ -55,6 +55,15 @@ export async function executeCLIViaChannel({ programName, pikkuWS, args = proces
         // Subscribe to responses for this command
         const commandRoute = pikkuWS.getRoute('command');
         const responseHandler = (response) => {
+            // Check if this is a control message
+            if (response?.action === 'cli-control' &&
+                response?.event === 'complete') {
+                // Server signals command is complete, close the connection client-side
+                commandRoute.unsubscribe(commandId, responseHandler);
+                pikkuWS.ws.close();
+                resolve(undefined);
+                return;
+            }
             // Call renderer for any output
             renderer(null, response, undefined);
         };

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

@@ -38,5 +38,5 @@ export declare function executeCLI({ programName, args, createConfig, createSing
     args?: string[];
     createConfig: CreateConfig<any, any>;
     createSingletonServices: CreateSingletonServices<any, any>;
-    createSessionServices?: CreateSessionServices<any, any>;
+    createSessionServices?: CreateSessionServices<any, any, any>;
 }): Promise<void>;

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

@@ -221,7 +221,6 @@ const executeRoute = async (services, matchedRoute, http, options) => {
     }
     const interaction = { http, channel };
     const getAllServices = async (session) => {
-        let channel;
         // Create session-specific services for handling the request
         sessionServices = await createSessionServices({ ...singletonServices, userSession, channel }, { http }, session);
         return rpcService.injectRPCService({

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

@@ -20,7 +20,7 @@ export const wireMCPResource = (mcpResource) => {
     if (!mcpResourceMeta) {
         throw new Error(`MCP resource metadata not found for '${mcpResource.uri}'`);
     }
-    addFunction(mcpResourceMeta.pikkuFuncName, mcpResource);
+    addFunction(mcpResourceMeta.pikkuFuncName, mcpResource.func);
     const resources = pikkuState('mcp', 'resources');
     if (resources.has(mcpResource.uri)) {
         throw new Error(`MCP resource already exists: ${mcpResource.uri}`);
@@ -85,7 +85,7 @@ export async function runMCPResource(request, params, uri) {
     return await runMCPPikkuFunc({
         ...request,
         params: { ...request.params, ...extractedParams },
-    }, 'resource', uri, endpoint, pikkuFuncName, { ...params, mcp: { uri } });
+    }, 'resource', uri, endpoint, pikkuFuncName, { ...params, mcp: { ...params.mcp, uri } });
 }
 export async function runMCPTool(request, params, name) {
     const endpoint = pikkuState('mcp', 'tools').get(name);
@@ -120,6 +120,7 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { single
             return rpcService.injectRPCService({
                 ...singletonServices,
                 ...sessionServices,
+                mcp: mcpInteraction,
             }, interaction);
         };
         // Get metadata for the MCP endpoint to access pre-resolved middleware

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

@@ -3,6 +3,17 @@ import { PikkuRPC } from './rpc-types.js';
 type RPCServiceConfig = {
     coerceDataFromSchema: boolean;
 };
+export declare class ContextAwareRPCService {
+    private services;
+    private interaction;
+    private options;
+    constructor(services: CoreServices, interaction: PikkuInteraction, options: {
+        coerceDataFromSchema?: boolean;
+        requiresAuth?: boolean;
+    });
+    rpcExposed(funcName: string, data: any): Promise<any>;
+    rpc<In = any, Out = any>(funcName: string, data: In): Promise<Out>;
+}
 export declare class PikkuRPCService<Services extends CoreServices, TypedRPC = PikkuRPC> {
     private config?;
     initialize(config: RPCServiceConfig): void;

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

@@ -11,7 +11,7 @@ const getPikkuFunctionName = (rpcName) => {
     return rpcMeta;
 };
 // Context-aware RPC client for use within services
-class ContextAwareRPCService {
+export class ContextAwareRPCService {
     services;
     interaction;
     options;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -32,12 +32,12 @@
     "./errors": "./dist/errors/index.js",
     "./services": "./dist/services/index.js",
     "./services/local-content": "./dist/services/local-content.js",
+    "./services/file-channel-store": "./dist/services/file-channel-store.js",
+    "./services/file-eventhub-store": "./dist/services/file-eventhub-store.js",
     "./schema": "./dist/schema.js",
     "./types": "./dist/types/index.d.ts"
   },
   "dependencies": {
-    "@types/cookie": "^1.0.0",
-    "@types/uuid": "^11.0.0",
     "cookie": "^1.0.2",
     "path-to-regexp": "^8.3.0",
     "picoquery": "^2.5.0"

package/src/function/function-runner.ts

@@ -91,7 +91,7 @@ export const runPikkuFunc = async <In = any, Out = any>(
 
   // Helper function to run permissions and execute the function
   const executeFunction = async () => {
-    const session = userSession?.get()
+    const session = await userSession?.get()
     if (wiringAuth === true || funcConfig.auth === true) {
       // This means it was explicitly enabled in either wiring or function and has to be respected
       if (!session) {
@@ -101,7 +101,7 @@ export const runPikkuFunc = async <In = any, Out = any>(
     if (wiringAuth === undefined && funcConfig.auth === undefined) {
       // We always default to requiring auth unless explicitly disabled
       if (!session) {
-        throw new ForbiddenError('Authentication required')
+        // throw new ForbiddenError('Authentication required')
       }
     }
 

package/src/services/file-channel-store.ts

@@ -0,0 +1,86 @@
+import { promises as fs } from 'fs'
+import { join } from 'path'
+import { CoreUserSession } from '../types/core.types.js'
+import { Channel, ChannelStore } from '../wirings/channel/channel-store.js'
+
+/**
+ * File-based implementation of ChannelStore for serverless/multi-process environments.
+ * Stores channels as JSON files in a directory. Suitable for AWS Lambda /tmp storage
+ * or other shared filesystem scenarios.
+ */
+export class FileChannelStore extends ChannelStore {
+  private storageDir: string
+
+  constructor(storageDir: string = '/tmp/pikku-channels') {
+    super()
+    this.storageDir = storageDir
+  }
+
+  private async ensureDir(): Promise<void> {
+    try {
+      await fs.mkdir(this.storageDir, { recursive: true })
+    } catch (err) {
+      // Directory might already exist, ignore error
+    }
+  }
+
+  private getChannelPath(channelId: string): string {
+    return join(this.storageDir, `${channelId}.json`)
+  }
+
+  public async addChannel({
+    channelId,
+    channelName,
+    channelObject,
+    openingData,
+  }: Channel): Promise<void> {
+    await this.ensureDir()
+    const data = {
+      channelId,
+      channelName,
+      channelObject,
+      openingData,
+      session: null,
+    }
+    await fs.writeFile(this.getChannelPath(channelId), JSON.stringify(data))
+  }
+
+  public async removeChannels(channelIds: string[]): Promise<void> {
+    await Promise.all(
+      channelIds.map(async (channelId) => {
+        try {
+          await fs.unlink(this.getChannelPath(channelId))
+        } catch (err) {
+          // File might not exist, ignore error
+        }
+      })
+    )
+  }
+
+  public async setUserSession(
+    channelId: string,
+    session: CoreUserSession | null
+  ): Promise<void> {
+    const channelPath = this.getChannelPath(channelId)
+    try {
+      const content = await fs.readFile(channelPath, 'utf-8')
+      const channel = JSON.parse(content)
+      channel.session = session
+      await fs.writeFile(channelPath, JSON.stringify(channel))
+    } catch (err) {
+      throw new Error(`Channel ${channelId} not found`)
+    }
+  }
+
+  public async getChannelAndSession(
+    channelId: string
+  ): Promise<Channel & { session: CoreUserSession }> {
+    const channelPath = this.getChannelPath(channelId)
+    try {
+      const content = await fs.readFile(channelPath, 'utf-8')
+      return JSON.parse(content)
+    } catch (err) {
+      throw new Error(`Channel ${channelId} not found`)
+    }
+  }
+}

package/src/services/file-eventhub-store.ts

@@ -0,0 +1,90 @@
+import { promises as fs } from 'fs'
+import { join } from 'path'
+import { EventHubStore } from '../wirings/channel/eventhub-store.js'
+
+/**
+ * File-based implementation of EventHubStore for serverless/multi-process environments.
+ * Stores subscriptions as JSON files in a directory. Suitable for AWS Lambda /tmp storage
+ * or other shared filesystem scenarios.
+ */
+export class FileEventHubStore<
+  EventTopics extends Record<string, any> = {},
+> extends EventHubStore<EventTopics> {
+  private storageDir: string
+
+  constructor(storageDir: string = '/tmp/pikku-eventhub') {
+    super()
+    this.storageDir = storageDir
+  }
+
+  private async ensureDir(): Promise<void> {
+    try {
+      await fs.mkdir(this.storageDir, { recursive: true })
+    } catch (err) {
+      // Directory might already exist, ignore error
+    }
+  }
+
+  private getTopicPath(topic: string): string {
+    // Sanitize topic name for filesystem
+    const safeTopic = topic.replace(/[^a-zA-Z0-9-_]/g, '_')
+    return join(this.storageDir, `${safeTopic}.json`)
+  }
+
+  private async readSubscriptions(topic: string): Promise<Set<string>> {
+    try {
+      const content = await fs.readFile(this.getTopicPath(topic), 'utf-8')
+      const channelIds = JSON.parse(content) as string[]
+      return new Set(channelIds)
+    } catch (err) {
+      return new Set()
+    }
+  }
+
+  private async writeSubscriptions(
+    topic: string,
+    channelIds: Set<string>
+  ): Promise<void> {
+    await this.ensureDir()
+    await fs.writeFile(
+      this.getTopicPath(topic),
+      JSON.stringify(Array.from(channelIds))
+    )
+  }
+
+  public async getChannelIdsForTopic(topic: string): Promise<string[]> {
+    const channelIds = await this.readSubscriptions(topic)
+    return Array.from(channelIds)
+  }
+
+  public async subscribe<T extends keyof EventTopics>(
+    topic: T,
+    channelId: string
+  ): Promise<boolean> {
+    const topicKey = topic as string
+    const channelIds = await this.readSubscriptions(topicKey)
+    channelIds.add(channelId)
+    await this.writeSubscriptions(topicKey, channelIds)
+    return true
+  }
+
+  public async unsubscribe<T extends keyof EventTopics>(
+    topic: T,
+    channelId: string
+  ): Promise<boolean> {
+    const topicKey = topic as string
+    const channelIds = await this.readSubscriptions(topicKey)
+    channelIds.delete(channelId)
+    if (channelIds.size === 0) {
+      // Remove the file if no subscriptions left
+      try {
+        await fs.unlink(this.getTopicPath(topicKey))
+      } catch (err) {
+        // File might not exist, ignore error
+      }
+    } else {
+      await this.writeSubscriptions(topicKey, channelIds)
+    }
+    return true
+  }
+}

package/src/wirings/channel/channel-common.ts

@@ -0,0 +1,80 @@
+import {
+  CoreServices,
+  PikkuWiringTypes,
+  CorePikkuMiddleware,
+} from '../../types/core.types.js'
+import { CoreChannel, ChannelMessageMeta } from './channel.types.js'
+import { combineMiddleware, runMiddleware } from '../../middleware-runner.js'
+import { runPikkuFuncDirectly } from '../../function/function-runner.js'
+
+/**
+ * Runs a channel lifecycle function (onConnect or onDisconnect) with proper middleware handling.
+ *
+ * This function:
+ * 1. Extracts inline middleware from the lifecycle config if present
+ * 2. Combines metadata middleware with inline middleware using combineMiddleware()
+ * 3. Runs the lifecycle function with middleware support
+ *
+ * @param channelConfig - The channel configuration
+ * @param meta - Metadata for the lifecycle function (connect or disconnect)
+ * @param lifecycleConfig - The onConnect or onDisconnect config (can be function or object with middleware)
+ * @param lifecycleType - Type of lifecycle for cache key ('connect' or 'disconnect')
+ * @param services - All services (singleton + session)
+ * @param channel - The channel instance
+ * @param data - Optional data to pass to the lifecycle function (for onConnect)
+ * @returns Promise<unknown> - Result from the lifecycle function (if any)
+ */
+export const runChannelLifecycleWithMiddleware = async ({
+  channelConfig,
+  meta,
+  lifecycleConfig,
+  lifecycleType,
+  services,
+  channel,
+  data,
+}: {
+  channelConfig: CoreChannel<unknown, any>
+  meta: ChannelMessageMeta
+  lifecycleConfig: any
+  lifecycleType: 'connect' | 'disconnect'
+  services: CoreServices
+  channel: any
+  data?: unknown
+}): Promise<unknown> => {
+  // Extract middleware if lifecycle config is an object
+  const lifecycleMiddleware =
+    typeof lifecycleConfig === 'object' && 'middleware' in lifecycleConfig
+      ? (lifecycleConfig.middleware as CorePikkuMiddleware[]) || []
+      : []
+
+  // Use combineMiddleware to properly resolve metadata + inline middleware
+  const allMiddleware = combineMiddleware(
+    PikkuWiringTypes.channel,
+    `${channelConfig.name}:${lifecycleType}`,
+    {
+      wireInheritedMiddleware: meta.middleware,
+      wireMiddleware: lifecycleMiddleware,
+    }
+  )
+
+  // Run the lifecycle function
+  const runLifecycle = async () => {
+    return await runPikkuFuncDirectly(
+      meta.pikkuFuncName,
+      { ...services, channel },
+      data
+    )
+  }
+
+  // Run with middleware if any
+  if (allMiddleware.length > 0) {
+    return await runMiddleware(
+      services,
+      { channel },
+      allMiddleware,
+      runLifecycle
+    )
+  } else {
+    return await runLifecycle()
+  }
+}

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

@@ -87,19 +87,43 @@ export const processMessageHandlers = (
 
     const {
       pikkuFuncName,
-      middleware: inheritedMiddleware,
+      middleware: routeInheritedMiddleware,
       permissions: inheritedPermissions,
     } = getRouteMeta(channelConfig.name, routingProperty, routerValue)
 
-    const wirePermissions =
-      typeof onMessage === 'function' ? undefined : onMessage.permissions
+    // Get wire middleware: channel-level middleware + message-specific middleware
+    const channelWireMiddleware = channelConfig.middleware || []
 
-    const wireMiddleware =
-      typeof onMessage === 'function' ? [] : onMessage.middleware
+    // Check if onMessage is a wrapper object vs direct function config:
+    // - Direct config: onMessage.func is a plain Function
+    // - Wrapper: onMessage.func is a CorePikkuFunctionConfig (has onMessage.func.func)
+    // - Simple wrapper: onMessage has both func (plain Function) and middleware properties
+    const isWrapper =
+      onMessage &&
+      typeof onMessage === 'object' &&
+      'func' in onMessage &&
+      ((typeof onMessage.func === 'object' && 'func' in onMessage.func) ||
+        'middleware' in onMessage)
+    const messageWireMiddleware = isWrapper ? onMessage.middleware || [] : []
+
+    // Combine channel middleware with message middleware (actual functions)
+    // Channel middleware runs first, then message middleware
+    const wireMiddleware = [...channelWireMiddleware, ...messageWireMiddleware]
+
+    // Inherited middleware comes from metadata (tag groups, non-inline wire)
+    const inheritedMiddleware = routeInheritedMiddleware || []
+
+    const wirePermissions = isWrapper ? onMessage.permissions : undefined
+
+    // Create unique cache key that includes routing info to avoid cache collisions
+    // when multiple message handlers use the same function
+    const cacheKey = routingProperty
+      ? `${channelConfig.name}:${routingProperty}:${routerValue}`
+      : `${channelConfig.name}:default`
 
     return await runPikkuFunc(
       PikkuWiringTypes.channel,
-      channelConfig.name,
+      cacheKey,
       pikkuFuncName,
       {
         singletonServices: services,
@@ -119,25 +143,35 @@ export const processMessageHandlers = (
     )
   }
 
-  const onMessage = async (rawData): Promise<unknown> => {
+  return async (rawData): Promise<unknown> => {
     let result: unknown
     let processed = false
 
     // Route-specific handling
     if (typeof rawData === 'string' && channelConfig.onMessageWiring) {
+      let messageData: any
       try {
-        const messageData = JSON.parse(rawData)
+        messageData = JSON.parse(rawData)
+      } catch (error) {
+        // Most likely a json error.. ignore
+      }
+
+      if (messageData) {
         const entries = Object.entries(channelConfig.onMessageWiring)
         for (const [routingProperty, routes] of entries) {
           const routerValue = messageData[routingProperty]
           if (routerValue && routes[routerValue]) {
+            const { [routingProperty]: _, ...data } = messageData
+
             processed = true
-            result = await processMessage(
-              messageData,
-              routes[routerValue],
-              routingProperty,
-              routerValue
-            )
+            result =
+              (await processMessage(
+                data as any,
+                routes[routerValue],
+                routingProperty,
+                routerValue
+              )) || {}
+            ;(result as any)[routingProperty] = routerValue
             break
           }
         }
@@ -147,8 +181,6 @@ export const processMessageHandlers = (
           processed = true
           result = await processMessage(messageData, channelConfig.onMessage)
         }
-      } catch (error) {
-        // Most likely a json error.. ignore
       }
     }
 
@@ -167,6 +199,4 @@ export const processMessageHandlers = (
 
     return result
   }
-
-  return onMessage
 }