@pikku/core 0.12.14 → 0.12.16

package/dist/services/in-memory-queue-service.js

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

package/dist/services/index.d.ts

@@ -10,8 +10,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';
@@ -34,3 +35,5 @@ export type { CredentialService } from './credential-service.js';
 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 { 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

@@ -10,8 +10,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';

package/dist/services/logger-console.d.ts

@@ -1,53 +1,39 @@
 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 declare class ConsoleLogger implements Logger {
-    /**
-     * The current logging level.
-     */
     private level;
-    /**
-     * Sets the logging level.
-     * @param level - The logging level to set.
-     */
+    private prefix;
+    constructor(traceId?: string);
     setLevel(level: LogLevel): void;
-    /**
-     * Logs a trace message.
-     * @param message - The message to log.
-     * @param meta - Additional metadata to log.
-     */
-    trace?(message: string, ...meta: any[]): void;
-    /**
-     * Logs a debug message.
-     * @param message - The message to log.
-     * @param meta - Additional metadata to log.
-     */
+    scope(traceId: string): Logger;
+    private log_;
+    trace(message: string, ...meta: any[]): void;
     debug(message: string, ...meta: any[]): void;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
 }
+/**
+ * JSON-mode console logger.
+ * Output: `{"level":"info","message":"...","traceId":"..."}`
+ * CF Workers Logs auto-indexes JSON keys for filtering.
+ */
+export declare class JsonConsoleLogger implements Logger {
+    private level;
+    private traceId;
+    constructor(traceId?: string);
+    setLevel(level: LogLevel): void;
+    scope(traceId: string): Logger;
+    trace(message: string, ...meta: any[]): void;
+    debug(message: string, ...meta: any[]): void;
+    info(messageOrObj: string | Record<string, any>, ...meta: any[]): void;
+    warn(messageOrObj: string | Record<string, any>, ...meta: any[]): void;
+    error(messageOrObj: string | Record<string, any> | Error, ...meta: any[]): void;
+    log(level: string, message: string, ...meta: any[]): void;
+    private emit;
+}

package/dist/services/logger-console.js

@@ -1,82 +1,138 @@
 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 {
-    /**
-     * The current logging level.
-     */
     level = LogLevel.info;
-    /**
-     * Sets the logging level.
-     * @param level - The logging level to set.
-     */
+    prefix;
+    constructor(traceId) {
+        this.prefix = traceId ? `[${traceId}]` : '';
+    }
     setLevel(level) {
         this.level = level;
     }
-    /**
-     * Logs a trace message.
-     * @param message - The message to log.
-     * @param meta - Additional metadata to log.
-     */
+    scope(traceId) {
+        const scoped = new ConsoleLogger(traceId);
+        scoped.level = this.level;
+        return scoped;
+    }
+    log_(fn, label, ...args) {
+        if (this.prefix) {
+            fn(this.prefix, label, ...args);
+        }
+        else {
+            fn(label, ...args);
+        }
+    }
     trace(message, ...meta) {
         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, ...meta) {
         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, ...meta) {
         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, ...meta) {
         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, ...meta) {
         if (this.level <= LogLevel.error) {
-            console.error('ERROR:', messageOrObj instanceof Error ? messageOrObj.message : messageOrObj, ...meta);
+            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);
             }
         }
     }
