@pikku/core 0.12.19 → 0.12.21

package/src/services/local-content.ts

@@ -1,7 +1,18 @@
 import { createReadStream, createWriteStream, promises } from 'fs'
 import { mkdir, readFile } from 'fs/promises'
 import { resolve, normalize } from 'path'
-import type { ContentService, JWTService, Logger } from '@pikku/core/services'
+import type {
+  BucketKeyArgs,
+  ContentService,
+  CopyFileArgs,
+  GetUploadURLArgs,
+  JWTService,
+  Logger,
+  SignContentKeyArgs,
+  SignURLArgs,
+  UploadURLResult,
+  WriteFileArgs,
+} from '@pikku/core/services'
 import { pipeline } from 'stream/promises'
 import type { Readable } from 'stream'
 
@@ -20,15 +31,20 @@ export class LocalContent implements ContentService {
     private jwt?: JWTService
   ) {}
 
-  private safePath(assetKey: string): string {
+  private safePath(bucket: string, key: string): string {
     const base = resolve(this.config.localFileUploadPath)
-    const target = resolve(base, normalize(assetKey))
+    const scoped = resolve(base, normalize(bucket))
+    const target = resolve(scoped, normalize(key))
     if (!target.startsWith(base + '/') && target !== base) {
       throw new Error('Invalid asset key')
     }
     return target
   }
 
+  private joinKey(bucket: string, key: string): string {
+    return `${bucket}/${key}`
+  }
+
   public async init() {}
 
   private async signParams(
@@ -49,114 +65,125 @@ export class LocalContent implements ContentService {
         1,
         Math.floor((expiresAt - signedAt) / 1000)
       )
+      const payload: {
+        signedAt: number
+        expiresAt: number
+        notBefore?: number
+      } = {
+        signedAt,
+        expiresAt,
+      }
+      if (dateGreaterThan) {
+        payload.notBefore = dateGreaterThan.getTime()
+      }
       const signature = await this.jwt.encode(
         { value: expiresInSeconds, unit: 'second' },
-        { signedAt, expiresAt }
+        payload
       )
       params.set('signature', signature)
     }
     return params.toString()
   }
 
