@donkeylabs/server 2.0.21 → 2.0.23

package/src/core.ts

@@ -1,7 +1,7 @@
 import { sql, type Kysely } from "kysely";
 import { readdir } from "node:fs/promises";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import type { z } from "zod";
 import type { Logger } from "./core/logger";
 import type { Cache } from "./core/cache";
@@ -16,6 +16,33 @@ import type { Processes } from "./core/processes";
 import type { Audit } from "./core/audit";
 import type { WebSocketService } from "./core/websocket";
 import type { Storage } from "./core/storage";
+import type { Logs } from "./core/logs";
+
+// ============================================
+// Auto-detect caller module for plugin define()
+// ============================================
+
+const CORE_FILE = resolve(fileURLToPath(import.meta.url));
+
+/**
+ * Walk the call stack to find the file that invoked define().
+ * Returns a file:// URL string or undefined if detection fails.
+ * Skips frames originating from this file (core.ts).
+ */
+function captureCallerUrl(): string | undefined {
+  const stack = new Error().stack ?? "";
+  for (const line of stack.split("\n").slice(1)) {
+    const match = line.match(/at\s+(?:.*?\s+\(?)?([^\s():]+):\d+:\d+/);
+    if (match) {
+      let filePath = match[1];
+      if (filePath.startsWith("file://")) filePath = fileURLToPath(filePath);
+      if (filePath.startsWith("native")) continue;
+      filePath = resolve(filePath);
+      if (filePath !== CORE_FILE) return pathToFileURL(filePath).href;
+    }
+  }
+  return undefined;
+}
 
 export interface PluginRegistry {}
 
@@ -109,6 +136,7 @@ export interface CoreServices {
   audit: Audit;
   websocket: WebSocketService;
   storage: Storage;
+  logs: Logs;
 }
 
 /**
@@ -328,7 +356,7 @@ export class PluginBuilder<LocalSchema = {}> {
     client?: ClientConfig;
     customErrors?: CustomErrors;
   } {
-    return config as any;
+    return { ...config, _modulePath: captureCallerUrl() } as any;
   }
 }
 
@@ -384,9 +412,11 @@ export class ConfiguredPluginBuilder<LocalSchema, Config> {
     client?: ClientConfig;
     customErrors?: CustomErrors;
   }> {
+    const modulePath = captureCallerUrl();
     const factory = (config: Config) => ({
       ...pluginDef,
       _boundConfig: config,
+      _modulePath: modulePath,
     });
     return factory as any;
   }
@@ -423,6 +453,8 @@ export type Plugin = {
     service: (ctx: any) => any;
     /** Called after service is created - use for registering crons, events, etc. */
     init?: (ctx: any, service: any) => void | Promise<void>;
+    /** Auto-detected module path where the plugin was defined */
+    _modulePath?: string;
 };
 
 export type PluginWithConfig<Config = void> = Plugin & {
@@ -452,6 +484,54 @@ export class PluginManager {
       return Array.from(this.plugins.values());
   }
 
+  getPluginNames(): string[] {
+      return Array.from(this.plugins.keys());
+  }
+
+  /** Returns { name: modulePath } for plugins that have a captured module path */
+  getPluginModulePaths(): Record<string, string> {
+    const result: Record<string, string> = {};
+    for (const [name, plugin] of this.plugins) {
+      if (plugin._modulePath) {
+        result[name] = plugin._modulePath;
+      }
+    }
+    return result;
+  }
+
+  /** Returns { name: boundConfig } for configured plugins */
+  getPluginConfigs(): Record<string, any> {
+    const result: Record<string, any> = {};
+    for (const [name, plugin] of this.plugins) {
+      if ((plugin as ConfiguredPlugin)._boundConfig !== undefined) {
+        result[name] = (plugin as ConfiguredPlugin)._boundConfig;
+      }
+    }
+    return result;
+  }
+
+  /** Returns { name: [...deps] } for plugins with dependencies */
+  getPluginDependencies(): Record<string, string[]> {
+    const result: Record<string, string[]> = {};
+    for (const [name, plugin] of this.plugins) {
+      if (plugin.dependencies && plugin.dependencies.length > 0) {
+        result[name] = [...plugin.dependencies];
+      }
+    }
+    return result;
+  }
+
+  /** Returns custom error definitions per plugin */
+  getPluginCustomErrors(): Record<string, Record<string, any>> {
+    const result: Record<string, Record<string, any>> = {};
+    for (const [name, plugin] of this.plugins) {
+      if (plugin.customErrors && Object.keys(plugin.customErrors).length > 0) {
+        result[name] = plugin.customErrors;
+      }
+    }
+    return result;
+  }
+
   register(plugin: ConfiguredPlugin): void {
     if (this.plugins.has(plugin.name)) {
       throw new Error(`Plugin ${plugin.name} is already registered.`);

package/src/harness.ts

@@ -16,9 +16,11 @@ import {
   createAudit,
   createWebSocket,
   createStorage,
+  createLogs,
   KyselyJobAdapter,
   KyselyWorkflowAdapter,
   MemoryAuditAdapter,
+  MemoryLogsAdapter,
 } from "./core/index";
 import { AppServer, type ServerConfig } from "./server";
 import type { IRouter, RouteDefinition } from "./router";
@@ -68,6 +70,7 @@ export async function createTestHarness(targetPlugin: Plugin, dependencies: Plug
   const audit = createAudit({ adapter: new MemoryAuditAdapter() });
   const websocket = createWebSocket();
   const storage = createStorage(); // Uses memory adapter by default
+  const logs = createLogs({ adapter: new MemoryLogsAdapter(), events });
 
   const core: CoreServices = {
     db,
@@ -85,6 +88,7 @@ export async function createTestHarness(targetPlugin: Plugin, dependencies: Plug
     audit,
     websocket,
     storage,
+    logs,
   };
 
   const manager = new PluginManager(core);

package/src/index.ts

@@ -99,6 +99,16 @@ export {
   type ErrorFactories,
 } from "./core/index";
 
+// Logs (persistent logging)
+export {
+  type Logs,
+  type LogSource,
+  type PersistentLogEntry,
+  type LogsQueryFilters,
+  type LogsConfig,
+  type LogsRetentionConfig,
+} from "./core/logs";
+
 // Workflows (step functions)
 export {
   workflow,

package/src/server.ts

@@ -19,12 +19,16 @@ import {
   createAudit,
   createWebSocket,
   createStorage,
+  createLogs,
   extractClientIP,
   HttpError,
   KyselyJobAdapter,
   KyselyProcessAdapter,
   KyselyWorkflowAdapter,
   KyselyAuditAdapter,
+  KyselyLogsAdapter,
+  PersistentTransport,
+  ConsoleTransport,
   type LoggerConfig,
   type CacheConfig,
   type EventsConfig,
@@ -38,6 +42,7 @@ import {
   type AuditConfig,
   type WebSocketConfig,
   type StorageConfig,
+  type LogsConfig,
 } from "./core/index";
 import type { AdminConfig } from "./admin";
 import { zodSchemaToTs } from "./generator/zod-to-ts";
@@ -80,6 +85,7 @@ export interface ServerConfig {
   audit?: AuditConfig;
   websocket?: WebSocketConfig;
   storage?: StorageConfig;
+  logs?: LogsConfig;
   /**
    * Admin dashboard configuration.
    * Automatically enabled in dev mode, disabled in production.
@@ -224,23 +230,52 @@ export class AppServer {
     const useLegacy = options.useLegacyCoreDatabases ?? false;
 
     // Initialize core services
-    const logger = createLogger(options.logger);
+    // Order matters: events → logs → logger (with PersistentTransport) → cron/jobs (with logger)
     const cache = createCache(options.cache);
     const events = createEvents(options.events);
-    const cron = createCron(options.cron);
     const sse = createSSE(options.sse);
     const rateLimiter = createRateLimiter(options.rateLimiter);
     const errors = createErrors(options.errors);
 
+    // Create logs service with its own database
+    const logsAdapter = options.logs?.adapter ?? new KyselyLogsAdapter({
+      dbPath: options.logs?.dbPath,
+    });
+    const logs = createLogs({
+      ...options.logs,
+      adapter: logsAdapter,
+      events,
+    });
+
+    // Create logger with both console and persistent transports
+    const persistentTransport = new PersistentTransport(logs, {
+      minLevel: options.logs?.minLevel,
+    });
+    const loggerTransports = [
+      new ConsoleTransport(options.logger?.format ?? "pretty"),
+      persistentTransport,
+    ];
+    const logger = createLogger({
+      ...options.logger,
+      transports: options.logger?.transports ?? loggerTransports,
+    });
+
+    // Cron with logger for scoped logging
+    const cron = createCron({
+      ...options.cron,
+      logger,
+    });
+
     // Create adapters - use Kysely by default, or legacy SQLite if requested
     const jobAdapter = options.jobs?.adapter ?? (useLegacy ? undefined : new KyselyJobAdapter(options.db));
     const workflowAdapter = options.workflows?.adapter ?? (useLegacy ? undefined : new KyselyWorkflowAdapter(options.db));
     const auditAdapter = options.audit?.adapter ?? new KyselyAuditAdapter(options.db);
 
-    // Jobs can emit events and use Kysely adapter
+    // Jobs can emit events and use Kysely adapter, with logger for scoped logging
     const jobs = createJobs({
       ...options.jobs,
       events,
+      logger,
       adapter: jobAdapter,
       // Disable built-in persistence when using Kysely adapter
       persist: useLegacy ? options.jobs?.persist : false,
@@ -256,8 +291,6 @@ export class AppServer {
     });
 
     // Processes - still uses its own adapter pattern but can use Kysely
-    // Note: ProcessesImpl creates its own SqliteProcessAdapter internally
-    // For full Kysely support, we need to modify processes.ts
     const processes = createProcesses({
       ...options.processes,
       events,
@@ -287,6 +320,7 @@ export class AppServer {
       audit,
       websocket,
       storage,
+      logs,
     };
 
     // Resolve circular dependency: workflows needs core for step handlers
@@ -989,10 +1023,20 @@ ${factoryFunction}
     // Pass plugins to workflows so handlers can access ctx.plugins
     this.coreServices.workflows.setPlugins(this.manager.getServices());
 
+    // Forward plugin metadata so isolated workflows can instantiate plugins locally
+    this.coreServices.workflows.setPluginMetadata({
+      names: this.manager.getPluginNames(),
+      modulePaths: this.manager.getPluginModulePaths(),
+      configs: this.manager.getPluginConfigs(),
+      dependencies: this.manager.getPluginDependencies(),
+      customErrors: this.manager.getPluginCustomErrors(),
+    });
+
     this.isInitialized = true;
 
     this.coreServices.cron.start();
     this.coreServices.jobs.start();
+    await this.coreServices.workflows.resolveDbPath();
     await this.coreServices.workflows.resume();
     this.coreServices.processes.start();
     logger.info("Background services started (cron, jobs, workflows, processes)");
@@ -1407,6 +1451,10 @@ ${factoryFunction}
     // Run user shutdown handlers first (in reverse order - LIFO)
     await this.runShutdownHandlers();
 
+    // Flush and stop logs before other services shut down
+    await this.coreServices.logs.flush();
+    this.coreServices.logs.stop();
+
     // Stop SSE (closes all client connections)
     this.coreServices.sse.shutdown();