@pikku/core 0.10.2 → 0.11.1

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

@@ -1,5 +1,5 @@
 import { CorePikkuPermission } from '../../function/functions.types.js';
-import { UserSessionService } from '../../services/user-session-service.js';
+import { SessionService } from '../../services/user-session-service.js';
 import { CorePikkuMiddleware } from '../../types/core.types.js';
 import { ChannelMeta, CoreChannel, RunChannelOptions, RunChannelParams } from './channel.types.js';
 /**
@@ -8,7 +8,7 @@ import { ChannelMeta, CoreChannel, RunChannelOptions, RunChannelParams } from '.
  */
 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>;
+    userSession: SessionService<any>;
 } & RunChannelOptions) => Promise<{
     openingData: unknown;
     channelConfig: CoreChannel<unknown, any>;

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

@@ -1,6 +1,6 @@
 import { PikkuError } from '../../errors/error-handler.js';
 import { HTTPFunctionMetaInputTypes, PikkuHTTPRequest, PikkuHTTPResponse } from '../http/http.types.js';
-import { PikkuDocs, CoreSingletonServices, CreateSessionServices, CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+import { CoreSingletonServices, CreateWireServices, 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;
@@ -14,11 +14,14 @@ export type RunChannelParams<ChannelData> = {
     singletonServices: CoreSingletonServices;
     request?: PikkuHTTPRequest<ChannelData>;
     response?: PikkuHTTPResponse;
-    createSessionServices?: CreateSessionServices;
+    createWireServices?: CreateWireServices;
 };
 export interface ChannelMessageMeta {
     pikkuFuncName: string;
-    docs?: PikkuDocs;
+    summary?: string;
+    description?: string;
+    errors?: string[];
+    tags?: string[];
     middleware?: MiddlewareMetadata[];
     permissions?: PermissionMetadata[];
 }
@@ -33,13 +36,15 @@ export interface ChannelMeta {
     disconnect: ChannelMessageMeta | null;
     message: ChannelMessageMeta | null;
     messageWirings: Record<string, Record<string, ChannelMessageMeta>>;
-    docs?: PikkuDocs;
+    summary?: string;
+    description?: string;
+    errors?: string[];
     tags?: string[];
     middleware?: MiddlewareMetadata[];
     permissions?: PermissionMetadata[];
 }
 export type ChannelsMeta = Record<string, ChannelMeta>;
-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> = {
+export type CoreChannel<ChannelData, Channel extends string, ChannelConnect = CorePikkuFunctionConfig<CorePikkuFunction<void, unknown> | CorePikkuFunctionSessionless<void, unknown>, CorePikkuPermission<void>, CorePikkuMiddleware>, ChannelDisconnect = CorePikkuFunctionConfig<CorePikkuFunction<void, void> | CorePikkuFunctionSessionless<void, void>, CorePikkuPermission<void>, CorePikkuMiddleware>, ChannelFunctionMessage = CorePikkuFunctionConfig<CorePikkuFunction<unknown, unknown> | CorePikkuFunctionSessionless<unknown, unknown>, CorePikkuPermission<unknown>, CorePikkuMiddleware>, PikkuPermission = CorePikkuPermission<ChannelData>, PikkuMiddleware = CorePikkuMiddleware> = {
     name: string;
     route: Channel;
     onConnect?: ChannelConnect | {

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

@@ -1,3 +1,3 @@
 import { CoreChannel, RunChannelOptions, RunChannelParams } from '../channel.types.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
-export declare const runLocalChannel: ({ singletonServices, channelId, request, response, route, createSessionServices, skipUserSession, respondWith404, coerceDataFromSchema, logWarningsForStatusCodes, bubbleErrors, }: Partial<Pick<CoreChannel<unknown, any>, "route">> & RunChannelOptions & RunChannelParams<unknown>) => Promise<PikkuLocalChannelHandler | void>;
+export declare const runLocalChannel: ({ singletonServices, channelId, request, response, route, createWireServices, skipUserSession, respondWith404, coerceDataFromSchema, logWarningsForStatusCodes, bubbleErrors, }: Partial<Pick<CoreChannel<unknown, any>, "route">> & RunChannelOptions & RunChannelParams<unknown>) => Promise<PikkuLocalChannelHandler | void>;

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

@@ -1,19 +1,18 @@
 import { openChannel } from '../channel-runner.js';
-import { createHTTPInteraction } from '../../http/http-runner.js';
-import { closeSessionServices } from '../../../utils.js';
+import { createHTTPWire } from '../../http/http-runner.js';
+import { closeWireServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
 import { handleHTTPError } from '../../../handle-error.js';
-import { PikkuUserSessionService } from '../../../services/user-session-service.js';
-import { rpcService } from '../../rpc/rpc-runner.js';
+import { PikkuSessionService } from '../../../services/user-session-service.js';
 import { runChannelLifecycleWithMiddleware } from '../channel-common.js';
-export const runLocalChannel = async ({ singletonServices, channelId, request, response, route, createSessionServices, skipUserSession = false, respondWith404 = true, coerceDataFromSchema = true, logWarningsForStatusCodes = [], bubbleErrors = false, }) => {
-    let sessionServices;
+export const runLocalChannel = async ({ singletonServices, channelId, request, response, route, createWireServices, skipUserSession = false, respondWith404 = true, coerceDataFromSchema = true, logWarningsForStatusCodes = [], bubbleErrors = false, }) => {
+    let wireServices;
     let channelHandler;
-    const userSession = new PikkuUserSessionService();
+    const userSession = new PikkuSessionService();
     let http;
     if (request) {
-        http = createHTTPInteraction(request, response);
+        http = createHTTPWire(request, response);
         route = http?.request?.path();
     }
     let openingData, channelConfig, meta;
@@ -21,7 +20,7 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
         ;
         ({ openingData, channelConfig, meta } = await openChannel({
             channelId,
-            createSessionServices,
+            createWireServices,
             respondWith404,
             request,
             response,
@@ -40,17 +39,11 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
         try {
             channelHandler = new PikkuLocalChannelHandler(channelId, channelConfig.name, openingData);
             const channel = channelHandler.getChannel();
-            const session = await userSession.get();
-            if (createSessionServices) {
-                sessionServices = await createSessionServices(singletonServices, { http, channel }, session);
+            const wire = { channel, session: userSession };
+            if (createWireServices) {
+                wireServices = await createWireServices(singletonServices, wire);
             }
-            const getAllServices = (channel, requiresAuth) => rpcService.injectRPCService({
-                ...singletonServices,
-                ...sessionServices,
-                channel,
-                userSession,
-            }, interaction, requiresAuth);
-            const interaction = { channel };
+            const services = { ...singletonServices, ...wireServices };
             channelHandler.registerOnOpen(async () => {
                 if (channelConfig.onConnect && meta.connect) {
                     try {
@@ -59,7 +52,7 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
                             meta: meta.connect,
                             lifecycleConfig: channelConfig.onConnect,
                             lifecycleType: 'connect',
-                            services: getAllServices(channel, false),
+                            services,
                             channel,
                             data: openingData,
                         });
@@ -81,7 +74,7 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
                             meta: meta.disconnect,
                             lifecycleConfig: channelConfig.onDisconnect,
                             lifecycleType: 'disconnect',
-                            services: getAllServices(channel, false),
+                            services,
                             channel,
                         });
                     }
@@ -90,11 +83,11 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
                         channel.send({ error: e.message || 'Unknown error' });
                     }
                 }
-                if (sessionServices) {
-                    await closeSessionServices(singletonServices.logger, sessionServices);
+                if (wireServices) {
+                    await closeWireServices(singletonServices.logger, wireServices);
                 }
             });
-            const onMessage = processMessageHandlers(getAllServices(channel), channelConfig, channelHandler);
+            const onMessage = processMessageHandlers(services, channelConfig, channelHandler, userSession);
             channelHandler.registerOnMessage(async (data) => {
                 try {
                     const result = await onMessage(data);
@@ -110,8 +103,8 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
             handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
         }
         finally {
-            if (sessionServices) {
-                await closeSessionServices(singletonServices.logger, sessionServices);
+            if (wireServices) {
+                await closeWireServices(singletonServices.logger, wireServices);
             }
         }
     };

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

@@ -5,6 +5,6 @@ export interface RunServerlessChannelParams<ChannelData> extends RunChannelParam
     channelHandlerFactory: PikkuChannelHandlerFactory;
     channelObject?: unknown;
 }
-export declare const runChannelConnect: ({ singletonServices, channelId, channelObject, request, response, route, createSessionServices, channelStore, channelHandlerFactory, coerceDataFromSchema, logWarningsForStatusCodes, respondWith404, bubbleErrors, }: Pick<CoreChannel<unknown, any>, "route"> & RunChannelOptions & RunServerlessChannelParams<unknown>) => Promise<void>;
+export declare const runChannelConnect: ({ singletonServices, channelId, channelObject, request, response, route, createWireServices, channelStore, channelHandlerFactory, coerceDataFromSchema, logWarningsForStatusCodes, respondWith404, bubbleErrors, }: Pick<CoreChannel<unknown, any>, "route"> & RunChannelOptions & RunServerlessChannelParams<unknown>) => Promise<void>;
 export declare const runChannelDisconnect: ({ singletonServices, ...params }: RunServerlessChannelParams<unknown>) => Promise<void>;
 export declare const runChannelMessage: ({ singletonServices, ...params }: RunServerlessChannelParams<unknown>, data: unknown) => Promise<unknown>;

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

@@ -1,13 +1,12 @@
-import { closeSessionServices } from '../../../utils.js';
+import { closeWireServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { openChannel } from '../channel-runner.js';
-import { createHTTPInteraction } from '../../http/http-runner.js';
+import { createHTTPWire } from '../../http/http-runner.js';
 import { handleHTTPError } from '../../../handle-error.js';
-import { PikkuUserSessionService } from '../../../services/user-session-service.js';
+import { PikkuSessionService } from '../../../services/user-session-service.js';
 import { pikkuState } from '../../../pikku-state.js';
 import { PikkuFetchHTTPRequest } from '../../http/pikku-fetch-http-request.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.get(channelName);
@@ -27,16 +26,16 @@ const getVariablesForChannel = ({ channelId, channelName, channelHandlerFactory,
         meta,
     };
 };
-export const runChannelConnect = async ({ singletonServices, channelId, channelObject, request, response, route, createSessionServices, channelStore, channelHandlerFactory, coerceDataFromSchema = true, logWarningsForStatusCodes = [], respondWith404 = true, bubbleErrors = false, }) => {
-    let sessionServices;
+export const runChannelConnect = async ({ singletonServices, channelId, channelObject, request, response, route, createWireServices, channelStore, channelHandlerFactory, coerceDataFromSchema = true, logWarningsForStatusCodes = [], respondWith404 = true, bubbleErrors = false, }) => {
+    let wireServices;
     let http;
     if (request instanceof Request) {
-        http = createHTTPInteraction(new PikkuFetchHTTPRequest(request), response);
+        http = createHTTPWire(new PikkuFetchHTTPRequest(request), response);
     }
-    const userSession = new PikkuUserSessionService(channelStore, channelId);
+    const userSession = new PikkuSessionService(channelStore, channelId);
     const { channelConfig, openingData, meta } = await openChannel({
         channelId,
-        createSessionServices,
+        createWireServices,
         request,
         route,
         singletonServices,
@@ -55,23 +54,21 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
             channelHandlerFactory,
             channelName: channelConfig.name,
         });
-        if (createSessionServices) {
-            sessionServices = await createSessionServices(singletonServices, { http }, await userSession.get());
+        const wire = { channel, session: userSession };
+        if (createWireServices) {
+            wireServices = await createWireServices(singletonServices, wire);
         }
-        const interaction = { channel };
-        const getAllServices = (requiresAuth) => rpcService.injectRPCService({
+        const services = {
             ...singletonServices,
-            ...sessionServices,
-            channel,
-            userSession,
-        }, interaction, requiresAuth);
+            ...wireServices,
+        };
         if (channelConfig.onConnect && meta.connect) {
             await runChannelLifecycleWithMiddleware({
                 channelConfig,
                 meta: meta.connect,
                 lifecycleConfig: channelConfig.onConnect,
                 lifecycleType: 'connect',
-                services: getAllServices(false),
+                services,
                 channel,
                 data: openingData,
             });
@@ -82,13 +79,13 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
         handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
     }
     finally {
-        if (sessionServices) {
-            await closeSessionServices(singletonServices.logger, sessionServices);
+        if (wireServices) {
+            await closeWireServices(singletonServices.logger, wireServices);
         }
     }
 };
 export const runChannelDisconnect = async ({ singletonServices, ...params }) => {
-    let sessionServices;
+    let wireServices;
     // 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,
@@ -107,17 +104,16 @@ export const runChannelDisconnect = async ({ singletonServices, ...params }) =>
         openingData,
         channelName,
     });
-    const userSession = new PikkuUserSessionService(params.channelStore, params.channelId);
-    if (!sessionServices && params.createSessionServices) {
-        sessionServices = await params.createSessionServices(singletonServices, { channel }, session);
+    const userSession = new PikkuSessionService(params.channelStore, params.channelId);
+    userSession.setInitial(session);
+    const wire = { channel, session: userSession };
+    if (!wireServices && params.createWireServices) {
+        wireServices = await params.createWireServices(singletonServices, wire);
     }
-    const interaction = { channel };
-    const getAllServices = (requiresAuth) => rpcService.injectRPCService({
+    const services = {
         ...singletonServices,
-        ...sessionServices,
-        channel,
-        userSession,
-    }, interaction, requiresAuth);
+        ...wireServices,
+    };
     if (channelConfig.onDisconnect && meta.disconnect) {
         try {
             await runChannelLifecycleWithMiddleware({
@@ -125,7 +121,7 @@ export const runChannelDisconnect = async ({ singletonServices, ...params }) =>
                 meta: meta.disconnect,
                 lifecycleConfig: channelConfig.onDisconnect,
                 lifecycleType: 'disconnect',
-                services: getAllServices(false),
+                services,
                 channel,
             });
         }
@@ -134,32 +130,31 @@ export const runChannelDisconnect = async ({ singletonServices, ...params }) =>
         }
     }
     await params.channelStore.removeChannels([channel.channelId]);
-    if (sessionServices) {
-        await closeSessionServices(singletonServices.logger, sessionServices);
+    if (wireServices) {
+        await closeWireServices(singletonServices.logger, wireServices);
     }
 };
 export const runChannelMessage = async ({ singletonServices, ...params }, data) => {
-    let sessionServices;
+    let wireServices;
     const { openingData, channelName, session } = await params.channelStore.getChannelAndSession(params.channelId);
     const { channel, channelHandler, channelConfig } = getVariablesForChannel({
         ...params,
         openingData,
         channelName,
     });
-    const userSession = new PikkuUserSessionService(params.channelStore, params.channelId);
-    if (params.createSessionServices) {
-        sessionServices = await params.createSessionServices(singletonServices, { channel }, session);
+    const userSession = new PikkuSessionService(params.channelStore, params.channelId);
+    userSession.setInitial(session);
+    const wire = { channel, session: userSession };
+    if (params.createWireServices) {
+        wireServices = await params.createWireServices(singletonServices, wire);
     }
-    const interaction = { channel };
-    const getAllServices = () => rpcService.injectRPCService({
+    const services = {
         ...singletonServices,
-        ...sessionServices,
-        channel,
-        userSession,
-    }, interaction);
+        ...wireServices,
+    };
     let response;
     try {
-        const onMessage = processMessageHandlers(getAllServices(), channelConfig, channelHandler);
+        const onMessage = processMessageHandlers(services, channelConfig, channelHandler, userSession);
         response = await onMessage(data);
     }
     catch (e) {
@@ -167,8 +162,8 @@ export const runChannelMessage = async ({ singletonServices, ...params }, data)
         return { error: e.message || 'Unknown error' };
     }
     finally {
-        if (sessionServices) {
-            await closeSessionServices(singletonServices.logger, sessionServices);
+        if (wireServices) {
+            await closeWireServices(singletonServices.logger, wireServices);
         }
     }
     return response;

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

@@ -14,7 +14,7 @@ export async function executeCLIViaChannel({ programName, pikkuWS, args = proces
     // Get CLI metadata from state
     const allCLIMeta = pikkuState('cli', 'meta');
     if (!allCLIMeta) {
-        throw new Error('[PKU342] CLI metadata not found. No CLI wirings were registered. See https://pikku.dev/errors/pku342 for more information.');
+        throw new Error('[PKU342] CLI metadata not found. No CLI wirings were registered. See https://pikku.dev/docs/pikku-cli/errors/pku342 for more information.');
     }
     const programMeta = allCLIMeta.programs[programName];
     if (!programMeta) {

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

@@ -1,6 +1,6 @@
 import { CorePikkuMiddleware, CoreUserSession } from '../../types/core.types.js';
 import { CoreCLI, CorePikkuCLIRender, CoreCLICommandConfig } from './cli.types.js';
-import type { CoreSingletonServices, CoreServices, CreateSessionServices, CreateConfig, CreateSingletonServices } from '../../types/core.types.js';
+import type { CoreSingletonServices, CoreServices, CreateWireServices, CreateConfig, CreateSingletonServices } from '../../types/core.types.js';
 /**
  * CLI command execution error - thrown when CLI execution fails
  * Should be caught by the wrapper to call process.exit()
@@ -16,12 +16,12 @@ export declare const wireCLI: <Commands extends Record<string, CoreCLICommandCon
 /**
  * Executes a CLI command for a specific program
  */
-export declare function runCLICommand({ program, commandPath, data, singletonServices, createSessionServices, }: {
+export declare function runCLICommand({ program, commandPath, data, singletonServices, createWireServices, }: {
     program: string;
     commandPath: string[];
     data: Record<string, any>;
     singletonServices: CoreSingletonServices;
-    createSessionServices?: CreateSessionServices;
+    createWireServices?: CreateWireServices;
 }): Promise<any>;
 /**
  * Factory function for CLI-specific renderers
@@ -33,10 +33,10 @@ export declare const pikkuCLIRender: <Data, Services extends CoreSingletonServic
  *
  * @throws {CLIError} When CLI execution fails - should be caught by wrapper to call process.exit()
  */
-export declare function executeCLI({ programName, args, createConfig, createSingletonServices, createSessionServices, }: {
+export declare function executeCLI({ programName, args, createConfig, createSingletonServices, createWireServices, }: {
     programName: string;
     args?: string[];
     createConfig: CreateConfig<any, any>;
     createSingletonServices: CreateSingletonServices<any, any>;
-    createSessionServices?: CreateSessionServices<any, any, any>;
+    createWireServices?: CreateWireServices<any, any, any>;
 }): Promise<void>;

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

@@ -1,10 +1,7 @@
 import { NotFoundError } from '../../errors/errors.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
-import { PikkuWiringTypes, } from '../../types/core.types.js';
-import { closeSessionServices } from '../../utils.js';
-import { rpcService } from '../rpc/rpc-runner.js';
-import { PikkuUserSessionService } from '../../services/user-session-service.js';
+import { PikkuSessionService } from '../../services/user-session-service.js';
 import { LocalVariablesService } from '../../services/local-variables.js';
 import { generateCommandHelp, parseCLIArguments } from './command-parser.js';
 /**
@@ -157,7 +154,7 @@ function pluckCLIData(mergedData, funcName, availableOptions) {
 /**
  * Executes a CLI command for a specific program
  */
-export async function runCLICommand({ program, commandPath, data, singletonServices, createSessionServices, }) {
+export async function runCLICommand({ program, commandPath, data, singletonServices, createWireServices, }) {
     // Get the command metadata to find the function name
     const cliMeta = pikkuState('cli', 'meta');
     const programMeta = cliMeta.programs?.[program];
@@ -217,39 +214,28 @@ export async function runCLICommand({ program, commandPath, data, singletonServi
         },
         state: 'open',
     };
-    const userSession = new PikkuUserSessionService();
-    let sessionServices;
-    const interaction = {
+    const userSession = new PikkuSessionService();
+    const wire = {
         cli: {
             program,
             command: commandPath,
             data: pluckedData,
             channel,
         },
-    };
-    const getAllServices = async (session) => {
-        // Create session-specific services for handling the command
-        sessionServices = await createSessionServices?.(singletonServices, interaction, session);
-        return rpcService.injectRPCService({
-            ...singletonServices,
-            ...sessionServices,
-            userSession,
-            channel,
-        }, interaction, false);
+        session: userSession,
     };
     try {
-        const result = await runPikkuFunc(PikkuWiringTypes.cli, commandId, funcName, {
+        const result = await runPikkuFunc('cli', commandId, funcName, {
             singletonServices,
-            getAllServices,
+            createWireServices,
             data: pluckedData,
             auth: false,
-            userSession,
             inheritedMiddleware: currentCommand.middleware,
             wireMiddleware: allWireMiddleware,
             inheritedPermissions: currentCommand.permissions,
             wirePermissions: undefined,
             tags: programData?.tags,
-            interaction,
+            wire,
         });
         // Apply renderer one final time with the final output (if renderer exists)
         if (renderer) {
@@ -260,10 +246,6 @@ export async function runCLICommand({ program, commandPath, data, singletonServi
     finally {
         // Close the channel
         channel.close();
-        // Clean up session services
-        if (sessionServices) {
-            await closeSessionServices(singletonServices.logger, sessionServices);
-        }
     }
 }
 /**
@@ -278,7 +260,7 @@ export const pikkuCLIRender = (renderer) => {
  *
  * @throws {CLIError} When CLI execution fails - should be caught by wrapper to call process.exit()
  */
-export async function executeCLI({ programName, args, createConfig, createSingletonServices, createSessionServices, }) {
+export async function executeCLI({ programName, args, createConfig, createSingletonServices, createWireServices, }) {
     if (!args) {
         throw new Error('CLI arguments are required, this is to satisfy release diffs');
     }
@@ -286,7 +268,7 @@ export async function executeCLI({ programName, args, createConfig, createSingle
         // Get CLI metadata from state
         const allCLIMeta = pikkuState('cli', 'meta');
         if (!allCLIMeta) {
-            throw new Error('[PKU342] CLI metadata not found. No CLI wirings were registered. See https://pikku.dev/errors/pku342 for more information.');
+            throw new Error('[PKU342] CLI metadata not found. No CLI wirings were registered. See https://pikku.dev/docs/pikku-cli/errors/pku342 for more information.');
         }
         const programMeta = allCLIMeta.programs[programName];
         if (!programMeta) {
@@ -333,7 +315,7 @@ export async function executeCLI({ programName, args, createConfig, createSingle
             commandPath: parsed.commandPath,
             data,
             singletonServices,
-            createSessionServices,
+            createWireServices,
         });
     }
     catch (error) {

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

@@ -1,4 +1,4 @@
-import { CorePikkuMiddleware, CoreSingletonServices, CoreUserSession, PikkuDocs, CoreServices, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+import { CorePikkuMiddleware, CoreSingletonServices, CoreUserSession, CoreServices, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
 import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuFunction, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 import { PikkuChannel } from '../channel/channel.types.js';
 /**
@@ -27,7 +27,7 @@ export interface CLIPositional {
     variadic?: boolean;
 }
 /**
- * CLI interaction context
+ * CLI wire context
  */
 export type PikkuCLI = {
     program: string;
@@ -55,8 +55,9 @@ export interface CLICommandMeta {
     positionals: CLIPositional[];
     options: Record<string, CLIOption>;
     renderName?: string;
+    summary?: string;
     description?: string;
-    docs?: PikkuDocs;
+    errors?: string[];
     tags?: string[];
     subcommands?: Record<string, CLICommandMeta>;
     middleware?: MiddlewareMetadata[];
@@ -99,7 +100,7 @@ export type CorePikkuCLIRender<Data, Services extends CoreSingletonServices = Co
 /**
  * Extract input parameters from a Pikku function config type
  */
-export type ExtractFunctionInput<Func> = Func extends CorePikkuFunctionConfig<infer FuncType, any, any> ? FuncType extends CorePikkuFunction<infer Input, any, any, any, any> | CorePikkuFunctionSessionless<infer Input, any, any, any, any> ? Input : never : never;
+export type ExtractFunctionInput<Func> = Func extends CorePikkuFunctionConfig<infer FuncType, any, any> ? FuncType extends CorePikkuFunction<infer Input, any, any, any> | CorePikkuFunctionSessionless<infer Input, any, any, any> ? Input : never : never;
 /**
  * Strip < > [ ] characters from a string
  */
@@ -131,12 +132,12 @@ export type ValidateParameters<Params extends string, Input> = AllParamsValid<Ex
 /**
  * Extract output type from a Pikku function config type
  */
-export type ExtractFunctionOutput<Func> = Func extends CorePikkuFunctionConfig<infer FuncType, any, any> ? FuncType extends CorePikkuFunction<any, infer Output, any, any, any> | CorePikkuFunctionSessionless<any, infer Output, any, any, any> ? Output : never : never;
+export type ExtractFunctionOutput<Func> = Func extends CorePikkuFunctionConfig<infer FuncType, any, any> ? FuncType extends CorePikkuFunction<any, infer Output, any, any> | CorePikkuFunctionSessionless<any, infer Output, any, any> ? Output : never : never;
 /**
  * CLI command configuration that infers options from function input type.
  * This is a helper type for creating type-safe CLI commands.
  */
-export type CoreCLICommandConfig<FuncConfig, PikkuMiddleware extends CorePikkuMiddleware<any> = CorePikkuMiddleware<any>, PikkuCLIRender extends CorePikkuCLIRender<any, any, any> = CorePikkuCLIRender<any, any>, Params extends string = string> = {
+export type CoreCLICommandConfig<FuncConfig, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any, any>, PikkuCLIRender extends CorePikkuCLIRender<any, any, any> = CorePikkuCLIRender<any, any>, Params extends string = string> = {
     parameters?: ValidateParameters<Params, ExtractFunctionInput<FuncConfig>>;
     func?: FuncConfig;
     description?: string;
@@ -157,7 +158,7 @@ export type CoreCLICommandConfig<FuncConfig, PikkuMiddleware extends CorePikkuMi
 /**
  * CLI command definition
  */
-export interface CoreCLICommand<In, Out, PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunction<In, Out, any, any, any> | CorePikkuFunctionSessionless<In, Out, any, any, any>>, PikkuPermission extends CorePikkuPermission<any, any, any>, PikkuMiddleware extends CorePikkuMiddleware, Options = any, Subcommands extends Record<string, CoreCLICommandConfig<any, any, any>> = Record<string, CoreCLICommandConfig<any, any, any>>> {
+export interface CoreCLICommand<In, Out, PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunction<In, Out, any, any> | CorePikkuFunctionSessionless<In, Out, any, any>>, PikkuPermission extends CorePikkuPermission<any, any, any>, PikkuMiddleware extends CorePikkuMiddleware, Options = any, Subcommands extends Record<string, CoreCLICommandConfig<any, any, any>> = Record<string, CoreCLICommandConfig<any, any, any>>> {
     parameters?: string;
     func: PikkuFunctionConfig;
     render?: CorePikkuCLIRender<Out>;
@@ -166,18 +167,20 @@ export interface CoreCLICommand<In, Out, PikkuFunctionConfig extends CorePikkuFu
     middleware?: PikkuMiddleware[];
     permissions?: Record<string, PikkuPermission | PikkuPermission[]>;
     auth?: boolean;
-    docs?: PikkuDocs;
+    summary?: string;
+    errors?: string[];
+    tags?: string[];
     subcommands?: Subcommands;
     isDefault?: boolean;
 }
 /**
  * Shorthand command definition (just a function)
  */
-export type CLICommandShorthand<In, Out, PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunction<In, Out, any, any, any> | CorePikkuFunctionSessionless<In, Out, any, any, any>>> = PikkuFunctionConfig;
+export type CLICommandShorthand<In, Out, PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunction<In, Out, any, any> | CorePikkuFunctionSessionless<In, Out, any, any>>> = PikkuFunctionConfig;
 /**
  * Command definition (either full or shorthand)
  */
-export type CLICommandDefinition<In, Out, PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunction<In, Out, any, any, any> | CorePikkuFunctionSessionless<In, Out, any, any, any>>, PikkuPermission extends CorePikkuPermission<any, any, any>, PikkuMiddleware extends CorePikkuMiddleware, Options = any, Subcommands extends Record<string, CoreCLICommandConfig<any, any, any>> = Record<string, CoreCLICommandConfig<any, any, any>>> = CoreCLICommand<In, Out, PikkuFunctionConfig, PikkuPermission, PikkuMiddleware, Options, Subcommands> | CLICommandShorthand<In, Out, PikkuFunctionConfig>;
+export type CLICommandDefinition<In, Out, PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunction<In, Out, any, any> | CorePikkuFunctionSessionless<In, Out, any, any>>, PikkuPermission extends CorePikkuPermission<any, any, any>, PikkuMiddleware extends CorePikkuMiddleware, Options = any, Subcommands extends Record<string, CoreCLICommandConfig<any, any, any>> = Record<string, CoreCLICommandConfig<any, any, any>>> = CoreCLICommand<In, Out, PikkuFunctionConfig, PikkuPermission, PikkuMiddleware, Options, Subcommands> | CLICommandShorthand<In, Out, PikkuFunctionConfig>;
 /**
  * CLI wiring configuration
  */
@@ -188,7 +191,8 @@ export interface CoreCLI<Commands extends Record<string, CoreCLICommandConfig<an
     options?: CLIOptions<Options>;
     middleware?: PikkuMiddleware[];
     render?: PikkuCLIRender;
-    docs?: PikkuDocs;
+    summary?: string;
+    errors?: string[];
     tags?: string[];
 }
 /**