@pikku/core 0.12.16 → 0.12.18

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 ## 0.12.4
 
+## 0.12.18
+
+### Patch Changes
+
+- 311c0c4: Unify session persistence through SessionStore, remove session blob from ChannelStore
+
+  - PikkuSessionService now persists sessions via SessionStore on set()/clear() instead of every function call
+  - ChannelStore no longer stores session data — maps channelId to pikkuUserId only
+  - ChannelStore API: setUserSession/getChannelAndSession replaced with setPikkuUserId/getChannel
+  - Serverless channel runner resolves sessions from SessionStore using pikkuUserId from ChannelStore
+
+## 0.12.17
+
+### Patch Changes
+
+- 854737b: Add `ListInput<F, S>` / `ListOutput<Row>` / `Filter<F>` types for list-function primitives.
+
+  A "list function" is any Pikku function that returns a paginated collection. Adopting this shape unlocks a shared vocabulary across MCP tools, AI agents, typed RPC clients, and widget libraries — they all reason about cursor, filter, sort, and search uniformly.
+
+  These are purely structural constraints; no runtime behaviour change. A list function is still a normal `pikkuFunc` whose input extends `ListInput<F, S>` and output extends `ListOutput<Row>`.
+
+  ```ts
+  import { pikkuFunc } from '#pikku'
+  import type { ListInput, ListOutput } from '@pikku/core'
+
+  export const listSessions = pikkuFunc<
+    ListInput<{ status?: SessionStatus[] }, 'user' | 'status' | 'uploaded_at'>,
+    ListOutput<Session>
+  >({
+    func: async ({ kysely }, input) => {
+      /* ... */
+    },
+  })
+  ```
+
+  `Filter<F>` is a recursive AND/OR tree: arrays are AND of children, objects with label keys are OR of children, single-key objects with a field name from `F` are leaf predicates. Leaf operators mirror Prisma's vocabulary (`equals`, `in`, `notIn`, `gt`, `gte`, `lt`, `lte`, `contains`, `startsWith`, `endsWith`, `not`, `mode`).
+
+  Follow-ups (separate PRs): `applyFilter<DB>(qb, filter)` Kysely helper, `usePikkuListQuery` in the CLI's react-query generator, first-class MCP list-tool shape.
+
 ## 0.12.16
 
 ### Patch Changes

package/dist/function/function-runner.js

@@ -4,11 +4,31 @@ import { runPermissions } from '../permissions.js';
 import { pikkuState } from '../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
 import { parseVersionedId } from '../version.js';
-import { createFunctionSessionWireProps } from '../services/user-session-service.js';
+import { PikkuSessionService, createFunctionSessionWireProps, } from '../services/user-session-service.js';
 import { ForbiddenError, ReadonlySessionError } from '../errors/errors.js';
 import { PikkuCredentialWireService, createWireServicesCredentialWireProps, } from '../services/credential-wire-service.js';
+import { defaultPikkuUserIdResolver } from '../services/pikku-user-id.js';
 import { rpcService } from '../wirings/rpc/rpc-runner.js';
 import { closeWireServices } from '../utils.js';
