@donkeylabs/server 0.3.0 → 0.4.0

package/src/core/logger.ts

@@ -19,8 +19,6 @@ export interface LoggerConfig {
   level?: LogLevel;
   transports?: LogTransport[];
   format?: "json" | "pretty";
-  /** Timezone for timestamps (e.g., "America/New_York", "UTC"). Defaults to local timezone. */
-  timezone?: string;
 }
 
 export interface Logger {
@@ -49,86 +47,27 @@ const RESET = "\x1b[0m";
 
 // Console transport with pretty or JSON formatting
 export class ConsoleTransport implements LogTransport {
-  private format: "json" | "pretty";
-  private timezone?: string;
-
-  constructor(format: "json" | "pretty" = "pretty", timezone?: string) {
-    this.format = format;
-    this.timezone = timezone;
-  }
-
-  private formatTimestamp(date: Date): string {
-    if (this.timezone) {
-      try {
-        return date.toLocaleString("en-US", {
-          timeZone: this.timezone,
-          hour12: false,
-          hour: "2-digit",
-          minute: "2-digit",
-          second: "2-digit",
-          fractionalSecondDigits: 3,
-        } as Intl.DateTimeFormatOptions);
-      } catch {
-        // Invalid timezone, fall back to ISO
-        return date.toISOString().slice(11, 23);
-      }
-    }
-    return date.toISOString().slice(11, 23);
-  }
-
-  private formatTimezone(): string {
-    if (!this.timezone) return "";
-    // Get short timezone abbreviation
-    try {
-      const tzPart = new Date().toLocaleString("en-US", {
-        timeZone: this.timezone,
-        timeZoneName: "short",
-      }).split(" ").pop();
-      return ` ${tzPart}`;
-    } catch {
-      return "";
-    }
-  }
+  constructor(private format: "json" | "pretty" = "pretty") {}
 
   log(entry: LogEntry): void {
     if (this.format === "json") {
       console.log(JSON.stringify({
         timestamp: entry.timestamp.toISOString(),
         level: entry.level,
-        ...(entry.context?.plugin ? { plugin: entry.context.plugin } : {}),
         message: entry.message,
         ...entry.data,
-        // Include other context fields except plugin (already extracted)
-        ...(entry.context ? Object.fromEntries(
-          Object.entries(entry.context).filter(([k]) => k !== "plugin")
-        ) : {}),
+        ...entry.context,
       }));
     } else {
-      const time = this.formatTimestamp(entry.timestamp);
-      const tz = this.formatTimezone();
-      const level = entry.level.toUpperCase();
-      const levelColor = LEVEL_COLORS[entry.level];
-
-      // Extract plugin from context for prefix display
-      const plugin = entry.context?.plugin;
-
-      // Build prefix: [timestamp tz][plugin][LEVEL]
-      const timePart = `\x1b[90m[${time}${tz}]${RESET}`;
-      const pluginPart = plugin ? `\x1b[35m[${plugin}]${RESET}` : "";
-      const levelPart = `${levelColor}[${level}]${RESET}`;
-
-      let output = `${timePart}${pluginPart}${levelPart} ${entry.message}`;
-
-      // Show data as key=value pairs (excluding plugin from context since it's in prefix)
-      const contextWithoutPlugin = entry.context
-        ? Object.fromEntries(Object.entries(entry.context).filter(([k]) => k !== "plugin"))
-        : {};
-      const extra = { ...entry.data, ...contextWithoutPlugin };
+      const color = LEVEL_COLORS[entry.level];
+      const time = entry.timestamp.toISOString().slice(11, 23);
+      const level = entry.level.toUpperCase().padEnd(5);
+
+      let output = `${color}[${time}] ${level}${RESET} ${entry.message}`;
+
+      const extra = { ...entry.data, ...entry.context };
       if (Object.keys(extra).length > 0) {
-        const pairs = Object.entries(extra)
-          .map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`)
-          .join(" ");
-        output += ` ${"\x1b[90m"}${pairs}${RESET}`;
+        output += ` ${"\x1b[90m"}${JSON.stringify(extra)}${RESET}`;
       }
 
       console.log(output);
@@ -140,12 +79,10 @@ class LoggerImpl implements Logger {
   private minLevel: number;
   private transports: LogTransport[];
   private context: Record<string, any>;
-  private config: LoggerConfig;
 
   constructor(config: LoggerConfig = {}, context: Record<string, any> = {}) {
-    this.config = config;
     this.minLevel = LOG_LEVELS[config.level ?? "info"];
-    this.transports = config.transports ?? [new ConsoleTransport(config.format ?? "pretty", config.timezone)];
+    this.transports = config.transports ?? [new ConsoleTransport(config.format ?? "pretty")];
     this.context = context;
   }
 
@@ -183,11 +120,7 @@ class LoggerImpl implements Logger {
 
   child(context: Record<string, any>): Logger {
     return new LoggerImpl(
-      {
-        ...this.config,
-        level: Object.keys(LOG_LEVELS).find(k => LOG_LEVELS[k as LogLevel] === this.minLevel) as LogLevel,
-        transports: this.transports,
-      },
+      { level: Object.keys(LOG_LEVELS).find(k => LOG_LEVELS[k as LogLevel] === this.minLevel) as LogLevel, transports: this.transports },
       { ...this.context, ...context }
     );
   }

package/src/core/rate-limiter.ts

@@ -19,34 +19,9 @@ export interface RateLimiterConfig {
   adapter?: RateLimitAdapter;
 }
 
-export interface RateLimitRule {
-  /** Max requests allowed in window */
-  limit: number;
-  /** Time window (supports "10s", "1m", "1h" or milliseconds) */
-  window: string | number;
-  /** Custom key extraction (defaults to IP + route) */
-  keyFn?: (ctx: { ip: string; route: string; user?: any }) => string;
-  /** Skip rate limiting for certain conditions */
-  skip?: (ctx: { ip: string; route: string; user?: any }) => boolean;
-  /** Custom error message when rate limited */
-  message?: string;
-}
-
 export interface RateLimiter {
-  // Manual rate limiting
   check(key: string, limit: number, windowMs: number): Promise<RateLimitResult>;
   reset(key: string): Promise<void>;
-
-  // Declarative rule registration
-  registerRule(pattern: string, rule: RateLimitRule): void;
-  registerRules(rules: Record<string, RateLimitRule>): void;
-  getRule(route: string): { pattern: string; rule: RateLimitRule } | undefined;
-  matchRoute(route: string): RateLimitRule | undefined;
-  /** List all registered rules */
-  listRules(): Array<{ pattern: string; limit: number; window: string | number }>;
-
-  /** Check a route against registered rules */
-  checkRoute(route: string, ctx: { ip: string; user?: any }): Promise<RateLimitResult | null>;
 }
 
 // In-memory rate limit adapter using sliding window
@@ -105,90 +80,11 @@ export class MemoryRateLimitAdapter implements RateLimitAdapter {
 
 class RateLimiterImpl implements RateLimiter {
   private adapter: RateLimitAdapter;
-  private rules = new Map<string, RateLimitRule>();
-  private rulePatterns: Array<{ pattern: string; regex: RegExp; rule: RateLimitRule }> = [];
 
   constructor(config: RateLimiterConfig = {}) {
     this.adapter = config.adapter ?? new MemoryRateLimitAdapter();
   }
 
-  registerRule(pattern: string, rule: RateLimitRule): void {
-    this.rules.set(pattern, rule);
-
-    // Pre-compile regex for patterns with wildcards
-    if (pattern.includes("*")) {
-      const regex = new RegExp(
-        "^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$"
-      );
-      this.rulePatterns.push({ pattern, regex, rule });
-    }
-  }
-
-  registerRules(rules: Record<string, RateLimitRule>): void {
-    for (const [pattern, rule] of Object.entries(rules)) {
-      this.registerRule(pattern, rule);
-    }
-  }
-
-  getRule(route: string): { pattern: string; rule: RateLimitRule } | undefined {
-    // Exact match first
-    const exact = this.rules.get(route);
-    if (exact && !route.includes("*")) {
-      return { pattern: route, rule: exact };
-    }
-
-    // Pattern match (most specific first - by length)
-    const matches = this.rulePatterns
-      .filter(({ regex }) => regex.test(route))
-      .sort((a, b) => b.pattern.length - a.pattern.length);
-
-    const first = matches[0];
-    if (first) {
-      return { pattern: first.pattern, rule: first.rule };
-    }
-
-    return undefined;
-  }
-
-  matchRoute(route: string): RateLimitRule | undefined {
-    return this.getRule(route)?.rule;
-  }
-
-  listRules(): Array<{ pattern: string; limit: number; window: string | number }> {
-    return Array.from(this.rules.entries()).map(([pattern, rule]) => ({
-      pattern,
-      limit: rule.limit,
-      window: rule.window,
-    }));
-  }
-
-  async checkRoute(
-    route: string,
-    ctx: { ip: string; user?: any }
-  ): Promise<RateLimitResult | null> {
-    const match = this.getRule(route);
-    if (!match) return null;
-
-    const { rule } = match;
-
-    // Check skip condition
-    if (rule.skip?.({ ip: ctx.ip, route, user: ctx.user })) {
-      return null;
-    }
-
-    // Generate key
-    const key = rule.keyFn
-      ? rule.keyFn({ ip: ctx.ip, route, user: ctx.user })
-      : createRateLimitKey(route, ctx.ip);
-
-    // Parse window
-    const windowMs = typeof rule.window === "string"
-      ? parseDuration(rule.window)
-      : rule.window;
-
-    return this.check(key, rule.limit, windowMs);
-  }
-
   async check(key: string, limit: number, windowMs: number): Promise<RateLimitResult> {
     const { count, resetAt } = await this.adapter.increment(key, windowMs);
 
@@ -218,7 +114,18 @@ export function createRateLimiter(config?: RateLimiterConfig): RateLimiter {
   return new RateLimiterImpl(config);
 }
 
+// ==========================================
 // IP Extraction Utilities
+// ==========================================
+
+/**
+ * Priority order for IP detection headers:
+ * 1. CF-Connecting-IP (Cloudflare)
+ * 2. True-Client-IP (Akamai, Cloudflare Enterprise)
+ * 3. X-Real-IP (Nginx)
+ * 4. X-Forwarded-For (first IP in chain)
+ * 5. Request socket address (direct connection)
+ */
 const IP_HEADERS = [
   "cf-connecting-ip",
   "true-client-ip",
@@ -226,7 +133,10 @@ const IP_HEADERS = [
   "x-forwarded-for",
 ] as const;
 
-/** Extract client IP address from request headers (handles Cloudflare, Nginx, etc.) */
+/**
+ * Extract client IP address from request headers
+ * Handles various proxy configurations (Cloudflare, Nginx, etc.)
+ */
 export function extractClientIP(req: Request, socketAddr?: string): string {
   for (const header of IP_HEADERS) {
     const value = req.headers.get(header);
@@ -249,7 +159,9 @@ export function extractClientIP(req: Request, socketAddr?: string): string {
   return "unknown";
 }
 
-/** Basic IP address validation (IPv4 and IPv6) */
+/**
+ * Basic IP address validation (IPv4 and IPv6)
+ */
 function isValidIP(ip: string): boolean {
   // IPv4 pattern
   const ipv4Pattern = /^(\d{1,3}\.){3}\d{1,3}$/;
@@ -271,7 +183,14 @@ function isValidIP(ip: string): boolean {
   return false;
 }
 
-/** Parse duration string to milliseconds (supports: "100ms", "10s", "5m", "1h", "1d") */
+// ==========================================
+// Rate Limit Helper Utilities
+// ==========================================
+
+/**
+ * Parse duration string to milliseconds
+ * Supports: "100ms", "10s", "5m", "1h", "1d"
+ */
 export function parseDuration(duration: string): number {
   const match = duration.match(/^(\d+)(ms|s|m|h|d)$/);
   if (!match || !match[1] || !match[2]) {
@@ -291,7 +210,9 @@ export function parseDuration(duration: string): number {
   }
 }
 
-/** Create a rate limit key for a specific route + IP combination */
+/**
+ * Create a rate limit key for a specific route + IP combination
+ */
 export function createRateLimitKey(route: string, ip: string): string {
   return `ratelimit:${route}:${ip}`;
 }

package/src/core/sse.ts

@@ -1,16 +1,5 @@
 // Core SSE Service
-// Server-Sent Events for server→client push with channel validation
-
-import { z } from "zod";
-
-export interface SSEChannelConfig {
-  /** Event schemas for this channel */
-  events?: Record<string, z.ZodType<any>>;
-  /** If true, channel name is a pattern (e.g., "user:*") */
-  pattern?: boolean;
-  /** Optional description */
-  description?: string;
-}
+// Server-Sent Events for server→client push
 
 export interface SSEClient {
   id: string;
@@ -26,27 +15,14 @@ export interface SSEConfig {
 }
 
 export interface SSE {
-  // Channel registration (strict - channels must be registered)
-  registerChannel(name: string, config?: SSEChannelConfig): void;
-  registerChannels(channels: Record<string, SSEChannelConfig>): void;
-  isChannelRegistered(channel: string): boolean;
-  getChannelConfig(channel: string): SSEChannelConfig | undefined;
-  /** List all registered channel names (including patterns) */
-  listChannels(): string[];
-
-  // Client management
   addClient(options?: { lastEventId?: string }): { client: SSEClient; response: Response };
   removeClient(clientId: string): void;
   getClient(clientId: string): SSEClient | undefined;
   subscribe(clientId: string, channel: string): boolean;
   unsubscribe(clientId: string, channel: string): boolean;
-
-  // Broadcasting (validates against registered channel schemas)
   broadcast(channel: string, event: string, data: any, id?: string): void;
   broadcastAll(event: string, data: any, id?: string): void;
   sendTo(clientId: string, event: string, data: any, id?: string): boolean;
-
-  // Queries
   getClients(): SSEClient[];
   getClientsByChannel(channel: string): SSEClient[];
   shutdown(): void;
@@ -54,8 +30,6 @@ export interface SSE {
 
 class SSEImpl implements SSE {
   private clients = new Map<string, SSEClient>();
-  private channels = new Map<string, SSEChannelConfig>();
-  private channelPatterns: Array<{ pattern: string; regex: RegExp; config: SSEChannelConfig }> = [];
   private heartbeatInterval: number;
   private retryInterval: number;
   private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
@@ -72,48 +46,6 @@ class SSEImpl implements SSE {
     }, this.heartbeatInterval);
   }
 
-  registerChannel(name: string, config: SSEChannelConfig = {}): void {
-    if (config.pattern || name.includes("*")) {
-      const regex = new RegExp(
-        "^" + name.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$"
-      );
-      this.channelPatterns.push({ pattern: name, regex, config });
-    } else {
-      this.channels.set(name, config);
-    }
-  }
-
-  registerChannels(channels: Record<string, SSEChannelConfig>): void {
-    for (const [name, config] of Object.entries(channels)) {
-      this.registerChannel(name, config);
-    }
-  }
-
-  isChannelRegistered(channel: string): boolean {
-    if (this.channels.has(channel)) return true;
-    return this.channelPatterns.some(({ regex }) => regex.test(channel));
-  }
-
-  getChannelConfig(channel: string): SSEChannelConfig | undefined {
-    // Direct match first
-    const direct = this.channels.get(channel);
-    if (direct) return direct;
-
-    // Pattern match (most specific first - by pattern length)
-    const matches = this.channelPatterns
-      .filter(({ regex }) => regex.test(channel))
-      .sort((a, b) => b.pattern.length - a.pattern.length);
-
-    return matches[0]?.config;
-  }
-
-  listChannels(): string[] {
-    return [
-      ...Array.from(this.channels.keys()),
-      ...this.channelPatterns.map(p => p.pattern),
-    ];
-  }
-
   addClient(options: { lastEventId?: string } = {}): { client: SSEClient; response: Response } {
     const id = `sse_${++this.clientCounter}_${Date.now()}`;
 
@@ -184,21 +116,6 @@ class SSEImpl implements SSE {
   }
 
   broadcast(channel: string, event: string, data: any, id?: string): void {
-    // Strict mode: channel must be registered
-    const config = this.getChannelConfig(channel);
-    if (!config) {
-      throw new Error(`SSE channel '${channel}' is not registered. Register it first with sse.registerChannel() or in plugin sseChannels config.`);
-    }
-
-    // Validate event data if schema exists
-    if (config.events?.[event]) {
-      const schema = config.events[event];
-      const result = schema.safeParse(data);
-      if (!result.success) {
-        throw new Error(`SSE event '${event}' on channel '${channel}' validation failed: ${result.error.message}`);
-      }
-    }
-
     for (const client of this.clients.values()) {
       if (client.channels.has(channel)) {
         this.sendEvent(client, event, data, id);

package/src/core.ts

@@ -3,12 +3,11 @@ import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import type { z } from "zod";
 import type { Logger } from "./core/logger";
-export type { Logger } from "./core/logger";
-import type { Cache, NamespacedCache } from "./core/cache";
+import type { Cache } from "./core/cache";
 import type { Events } from "./core/events";
-import type { Cron, CronTaskDefinition } from "./core/cron";
-import type { Jobs, JobDefinition } from "./core/jobs";
-import type { SSE, SSEChannelConfig } from "./core/sse";
+import type { Cron } from "./core/cron";
+import type { Jobs } from "./core/jobs";
+import type { SSE } from "./core/sse";
 import type { RateLimiter } from "./core/rate-limiter";
 import type { Errors, CustomErrorRegistry } from "./core/errors";
 
@@ -81,39 +80,15 @@ export interface GlobalContext {
 }
 
 export class PluginContext<Deps = any, Schema = any, Config = void> {
-  private _logger?: Logger;
-  private _cache?: NamespacedCache;
-
   constructor(
     public readonly core: CoreServices,
     public readonly deps: Deps,
-    public readonly config: Config,
-    public readonly pluginName?: string
+    public readonly config: Config
   ) {}
 
   get db(): Kysely<Schema> {
     return this.core.db as unknown as Kysely<Schema>;
   }
-
-  /** Get a child logger with plugin context */
-  get logger(): Logger {
-    if (!this._logger) {
-      this._logger = this.pluginName
-        ? this.core.logger.child({ plugin: this.pluginName })
-        : this.core.logger;
-    }
-    return this._logger;
-  }
-
-  /** Get a namespaced cache for this plugin */
-  get cache(): NamespacedCache {
-    if (!this._cache) {
-      this._cache = this.pluginName
-        ? this.core.cache.namespace(this.pluginName)
-        : this.core.cache.namespace("default");
-    }
-    return this._cache;
-  }
 }
 
 type UnionToIntersection<U> =
@@ -221,12 +196,6 @@ export class PluginBuilder<LocalSchema = {}> {
         service: Service
       ) => Middleware;
       events?: Events;
-      /** SSE channel configurations with event schemas */
-      sseChannels?: Record<string, SSEChannelConfig>;
-      /** Job definitions with schemas for payload validation */
-      jobs?: Record<string, JobDefinition>;
-      /** Cron task definitions */
-      cronTasks?: Record<string, CronTaskDefinition>;
       client?: ClientConfig;
       customErrors?: CustomErrors;
       service: (
@@ -250,8 +219,6 @@ export class PluginBuilder<LocalSchema = {}> {
     handlers?: Handlers;
     middleware?: (ctx: PluginContext<ExtractServices<Deps>, LocalSchema & ExtractSchemas<Deps>, void>, service: Service) => Middleware;
     events?: Events;
-    jobs?: Record<string, JobDefinition>;
-    cronTasks?: Record<string, CronTaskDefinition>;
     client?: ClientConfig;
     customErrors?: CustomErrors;
   } {
@@ -284,12 +251,6 @@ export class ConfiguredPluginBuilder<LocalSchema, Config> {
         service: Service
       ) => Middleware;
       events?: Events;
-      /** SSE channel configurations with event schemas */
-      sseChannels?: Record<string, SSEChannelConfig>;
-      /** Job definitions with schemas for payload validation */
-      jobs?: Record<string, JobDefinition>;
-      /** Cron task definitions */
-      cronTasks?: Record<string, CronTaskDefinition>;
       client?: ClientConfig;
       customErrors?: CustomErrors;
       service: (
@@ -314,9 +275,6 @@ export class ConfiguredPluginBuilder<LocalSchema, Config> {
     handlers?: Handlers;
     middleware?: (ctx: PluginContext<ExtractServices<Deps>, LocalSchema & ExtractSchemas<Deps>, Config>, service: Service) => Middleware;
     events?: Events;
-    sseChannels?: Record<string, SSEChannelConfig>;
-    jobs?: Record<string, JobDefinition>;
-    cronTasks?: Record<string, CronTaskDefinition>;
     client?: ClientConfig;
     customErrors?: CustomErrors;
   }> {
@@ -346,12 +304,6 @@ export type InferCustomErrors<T> = UnwrapPluginFactory<T> extends { customErrors
 
 export type { ExtractServices, ExtractSchemas };
 
-export interface Migration {
-    name: string;
-    up: (db: Kysely<any>) => Promise<void>;
-    down?: (db: Kysely<any>) => Promise<void>;
-}
-
 export type Plugin = {
     name: string;
     version?: string;
@@ -360,14 +312,6 @@ export type Plugin = {
     /** Middleware function - receives PluginContext and service, returns middleware definitions */
     middleware?: (ctx: any, service: any) => Record<string, any>;
     events?: Record<string, any>;
-    /** SSE channel configurations with event schemas */
-    sseChannels?: Record<string, SSEChannelConfig>;
-    /** Job definitions with schemas for payload validation */
-    jobs?: Record<string, JobDefinition>;
-    /** Cron task definitions */
-    cronTasks?: Record<string, CronTaskDefinition>;
-    /** Inline migrations (alternative to file-based migrations) */
-    migrations?: Migration[];
     client?: ClientConfig;
     customErrors?: CustomErrorRegistry;
     service: (ctx: any) => any;
@@ -410,28 +354,13 @@ export class PluginManager {
   }
 
   async migrate(): Promise<void> {
+    console.log("Running migrations (File-System Based)...");
     const sortedPlugins = this.resolveOrder();
 
     for (const plugin of sortedPlugins) {
         const pluginName = plugin.name;
-
-        // 1. Check for inline migrations (migrations array in plugin definition)
-        if (plugin.migrations && Array.isArray(plugin.migrations) && plugin.migrations.length > 0) {
-          for (const migration of plugin.migrations) {
-            if (migration.up) {
-              try {
-                await migration.up(this.core.db);
-              } catch (e) {
-                console.error(`[${pluginName}] Migration '${migration.name}' failed:`, e);
-              }
-            }
-          }
-          continue; // Skip file-based migrations if inline migrations exist
-        }
-
-        // 2. Fall back to file-based migrations
         const possibleMigrationDirs = [
-          join(process.cwd(), "examples/starter/src/plugins", pluginName, "migrations"),
+          join(process.cwd(), "examples/basic-server/src/plugins", pluginName, "migrations"),
           join(process.cwd(), "src/plugins", pluginName, "migrations"),
           join(process.cwd(), "plugins", pluginName, "migrations"),
         ];
@@ -454,15 +383,19 @@ export class PluginManager {
              const migrationFiles = files.filter(f => f.endsWith(".ts"));
 
              if (migrationFiles.length > 0) {
+                 console.log(`[Migration] checking plugin: ${pluginName} at ${migrationDir}`);
+
                  for (const file of migrationFiles.sort()) {
+                     console.log(`  - Executing migration: ${file}`);
                      const migrationPath = join(migrationDir, file);
                      const migration = await import(migrationPath);
 
                      if (migration.up) {
                          try {
                               await migration.up(this.core.db);
+                              console.log(`    Success`);
                          } catch (e) {
-                             console.error(`[${pluginName}] Migration '${file}' failed:`, e);
+                             console.error(`    Failed to run ${file}:`, e);
                          }
                      }
                  }
@@ -495,30 +428,6 @@ export class PluginManager {
             }
         }
 
-        // Auto-register plugin event schemas
-        if (plugin.events) {
-            this.core.events.registerMany(plugin.events as Record<string, any>);
-            console.log(`[${plugin.name}] Registered ${Object.keys(plugin.events).length} event schemas`);
-        }
-
-        // Auto-register plugin SSE channels
-        if (plugin.sseChannels) {
-            this.core.sse.registerChannels(plugin.sseChannels);
-            console.log(`[${plugin.name}] Registered ${Object.keys(plugin.sseChannels).length} SSE channels`);
-        }
-
-        // Auto-register plugin jobs (with schema validation)
-        if (plugin.jobs) {
-            this.core.jobs.registerJobs(plugin.jobs, plugin.name);
-            console.log(`[${plugin.name}] Registered ${Object.keys(plugin.jobs).length} job handlers`);
-        }
-
-        // Auto-register plugin cron tasks
-        if (plugin.cronTasks) {
-            this.core.cron.registerTasks(plugin.cronTasks, plugin.name);
-            console.log(`[${plugin.name}] Registered ${Object.keys(plugin.cronTasks).length} cron tasks`);
-        }
-
         const pluginDeps: Record<string, unknown> = {};
         if (plugin.dependencies) {
             for (const depName of plugin.dependencies) {
@@ -527,7 +436,7 @@ export class PluginManager {
         }
 
         const pluginConfig = (plugin as ConfiguredPlugin)._boundConfig;
-        const ctx = new PluginContext(this.core, pluginDeps, pluginConfig, plugin.name);
+        const ctx = new PluginContext(this.core, pluginDeps, pluginConfig);
         const service = await plugin.service(ctx);
 
         if (service) {