@pikku/core 0.9.11 → 0.10.0

package/dist/types/core.types.d.ts

@@ -1,6 +1,7 @@
 import type { Logger, LogLevel } from '../services/logger.js';
 import { VariablesService } from '../services/variables-service.js';
 import { SchemaService } from '../services/schema-service.js';
+import { JWTService } from '../services/jwt-service.js';
 import { PikkuHTTP } from '../wirings/http/http.types.js';
 import { UserSessionService } from '../services/user-session-service.js';
 import { PikkuChannel } from '../wirings/channel/channel.types.js';
@@ -8,18 +9,54 @@ import { PikkuRPC } from '../wirings/rpc/rpc-types.js';
 import { PikkuMCP } from '../wirings/mcp/mcp.types.js';
 import { PikkuScheduledTask } from '../wirings/scheduler/scheduler.types.js';
 import { PikkuQueue } from '../wirings/queue/queue.types.js';
+import { PikkuCLI } from '../wirings/cli/cli.types.js';
 export declare enum PikkuWiringTypes {
     http = "http",
     scheduler = "scheduler",
     channel = "channel",
     rpc = "rpc",
     queue = "queue",
-    mcp = "mcp"
+    mcp = "mcp",
+    cli = "cli"
 }
 export interface FunctionServicesMeta {
     optimized: boolean;
     services: string[];
 }
