@pikku/core 0.12.14 → 0.12.16

package/src/remote.ts

@@ -0,0 +1,46 @@
+import type { JWTService } from './services/jwt-service.js'
+import type { SecretService } from './services/secret-service.js'
+import { encryptJSON } from './crypto-utils.js'
+
+/**
+ * Build Authorization headers with JWT-signed session and traceId for
+ * pikkuRemoteAuthMiddleware on the receiving end.
+ *
+ * Used by all deployment services (Kysely, Redis, MongoDB, Lambda, CF, Azure)
+ * regardless of transport (HTTP, Lambda Invoke, service bindings).
+ */
+export async function buildRemoteHeaders(
+  jwt: JWTService | undefined,
+  secrets: SecretService | undefined,
+  funcName: string,
+  session?: unknown,
+  traceId?: string
+): Promise<Record<string, string>> {
+  const headers: Record<string, string> = {
+    'content-type': 'application/json',
+    ...(traceId && { 'x-request-id': traceId }),
+  }
+
+  let secret: string | undefined
+  try {
+    secret = await secrets?.getSecret('PIKKU_REMOTE_SECRET')
+  } catch {}
+
+  if (secret && jwt) {
+    const sessionEnc = session
+      ? await encryptJSON(secret, { session })
+      : undefined
+    const token = await jwt.encode(
+      { value: 5, unit: 'minute' },
+      {
+        aud: 'pikku-remote',
+        fn: funcName,
+        iat: Math.floor(Date.now() / 1000),
+        session: sessionEnc,
+      }
+    )
+    headers.authorization = `Bearer ${token}`
+  }
+
+  return headers
+}

package/src/schema.ts

@@ -100,6 +100,7 @@ export const coerceTopLevelDataFromSchema = (
   packageName: string | null = null
 ) => {
   const schema = pikkuState(packageName, 'misc', 'schemas').get(schemaName)
+  if (!schema?.properties) return
   for (const key in schema.properties) {
     const property = schema.properties[key]
     if (typeof property === 'boolean') {

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/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
 }