@pikku/core 0.10.1 → 0.10.2

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

@@ -56,7 +56,12 @@ export const wireChannel = <
 
   // Register onMessage function if provided
   if (channel.onMessage && channelMeta.message?.pikkuFuncName) {
-    addFunction(channelMeta.message.pikkuFuncName, channel.onMessage as any)
+    addFunction(
+      channelMeta.message.pikkuFuncName,
+      (channel.onMessage as any).func instanceof Function
+        ? channel.onMessage
+        : (channel.onMessage as any).func
+    )
   }
 
   // Register functions in onMessageWiring
@@ -72,7 +77,13 @@ export const wireChannel = <
         if (!wiringMeta) return
 
         // Register the function using the pikku name from metadata
-        addFunction(wiringMeta.pikkuFuncName, handler as any)
+        // It could be a FuncConfig or a wiring override with a funcConfig
+        addFunction(
+          wiringMeta.pikkuFuncName,
+          (handler as any).func instanceof Function
+            ? handler
+            : (handler as any).func
+        )
       })
     })
   }
@@ -81,8 +92,8 @@ export const wireChannel = <
   pikkuState('channel', 'channels').set(channel.name, channel as any)
 }
 
-const getMatchingChannelConfig = (request: string) => {
-  const matchedPath = httpRouter.match('get', request)
+const getMatchingChannelConfig = (path: string) => {
+  const matchedPath = httpRouter.match('get', path)
   if (!matchedPath) {
     return null
   }

package/src/wirings/channel/channel.types.ts

@@ -88,8 +88,18 @@ export type CoreChannel<
 > = {
   name: string
   route: Channel
-  onConnect?: ChannelConnect
-  onDisconnect?: ChannelDisconnect
+  onConnect?:
+    | ChannelConnect
+    | {
+        func?: ChannelConnect
+        middleware?: PikkuMiddleware[]
+      }
+  onDisconnect?:
+    | ChannelDisconnect
+    | {
+        func?: ChannelDisconnect
+        middleware?: PikkuMiddleware[]
+      }
   onMessage?: ChannelFunctionMessage
   onMessageWiring?: Record<
     string,

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

@@ -33,6 +33,9 @@ export class PikkuLocalChannelHandler<
   }
 
   public close() {
+    if (this.getChannel().state === 'closed') {
+      return
+    }
     super.close()
     this.closeCallback?.()
   }

package/src/wirings/channel/local/local-channel-runner.ts

@@ -8,17 +8,12 @@ import {
   RunChannelParams,
 } from '../channel.types.js'
 import { PikkuLocalChannelHandler } from './local-channel-handler.js'
-import {
-  PikkuInteraction,
-  PikkuWiringTypes,
-  SessionServices,
-} from '../../../types/core.types.js'
+import { PikkuInteraction, SessionServices } from '../../../types/core.types.js'
 import { handleHTTPError } from '../../../handle-error.js'
-import { combineMiddleware, runMiddleware } from '../../../middleware-runner.js'
 import { PikkuUserSessionService } from '../../../services/user-session-service.js'
 import { PikkuHTTP } from '../../http/http.types.js'
-import { runPikkuFuncDirectly } from '../../../function/function-runner.js'
 import { rpcService } from '../../rpc/rpc-runner.js'
+import { runChannelLifecycleWithMiddleware } from '../channel-common.js'
 
 export const runLocalChannel = async ({
   singletonServices,
@@ -95,6 +90,7 @@ export const runLocalChannel = async ({
           {
             ...singletonServices,
             ...sessionServices,
+            channel,
             userSession,
           },
           interaction,
@@ -103,23 +99,43 @@ export const runLocalChannel = async ({
 
       const interaction: PikkuInteraction = { channel }
 
-      channelHandler.registerOnOpen(() => {
+      channelHandler.registerOnOpen(async () => {
         if (channelConfig.onConnect && meta.connect) {
-          runPikkuFuncDirectly(
-            meta.connect.pikkuFuncName,
-            getAllServices(channel, false),
-            openingData
-          )
+          try {
+            const result = await runChannelLifecycleWithMiddleware({
+              channelConfig,
+              meta: meta.connect,
+              lifecycleConfig: channelConfig.onConnect,
+              lifecycleType: 'connect',
+              services: getAllServices(channel, false),
+              channel,
+              data: openingData,
+            })
+            if (result !== undefined) {
+              await channel.send(result)
+            }
+          } catch (e) {
+            singletonServices.logger.error(`Error handling onConnect: ${e}`)
+            channel.send({ error: e.message || 'Unknown error' })
+          }
         }
       })
 
       channelHandler.registerOnClose(async () => {
         if (channelConfig.onDisconnect && meta.disconnect) {
-          runPikkuFuncDirectly(
-            meta.disconnect.pikkuFuncName,
-            getAllServices(channel, false),
-            openingData
-          )
+          try {
+            await runChannelLifecycleWithMiddleware({
+              channelConfig,
+              meta: meta.disconnect,
+              lifecycleConfig: channelConfig.onDisconnect,
+              lifecycleType: 'disconnect',
+              services: getAllServices(channel, false),
+              channel,
+            })
+          } catch (e) {
+            singletonServices.logger.error(`Error handling onDisconnect: ${e}`)
+            channel.send({ error: e.message || 'Unknown error' })
+          }
         }
 
         if (sessionServices) {
@@ -127,13 +143,20 @@ export const runLocalChannel = async ({
         }
       })
 
-      channelHandler.registerOnMessage(
-        processMessageHandlers(
-          getAllServices(channel),
-          channelConfig as any,
-          channelHandler
-        )
+      const onMessage = processMessageHandlers(
+        getAllServices(channel),
+        channelConfig as any,
+        channelHandler
       )
+      channelHandler.registerOnMessage(async (data) => {
+        try {
+          const result = await onMessage(data)
+          await channel.send(result)
+        } catch (e) {
+          singletonServices.logger.error(`Error handling message: ${e.message}`)
+          channel.send({ error: e.message || 'Unknown error' })
+        }
+      })
     } catch (e: any) {
       handleHTTPError(
         e,
@@ -151,18 +174,7 @@ export const runLocalChannel = async ({
     }
   }
 
-  await runMiddleware(
-    {
-      ...singletonServices,
-      userSession,
-    },
-    { http },
-    combineMiddleware(PikkuWiringTypes.channel, channelConfig.name, {
-      wireInheritedMiddleware: meta.middleware,
-      wireMiddleware: channelConfig.middleware,
-    }),
-    main
-  )
+  await main()
 
   return channelHandler
 }

package/src/wirings/channel/serverless/serverless-channel-runner.ts

@@ -1,4 +1,4 @@
-import { PikkuWiringTypes, SessionServices } from '../../../types/core.types.js'
+import { PikkuInteraction, SessionServices } from '../../../types/core.types.js'
 import { closeSessionServices } from '../../../utils.js'
 import { processMessageHandlers } from '../channel-handler.js'
 import { openChannel } from '../channel-runner.js'
@@ -12,11 +12,11 @@ import { createHTTPInteraction } from '../../http/http-runner.js'
 import { ChannelStore } from '../channel-store.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 { PikkuHTTP } from '../../http/http.types.js'
-import { runPikkuFuncDirectly } from '../../../function/function-runner.js'
+import { runChannelLifecycleWithMiddleware } from '../channel-common.js'
+import { rpcService } from '../../rpc/rpc-runner.js'
 
 export interface RunServerlessChannelParams<ChannelData>
   extends RunChannelParams<ChannelData> {
@@ -37,7 +37,7 @@ const getVariablesForChannel = ({
   openingData?: unknown
 }) => {
   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) {
@@ -95,63 +95,66 @@ export const runChannelConnect = async ({
     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)
-    } catch (e: any) {
-      handleHTTPError(
-        e,
-        http,
-        channelId,
-        singletonServices.logger,
-        logWarningsForStatusCodes,
-        respondWith404,
-        bubbleErrors
+  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()
       )
-    } 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
-  )
+    const interaction: PikkuInteraction = { channel }
+    const getAllServices = (requiresAuth?: boolean) =>
+      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,
+      })
+    }
+    http?.response?.status(101)
+  } catch (e: any) {
+    handleHTTPError(
+      e,
+      http,
+      channelId,
+      singletonServices.logger,
+      logWarningsForStatusCodes,
+      respondWith404,
+      bubbleErrors
+    )
+  } finally {
+    if (sessionServices) {
+      await closeSessionServices(singletonServices.logger, sessionServices)
+    }
+  }
 }
 
 export const runChannelDisconnect = async ({
@@ -159,13 +162,33 @@ export const runChannelDisconnect = async ({
   ...params
 }: RunServerlessChannelParams<unknown>): Promise<void> => {
   let sessionServices: SessionServices | undefined
-  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,
@@ -173,12 +196,35 @@ export const runChannelDisconnect = async ({
       session
     )
   }
-  if (channelConfig.onDisconnect && meta.disconnect) {
-    await runPikkuFuncDirectly(
-      meta.disconnect.pikkuFuncName,
-      { ...singletonServices, ...sessionServices, channel },
-      undefined
+
+  const interaction: PikkuInteraction = { channel }
+  const getAllServices = (requiresAuth?: boolean) =>
+    rpcService.injectRPCService(
+      {
+        ...singletonServices,
+        ...sessionServices,
+        channel,
+        userSession,
+      },
+      interaction,
+      requiresAuth
     )
+
+  if (channelConfig.onDisconnect && meta.disconnect) {
+    try {
+      await runChannelLifecycleWithMiddleware({
+        channelConfig,
+        meta: meta.disconnect,
+        lifecycleConfig: channelConfig.onDisconnect,
+        lifecycleType: 'disconnect',
+        services: getAllServices(false),
+        channel,
+      })
+    } catch (e: any) {
+      singletonServices.logger.error(
+        `Error handling onDisconnect: ${e.message || e}`
+      )
+    }
   }
   await params.channelStore.removeChannels([channel.channelId])
   if (sessionServices) {
@@ -199,6 +245,10 @@ export const runChannelMessage = async (
     openingData,
     channelName,
   })
+  const userSession = new PikkuUserSessionService(
+    params.channelStore,
+    params.channelId
+  )
   if (params.createSessionServices) {
     sessionServices = await params.createSessionServices(
       singletonServices,
@@ -206,14 +256,32 @@ export const runChannelMessage = async (
       session
     )
   }
+
+  const interaction: PikkuInteraction = { channel }
+  const getAllServices = () =>
+    rpcService.injectRPCService(
+      {
+        ...singletonServices,
+        ...sessionServices,
+        channel,
+        userSession,
+      },
+      interaction
+    )
+
   let response: unknown
   try {
     const onMessage = processMessageHandlers(
-      { ...singletonServices, ...sessionServices },
+      getAllServices(),
       channelConfig,
       channelHandler
     )
     response = await onMessage(data)
+  } catch (e: any) {
+    singletonServices.logger.error(
+      `Error processing message: ${e.message || e}`
+    )
+    return { error: e.message || 'Unknown error' }
   } finally {
     if (sessionServices) {
       await closeSessionServices(singletonServices.logger, sessionServices)

package/src/wirings/cli/channel/cli-channel-runner.ts

@@ -92,6 +92,18 @@ export async function executeCLIViaChannel({
     const commandRoute = pikkuWS.getRoute('command')
 
     const responseHandler = (response: any) => {
+      // 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 as any, response, undefined)
     }

package/src/wirings/cli/cli-runner.ts

@@ -434,7 +434,7 @@ export async function executeCLI({
   args?: string[]
   createConfig: CreateConfig<any, any>
   createSingletonServices: CreateSingletonServices<any, any>
-  createSessionServices?: CreateSessionServices<any, any>
+  createSessionServices?: CreateSessionServices<any, any, any>
 }): Promise<void> {
   if (!args) {
     throw new Error(

package/src/wirings/http/http-runner.ts

@@ -327,8 +327,6 @@ const executeRoute = async (
   const interaction: PikkuInteraction = { http, channel }
 
   const getAllServices = async (session?: CoreUserSession) => {
-    let channel: PikkuChannel<unknown, unknown> | undefined
-
     // Create session-specific services for handling the request
     sessionServices = await createSessionServices(
       { ...singletonServices, userSession, channel },

package/src/wirings/mcp/mcp-runner.ts

@@ -62,7 +62,7 @@ export const wireMCPResource = <
   if (!mcpResourceMeta) {
     throw new Error(`MCP resource metadata not found for '${mcpResource.uri}'`)
   }
-  addFunction(mcpResourceMeta.pikkuFuncName, mcpResource)
+  addFunction(mcpResourceMeta.pikkuFuncName, mcpResource.func as any)
   const resources = pikkuState('mcp', 'resources')
   if (resources.has(mcpResource.uri)) {
     throw new Error(`MCP resource already exists: ${mcpResource.uri}`)
@@ -160,7 +160,9 @@ export async function runMCPResource(
     uri,
     endpoint,
     pikkuFuncName,
-    { ...params, mcp: { uri } } as RunMCPEndpointParams<keyof CoreMCPResource>
+    { ...params, mcp: { ...params.mcp, uri } } as RunMCPEndpointParams<
+      keyof CoreMCPResource
+    >
   )
 }
 
@@ -250,6 +252,7 @@ async function runMCPPikkuFunc(
         {
           ...singletonServices,
           ...sessionServices,
+          mcp: mcpInteraction,
         },
         interaction
       )

package/src/wirings/rpc/rpc-runner.ts

@@ -23,7 +23,7 @@ const getPikkuFunctionName = (rpcName: string): string => {
 }
 
 // Context-aware RPC client for use within services
-class ContextAwareRPCService {
+export class ContextAwareRPCService {
   constructor(
     private services: CoreServices,
     private interaction: PikkuInteraction,