+async function resolveSession(wire, singletonServices, sessionService) {
+    const pikkuUserId = defaultPikkuUserIdResolver(wire);
+    if (pikkuUserId) {
+        wire.pikkuUserId = pikkuUserId;
+        if (sessionService instanceof PikkuSessionService) {
+            sessionService.setPikkuUserId(pikkuUserId);
+        }
+    }
+    const { sessionStore } = singletonServices;
+    if (!sessionStore || !pikkuUserId)
+        return;
+    if (!wire.session) {
+        const stored = await sessionStore.get(pikkuUserId);
+        if (stored) {
+            wire.session = stored;
+            sessionService?.setInitial(stored);
+        }
+    }
+}
 /**
  * Get or create singleton services for an addon package.
  * Services are cached in pikkuState to avoid recreation on each call.
@@ -134,6 +154,7 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
     }
     // Helper function to run permissions and execute the function
     const executeFunction = async () => {
+        await resolveSession(resolvedWire, resolvedSingletonServices, sessionService);
         if (sessionService) {
             resolvedWire.session = sessionService.freezeInitial();
             resolvedWire.setSession = (s) => sessionService.set(s);

package/dist/function/index.d.ts

@@ -1,3 +1,4 @@
 export { addFunction, getAllFunctionNames } from './function-runner.js';
 export { pikkuAuth, pikkuPermission, pikkuPermissionFactory, pikkuApprovalDescription, } from './functions.types.js';
 export type { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission, } from './functions.types.js';
+export type { ListInput, ListOutput, Filter, LeafFilter, LeafValue, } from './list.types.js';

package/dist/function/list.types.d.ts

@@ -0,0 +1,113 @@
+/**
+ * List-function primitives.
+ *
+ * A "list function" is any Pikku function that returns a paginated
+ * collection. Adopting this shape unlocks a shared vocabulary across
+ * MCP tools, AI agents, typed RPC clients, and widget libraries — they
+ * all reason about cursor, filter, sort, and search uniformly.
+ *
+ * Under the hood, a list function is still a normal `pikkuFunc`. These
+ * types are purely structural constraints; no runtime behaviour change.
+ *
+ * @example
+ * ```ts
+ * import { pikkuFunc } from '#pikku'
+ * import type { ListInput, ListOutput } from '@pikku/core'
+ *
+ * export const listSessions = pikkuFunc<
+ *   ListInput<{ status?: SessionStatus[] }, 'user' | 'status' | 'uploaded_at'>,
+ *   ListOutput<Session>
+ * >({
+ *   func: async ({ kysely }, input) => {
+ *     // input.sort / input.filter / input.cursor / input.search are typed
+ *     return { rows, nextCursor, totalCount }
+ *   },
+ * })
+ * ```
+ */
+/**
+ * Shape every list function accepts as input.
+ *
+ * @template F - User-defined filter shape. Each key is a filterable field.
+ * @template S - String union of sortable column names.
+ */
+export interface ListInput<F extends Record<string, unknown> = Record<string, never>, S extends string = never> {
+    /** Opaque cursor from the previous page's `nextCursor`. */
+    cursor?: string;
+    /** Page size. Server may cap. */
+    limit?: number;
+    /** Ordered sort criteria — first entry is primary. */
+    sort?: Array<{
+        column: S;
+        direction: 'asc' | 'desc';
+    }>;
+    /** Structured filter tree. See {@link Filter}. */
+    filter?: Filter<F>;
+    /** Unstructured text search across server-configured fields. */
+    search?: string;
+}
+/**
+ * Shape every list function returns.
+ */
+export interface ListOutput<Row> {
+    rows: Row[];
+    /** Null when no more pages. */
+    nextCursor: string | null;
+    /** Optional — backend may skip when expensive. */
+    totalCount?: number;
+}
+/**
+ * Leaf predicate value on a single field.
+ *
+ * Operator keywords (`equals`, `not`, `in`, `notIn`, `gt`, `gte`, `lt`,
+ * `lte`, `contains`, `startsWith`, `endsWith`, `mode`) mirror Prisma's
+ * vocabulary for dev familiarity. These keys are reserved and cannot be
+ * used as user field names in a Filter's `F` type.
+ */
+export type LeafValue<T> = T | null | T[] | {
+    equals?: T | null;
+    not?: T | null | LeafValue<T>;
+    in?: T[];
+    notIn?: T[];
+    gt?: T;
+    gte?: T;
+    lt?: T;
+    lte?: T;
+    contains?: string;
+    startsWith?: string;
+    endsWith?: string;
+    mode?: 'sensitive' | 'insensitive';
+};
+/**
+ * A single-key object keyed by a field name from F, value is a leaf
+ * predicate. Single-key so the runtime discriminator is unambiguous:
+ * multi-key objects are OR groups.
+ */
+export type LeafFilter<F extends Record<string, unknown>> = {
+    [K in keyof F]: {
+        [Key in K]: LeafValue<F[K]>;
+    };
+}[keyof F];
+/**
+ * Recursive filter tree.
+ *
+ * - `Array<Filter<F>>` — AND of children.
+ * - `{ [label: string]: Filter<F> }` — OR of children. Keys are arbitrary
+ *   labels (unique strings), ignored at evaluation time.
+ * - `LeafFilter<F>` — single-key predicate on a declared field.
+ *
+ * @example "status = pending AND (therapist = kim OR therapist = park) AND uploaded_at > 2026-04-10"
+ * ```ts
+ * const filter: Filter<{ status: string; therapistId: string; uploadedAt: string }> = [
+ *   { status: 'pending' },
+ *   {
+ *     kim:  { therapistId: 'kim' },
+ *     park: { therapistId: 'park' },
+ *   },
+ *   { uploadedAt: { gt: '2026-04-10' } },
+ * ]
+ * ```
+ */
+export type Filter<F extends Record<string, unknown>> = LeafFilter<F> | Filter<F>[] | {
+    [label: string]: Filter<F>;
+};