+/**
+ * Metadata for middleware at any level
+ * - type: 'http' = HTTP route middleware group (references httpGroup in pikkuState)
+ * - type: 'tag' = Tag-based middleware group (references tagGroup in pikkuState)
+ * - type: 'wire' = Wire-level individual middleware
+ */
+export type MiddlewareMetadata = {
+    type: 'http';
+    route: string;
+} | {
+    type: 'tag';
+    tag: string;
+} | {
+    type: 'wire';
+    name: string;
+    inline?: boolean;
+};
+/**
+ * Metadata for permissions at any level
+ * - type: 'http' = HTTP route permission group (references httpGroup in pikkuState)
+ * - type: 'tag' = Tag-based permission group (references tagGroup in pikkuState)
+ * - type: 'wire' = Wire-level individual permission
+ */
+export type PermissionMetadata = {
+    type: 'http';
+    route: string;
+} | {
+    type: 'tag';
+    tag: string;
+} | {
+    type: 'wire';
+    name: string;
+    inline?: boolean;
+};
 export type FunctionRuntimeMeta = {
     pikkuFuncName: string;
     inputSchemaName: string | null;
@@ -34,6 +71,8 @@ export type FunctionMeta = FunctionRuntimeMeta & Partial<{
     tags: string[];
     docs: PikkuDocs;
     isDirectFunction: boolean;
+    middleware: MiddlewareMetadata[];
+    permissions: PermissionMetadata[];
 }>;
 export type FunctionsRuntimeMeta = Record<string, FunctionRuntimeMeta>;
 export type FunctionsMeta = Record<string, FunctionMeta>;
@@ -82,6 +121,8 @@ export interface CoreUserSession {
 export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     /** The schema library used to validate data */
     schema?: SchemaService;
+    /** The JWT service used to encode and decode tokens */
+    jwt?: JWTService;
     /** The core configuration for the application. */
     config: Config;
     /** The logger used by the application. */
@@ -99,6 +140,7 @@ export type PikkuInteraction<In = unknown, Out = unknown> = Partial<{
     channel: PikkuChannel<unknown, Out>;
     scheduledTask: PikkuScheduledTask;
     queue: PikkuQueue;
+    cli: PikkuCLI;
 }>;
 /**
  * A function that can wrap an interaction and be called before or after
@@ -107,9 +149,73 @@ export type CorePikkuMiddleware<SingletonServices extends CoreSingletonServices
     userSession: UserSessionService<UserSession>;
 }, interactions: PikkuInteraction, next: () => Promise<void>) => Promise<void>;
 /**
- * Factory function for creating middleware with tree-shaking support
+ * Configuration object for creating middleware with metadata
+ *
+ * @template SingletonServices - The singleton services type
+ * @template UserSession - The user session type
+ */
+export type CorePikkuMiddlewareConfig<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = {
+    /** The middleware function */
+    func: CorePikkuMiddleware<SingletonServices, UserSession>;
+    /** Optional human-readable name for the middleware */
+    name?: string;
+    /** Optional description of what the middleware does */
+    description?: string;
+};
+/**
+ * A factory function that takes input and returns middleware
+ * Used when middleware needs configuration/input parameters
  */
-export declare const pikkuMiddleware: <SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession>(middleware: CorePikkuMiddleware<SingletonServices, UserSession>) => CorePikkuMiddleware<SingletonServices, UserSession>;
+export type CorePikkuMiddlewareFactory<In = any, SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (input: In) => CorePikkuMiddleware<SingletonServices, UserSession>;
+/**
+ * A group of middleware (combination of regular middleware and factories)
+ * Used with addMiddleware() and addHTTPMiddleware() to group related middleware together
+ */
+export type CorePikkuMiddlewareGroup<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = Array<CorePikkuMiddleware<SingletonServices, UserSession> | CorePikkuMiddlewareFactory<any, SingletonServices, UserSession>>;
+/**
+ * Factory function for creating middleware with tree-shaking support
+ * Supports both direct function and configuration object syntax
+ *
+ * @example
+ * ```typescript
+ * // Direct function syntax
+ * export const logMiddleware = pikkuMiddleware(
+ *   async ({ logger }, _interaction, next) => {
+ *     logger.info('Request started')
+ *     await next()
+ *   }
+ * )
+ *
+ * // Configuration object syntax with metadata
+ * export const logMiddleware = pikkuMiddleware({
+ *   name: 'Request Logger',
+ *   description: 'Logs request information',
+ *   func: async ({ logger }, _interaction, next) => {
+ *     logger.info('Request started')
+ *     await next()
+ *   }
+ * })
+ * ```
+ */
+export declare const pikkuMiddleware: <SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession>(middleware: CorePikkuMiddleware<SingletonServices, UserSession> | CorePikkuMiddlewareConfig<SingletonServices, UserSession>) => CorePikkuMiddleware<SingletonServices, UserSession>;
+/**
+ * Factory function for creating middleware factories
+ * Use this when your middleware needs configuration/input parameters
+ *
+ * @example
+ * ```typescript
+ * export const logMiddleware = pikkuMiddlewareFactory<LogOptions>(({
+ *   message,
+ *   level = 'info'
+ * }) => {
+ *   return pikkuMiddleware(async ({ logger }, _interaction, next) => {
+ *     logger[level](message)
+ *     await next()
+ *   })
+ * })
+ * ```
+ */
+export declare const pikkuMiddlewareFactory: <In = any>(factory: CorePikkuMiddlewareFactory<In>) => CorePikkuMiddlewareFactory<In>;
 /**
  * Represents the core services used by Pikku, including singleton services and the request/response interaction.
  */
@@ -128,7 +234,7 @@ export type CreateSessionServices<SingletonServices extends CoreSingletonService
 /**
  * Defines a function type for creating config.
  */
-export type CreateConfig<Config extends CoreConfig> = (variables?: VariablesService) => Promise<Config>;
+export type CreateConfig<Config extends CoreConfig, RemainingArgs extends any[] = unknown[]> = (variables?: VariablesService, ...args: RemainingArgs) => Promise<Config>;
 /**
  * Represents the documentation for a route, including summary, description, tags, and errors.
  */

package/dist/types/core.types.js

@@ -6,10 +6,53 @@ export var PikkuWiringTypes;
     PikkuWiringTypes["rpc"] = "rpc";
     PikkuWiringTypes["queue"] = "queue";
     PikkuWiringTypes["mcp"] = "mcp";
+    PikkuWiringTypes["cli"] = "cli";
 })(PikkuWiringTypes || (PikkuWiringTypes = {}));
 /**
  * Factory function for creating middleware with tree-shaking support
+ * Supports both direct function and configuration object syntax
+ *
+ * @example
+ * ```typescript
+ * // Direct function syntax
+ * export const logMiddleware = pikkuMiddleware(
+ *   async ({ logger }, _interaction, next) => {
+ *     logger.info('Request started')
+ *     await next()
+ *   }
+ * )
+ *
+ * // Configuration object syntax with metadata
+ * export const logMiddleware = pikkuMiddleware({
+ *   name: 'Request Logger',
+ *   description: 'Logs request information',
+ *   func: async ({ logger }, _interaction, next) => {
+ *     logger.info('Request started')
+ *     await next()
+ *   }
+ * })
+ * ```
  */
 export const pikkuMiddleware = (middleware) => {
-    return middleware;
+    return typeof middleware === 'function' ? middleware : middleware.func;
+};
+/**
+ * Factory function for creating middleware factories
+ * Use this when your middleware needs configuration/input parameters
+ *
+ * @example
+ * ```typescript
+ * export const logMiddleware = pikkuMiddlewareFactory<LogOptions>(({
+ *   message,
+ *   level = 'info'
+ * }) => {
+ *   return pikkuMiddleware(async ({ logger }, _interaction, next) => {
+ *     logger[level](message)
+ *     await next()
+ *   })
+ * })
+ * ```
+ */
+export const pikkuMiddlewareFactory = (factory) => {
+    return factory;
 };

