@pikku/core 0.12.13 → 0.12.15

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

@@ -1,22 +1,65 @@
+import type { CredentialService } from './credential-service.js'
+import { defaultPikkuUserIdResolver } from './pikku-user-id.js'
+import type { PikkuWire } from '../types/core.types.js'
+
 export class PikkuCredentialWireService {
   private credentials: Record<string, unknown> = {}
+  private loaded = false
+  private loadPromise: Promise<void> | undefined
+
+  constructor(
+    private credentialService?: CredentialService,
+    private wire?: PikkuWire
+  ) {}
 
   set(name: string, value: unknown): void {
     this.credentials[name] = value
   }
 
-  getAll(): Record<string, unknown> {
-    return this.credentials
+  get<T = unknown>(name: string): T | null | Promise<T | null> {
+    if (this.loaded) return (this.credentials[name] as T) ?? null
+    return this.lazyLoad().then(() => (this.credentials[name] as T) ?? null)
+  }
+
+  getAll(): Record<string, unknown> | Promise<Record<string, unknown>> {
+    if (this.loaded) return this.credentials
+    return this.lazyLoad().then(() => this.credentials)
+  }
+
+  getScoped(
+    allowedNames: string[]
+  ): Record<string, unknown> | Promise<Record<string, unknown>> {
+    const buildScoped = () => {
+      const scoped: Record<string, unknown> = {}
+      for (const name of allowedNames) {
+        if (name in this.credentials) {
+          scoped[name] = this.credentials[name]
+        }
+      }
+      return scoped
+    }
+    if (this.loaded) return buildScoped()
+    return this.lazyLoad().then(buildScoped)
+  }
+
+  private lazyLoad(): Promise<void> {
+    if (this.loadPromise) return this.loadPromise
+    this.loadPromise = this.doLoad()
+    return this.loadPromise
   }
 
-  getScoped(allowedNames: string[]): Record<string, unknown> {
-    const scoped: Record<string, unknown> = {}
-    for (const name of allowedNames) {
-      if (name in this.credentials) {
-        scoped[name] = this.credentials[name]
+  private async doLoad(): Promise<void> {
+    this.loaded = true
+    if (!this.credentialService || !this.wire) return
+    const userId = defaultPikkuUserIdResolver(this.wire)
+    if (!userId) return
+    this.wire.pikkuUserId = userId
+    const allCreds = await this.credentialService.getAll(userId)
+    for (const [name, value] of Object.entries(allCreds)) {
+      if (!(name in this.credentials)) {
+        this.credentials[name] = value
       }
     }
-    return scoped
   }
 }
 
@@ -36,6 +79,7 @@ export function createWireServicesCredentialWireProps(
   return {
     setCredential: (name: string, value: unknown) =>
       credentialWire.set(name, value),
+    getCredential: <T = unknown>(name: string) => credentialWire.get<T>(name),
     getCredentials: () =>
       allowedNames
         ? credentialWire.getScoped(allowedNames)

package/src/services/deployment-service.ts

@@ -18,5 +18,21 @@ export interface DeploymentService {
   init(): Promise<void>
   start(config: DeploymentConfig): Promise<void>
   stop(): Promise<void>
-  findFunction(name: string): Promise<DeploymentInfo[]>
+  /**
+   * Dispatch a remote RPC call to a function.
+   * The deployment service owns the full transport:
+   * - Resolving the target (endpoint, service binding, etc.)
+   * - Session propagation (JWT signing, headers)
+   * - The actual network call
+   *
+   * @param funcName - The function to invoke
+   * @param data - Input data for the function
+   * @param session - User session to propagate (optional)
+   */
+  invoke(
+    funcName: string,
+    data: unknown,
+    session?: unknown,
+    traceId?: string
+  ): Promise<unknown>
 }

package/src/services/in-memory-queue-service.ts

@@ -0,0 +1,46 @@
+import type {
+  QueueService,
+  QueueJob,
+  JobOptions,
+} from '../wirings/queue/queue.types.js'
+import { runQueueJob } from '../wirings/queue/queue-runner.js'
+
+export class InMemoryQueueService implements QueueService {
+  readonly supportsResults = false
+  private jobCounter = 0
+
+  async add<T>(
+    queueName: string,
+    data: T,
+    options?: JobOptions
+  ): Promise<string> {
+    const jobId = `inmem-${++this.jobCounter}`
+
+    const job: QueueJob<T> = {
+      id: jobId,
+      queueName,
+      data,
+      status: () => 'active',
+      pikkuUserId: options?.pikkuUserId,
+    }
+
+    const delay = options?.delay ?? 0
+
+    setTimeout(async () => {
+      try {
+        await runQueueJob({ job })
+      } catch (e: any) {
+        console.error(
+          `[InMemoryQueue] Job ${jobId} on ${queueName} failed:`,
+          e.message
+        )
+      }
+    }, delay)
+
+    return jobId
+  }
+
+  async getJob(): Promise<null> {
+    return null
+  }
+}

package/src/services/index.ts

@@ -19,8 +19,9 @@ export { TypedVariablesService } from './typed-variables-service.js'
 export { LocalSecretService } from './local-secrets.js'
 export { LocalCredentialService } from './local-credential-service.js'
 export { LocalVariablesService } from './local-variables.js'
-export { ConsoleLogger } from './logger-console.js'
+export { ConsoleLogger, JsonConsoleLogger } from './logger-console.js'
 export { InMemoryWorkflowService } from './in-memory-workflow-service.js'
+export { InMemoryQueueService } from './in-memory-queue-service.js'
 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'
@@ -66,3 +67,22 @@ export type {
   CredentialMetaInfo,
 } from './typed-credential-service.js'
 export type { VariableStatus, VariableMeta } from './typed-variables-service.js'
+export type { MetaService } from './meta-service.js'
+export type {
+  MCPMeta,
+  RPCMetaRecord,
+  ServiceMeta,
+  ServicesMetaRecord,
+  MiddlewareDefinitionMeta,
+  MiddlewareInstanceMeta,
+  GroupMeta,
+  MiddlewareGroupsMeta,
+  PermissionDefinitionMeta,
+  PermissionsGroupsMeta,
+  FunctionsMeta,
+  FunctionMeta,
+  MiddlewareMeta,
+  PermissionMeta,
+  AgentsMeta,
+  AgentMeta,
+} from './meta-service.js'

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

@@ -38,4 +38,26 @@ export class LocalCredentialService implements CredentialService {
     }
     return result
   }
+
+  async getUsersWithCredential(name: string): Promise<string[]> {
+    const suffix = `:${name}`
+    const users: string[] = []
+    for (const key of this.store.keys()) {
+      if (key.endsWith(suffix)) {
+        users.push(key.slice(0, -suffix.length))
+      }
+    }
+    return users
+  }
+
+  async getAllUsers(): Promise<string[]> {
+    const users = new Set<string>()
+    for (const key of this.store.keys()) {
+      const colonIndex = key.indexOf(':')
+      if (colonIndex > 0) {
+        users.add(key.slice(0, colonIndex))
+      }
+    }
+    return [...users]
+  }
 }

package/src/services/logger-console.ts

@@ -2,97 +2,177 @@ import type { Logger } from './logger.js'
 import { LogLevel } from './logger.js'
 
 /**
- * A logger implementation that logs messages to the console.
+ * Text-mode console logger.
+ * Output: `INFO: message` or `[traceId] INFO: message`
  */
 export class ConsoleLogger implements Logger {
-  /**
-   * The current logging level.
-   */
   private level: LogLevel = LogLevel.info
+  private prefix: string
+
+  constructor(traceId?: string) {
+    this.prefix = traceId ? `[${traceId}]` : ''
+  }
 
-  /**
-   * Sets the logging level.
-   * @param level - The logging level to set.
-   */
   setLevel(level: LogLevel): void {
     this.level = level
   }
 
-  /**
-   * Logs a trace message.
-   * @param message - The message to log.
-   * @param meta - Additional metadata to log.
-   */
-  trace?(message: string, ...meta: any[]): void {
+  scope(traceId: string): Logger {
+    const scoped = new ConsoleLogger(traceId)
+    scoped.level = this.level
+    return scoped
+  }
+
+  private log_(
+    fn: (...args: unknown[]) => void,
+    label: string,
+    ...args: unknown[]
+  ): void {
+    if (this.prefix) {
+      fn(this.prefix, label, ...args)
+    } else {
+      fn(label, ...args)
+    }
+  }
+
+  trace(message: string, ...meta: any[]): void {
     if (this.level <= LogLevel.trace) {
-      console.trace('TRACE:', message, ...meta)
+      this.log_(console.trace, 'TRACE:', message, ...meta)
     }
   }
 
-  /**
-   * Logs a debug message.
-   * @param message - The message to log.
-   * @param meta - Additional metadata to log.
-   */
   debug(message: string, ...meta: any[]): void {
     if (this.level <= LogLevel.debug) {
-      console.debug('DEBUG:', message, ...meta)
+      this.log_(console.debug, 'DEBUG:', message, ...meta)
     }
   }
 
-  /**
-   * Logs an informational message.
-   * @param messageOrObj - The message or object to log.
-   * @param meta - Additional metadata to log.
-   */
   info(messageOrObj: string | Record<string, any>, ...meta: any[]): void {
     if (this.level <= LogLevel.info) {
-      console.info('INFO:', messageOrObj, ...meta)
+      this.log_(console.info, 'INFO:', messageOrObj, ...meta)
     }
   }
 
-  /**
-   * Logs a warning message.
-   * @param messageOrObj - The message or object to log.
-   * @param meta - Additional metadata to log.
-   */
   warn(messageOrObj: string | Record<string, any>, ...meta: any[]): void {
     if (this.level <= LogLevel.warn) {
-      console.warn('WARN:', messageOrObj, ...meta)
+      this.log_(console.warn, 'WARN:', messageOrObj, ...meta)
     }
   }
 
-  /**
-   * Logs an error message.
-   * @param messageOrObj - The message, object, or error to log.
-   * @param meta - Additional metadata to log.
-   */
   error(
     messageOrObj: string | Record<string, any> | Error,
     ...meta: any[]
   ): void {
     if (this.level <= LogLevel.error) {
-      console.error(
+      this.log_(
+        console.error,
         'ERROR:',
         messageOrObj instanceof Error ? messageOrObj.message : messageOrObj,
         ...meta
       )
       if (messageOrObj instanceof Error) {
-        console.error('STACK:', messageOrObj.stack)
+        this.log_(console.error, 'STACK:', messageOrObj.stack)
+      }
+    }
+  }
+
+  log(level: string, message: string, ...meta: any[]): void {
+    const logLevel = LogLevel[level as keyof typeof LogLevel]
+    if (this.level <= logLevel) {
+      this.log_(console.log, `${level.toUpperCase()}:`, message, ...meta)
+    }
+  }
+}
+
+/**
+ * JSON-mode console logger.
+ * Output: `{"level":"info","message":"...","traceId":"..."}`
+ * CF Workers Logs auto-indexes JSON keys for filtering.
+ */
+export class JsonConsoleLogger implements Logger {
+  private level: LogLevel = LogLevel.info
+  private traceId: string | undefined
+
+  constructor(traceId?: string) {
+    this.traceId = traceId
+  }
+
+  setLevel(level: LogLevel): void {
+    this.level = level
+  }
+
+  scope(traceId: string): Logger {
+    const scoped = new JsonConsoleLogger(traceId)
+    scoped.level = this.level
+    return scoped
+  }
+
+  trace(message: string, ...meta: any[]): void {
+    if (this.level <= LogLevel.trace) {
+      this.emit(console.debug, 'trace', message, meta)
+    }
+  }
+
+  debug(message: string, ...meta: any[]): void {
+    if (this.level <= LogLevel.debug) {
+      this.emit(console.debug, 'debug', message, meta)
+    }
+  }
+
+  info(messageOrObj: string | Record<string, any>, ...meta: any[]): void {
+    if (this.level <= LogLevel.info) {
+      this.emit(console.info, 'info', messageOrObj, meta)
+    }
+  }
+
+  warn(messageOrObj: string | Record<string, any>, ...meta: any[]): void {
+    if (this.level <= LogLevel.warn) {
+      this.emit(console.warn, 'warn', messageOrObj, meta)
+    }
+  }
+
+  error(
+    messageOrObj: string | Record<string, any> | Error,
+    ...meta: any[]
+  ): void {
+    if (this.level <= LogLevel.error) {
+      if (messageOrObj instanceof Error) {
+        this.emit(console.error, 'error', messageOrObj.message, meta)
+        console.error(
+          JSON.stringify({
+            level: 'error',
+            message: 'stack',
+            stack: messageOrObj.stack,
+            ...(this.traceId ? { traceId: this.traceId } : {}),
+          })
+        )
+      } else {
+        this.emit(console.error, 'error', messageOrObj, meta)
       }
     }
   }
 
-  /**
-   * Logs a message at a specified level.
-   * @param level - The logging level.
-   * @param message - The message to log.
-   * @param meta - Additional metadata to log.
-   */
   log(level: string, message: string, ...meta: any[]): void {
     const logLevel = LogLevel[level as keyof typeof LogLevel]
     if (this.level <= logLevel) {
-      console.log(`${level.toUpperCase()}:`, message, ...meta)
+      this.emit(console.log, level, message, meta)
+    }
+  }
+
+  private emit(
+    fn: (...args: any[]) => void,
+    level: string,
+    messageOrObj: string | Record<string, any>,
+    meta: any[]
+  ): void {
+    const entry: Record<string, unknown> = { level }
+    if (this.traceId) entry.traceId = this.traceId
+    if (typeof messageOrObj === 'string') {
+      entry.message = messageOrObj
+    } else {
+      Object.assign(entry, messageOrObj)
     }
+    if (meta.length > 0) entry.meta = meta
+    fn(JSON.stringify(entry))
   }
 }

package/src/services/logger.ts

@@ -54,4 +54,10 @@ export interface Logger {
    * @param level - The logging level to set.
    */
   setLevel(level: LogLevel): void
+
+  /**
+   * Creates a scoped logger with a traceId included in every log entry.
+   * Used per-request to correlate logs across function calls.
+   */
+  scope?(traceId: string): Logger
 }