package/dist/function/list.types.js

@@ -0,0 +1,28 @@
+/**
+ * List-function primitives.
+ *
+ * A "list function" is any Pikku function that returns a paginated
+ * collection. Adopting this shape unlocks a shared vocabulary across
+ * MCP tools, AI agents, typed RPC clients, and widget libraries — they
+ * all reason about cursor, filter, sort, and search uniformly.
+ *
+ * Under the hood, a list function is still a normal `pikkuFunc`. These
+ * types are purely structural constraints; no runtime behaviour change.
+ *
+ * @example
+ * ```ts
+ * import { pikkuFunc } from '#pikku'
+ * import type { ListInput, ListOutput } from '@pikku/core'
+ *
+ * export const listSessions = pikkuFunc<
+ *   ListInput<{ status?: SessionStatus[] }, 'user' | 'status' | 'uploaded_at'>,
+ *   ListOutput<Session>
+ * >({
+ *   func: async ({ kysely }, input) => {
+ *     // input.sort / input.filter / input.cursor / input.search are typed
+ *     return { rows, nextCursor, totalCount }
+ *   },
+ * })
+ * ```
+ */
+export {};

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export { pikkuAIMiddleware, pikkuChannelMiddleware, pikkuChannelMiddlewareFactor
 export type { CorePikkuAuth, CorePikkuAuthConfig, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuPermissionConfig, CorePikkuPermissionFactory, CorePikkuApprovalDescription, CorePermissionGroup, ZodLike, } from './function/functions.types.js';
 export { pikkuAuth, pikkuPermission, pikkuPermissionFactory, pikkuApprovalDescription, } from './function/functions.types.js';
 export { addFunction, getAllFunctionNames } from './function/index.js';
+export type { ListInput, ListOutput, Filter, LeafFilter, LeafValue, } from './function/list.types.js';
 export { PikkuRequest } from './pikku-request.js';
 export { getRelativeTimeOffsetFromNow, parseDurationString, } from './time-utils.js';
 export type { RelativeTimeInput } from './time-utils.js';

package/dist/services/in-memory-session-store.d.ts

@@ -0,0 +1,8 @@
+import type { CoreUserSession } from '../types/core.types.js';
+import type { SessionStore } from './session-store.js';
+export declare class InMemorySessionStore<UserSession extends CoreUserSession = CoreUserSession> implements SessionStore<UserSession> {
+    private sessions;
+    get(pikkuUserId: string): Promise<UserSession | undefined>;
+    set(pikkuUserId: string, session: UserSession): Promise<void>;
+    clear(pikkuUserId: string): Promise<void>;
+}

package/dist/services/in-memory-session-store.js

@@ -0,0 +1,12 @@
+export class InMemorySessionStore {
+    sessions = new Map();
+    async get(pikkuUserId) {
+        return this.sessions.get(pikkuUserId);
+    }
+    async set(pikkuUserId, session) {
+        this.sessions.set(pikkuUserId, session);
+    }
+    async clear(pikkuUserId) {
+        this.sessions.delete(pikkuUserId);
+    }
+}

package/dist/services/index.d.ts

@@ -36,4 +36,6 @@ export { TypedCredentialService } from './typed-credential-service.js';
 export type { CredentialStatusInfo, CredentialMetaInfo, } from './typed-credential-service.js';
 export type { VariableStatus, VariableMeta } from './typed-variables-service.js';
 export type { MetaService } from './meta-service.js';
+export type { SessionStore } from './session-store.js';
+export { InMemorySessionStore } from './in-memory-session-store.js';
 export type { MCPMeta, RPCMetaRecord, ServiceMeta, ServicesMetaRecord, MiddlewareDefinitionMeta, MiddlewareInstanceMeta, GroupMeta, MiddlewareGroupsMeta, PermissionDefinitionMeta, PermissionsGroupsMeta, FunctionsMeta, FunctionMeta, MiddlewareMeta, PermissionMeta, AgentsMeta, AgentMeta, } from './meta-service.js';

package/dist/services/index.js

@@ -17,3 +17,4 @@ export { InMemoryTriggerService } from './in-memory-trigger-service.js';
 export { InMemoryAIRunStateService } from './in-memory-ai-run-state-service.js';
 export { LocalGatewayService } from './local-gateway-service.js';
 export { TypedCredentialService } from './typed-credential-service.js';
+export { InMemorySessionStore } from './in-memory-session-store.js';

package/dist/services/session-store.d.ts

@@ -0,0 +1,6 @@
+import type { CoreUserSession } from '../types/core.types.js';
+export interface SessionStore<UserSession extends CoreUserSession = CoreUserSession> {
+    get(pikkuUserId: string): Promise<UserSession | undefined>;
+    set(pikkuUserId: string, session: UserSession): Promise<void>;
+    clear(pikkuUserId: string): Promise<void>;
+}

package/dist/services/session-store.js

@@ -0,0 +1 @@
+export {};

package/dist/services/user-session-service.d.ts

@@ -1,5 +1,5 @@
-import type { ChannelStore } from '../wirings/channel/channel-store.js';
 import type { CoreUserSession } from '../types/core.types.js';
+import type { SessionStore } from './session-store.js';
 export interface SessionService<UserSession extends CoreUserSession> {
     sessionChanged: boolean;
     initial: UserSession | undefined;
@@ -7,31 +7,33 @@ export interface SessionService<UserSession extends CoreUserSession> {
     freezeInitial(): UserSession | undefined;
     set(session: UserSession): Promise<void> | void;
     clear(): Promise<void> | void;
-    get(): Promise<UserSession> | UserSession | undefined;
+    get(): UserSession | undefined;
 }
 export declare class PikkuSessionService<UserSession extends CoreUserSession> implements SessionService<UserSession> {
-    private channelStore?;
-    private channelId?;
+    private sessionStore?;
     sessionChanged: boolean;
     initial: UserSession | undefined;
     private session;
-    constructor(channelStore?: ChannelStore<unknown, unknown, UserSession> | undefined, channelId?: string | undefined);
+    private pikkuUserId?;
+    constructor(sessionStore?: SessionStore<UserSession> | undefined);
+    setPikkuUserId(id: string): void;
+    getPikkuUserId(): string | undefined;
     setInitial(session: UserSession): void;
     freezeInitial(): UserSession | undefined;
-    set(session: UserSession): void | Promise<void> | undefined;
-    clear(): void | Promise<void> | undefined;
-    get(): Promise<UserSession> | UserSession | undefined;
+    set(session: UserSession): Promise<void>;
+    clear(): Promise<void>;
+    get(): UserSession | undefined;
 }
 export declare function createMiddlewareSessionWireProps<UserSession extends CoreUserSession>(session: SessionService<UserSession>): {
     session: UserSession | undefined;
     setSession: (s: UserSession) => void;
-    getSession: () => UserSession | Promise<UserSession> | undefined;
+    getSession: () => UserSession | undefined;
     hasSessionChanged: () => boolean;
 };
 export declare function createFunctionSessionWireProps<UserSession extends CoreUserSession>(session: SessionService<UserSession>): {
     session: UserSession | undefined;
     setSession: (s: UserSession) => void | Promise<void>;
     clearSession: () => void | Promise<void>;
-    getSession: () => UserSession | Promise<UserSession> | undefined;
+    getSession: () => UserSession | undefined;
     hasSessionChanged: () => boolean;
 };

package/dist/services/user-session-service.js

@@ -1,15 +1,17 @@
 export class PikkuSessionService {
-    channelStore;
-    channelId;
+    sessionStore;
     sessionChanged = false;
     initial;
     session;
-    constructor(channelStore, channelId) {
-        this.channelStore = channelStore;
-        this.channelId = channelId;
-        if (channelStore && !channelId) {
-            throw new Error('Channel ID is required when using channel store');
-        }
+    pikkuUserId;
+    constructor(sessionStore) {
+        this.sessionStore = sessionStore;
+    }
+    setPikkuUserId(id) {
+        this.pikkuUserId = id;
+    }
+    getPikkuUserId() {
+        return this.pikkuUserId;
     }
     setInitial(session) {
         this.session = session;
@@ -20,26 +22,21 @@ export class PikkuSessionService {
         }
         return this.initial;
     }
-    set(session) {
+    async set(session) {
         this.sessionChanged = true;
         this.session = session;
-        return this.channelStore?.setUserSession(this.channelId, session);
+        if (this.sessionStore && this.pikkuUserId) {
+            await this.sessionStore.set(this.pikkuUserId, session);
+        }
     }
-    clear() {
+    async clear() {
         this.sessionChanged = true;
         this.session = undefined;
-        return this.channelStore?.setUserSession(this.channelId, null);
+        if (this.sessionStore && this.pikkuUserId) {
+            await this.sessionStore.clear(this.pikkuUserId);
+        }
     }
     get() {
-        if (this.channelStore) {
-            const channel = this.channelStore.getChannelAndSession(this.channelId);
-            if (channel instanceof Promise) {
-                return channel.then(({ session }) => session);
-            }
-            else {
-                return channel.session;
-            }
-        }
         return this.session;
     }
 }

package/dist/testing/service-tests.d.ts

@@ -8,6 +8,7 @@ import type { AIRunStateService } from '../services/ai-run-state-service.js';
 import type { SecretService } from '../services/secret-service.js';
 import type { CredentialService } from '../services/credential-service.js';
 import type { AgentRunService } from '../wirings/ai-agent/ai-agent.types.js';
+import type { SessionStore } from '../services/session-store.js';
 export interface ServiceTestConfig {
     name: string;
     services: {
@@ -34,6 +35,7 @@ export interface ServiceTestConfig {
         }) => Promise<CredentialService & {
             rotateKEK?(): Promise<number>;
         }>;
+        sessionStore?: () => Promise<SessionStore>;
     };
 }
 export declare function defineServiceTests(config: ServiceTestConfig): void;

package/dist/testing/service-tests.js

@@ -9,27 +9,31 @@ export function defineServiceTests(config) {
             before(async () => {
                 store = await factory();
             });
-            test('addChannel and getChannelAndSession', async () => {
+            test('addChannel and getChannel', async () => {
                 await store.addChannel({
                     channelId: 'ch-1',
                     channelName: 'test-channel',
                     openingData: { foo: 'bar' },
                 });
-                const result = await store.getChannelAndSession('ch-1');
+                const result = await store.getChannel('ch-1');
                 assert.equal(result.channelId, 'ch-1');
                 assert.equal(result.channelName, 'test-channel');
                 assert.deepEqual(result.openingData, { foo: 'bar' });
-                assert.deepEqual(result.session, {});
+                assert.equal(result.pikkuUserId, undefined);
             });
-            test('setUserSession', async () => {
-                const session = { userId: 'user-1' };
-                await store.setUserSession('ch-1', session);
-                const result = await store.getChannelAndSession('ch-1');
-                assert.deepEqual(result.session, session);
+            test('setPikkuUserId', async () => {
+                await store.setPikkuUserId('ch-1', 'user-1');
+                const result = await store.getChannel('ch-1');
+                assert.equal(result.pikkuUserId, 'user-1');
             });
-            test('getChannelAndSession throws for missing channel', async () => {
+            test('setPikkuUserId to null', async () => {
+                await store.setPikkuUserId('ch-1', null);
+                const result = await store.getChannel('ch-1');
+                assert.equal(result.pikkuUserId, undefined);
+            });
+            test('getChannel throws for missing channel', async () => {
                 await assert.rejects(async () => {
-                    await store.getChannelAndSession('missing');
+                    await store.getChannel('missing');
                 }, { message: 'Channel not found: missing' });
             });
             test('removeChannels', async () => {
@@ -39,7 +43,7 @@ export function defineServiceTests(config) {
                 });
                 await store.removeChannels(['ch-2']);
                 await assert.rejects(async () => {
-                    await store.getChannelAndSession('ch-2');
+                    await store.getChannel('ch-2');
                 });
             });
             test('removeChannels with empty array is no-op', async () => {
@@ -693,4 +697,39 @@ export function defineServiceTests(config) {
             });
         });
     }
+    if (services.sessionStore) {
+        const factory = services.sessionStore;
+        describe(`SessionStore [${name}]`, () => {
+            let store;
+            before(async () => {
+                store = await factory();
+            });
+            test('get returns undefined for unknown user', async () => {
+                const result = await store.get('unknown-user');
+                assert.equal(result, undefined);
+            });
+            test('set and get round-trip', async () => {
+                const session = { userId: 'user-1', organizationId: 'org-1' };
+                await store.set('user-1', session);
+                const result = await store.get('user-1');
+                assert.deepEqual(result, session);
+            });
+            test('set overwrites previous session', async () => {
+                await store.set('user-2', { userId: 'user-2', role: 'admin' });
+                await store.set('user-2', { userId: 'user-2', role: 'member' });
+                const result = await store.get('user-2');
+                assert.deepEqual(result, { userId: 'user-2', role: 'member' });
+            });
+            test('clear removes session', async () => {
+                await store.set('user-3', { userId: 'user-3' });
+                assert.ok(await store.get('user-3'));
+                await store.clear('user-3');
+                const result = await store.get('user-3');
+                assert.equal(result, undefined);
+            });
+            test('clear is no-op for unknown user', async () => {
+                await store.clear('nonexistent');
+            });
+        });
+    }
 }

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

@@ -25,6 +25,7 @@ import type { PikkuAIMiddlewareHooks } from '../wirings/ai-agent/ai-agent.types.
 import type { WorkflowRunService } from '../wirings/workflow/workflow.types.js';
 import type { CredentialService } from '../services/credential-service.js';
 import type { MetaService } from '../services/meta-service.js';
+import type { SessionStore } from '../services/session-store.js';
 export type PikkuWiringTypes = 'http' | 'scheduler' | 'trigger' | 'channel' | 'rpc' | 'queue' | 'mcp' | 'cli' | 'workflow' | 'agent' | 'gateway';
 export interface FunctionServicesMeta {
     optimized: boolean;
@@ -181,6 +182,8 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     credentialService?: CredentialService;
     /** Meta service for reading .pikku metadata files (filesystem on Node, R2/KV on CF) */
     metaService?: MetaService;
+    /** Session store for persisting user sessions keyed by pikkuUserId */
+    sessionStore?: SessionStore;
 }
 /**
  * Represents different forms of wire within Pikku and the outside world.

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

@@ -1,17 +1,16 @@
-import type { CoreUserSession } from '../../types/core.types.js';
 export type Channel<ChannelType = unknown, OpeningData = unknown> = {
     channelId: string;
     channelName: string;
     channelObject?: ChannelType;
     openingData?: OpeningData;
 };
-export declare abstract class ChannelStore<ChannelType = unknown, OpeningData = unknown, UserSession extends CoreUserSession = CoreUserSession, TypedChannel = Channel<ChannelType, OpeningData>> {
+export declare abstract class ChannelStore<ChannelType = unknown, OpeningData = unknown, TypedChannel = Channel<ChannelType, OpeningData>> {
     abstract addChannel(channel: Channel<ChannelType, OpeningData>): Promise<void> | void;
     abstract removeChannels(channelId: string[]): Promise<void> | void;
-    abstract setUserSession(channelId: string, userSession: UserSession | null): Promise<void> | void;
-    abstract getChannelAndSession(channelId: string): Promise<TypedChannel & {
-        session: UserSession;
+    abstract setPikkuUserId(channelId: string, pikkuUserId: string | null): Promise<void> | void;
+    abstract getChannel(channelId: string): Promise<TypedChannel & {
+        pikkuUserId?: string;
     }> | (TypedChannel & {
-        session: UserSession;
+        pikkuUserId?: string;
     });
 }

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

@@ -15,7 +15,7 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
     let wireServices;
     let closedWireServices = false;
     let channelHandler;
-    const userSession = new PikkuSessionService();
+    const userSession = new PikkuSessionService(singletonServices.sessionStore);
     let http;
     if (request) {
         http = createHTTPWire(request, response);
@@ -79,7 +79,8 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
                         singletonServices.logger.error(`Error handling onConnect: ${e}`);
                         const errorResponse = getErrorResponse(e);
                         channel.send({
-                            error: errorResponse?.message ?? (isProduction() ? 'Internal server error' : e.message),
+                            error: errorResponse?.message ??
+                                (isProduction() ? 'Internal server error' : e.message),
                             ...(!isProduction() && { errorName: e.constructor?.name }),
                         });
                     }
@@ -102,7 +103,8 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
                         singletonServices.logger.error(`Error handling onDisconnect: ${e}`);
                         const errorResponse = getErrorResponse(e);
                         channel.send({
-                            error: errorResponse?.message ?? (isProduction() ? 'Internal server error' : e.message),
+                            error: errorResponse?.message ??
+                                (isProduction() ? 'Internal server error' : e.message),
                             ...(!isProduction() && { errorName: e.constructor?.name }),
                         });
                     }
@@ -119,7 +121,8 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
                     singletonServices.logger.error(e);
                     const errorResponse = getErrorResponse(e);
                     channel.send({
-                        error: errorResponse?.message ?? (isProduction() ? 'Internal server error' : e.message),
+                        error: errorResponse?.message ??
+                            (isProduction() ? 'Internal server error' : e.message),
                         ...(!isProduction() && { errorName: e.constructor?.name }),
                     });
                     setTimeout(() => channel.close(), 200);