-  public async signURL(
-    url: string,
-    dateLessThan: Date,
-    dateGreaterThan?: Date
-  ): Promise<string> {
-    const params = await this.signParams(dateLessThan, dateGreaterThan)
-    return `${url}?${params}`
+  public async signURL(args: SignURLArgs): Promise<string> {
+    const params = await this.signParams(
+      args.dateLessThan,
+      args.dateGreaterThan
+    )
+    return `${args.url}?${params}`
   }
 
-  public async signContentKey(
-    assetKey: string,
-    dateLessThan: Date,
-    dateGreaterThan?: Date
-  ): Promise<string> {
+  public async signContentKey(args: SignContentKeyArgs): Promise<string> {
+    const fullKey = this.joinKey(args.bucket, args.contentKey)
     const base = this.config.server
-      ? `${this.config.server}${this.config.assetUrlPrefix}/${assetKey}`
-      : `${this.config.assetUrlPrefix}/${assetKey}`
-    return this.signURL(base, dateLessThan, dateGreaterThan)
+      ? `${this.config.server}${this.config.assetUrlPrefix}/${fullKey}`
+      : `${this.config.assetUrlPrefix}/${fullKey}`
+    return this.signURL({
+      url: base,
+      dateLessThan: args.dateLessThan,
+      dateGreaterThan: args.dateGreaterThan,
+    })
   }
 
-  public async getUploadURL(assetKey: string) {
-    this.logger.debug(`Going to upload with key: ${assetKey}`)
+  public async getUploadURL(args: GetUploadURLArgs): Promise<UploadURLResult> {
+    const fullKey = this.joinKey(args.bucket, args.fileKey)
+    this.logger.debug(`Going to upload with key: ${fullKey}`)
     return {
-      uploadUrl: `${this.config.uploadUrlPrefix}/${assetKey}`,
-      assetKey,
+      uploadUrl: `${this.config.uploadUrlPrefix}/${fullKey}`,
+      assetKey: fullKey,
     }
   }
 
-  public async writeFile(
-    assetKey: string,
-    stream: ReadableStream | NodeJS.ReadableStream
-  ): Promise<boolean> {
-    this.logger.debug(`Writing file: ${assetKey}`)
+  public async writeFile(args: WriteFileArgs): Promise<boolean> {
+    this.logger.debug(`Writing file: ${args.bucket}/${args.key}`)
 
-    const path = this.safePath(assetKey)
+    const path = this.safePath(args.bucket, args.key)
 
     try {
       await this.createDirectoryForFile(path)
       const fileStream = createWriteStream(path)
-      // Use pipeline to properly manage stream piping and errors
-      await pipeline(stream as Readable, fileStream)
+      await pipeline(args.stream as Readable, fileStream)
       return true
     } catch (e) {
       console.error(e)
-      this.logger.error(`Error writing content ${assetKey}`, e)
+      this.logger.error(`Error writing content ${args.bucket}/${args.key}`, e)
       return false
     }
   }
 
-  public async copyFile(
-    assetKey: string,
-    fromAbsolutePath: string
-  ): Promise<boolean> {
-    this.logger.debug(`Writing file: ${assetKey}`)
+  public async copyFile(args: CopyFileArgs): Promise<boolean> {
+    this.logger.debug(`Writing file: ${args.bucket}/${args.key}`)
     try {
-      const path = this.safePath(assetKey)
+      const path = this.safePath(args.bucket, args.key)
       await this.createDirectoryForFile(path)
-      await promises.copyFile(fromAbsolutePath, path)
+      await promises.copyFile(args.fromAbsolutePath, path)
+      return true
     } catch (e) {
       console.error(e)
-      this.logger.error(`Error inserting content ${assetKey}`, e)
+      this.logger.error(`Error inserting content ${args.bucket}/${args.key}`, e)
     }
     return false
   }
 
   public async readFile(
-    assetKey: string
+    args: BucketKeyArgs
   ): Promise<ReadableStream | NodeJS.ReadableStream> {
-    this.logger.debug(`Getting key: ${assetKey}`)
+    this.logger.debug(`Getting key: ${args.bucket}/${args.key}`)
 
-    const filePath = this.safePath(assetKey)
+    const filePath = this.safePath(args.bucket, args.key)
 
     try {
       const stream = createReadStream(filePath)
-      // Handle early stream errors (like file not found, permission denied, etc.)
       stream.on('error', (err) => {
-        this.logger.error(`Error getting content ${assetKey}`, err)
+        this.logger.error(
+          `Error getting content ${args.bucket}/${args.key}`,
+          err
+        )
       })
 
       return stream
     } catch (e) {
-      this.logger.error(`Error setting up stream for ${assetKey}`, e)
+      this.logger.error(
+        `Error setting up stream for ${args.bucket}/${args.key}`,
+        e
+      )
       throw e
     }
   }
 
-  public async readFileAsBuffer(assetKey: string): Promise<Buffer> {
-    const filePath = this.safePath(assetKey)
-    this.logger.debug(`Reading file as buffer: ${assetKey}`)
+  public async readFileAsBuffer(args: BucketKeyArgs): Promise<Buffer> {
+    const filePath = this.safePath(args.bucket, args.key)
+    this.logger.debug(`Reading file as buffer: ${args.bucket}/${args.key}`)
     return readFile(filePath)
   }
 
-  public async deleteFile(assetKey: string): Promise<boolean> {
-    this.logger.debug(`deleting key: ${assetKey}`)
+  public async deleteFile(args: BucketKeyArgs): Promise<boolean> {
+    this.logger.debug(`deleting key: ${args.bucket}/${args.key}`)
     try {
-      await promises.unlink(this.safePath(assetKey))
+      await promises.unlink(this.safePath(args.bucket, args.key))
       return true
     } catch (e: any) {
-      this.logger.error(`Error deleting content ${assetKey}`, e)
+      this.logger.error(`Error deleting content ${args.bucket}/${args.key}`, e)
     }
     return false
   }

package/src/services/typed-credential-service.ts

@@ -15,9 +15,9 @@ export type CredentialMetaInfo = {
   oauth2?: boolean
 }
 
-export class TypedCredentialService<TMap = Record<string, unknown>>
-  implements CredentialService
-{
+export class TypedCredentialService<
+  TMap = Record<string, unknown>,
+> implements CredentialService {
   constructor(
     private credentials: CredentialService,
     private credentialsMeta: Record<string, CredentialMetaInfo>

package/src/services/typed-secret-service.ts

@@ -14,9 +14,9 @@ export type CredentialMeta = {
   oauth2?: { tokenSecretId: string }
 }
 
-export class TypedSecretService<TMap = Record<string, unknown>>
-  implements SecretService
-{
+export class TypedSecretService<
+  TMap = Record<string, unknown>,
+> implements SecretService {
   constructor(
     private secrets: SecretService,
     private credentialsMeta: Record<string, CredentialMeta>

package/src/services/typed-variables-service.ts

@@ -12,9 +12,9 @@ export type VariableMeta = {
   displayName: string
 }
 
-export class TypedVariablesService<TMap = Record<string, unknown>>
-  implements VariablesService
-{
+export class TypedVariablesService<
+  TMap = Record<string, unknown>,
+> implements VariablesService {
   constructor(
     private variables: VariablesService,
     private variablesMeta: Record<string, VariableMeta>

package/src/services/user-session-service.ts

@@ -11,12 +11,12 @@ export interface SessionService<UserSession extends CoreUserSession> {
   get(): UserSession | undefined
 }
 
-export class PikkuSessionService<UserSession extends CoreUserSession>
-  implements SessionService<UserSession>
-{
+export class PikkuSessionService<
+  UserSession extends CoreUserSession,
+> implements SessionService<UserSession> {
   public sessionChanged = false
   public initial: UserSession | undefined
-  private session: UserSession | undefined
+  protected session: UserSession | undefined
   private pikkuUserId?: string
 
   constructor(private sessionStore?: SessionStore<UserSession>) {}

package/src/testing/service-tests.ts

@@ -102,6 +102,36 @@ export function defineServiceTests(config: ServiceTestConfig): void {
       test('removeChannels with empty array is no-op', async () => {
         await store.removeChannels([])
       })
+
+      test('session round-trip — set / get / clear', async () => {
+        await store.addChannel({
+          channelId: 'ch-state',
+          channelName: 'test-channel',
+        })
+
+        // initially undefined
+        const empty = await store.getState('ch-state')
+        assert.equal(empty, undefined)
+
+        // set + get
+        const payload = { userId: 'u-7', meta: { foo: 1 } }
+        await store.setState('ch-state', payload)
+        const got = await store.getState('ch-state')
+        assert.deepEqual(got, payload)
+
+        // overwrite
+        const next = { userId: 'u-8' }
+        await store.setState('ch-state', next)
+        const got2 = await store.getState('ch-state')
+        assert.deepEqual(got2, next)
+
+        // clear
+        await store.clearState('ch-state')
+        const after = await store.getState('ch-state')
+        assert.equal(after, undefined)
+
+        await store.removeChannels(['ch-state'])
+      })
     })
   }
 

package/src/types/core.types.ts

@@ -9,6 +9,7 @@ import type {
   CorePikkuChannelMiddleware,
   CorePikkuChannelMiddlewareFactory,
 } from '../wirings/channel/channel.types.js'
+import type { EventHubService } from '../wirings/channel/eventhub-service.js'
 import type { PikkuRPC } from '../wirings/rpc/rpc-types.js'
 import type { PikkuMCP } from '../wirings/mcp/mcp.types.js'
 import type { PikkuScheduledTask } from '../wirings/scheduler/scheduler.types.js'
@@ -115,6 +116,7 @@ export type FunctionRuntimeMeta = {
   version?: number
   approvalRequired?: boolean
   approvalDescription?: string
+  implementationHash?: string
   contractHash?: string
   inputHash?: string
   outputHash?: string
@@ -216,6 +218,8 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
   workflowService?: WorkflowService
   /** The queue service */
   queueService?: QueueService
+  /** Event hub for realtime pub/sub across channels */
+  eventHub?: EventHubService<Record<string, any>>
   /** The scheduler service */
   schedulerService?: SchedulerService
   /** The deployment service for service discovery */
@@ -485,8 +489,8 @@ export type CreateSingletonServices<
  */
 export type CreateWireServices<
   SingletonServices extends CoreSingletonServices = CoreSingletonServices,
-  Services extends
-    CoreServices<SingletonServices> = CoreServices<SingletonServices>,
+  Services extends CoreServices<SingletonServices> =
+    CoreServices<SingletonServices>,
   UserSession extends CoreUserSession = CoreUserSession,
 > = (
   services: SingletonServices,

package/src/types/state.types.ts

@@ -138,6 +138,7 @@ export interface PikkuPackageState {
   middleware: {
     tagGroup: Record<string, CorePikkuMiddlewareGroup>
     httpGroup: Record<string, CorePikkuMiddlewareGroup>
+    global: CorePikkuMiddlewareGroup
   }
   channelMiddleware: {
     tagGroup: Record<string, CorePikkuChannelMiddleware[]>
@@ -145,6 +146,7 @@ export interface PikkuPackageState {
   permissions: {
     tagGroup: Record<string, CorePermissionGroup | CorePikkuPermission[]>
     httpGroup: Record<string, CorePermissionGroup | CorePikkuPermission[]>
+    global: (CorePermissionGroup | CorePikkuPermission)[]
   }
   misc: {
     errors: Map<PikkuError, ErrorDetails>
@@ -153,19 +155,6 @@ export interface PikkuPackageState {
     channelMiddleware: Record<string, CorePikkuChannelMiddleware[]>
     permissions: Record<string, CorePermissionGroup | CorePikkuPermission[]>
   }
-  models: {
-    config: {
-      models?: Record<
-        string,
-        string | { model: string; temperature?: number; maxSteps?: number }
-      >
-      agentDefaults?: { temperature?: number; maxSteps?: number }
-      agentOverrides?: Record<
-        string,
-        { model?: string; temperature?: number; maxSteps?: number }
-      >
-    } | null
-  }
   package: {
     /** Service factory functions for addon packages */
     factories: {