-    /**
-     * 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, message, ...meta) {
         const logLevel = LogLevel[level];
         if (this.level <= logLevel) {
-            console.log(`${level.toUpperCase()}:`, message, ...meta);
+            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 {
+    level = LogLevel.info;
+    traceId;
+    constructor(traceId) {
+        this.traceId = traceId;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    scope(traceId) {
+        const scoped = new JsonConsoleLogger(traceId);
+        scoped.level = this.level;
+        return scoped;
+    }
+    trace(message, ...meta) {
+        if (this.level <= LogLevel.trace) {
+            this.emit(console.debug, 'trace', message, meta);
+        }
+    }
+    debug(message, ...meta) {
+        if (this.level <= LogLevel.debug) {
+            this.emit(console.debug, 'debug', message, meta);
+        }
+    }
+    info(messageOrObj, ...meta) {
+        if (this.level <= LogLevel.info) {
+            this.emit(console.info, 'info', messageOrObj, meta);
+        }
+    }
+    warn(messageOrObj, ...meta) {
+        if (this.level <= LogLevel.warn) {
+            this.emit(console.warn, 'warn', messageOrObj, meta);
+        }
+    }
+    error(messageOrObj, ...meta) {
+        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);
+            }
+        }
+    }
+    log(level, message, ...meta) {
+        const logLevel = LogLevel[level];
+        if (this.level <= logLevel) {
+            this.emit(console.log, level, message, meta);
+        }
+    }
+    emit(fn, level, messageOrObj, meta) {
+        const entry = { 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/dist/services/logger.d.ts

@@ -45,4 +45,9 @@ 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;
 }

package/dist/services/meta-service.d.ts

@@ -0,0 +1,175 @@
+import type { JSONSchema7 } from 'json-schema';
+import type { HTTPWiringsMeta } from '../wirings/http/http.types.js';
+import type { ChannelsMeta } from '../wirings/channel/channel.types.js';
+import type { ScheduledTasksMeta } from '../wirings/scheduler/scheduler.types.js';
+import type { QueueWorkersMeta } from '../wirings/queue/queue.types.js';
+import type { CLIMeta } from '../wirings/cli/cli.types.js';
+import type { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '../wirings/mcp/mcp.types.js';
+import type { WorkflowsMeta } from '../wirings/workflow/workflow.types.js';
+import type { TriggerMeta, TriggerSourceMeta } from '../wirings/trigger/trigger.types.js';
+import type { SecretDefinitionsMeta } from '../wirings/secret/secret.types.js';
+import type { CredentialDefinitionsMeta } from '../wirings/credential/credential.types.js';
+import type { VariableDefinitionsMeta } from '../wirings/variable/variable.types.js';
+import type { FunctionMeta, FunctionsMeta, MiddlewareMetadata, PermissionMetadata } from '../types/core.types.js';
+import type { AIAgentMeta } from '../wirings/ai-agent/ai-agent.types.js';
+export type { FunctionMeta, FunctionsMeta, MiddlewareMetadata as MiddlewareMeta, PermissionMetadata as PermissionMeta, };
+export type AgentsMeta = AIAgentMeta;
+export type AgentMeta = AIAgentMeta[string];
+export interface MCPMeta {
+    resources: MCPResourceMeta;
+    tools: MCPToolMeta;
+    prompts: MCPPromptMeta;
+}
+export type RPCMetaRecord = Record<string, string>;
+export interface ServiceMeta {
+    name: string;
+    summary: string;
+    description: string;
+    package: string;
+    path: string;
+    version: string;
+    interface: string;
+    expandedProperties: Record<string, string>;
+}
+export type ServicesMetaRecord = Record<string, ServiceMeta>;
+export interface MiddlewareDefinitionMeta {
+    services: {
+        optimized: boolean;
+        services: string[];
+    };
+    sourceFile: string;
+    position: number;
+    exportedName: string | null;
+    factory?: boolean;
+    name?: string;
+    description?: string;
+    package?: string;
+}
+export interface MiddlewareInstanceMeta {
+    definitionId: string;
+    sourceFile: string;
+    position: number;
+    isFactoryCall: boolean;
+}
+export interface GroupMeta {
+    exportName: string | null;
+    sourceFile: string;
+    position: number;
+    services: {
+        optimized: boolean;
+        services: string[];
+    };
+    count: number;
+    instanceIds: string[];
+    isFactory: boolean;
+}
+export interface MiddlewareGroupsMeta {
+    definitions: Record<string, MiddlewareDefinitionMeta>;
+    instances: Record<string, MiddlewareInstanceMeta>;
+    httpGroups: Record<string, GroupMeta>;
+    tagGroups: Record<string, GroupMeta>;
+}
+export interface PermissionDefinitionMeta {
+    services: {
+        optimized: boolean;
+        services: string[];
+    };
+    sourceFile: string;
+    position: number;
+    exportedName: string | null;
+    factory?: boolean;
+    name?: string;
+    description?: string;
+}
+export interface PermissionsGroupsMeta {
+    definitions: Record<string, PermissionDefinitionMeta>;
+    httpGroups: Record<string, GroupMeta>;
+    tagGroups: Record<string, GroupMeta>;
+}
+/**
+ * Abstraction over .pikku metadata file access.
+ * All paths are relative to the .pikku root directory.
+ *
+ * Node.js uses LocalMetaService (filesystem).
+ * Cloudflare uses an R2/KV implementation.
+ */
+export interface MetaService {
+    /** Base path for local filesystem implementations. Undefined for remote/non-local implementations. */
+    readonly basePath?: string;
+    /** Read a file's content by relative path. Returns null if not found. */
+    readFile(relativePath: string): Promise<string | null>;
+    /** List files in a directory by relative path. Returns empty array if not found. */
+    readDir(relativePath: string): Promise<string[]>;
+    getHttpMeta(): Promise<HTTPWiringsMeta>;
+    getChannelsMeta(): Promise<ChannelsMeta>;
+    getSchedulerMeta(): Promise<ScheduledTasksMeta>;
+    getQueueMeta(): Promise<QueueWorkersMeta>;
+    getCliMeta(): Promise<CLIMeta>;
+    getMcpMeta(): Promise<MCPMeta>;
+    getRpcMeta(): Promise<RPCMetaRecord>;
+    getWorkflowMeta(): Promise<WorkflowsMeta>;
+    getTriggerMeta(): Promise<TriggerMeta>;
+    getTriggerSourceMeta(): Promise<TriggerSourceMeta>;
+    getFunctionsMeta(): Promise<FunctionsMeta>;
+    getMiddlewareGroupsMeta(): Promise<MiddlewareGroupsMeta>;
+    getPermissionsGroupsMeta(): Promise<PermissionsGroupsMeta>;
+    getAgentsMeta(): Promise<AgentsMeta>;
+    getSecretsMeta(): Promise<SecretDefinitionsMeta>;
+    getCredentialsMeta(): Promise<CredentialDefinitionsMeta>;
+    getVariablesMeta(): Promise<VariableDefinitionsMeta>;
+    getServicesMeta(): Promise<ServicesMetaRecord>;
+    getSchema(schemaName: string): Promise<JSONSchema7 | null>;
+    getSchemas(schemaNames: string[]): Promise<Record<string, JSONSchema7 | null>>;
+    clearCache(): void;
+}
+/**
+ * Node.js filesystem implementation of MetaService.
+ * Reads .gen.json files from a local .pikku directory.
+ */
+export declare class LocalMetaService implements MetaService {
+    readonly basePath: string;
+    private httpMetaCache;
+    private channelsMetaCache;
+    private schedulerMetaCache;
+    private queueMetaCache;
+    private cliMetaCache;
+    private mcpMetaCache;
+    private rpcMetaCache;
+    private workflowMetaCache;
+    private triggerMetaCache;
+    private triggerSourceMetaCache;
+    private functionsMetaCache;
+    private servicesMetaCache;
+    private secretsMetaCache;
+    private credentialsMetaCache;
+    private variablesMetaCache;
+    private middlewareGroupsMetaCache;
+    private permissionsGroupsMetaCache;
+    private agentsMetaCache;
+    private schemaCache;
+    constructor(basePath: string);
+    readFile(relativePath: string): Promise<string | null>;
+    readDir(relativePath: string): Promise<string[]>;
+    clearCache(): void;
+    private readMetaJson;
+    getHttpMeta(): Promise<HTTPWiringsMeta>;
+    getChannelsMeta(): Promise<ChannelsMeta>;
+    getSchedulerMeta(): Promise<ScheduledTasksMeta>;
+    getQueueMeta(): Promise<QueueWorkersMeta>;
+    getCliMeta(): Promise<CLIMeta>;
+    getMcpMeta(): Promise<MCPMeta>;
+    getRpcMeta(): Promise<RPCMetaRecord>;
+    getWorkflowMeta(): Promise<WorkflowsMeta>;
+    getTriggerMeta(): Promise<TriggerMeta>;
+    getTriggerSourceMeta(): Promise<TriggerSourceMeta>;
+    getFunctionsMeta(): Promise<FunctionsMeta>;
+    getMiddlewareGroupsMeta(): Promise<MiddlewareGroupsMeta>;
+    getPermissionsGroupsMeta(): Promise<PermissionsGroupsMeta>;
+    getAgentsMeta(): Promise<AgentsMeta>;
+    getSecretsMeta(): Promise<SecretDefinitionsMeta>;
+    getCredentialsMeta(): Promise<CredentialDefinitionsMeta>;
+    getVariablesMeta(): Promise<VariableDefinitionsMeta>;
+    getServicesMeta(): Promise<ServicesMetaRecord>;
+    getSchema(schemaName: string): Promise<JSONSchema7 | null>;
+    getSchemas(schemaNames: string[]): Promise<Record<string, JSONSchema7 | null>>;
+}