package/dist/utils.d.ts

@@ -2,4 +2,4 @@ import { Logger } from './services/logger.js';
 export declare const closeSessionServices: (logger: Logger, sessionServices: Record<string, any>) => Promise<void>;
 export declare const createWeakUID: () => string;
 export declare const isSerializable: (data: any) => boolean;
-export declare const freezeDedupe: <T extends Function>(arr?: readonly T[] | T[] | undefined) => readonly T[];
+export declare const freezeDedupe: <T>(arr?: readonly T[] | T[] | undefined) => readonly T[];

package/dist/wirings/channel/channel-handler.d.ts

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

package/dist/wirings/channel/channel-handler.js

@@ -32,10 +32,10 @@ const validateAuth = (requiresSession, session, onMessage) => {
     }
     return true;
 };
-export const processMessageHandlers = (services, session, channelConfig, channelHandler) => {
+export const processMessageHandlers = (services, channelConfig, channelHandler) => {
     const logger = services.logger;
     const requiresSession = channelConfig.auth !== false;
-    const processMessage = async (data, onMessage, session, routingProperty, routerValue) => {
+    const processMessage = async (data, onMessage, routingProperty, routerValue) => {
         if (!validateAuth(requiresSession, channelHandler, onMessage)) {
             const routeMessage = routingProperty
                 ? `route '${routingProperty}:${routerValue}'`
@@ -45,19 +45,23 @@ export const processMessageHandlers = (services, session, channelConfig, channel
             channelHandler.getChannel().send(`Unauthorized for ${routeMessage}`);
             return;
         }
-        const { pikkuFuncName } = getRouteMeta(channelConfig.name, routingProperty, routerValue);
-        const permissions = typeof onMessage === 'function' ? {} : onMessage.permissions;
-        const middleware = typeof onMessage === 'function' ? [] : onMessage.middleware;
+        const { pikkuFuncName, middleware: inheritedMiddleware, permissions: inheritedPermissions, } = getRouteMeta(channelConfig.name, routingProperty, routerValue);
+        const wirePermissions = typeof onMessage === 'function' ? undefined : onMessage.permissions;
+        const wireMiddleware = typeof onMessage === 'function' ? [] : onMessage.middleware;
         return await runPikkuFunc(PikkuWiringTypes.channel, channelConfig.name, pikkuFuncName, {
+            singletonServices: services,
             getAllServices: () => ({
                 ...services,
                 channel: channelHandler.getChannel(),
             }),
-            data,
-            session,
-            permissions,
-            middleware,
+            data: () => data,
+            userSession: services.userSession,
+            inheritedMiddleware,
+            wireMiddleware,
+            inheritedPermissions,
+            wirePermissions,
             tags: channelConfig.tags,
+            interaction: { channel: channelHandler.getChannel() },
         });
     };
     const onMessage = async (rawData) => {
@@ -72,14 +76,14 @@ export const processMessageHandlers = (services, session, channelConfig, channel
                     const routerValue = messageData[routingProperty];
                     if (routerValue && routes[routerValue]) {
                         processed = true;
-                        result = await processMessage(messageData, routes[routerValue], session, routingProperty, routerValue);
+                        result = await processMessage(messageData, routes[routerValue], routingProperty, routerValue);
                         break;
                     }
                 }
                 // Default handler if no routes matched but json data was parsed
                 if (!processed && channelConfig.onMessage) {
                     processed = true;
-                    result = await processMessage(messageData, channelConfig.onMessage, session);
+                    result = await processMessage(messageData, channelConfig.onMessage);
                 }
             }
             catch (error) {
@@ -89,7 +93,7 @@ export const processMessageHandlers = (services, session, channelConfig, channel
         // Default handler if no routes matched and json data wasn't parsed
         if (!processed && channelConfig.onMessage) {
             processed = true;
-            result = await processMessage(rawData, channelConfig.onMessage, session);
+            result = await processMessage(rawData, channelConfig.onMessage);
         }
         if (!processed) {
             logger.error(`No handler found for message in channel ${channelConfig.name} for ${JSON.stringify(rawData)}`);

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

@@ -1,3 +1,4 @@
+import { CorePikkuPermission } from '../../function/functions.types.js';
 import { UserSessionService } from '../../services/user-session-service.js';
 import { CorePikkuMiddleware } from '../../types/core.types.js';
 import { ChannelMeta, CoreChannel, RunChannelOptions, RunChannelParams } from './channel.types.js';
@@ -5,12 +6,11 @@ import { ChannelMeta, CoreChannel, RunChannelOptions, RunChannelParams } from '.
  * Adds a channel and registers all functions referenced in it using the
  * function names already stored in the channel metadata
  */
-export declare const wireChannel: <In, Channel extends string, ChannelFunction, ChannelFunctionSessionless, PikkuPermission>(channel: CoreChannel<In, Channel, ChannelFunction, PikkuPermission>) => void;
+export declare const wireChannel: <In, Channel extends string, PikkuPermission extends CorePikkuPermission<In>, PikkuMiddleware extends CorePikkuMiddleware, ChannelFunction>(channel: CoreChannel<In, Channel, PikkuPermission, PikkuMiddleware, ChannelFunction>) => void;
 export declare const openChannel: ({ route, singletonServices, coerceDataFromSchema, request, }: Pick<CoreChannel<unknown, string>, "route"> & RunChannelParams<unknown> & {
     userSession: UserSessionService<any>;
 } & RunChannelOptions) => Promise<{
     openingData: unknown;
     channelConfig: CoreChannel<unknown, any>;
     meta: ChannelMeta;
-    httpMiddleware: CorePikkuMiddleware[] | undefined;
 }>;

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

@@ -17,24 +17,15 @@ export const wireChannel = (channel) => {
     pikkuState('channel', 'channels').set(channel.name, channel);
     // Register onConnect function if provided
     if (channel.onConnect && channelMeta.connect) {
-        addFunction(channelMeta.connect.pikkuFuncName, {
-            func: channel.onConnect,
-        });
+        addFunction(channelMeta.connect.pikkuFuncName, channel.onConnect);
     }
     // Register onDisconnect function if provided
     if (channel.onDisconnect && channelMeta.disconnect) {
-        addFunction(channelMeta.disconnect.pikkuFuncName, {
-            func: channel.onDisconnect,
-        });
+        addFunction(channelMeta.disconnect.pikkuFuncName, channel.onDisconnect);
     }
     // Register onMessage function if provided
     if (channel.onMessage && channelMeta.message?.pikkuFuncName) {
-        const messageFunc = typeof channel.onMessage === 'function'
-            ? channel.onMessage
-            : channel.onMessage.func;
-        addFunction(channelMeta.message.pikkuFuncName, {
-            func: messageFunc,
-        });
+        addFunction(channelMeta.message.pikkuFuncName, channel.onMessage);
     }
     // Register functions in onMessageWiring
     if (channel.onMessageWiring && channelMeta.messageWirings) {
@@ -48,16 +39,8 @@ export const wireChannel = (channel) => {
                 const wiringMeta = channelWirings[wiringKey];
                 if (!wiringMeta)
                     return;
-                // Extract the function from the handler
-                const wiringFunc = typeof handler === 'function'
-                    ? { func: handler }
-                    : {
-                        func: handler.func,
-                        auth: handler.auth,
-                        permissions: handler.permissions,
-                    };
                 // Register the function using the pikku name from metadata
-                addFunction(wiringMeta.pikkuFuncName, wiringFunc);
+                addFunction(wiringMeta.pikkuFuncName, handler);
             });
         });
     }
@@ -85,7 +68,6 @@ const getMatchingChannelConfig = (request) => {
         channelConfig,
         schemaName: channelMeta.input,
         meta: channelMeta,
-        httpMiddleware: matchedPath.middleware,
     };
 };
 export const openChannel = async ({ route, singletonServices, coerceDataFromSchema = true, request, }) => {
@@ -94,7 +76,7 @@ export const openChannel = async ({ route, singletonServices, coerceDataFromSche
         singletonServices.logger.info(`Channel not found: ${route}`);
         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);
     singletonServices.logger.info(`Matched channel: ${channelConfig.name} | route: ${channelConfig.route} | auth: ${requiresSession.toString()}`);
@@ -106,5 +88,5 @@ export const openChannel = async ({ route, singletonServices, coerceDataFromSche
         }
         await validateSchema(singletonServices.logger, singletonServices.schema, schemaName, openingData);
     }
-    return { openingData, channelConfig, meta, httpMiddleware };
+    return { openingData, channelConfig, meta };
 };

package/dist/wirings/channel/channel.types.d.ts

@@ -1,7 +1,7 @@
 import { PikkuError } from '../../errors/error-handler.js';
 import { HTTPFunctionMetaInputTypes, PikkuHTTPRequest, PikkuHTTPResponse } from '../http/http.types.js';
-import { PikkuDocs, CoreSingletonServices, CreateSessionServices, CorePikkuMiddleware } from '../../types/core.types.js';
-import { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuPermission } from '../../function/functions.types.js';
+import { PikkuDocs, CoreSingletonServices, CreateSessionServices, CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+import { CorePermissionGroup, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuFunctionSessionless, CorePikkuPermission } from '../../function/functions.types.js';
 export type RunChannelOptions = Partial<{
     skipUserSession: boolean;
     respondWith404: boolean;
@@ -19,6 +19,8 @@ export type RunChannelParams<ChannelData> = {
 export interface ChannelMessageMeta {
     pikkuFuncName: string;
     docs?: PikkuDocs;
+    middleware?: MiddlewareMetadata[];
+    permissions?: PermissionMetadata[];
 }
 export interface ChannelMeta {
     name: string;
@@ -33,25 +35,24 @@ export interface ChannelMeta {
     messageWirings: Record<string, Record<string, ChannelMessageMeta>>;
     docs?: PikkuDocs;
     tags?: string[];
+    middleware?: MiddlewareMetadata[];
+    permissions?: PermissionMetadata[];
 }
 export type ChannelsMeta = Record<string, ChannelMeta>;
-export type CoreChannel<ChannelData, Channel extends string, ChannelConnect = CorePikkuFunction<void, unknown, ChannelData> | CorePikkuFunctionSessionless<void, unknown, ChannelData>, ChannelDisconnect = CorePikkuFunction<void, void, ChannelData> | CorePikkuFunctionSessionless<void, void, ChannelData>, ChannelFunctionMessage = CorePikkuFunction<unknown, unknown, ChannelData> | CorePikkuFunctionSessionless<unknown, unknown, ChannelData>, PikkuPermission = CorePikkuPermission<ChannelData>> = {
+export type CoreChannel<ChannelData, Channel extends string, ChannelConnect = CorePikkuFunctionConfig<CorePikkuFunction<void, unknown, ChannelData> | CorePikkuFunctionSessionless<void, unknown, ChannelData>, CorePikkuPermission<void>, CorePikkuMiddleware>, ChannelDisconnect = CorePikkuFunctionConfig<CorePikkuFunction<void, void, ChannelData> | CorePikkuFunctionSessionless<void, void, ChannelData>, CorePikkuPermission<void>, CorePikkuMiddleware>, ChannelFunctionMessage = CorePikkuFunctionConfig<CorePikkuFunction<unknown, unknown, ChannelData> | CorePikkuFunctionSessionless<unknown, unknown, ChannelData>, CorePikkuPermission<unknown>, CorePikkuMiddleware>, PikkuPermission = CorePikkuPermission<ChannelData>, PikkuMiddleware = CorePikkuMiddleware> = {
     name: string;
     route: Channel;
     onConnect?: ChannelConnect;
     onDisconnect?: ChannelDisconnect;
-    onMessage?: {
-        func: ChannelFunctionMessage;
-        permissions?: Record<string, PikkuPermission[] | PikkuPermission>;
-        auth?: boolean;
-    } | ChannelFunctionMessage;
+    onMessage?: ChannelFunctionMessage;
     onMessageWiring?: Record<string, Record<string, ChannelFunctionMessage | {
         func: ChannelFunctionMessage;
-        permissions?: Record<string, PikkuPermission[] | PikkuPermission>;
+        permissions?: CorePermissionGroup<PikkuPermission>;
         auth?: boolean;
+        middleware?: PikkuMiddleware[];
     }>>;
-    middleware?: CorePikkuMiddleware[];
-    permissions?: Record<string, PikkuPermission[] | PikkuPermission>;
+    middleware?: PikkuMiddleware[];
+    permissions?: CorePermissionGroup<PikkuPermission>;
     auth?: boolean;
     docs?: Partial<{
         description: string;
@@ -61,11 +62,11 @@ export type CoreChannel<ChannelData, Channel extends string, ChannelConnect = Co
     }>;
     tags?: string[];
 };
-export interface PikkuChannel<OpeningData, Out> {
+export interface PikkuChannel<OpeningData, out Out> {
     channelId: string;
     openingData: OpeningData;
-    send: (data: Out, isBinary?: boolean) => Promise<void> | void;
-    close: () => Promise<void> | void;
+    send(data: Out, isBinary?: boolean): Promise<void> | void;
+    close(): Promise<void> | void;
     state: 'initial' | 'open' | 'closed';
 }
 export interface PikkuChannelHandler<OpeningData = unknown, Out = unknown> {

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

@@ -3,7 +3,7 @@ import { createHTTPInteraction } from '../../http/http-runner.js';
 import { closeSessionServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
-import { PikkuWiringTypes } from '../../../types/core.types.js';
+import { PikkuWiringTypes, } 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';
@@ -18,10 +18,10 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
         http = createHTTPInteraction(request, response);
         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,
@@ -46,25 +46,26 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
             if (createSessionServices) {
                 sessionServices = await createSessionServices(singletonServices, { http, channel }, session);
             }
-            const allServices = rpcService.injectRPCService({
+            const getAllServices = (channel, requiresAuth) => rpcService.injectRPCService({
                 ...singletonServices,
                 ...sessionServices,
-                userSession: userSession,
-            });
+                userSession,
+            }, interaction, requiresAuth);
+            const interaction = { channel };
             channelHandler.registerOnOpen(() => {
                 if (channelConfig.onConnect && meta.connect) {
-                    runPikkuFuncDirectly(meta.connect.pikkuFuncName, { ...allServices, channel }, openingData);
+                    runPikkuFuncDirectly(meta.connect.pikkuFuncName, getAllServices(channel, false), openingData);
                 }
             });
             channelHandler.registerOnClose(async () => {
                 if (channelConfig.onDisconnect && meta.disconnect) {
-                    runPikkuFuncDirectly(meta.disconnect.pikkuFuncName, { ...allServices, channel }, openingData);
+                    runPikkuFuncDirectly(meta.disconnect.pikkuFuncName, getAllServices(channel, false), openingData);
                 }
                 if (sessionServices) {
                     await closeSessionServices(singletonServices.logger, sessionServices);
                 }
             });
-            channelHandler.registerOnMessage(processMessageHandlers(allServices, session, channelConfig, channelHandler));
+            channelHandler.registerOnMessage(processMessageHandlers(getAllServices(channel), channelConfig, channelHandler));
         }
         catch (e) {
             handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
@@ -79,9 +80,8 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
         ...singletonServices,
         userSession,
     }, { http }, combineMiddleware(PikkuWiringTypes.channel, channelConfig.name, {
-        wiringMiddleware: channelConfig.middleware,
-        wiringTags: channelConfig.tags,
-        httpMiddleware,
+        wireInheritedMiddleware: meta.middleware,
+        wireMiddleware: channelConfig.middleware,
     }), main);
     return channelHandler;
 };

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

@@ -35,7 +35,7 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
         http = createHTTPInteraction(new PikkuFetchHTTPRequest(request), response);
     }
     const userSession = new PikkuUserSessionService(channelStore, channelId);
-    const { channelConfig, openingData, meta, httpMiddleware } = await openChannel({
+    const { channelConfig, openingData, meta } = await openChannel({
         channelId,
         createSessionServices,
         request,
@@ -78,9 +78,8 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
         ...singletonServices,
         userSession,
     }, { http }, combineMiddleware(PikkuWiringTypes.channel, channelConfig.name, {
-        wiringMiddleware: channelConfig.middleware,
-        wiringTags: channelConfig.tags,
-        httpMiddleware,
+        wireInheritedMiddleware: meta.middleware,
+        wireMiddleware: channelConfig.middleware,
     }), main);
 };
 export const runChannelDisconnect = async ({ singletonServices, ...params }) => {
@@ -92,7 +91,7 @@ export const runChannelDisconnect = async ({ singletonServices, ...params }) =>
         channelName,
     });
     if (!sessionServices && params.createSessionServices) {
-        sessionServices = await params.createSessionServices(singletonServices, {}, session);
+        sessionServices = await params.createSessionServices(singletonServices, { channel }, session);
     }
     if (channelConfig.onDisconnect && meta.disconnect) {
         await runPikkuFuncDirectly(meta.disconnect.pikkuFuncName, { ...singletonServices, ...sessionServices, channel }, undefined);
@@ -105,17 +104,17 @@ export const runChannelDisconnect = async ({ singletonServices, ...params }) =>
 export const runChannelMessage = async ({ singletonServices, ...params }, data) => {
     let sessionServices;
     const { openingData, channelName, session } = await params.channelStore.getChannelAndSession(params.channelId);
-    const { channelHandler, channelConfig } = getVariablesForChannel({
+    const { channel, channelHandler, channelConfig } = getVariablesForChannel({
         ...params,
         openingData,
         channelName,
     });
     if (params.createSessionServices) {
-        sessionServices = await params.createSessionServices(singletonServices, {}, session);
+        sessionServices = await params.createSessionServices(singletonServices, { channel }, session);
     }
     let response;
     try {
-        const onMessage = processMessageHandlers({ ...singletonServices, ...sessionServices }, session, channelConfig, channelHandler);
+        const onMessage = processMessageHandlers({ ...singletonServices, ...sessionServices }, channelConfig, channelHandler);
         response = await onMessage(data);
     }
     finally {

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

@@ -0,0 +1,12 @@
+import { CorePikkuCLIRender } from '../cli.types.js';
+/**
+ * Execute a CLI program via WebSocket channel
+ * This is the main entry point for CLI-over-Channel clients
+ */
+export declare function executeCLIViaChannel({ programName, pikkuWS, args, renderers, defaultRenderer, }: {
+    programName: string;
+    pikkuWS: any;
+    args?: string[];
+    renderers?: Record<string, CorePikkuCLIRender<any>>;
+    defaultRenderer?: CorePikkuCLIRender<any>;
+}): Promise<void>;