@pikku/core 0.9.11 → 0.9.12-next.0

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

@@ -3,7 +3,6 @@ import { addFunction } from '../../function/function-runner.js'
 import { pikkuState } from '../../pikku-state.js'
 import { coerceTopLevelDataFromSchema, validateSchema } from '../../schema.js'
 import { UserSessionService } from '../../services/user-session-service.js'
-import { CorePikkuMiddleware } from '../../types/core.types.js'
 import { httpRouter } from '../http/routers/http-router.js'
 import {
   ChannelMeta,
@@ -117,7 +116,6 @@ const getMatchingChannelConfig = (request: string) => {
     channelConfig,
     schemaName: channelMeta.input,
     meta: channelMeta,
-    httpMiddleware: matchedPath.middleware,
   }
 }
 
@@ -133,7 +131,6 @@ export const openChannel = async ({
   openingData: unknown
   channelConfig: CoreChannel<unknown, any>
   meta: ChannelMeta
-  httpMiddleware: CorePikkuMiddleware[] | undefined
 }> => {
   const matchingChannel = getMatchingChannelConfig(route)
   if (!matchingChannel) {
@@ -141,8 +138,7 @@ export const openChannel = async ({
     throw new NotFoundError(`Channel not found: ${route}`)
   }
 
-  const { params, channelConfig, schemaName, meta, httpMiddleware } =
-    matchingChannel
+  const { params, channelConfig, schemaName, meta } = matchingChannel
 
   const requiresSession = channelConfig.auth !== false
   request?.setParams(params)
@@ -165,5 +161,5 @@ export const openChannel = async ({
     )
   }
 
-  return { openingData, channelConfig, meta, httpMiddleware }
+  return { openingData, channelConfig, meta }
 }

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

@@ -9,6 +9,7 @@ import {
   CoreSingletonServices,
   CreateSessionServices,
   CorePikkuMiddleware,
+  MiddlewareMetadata,
 } from '../../types/core.types.js'
 import {
   CorePikkuFunction,
@@ -35,6 +36,7 @@ export type RunChannelParams<ChannelData> = {
 export interface ChannelMessageMeta {
   pikkuFuncName: string
   docs?: PikkuDocs
+  middleware?: MiddlewareMetadata[]
 }
 
 export interface ChannelMeta {
@@ -50,6 +52,7 @@ export interface ChannelMeta {
   messageWirings: Record<string, Record<string, ChannelMessageMeta>>
   docs?: PikkuDocs
   tags?: string[]
+  middleware?: MiddlewareMetadata[] // Pre-resolved middleware chain (tag + explicit)
 }
 
 export type ChannelsMeta = Record<string, ChannelMeta>
@@ -67,6 +70,7 @@ export type CoreChannel<
     | CorePikkuFunction<unknown, unknown, ChannelData>
     | CorePikkuFunctionSessionless<unknown, unknown, ChannelData>,
   PikkuPermission = CorePikkuPermission<ChannelData>,
+  PikkuMiddleware = CorePikkuMiddleware,
 > = {
   name: string
   route: Channel
@@ -91,7 +95,7 @@ export type CoreChannel<
         }
     >
   >
-  middleware?: CorePikkuMiddleware[]
+  middleware?: PikkuMiddleware[]
   permissions?: Record<string, PikkuPermission[] | PikkuPermission>
   auth?: boolean
   docs?: Partial<{

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

@@ -8,7 +8,11 @@ import {
   RunChannelParams,
 } from '../channel.types.js'
 import { PikkuLocalChannelHandler } from './local-channel-handler.js'
-import { PikkuWiringTypes, SessionServices } from '../../../types/core.types.js'
+import {
+  PikkuInteraction,
+  PikkuWiringTypes,
+  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'
@@ -42,9 +46,9 @@ export const runLocalChannel = async ({
     route = http?.request?.path()
   }
 
-  let openingData, channelConfig, meta, httpMiddleware
+  let openingData, channelConfig, meta
   try {
-    ;({ openingData, channelConfig, meta, httpMiddleware } = await openChannel({
+    ;({ openingData, channelConfig, meta } = await openChannel({
       channelId,
       createSessionServices,
       respondWith404,
@@ -86,17 +90,24 @@ export const runLocalChannel = async ({
         )
       }
 
-      const allServices = rpcService.injectRPCService({
-        ...singletonServices,
-        ...sessionServices,
-        userSession: userSession,
-      })
+      const getAllServices = (channel: any, requiresAuth?: boolean) =>
+        rpcService.injectRPCService(
+          {
+            ...singletonServices,
+            ...sessionServices,
+            userSession,
+          },
+          interaction,
+          requiresAuth
+        )
+
+      const interaction: PikkuInteraction = { channel }
 
       channelHandler.registerOnOpen(() => {
         if (channelConfig.onConnect && meta.connect) {
           runPikkuFuncDirectly(
             meta.connect.pikkuFuncName,
-            { ...allServices, channel },
+            getAllServices(channel, false),
             openingData
           )
         }
@@ -106,10 +117,11 @@ export const runLocalChannel = async ({
         if (channelConfig.onDisconnect && meta.disconnect) {
           runPikkuFuncDirectly(
             meta.disconnect.pikkuFuncName,
-            { ...allServices, channel },
+            getAllServices(channel, false),
             openingData
           )
         }
+
         if (sessionServices) {
           await closeSessionServices(singletonServices.logger, sessionServices)
         }
@@ -117,8 +129,7 @@ export const runLocalChannel = async ({
 
       channelHandler.registerOnMessage(
         processMessageHandlers(
-          allServices,
-          session,
+          getAllServices(channel),
           channelConfig as any,
           channelHandler
         )
@@ -147,9 +158,8 @@ export const runLocalChannel = async ({
     },
     { http },
     combineMiddleware(PikkuWiringTypes.channel, channelConfig.name, {
-      wiringMiddleware: channelConfig.middleware,
-      wiringTags: channelConfig.tags,
-      httpMiddleware,
+      wireInheritedMiddleware: meta.middleware,
+      wireMiddleware: channelConfig.middleware,
     }),
     main
   )

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

@@ -85,16 +85,15 @@ export const runChannelConnect = async ({
 
   const userSession = new PikkuUserSessionService(channelStore, channelId)
 
-  const { channelConfig, openingData, meta, httpMiddleware } =
-    await openChannel({
-      channelId,
-      createSessionServices,
-      request,
-      route,
-      singletonServices,
-      coerceDataFromSchema,
-      userSession,
-    })
+  const { channelConfig, openingData, meta } = await openChannel({
+    channelId,
+    createSessionServices,
+    request,
+    route,
+    singletonServices,
+    coerceDataFromSchema,
+    userSession,
+  })
 
   const main = async () => {
     try {
@@ -148,9 +147,8 @@ export const runChannelConnect = async ({
     },
     { http },
     combineMiddleware(PikkuWiringTypes.channel, channelConfig.name, {
-      wiringMiddleware: channelConfig.middleware,
-      wiringTags: channelConfig.tags,
-      httpMiddleware,
+      wireInheritedMiddleware: meta.middleware,
+      wireMiddleware: channelConfig.middleware,
     }),
     main
   )
@@ -171,7 +169,7 @@ export const runChannelDisconnect = async ({
   if (!sessionServices && params.createSessionServices) {
     sessionServices = await params.createSessionServices(
       singletonServices,
-      {},
+      { channel },
       session
     )
   }
@@ -195,7 +193,8 @@ export const runChannelMessage = async (
   let sessionServices: SessionServices | undefined
   const { openingData, channelName, session } =
     await params.channelStore.getChannelAndSession(params.channelId)
-  const { channelHandler, channelConfig } = getVariablesForChannel({
+
+  const { channel, channelHandler, channelConfig } = getVariablesForChannel({
     ...params,
     openingData,
     channelName,
@@ -203,7 +202,7 @@ export const runChannelMessage = async (
   if (params.createSessionServices) {
     sessionServices = await params.createSessionServices(
       singletonServices,
-      {},
+      { channel },
       session
     )
   }
@@ -211,7 +210,6 @@ export const runChannelMessage = async (
   try {
     const onMessage = processMessageHandlers(
       { ...singletonServices, ...sessionServices },
-      session,
       channelConfig,
       channelHandler
     )

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

@@ -0,0 +1,118 @@
+import { pikkuState } from '../../../pikku-state.js'
+import { CorePikkuCLIRender } from '../cli.types.js'
+import { generateCommandHelp, parseCLIArguments } from '../command-parser.js'
+
+/**
+ * Default JSON renderer for CLI output
+ */
+const defaultJSONRenderer: CorePikkuCLIRender<any> = (_services, data) => {
+  console.log(JSON.stringify(data, null, 2))
+}
+
+/**
+ * Execute a CLI program via WebSocket channel
+ * This is the main entry point for CLI-over-Channel clients
+ */
+export async function executeCLIViaChannel({
+  programName,
+  pikkuWS,
+  args = process.argv.slice(2),
+  renderers = {},
+  defaultRenderer,
+}: {
+  programName: string
+  pikkuWS: any // CorePikkuWebsocket instance
+  args?: string[]
+  renderers?: Record<string, CorePikkuCLIRender<any>>
+  defaultRenderer?: CorePikkuCLIRender<any>
+}): Promise<void> {
+  // Get CLI metadata from state
+  const allCLIMeta = pikkuState('cli', 'meta') || {}
+  const programMeta = allCLIMeta[programName]
+
+  if (!programMeta) {
+    console.error(`Error: CLI program "${programName}" not found`)
+    process.exit(1)
+  }
+
+  // Parse arguments for this specific program
+  const parsed = parseCLIArguments(args, programName, allCLIMeta)
+
+  // Handle help (check after parsing to support subcommand help)
+  if (args.includes('--help') || args.includes('-h') || args.length === 0) {
+    const helpText = generateCommandHelp(
+      programName,
+      allCLIMeta,
+      parsed.commandPath
+    )
+    console.log(helpText)
+    return
+  }
+
+  if (parsed.errors.length > 0) {
+    // Check if any error is about an unknown command
+    const hasUnknownCommand = parsed.errors.some(
+      (error) =>
+        error.startsWith('Unknown command:') ||
+        error.startsWith('Command not found:')
+    )
+
+    if (hasUnknownCommand) {
+      // Show help instead of error for unknown commands
+      const helpText = generateCommandHelp(
+        programName,
+        allCLIMeta,
+        parsed.commandPath
+      )
+      console.log(helpText)
+      process.exit(1)
+    } else {
+      // Show errors for other types of errors
+      console.error('Errors:')
+      parsed.errors.forEach((error) => console.error(`  ${error}`))
+      process.exit(1)
+    }
+  }
+
+  // Merge positionals and options into single data object
+  const data = { ...parsed.positionals, ...parsed.options }
+
+  // Get the renderer for this command
+  const commandId = parsed.commandPath.join('.')
+  const renderer =
+    renderers[commandId] || defaultRenderer || defaultJSONRenderer
+
+  return new Promise((resolve, reject) => {
+    // Subscribe to responses for this command
+    const commandRoute = pikkuWS.getRoute('command')
+
+    const responseHandler = (response: any) => {
+      // Call renderer for any output
+      renderer(null as any, response, undefined)
+    }
+
+    commandRoute.subscribe(commandId, responseHandler)
+
+    // Handle connection close
+    pikkuWS.ws.addEventListener('close', () => {
+      commandRoute.unsubscribe(commandId, responseHandler)
+      resolve(undefined)
+    })
+
+    pikkuWS.ws.addEventListener('error', (error: any) => {
+      commandRoute.unsubscribe(commandId, responseHandler)
+      reject(error)
+    })
+
+    // Send the command once connected
+    if (pikkuWS.ws.readyState === 1) {
+      // Already open
+      commandRoute.send(commandId, data)
+    } else {
+      // Wait for open
+      pikkuWS.ws.addEventListener('open', () => {
+        commandRoute.send(commandId, data)
+      })
+    }
+  })
+}

package/src/wirings/cli/channel/index.ts

@@ -0,0 +1 @@
+export * from './cli-channel-runner.js'