conduithub 0.0.3 → 1.0.0

package/dist/core/hook/index.mjs

@@ -1,4 +1,9 @@
-import { c as createLogger, g as generateUuid } from '../../shared/conduithub.74V0wiLi.mjs';
+import { C as ConduithubError } from '../../shared/conduithub.BDwZXllF.mjs';
+import { c as createLogger } from '../../shared/conduithub.BNefRQsK.mjs';
+import 'process';
+import 'readline';
+import { g as generateUuid } from '../../shared/conduithub.CkOQG3cD.mjs';
+import { E as ERROR_CODE } from '../../shared/conduithub.G7ICpZIy.mjs';
 import 'uuid';
 
 class Hook {
@@ -7,80 +12,136 @@ class Hook {
   logger;
   failFast;
   onError;
+  maxHandlersPerHook;
+  defaultTimeoutMs;
+  lock = Promise.resolve();
   constructor(options, logger) {
     this.failFast = options?.failFast ?? false;
     this.onError = options?.onError;
+    this.maxHandlersPerHook = options?.maxHandlersPerHook ?? 100;
+    this.defaultTimeoutMs = options?.defaultTimeoutMs ?? 5e3;
     this.logger = logger ?? createLogger({ name: "Hook" });
   }
-  ensure() {
-    if (!this.initialized) throw new Error("Hook system is not initialized");
+  async withLock(operation) {
+    const currentLock = this.lock;
+    let resolveLock;
+    this.lock = new Promise((resolve) => {
+      resolveLock = resolve;
+    });
+    await currentLock;
+    try {
+      return await operation();
+    } finally {
+      resolveLock();
+    }
   }
-  async initialize() {
+  ensureInitialized() {
     if (!this.initialized) {
+      throw new ConduithubError(ERROR_CODE.HOOK_SYSTEM_NOT_INITIALIZED);
+    }
+  }
+  sanitizeLog(data) {
+    if (typeof data === "string") {
+      return data.length > 100 ? `${data.substring(0, 100)}...` : data;
+    }
+    if (typeof data === "object" && data !== null) {
+      return "[Object]";
+    }
+    return String(data);
+  }
+  async initialize() {
+    return this.withLock(async () => {
+      if (this.initialized) return;
       this.initialized = true;
       this.logger.success("Hook system initialized successfully");
-    }
+    });
   }
   async shutdown() {
-    this.ensure();
-    const hookCount = Array.from(this.hooks.values()).reduce(
+    return this.withLock(async () => {
+      this.ensureInitialized();
+      const hookCount = this.getTotalHandlerCount();
+      this.hooks.clear();
+      this.initialized = false;
+      this.logger.success(
+        `Hook system shutdown completed - cleared ${hookCount} handlers`
+      );
+    });
+  }
+  getTotalHandlerCount() {
+    return Array.from(this.hooks.values()).reduce(
       (total, handlers) => total + handlers.length,
       0
     );
-    this.hooks.clear();
-    this.initialized = false;
-    this.logger.success(
-      `Hook system shutdown completed - cleared ${hookCount} handlers`
-    );
   }
-  registerHook(hook, handler, priority = 0, customId) {
-    this.ensure();
-    if (!this.hooks.has(hook)) this.hooks.set(hook, []);
-    const id = customId ?? generateUuid();
-    const entry = {
-      id,
-      hook: String(hook),
-      handler,
-      priority
-    };
-    this.hooks.get(hook).push(entry);
-    this.hooks.get(hook).sort((a, b) => b.priority - a.priority);
-    const handlerCount = this.hooks.get(hook).length;
-    this.logger.debug(
-      `Hook registered: '${String(hook)}' \u2192 ${id} (priority: ${priority}, total handlers: ${handlerCount})`
-    );
-    return id;
+  async registerHook(hook, handler, priority = 0, customId) {
+    return this.withLock(async () => {
+      this.ensureInitialized();
+      if (!this.hooks.has(hook)) this.hooks.set(hook, []);
+      const handlers = this.hooks.get(hook);
+      if (handlers.length >= this.maxHandlersPerHook) {
+        throw new ConduithubError(
+          `${ERROR_CODE.HOOK_HANDLER_LIMIT_EXCEEDED} ${String(hook)} (${this.maxHandlersPerHook})`
+        );
+      }
+      const id = customId ?? generateUuid();
+      if (customId && handlers.some((h) => h.id === customId)) {
+        throw new ConduithubError(
+          `${ERROR_CODE.DUPLICATE_HOOK_HANDLER_ID} ${String(hook)}: ${customId}`
+        );
+      }
+      const entry = {
+        id,
+        hook: String(hook),
+        handler,
+        priority
+      };
+      handlers.push(entry);
+      this.logger.debug(
+        `Hook registered: '${String(hook)}' \u2192 ${id} (priority: ${priority}, total handlers: ${handlers.length})`
+      );
+      return id;
+    });
   }
-  unregisterHook(hook, id) {
-    this.ensure();
-    const list = this.hooks.get(hook);
-    if (!list) {
+  async unregisterHook(hook, id) {
+    return this.withLock(async () => {
+      this.ensureInitialized();
+      const list = this.hooks.get(hook);
+      if (!list) {
+        this.logger.warn(
+          `Failed to unregister hook: '${String(hook)}' \u2192 ${id} (hook not found)`
+        );
+        return false;
+      }
+      const index = list.findIndex((h) => h.id === id);
+      if (index >= 0) {
+        list.splice(index, 1);
+        const remainingCount = list.length;
+        if (remainingCount === 0) this.hooks.delete(hook);
+        this.logger.debug(
+          `Hook unregistered: '${String(hook)}' \u2192 ${id} (remaining handlers: ${remainingCount})`
+        );
+        return true;
+      }
       this.logger.warn(
         `Failed to unregister hook: '${String(hook)}' \u2192 ${id} (handler not found)`
       );
       return false;
-    }
-    const index = list.findIndex((h) => h.id === id);
-    if (index >= 0) {
-      list.splice(index, 1);
-      const remainingCount = list.length;
-      if (remainingCount === 0) this.hooks.delete(hook);
-      this.logger.debug(
-        `Hook unregistered: '${String(hook)}' \u2192 ${id} (remaining handlers: ${remainingCount})`
-      );
-      return true;
-    }
-    this.logger.warn(
-      `Failed to unregister hook: '${String(hook)}' \u2192 ${id} (handler not found)`
-    );
-    return false;
+    });
   }
-  async handleHookResult(raw, failFast, hook, handlerId) {
+  async handleHookResult(raw, failFast, hook, handlerId, timeoutMs = this.defaultTimeoutMs) {
     try {
-      const result = await raw;
+      const result = await Promise.race([
+        Promise.resolve(raw),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Handler timeout")), timeoutMs)
+        )
+      ]);
       if (typeof result === "object" && result && "success" in result) {
         const res = result;
-        if (!res.success && failFast) throw new Error(res.error);
+        if (!res.success && failFast)
+          throw new ConduithubError(
+            res.error ?? ERROR_CODE.HOOK_EXECUTION_FAILED
+          );
         this.logger.debug(
           `Hook handler completed: '${String(hook)}' \u2192 ${handlerId} (success: ${res.success})`
         );
@@ -94,114 +155,90 @@ class Hook {
       if (failFast) throw err;
       const errorMessage = err instanceof Error ? err.message : String(err);
       this.logger.error(
-        `Hook handler failed: '${String(hook)}' \u2192 ${handlerId} - ${errorMessage}`
+        `Hook handler failed: '${String(hook)}' \u2192 ${handlerId} - ${this.sanitizeLog(errorMessage)}`
       );
       this.onError?.(err, hook);
-      return {
-        success: false,
-        error: errorMessage
-      };
+      return { success: false, error: errorMessage };
     }
   }
-  async executeHook(hook, data) {
-    this.ensure();
-    const list = this.hooks.get(hook);
-    if (!list?.length) {
+  async executeHook(hook, data, context) {
+    return this.withLock(async () => {
+      this.ensureInitialized();
+      const list = this.hooks.get(hook);
+      if (!list?.length) {
+        this.logger.debug(
+          `Hook execution skipped: '${String(hook)}' (no handlers registered)`
+        );
+        return data;
+      }
+      list.sort((a, b) => b.priority - a.priority);
       this.logger.debug(
-        `Hook execution skipped: '${String(hook)}' (no handlers registered)`
-      );
-      return data;
-    }
-    this.logger.debug(
-      `Hook execution started: '${String(hook)}' (${list.length} handlers)`
-    );
-    let result = data;
-    let successCount = 0;
-    let errorCount = 0;
-    for (const { handler, id } of list) {
-      const {
-        success,
-        data: output,
-        error
-      } = await this.handleHookResult(
-        Promise.resolve().then(() => handler(result)),
-        this.failFast,
-        hook,
-        id
+        `Hook execution started: '${String(hook)}' (${list.length} handlers)`
       );
-      if (success) {
-        successCount++;
-        if (output !== void 0) result = output;
-      } else {
-        errorCount++;
-        if (this.failFast) throw new Error(error);
+      let result = data;
+      let successCount = 0;
+      let errorCount = 0;
+      for (const { handler, id } of list) {
+        const {
+          success,
+          data: output,
+          error
+        } = await this.handleHookResult(
+          Promise.resolve().then(() => handler(result, context)),
+          this.failFast,
+          hook,
+          id
+        );
+        if (success) {
+          successCount++;
+          if (output !== void 0) result = output;
+        } else {
+          errorCount++;
+          if (this.failFast)
+            throw new ConduithubError(error ?? ERROR_CODE.UNKNOWN_ERROR);
+        }
       }
-    }
-    this.logger.debug(
-      `Hook execution completed: '${String(hook)}' (${successCount} succeeded, ${errorCount} failed)`
-    );
-    return result;
-  }
-  async executeHookSeries(hook, data) {
-    this.ensure();
-    const list = this.hooks.get(hook);
-    if (!list?.length) {
       this.logger.debug(
-        `Hook series execution skipped: '${String(hook)}' (no handlers registered)`
-      );
-      return [];
-    }
-    this.logger.debug(
-      `Hook series execution started: '${String(hook)}' (${list.length} handlers)`
-    );
-    const results = [];
-    for (const { handler, id } of list) {
-      const result = await this.handleHookResult(
-        Promise.resolve().then(() => handler(data)),
-        false,
-        // Never fail fast in series execution, just collect results
-        hook,
-        id
+        `Hook execution completed: '${String(hook)}' (${successCount} succeeded, ${errorCount} failed)`
       );
-      results.push(result);
-      if (!result.success && this.failFast) break;
-    }
-    const successCount = results.filter((r) => r.success).length;
-    const errorCount = results.filter((r) => !r.success).length;
-    this.logger.debug(
-      `Hook series execution completed: '${String(hook)}' (${successCount} succeeded, ${errorCount} failed)`
-    );
-    return results;
+      return result;
+    });
   }
-  async executeHookSeriesWithContext(hook, data, context) {
-    this.ensure();
-    const handlers = this.hooks.get(hook);
-    if (!handlers || handlers.length === 0) {
+  async executeHookSeries(hook, data, context) {
+    return this.withLock(async () => {
+      this.ensureInitialized();
+      const list = this.hooks.get(hook);
+      if (!list?.length) {
+        this.logger.debug(
+          `Hook series execution skipped: '${String(hook)}' (no handlers registered)`
+        );
+        return [];
+      }
+      list.sort((a, b) => b.priority - a.priority);
       this.logger.debug(
-        `Hook series execution skipped: '${String(hook)}' (no handlers registered)`
+        `Hook series execution started: '${String(hook)}' (${list.length} handlers)`
       );
-      return [];
-    }
-    this.logger.debug(
-      `Hook series execution started: '${String(hook)}' (${handlers.length} handlers)`
-    );
-    const results = [];
-    for (const { handler, id } of handlers) {
-      const result = await this.handleHookResult(
-        Promise.resolve().then(() => handler(data)),
-        this.failFast,
-        hook,
-        id
+      const results = [];
+      for (const { handler, id } of list) {
+        const result = await this.handleHookResult(
+          Promise.resolve().then(() => handler(data, context)),
+          false,
+          hook,
+          id
+        );
+        results.push(result);
+        if (!result.success && this.failFast) break;
+      }
+      const successCount = results.filter((r) => r.success).length;
+      const errorCount = results.length - successCount;
+      this.logger.debug(
+        `Hook series execution completed: '${String(hook)}' (${successCount} succeeded, ${errorCount} failed)`
       );
-      results.push(result);
-      if (!result.success && this.failFast) break;
-    }
-    const successCount = results.filter((r) => r.success).length;
-    const errorCount = results.filter((r) => !r.success).length;
-    this.logger.debug(
-      `Hook series execution completed: '${String(hook)}' (${successCount} succeeded, ${errorCount} failed)`
-    );
-    return results;
+      return results;
+    });
+  }
+  async executeHookSeriesWithContext(hook, data, context) {
+    return this.executeHookSeries(hook, data, context);
   }
 }
 

package/dist/core/index.cjs

@@ -1,11 +1,27 @@
 'use strict';
 
+const core_configManager_index = require('./config-manager/index.cjs');
 const core_eventBus_index = require('./event-bus/index.cjs');
 const core_hook_index = require('./hook/index.cjs');
-require('../shared/conduithub.CvMLTa-R.cjs');
+const core_plugin_index = require('./plugin/index.cjs');
+const core_serviceContainer_index = require('./service-container/index.cjs');
+const core_stateManager_index = require('./state-manager/index.cjs');
+const manager = require('../shared/conduithub.DsOOeNwU.cjs');
+require('../shared/conduithub.CmZo_Vuc.cjs');
+require('../shared/conduithub.DQO1dRnn.cjs');
+require('../shared/conduithub.BNQsddJO.cjs');
+require('process');
+require('readline');
 require('uuid');
+require('../shared/conduithub.BqUYv04j.cjs');
+require('../shared/conduithub.Bq_7Xj0J.cjs');
 
 
 
+exports.ConfigManager = core_configManager_index.ConfigManager;
 exports.EventBus = core_eventBus_index.EventBus;
 exports.Hook = core_hook_index.Hook;
+exports.BasePlugin = core_plugin_index.BasePlugin;
+exports.ServiceContainer = core_serviceContainer_index.ServiceContainer;
+exports.StateManager = core_stateManager_index.StateManager;
+exports.PluginManager = manager.PluginManager;

package/dist/core/index.d.cts

@@ -1,3 +1,184 @@
-export { EventBus, EventData, EventHandlerRecord } from './event-bus/index.cjs';
-export { Hook, HookHandler, HookResult } from './hook/index.cjs';
-import '../shared/conduithub.B7aryjPG.cjs';
+import { z } from 'zod';
+import { Hook, HookResult } from './hook/index.cjs';
+export { HookHandler } from './hook/index.cjs';
+import { a as Logger } from '../shared/conduithub.B7aryjPG.cjs';
+import { E as EventBus, a as EventData } from '../shared/conduithub.BZQmkQy7.cjs';
+import { ServiceContainer } from './service-container/index.cjs';
+export { ServiceDescriptor } from './service-container/index.cjs';
+import { StateManager } from './state-manager/index.cjs';
+export { StateChangeHandler } from './state-manager/index.cjs';
+
+interface PluginStatus {
+    name: string;
+    version: string;
+    status: "registered" | "initialized" | "running" | "stopped" | "destroyed" | "error";
+    config: PluginConfig;
+    error?: string;
+    lastActivity: number;
+}
+declare class PluginManager {
+    private eventBus;
+    private logger;
+    private serviceContainer;
+    private stateManager;
+    private hookSystem;
+    private configManager;
+    private plugins;
+    private pluginStatuses;
+    private pluginConfigs;
+    constructor(eventBus: EventBus<Record<string, unknown>>, logger: Logger, serviceContainer: ServiceContainer, stateManager: StateManager, hookSystem: Hook<Record<string, {
+        input: unknown;
+        output: unknown;
+    }>>, configManager: ConfigManager);
+    private log;
+    registerPlugin(plugin: BasePlugin, config?: PluginConfig): Promise<void>;
+    unregisterPlugin(pluginName: string): Promise<void>;
+    initializePlugin(pluginName: string): Promise<void>;
+    startPlugin(pluginName: string): Promise<void>;
+    stopPlugin(pluginName: string): Promise<void>;
+    shutdownAll(): Promise<void>;
+    isPluginRegistered(pluginName: string): boolean;
+    isPluginRunning(pluginName: string): boolean;
+    getPluginStatus(pluginName: string): PluginStatus | undefined;
+    listPlugins(): string[];
+    getAllPluginStatuses(): PluginStatus[];
+    getPlugin(pluginName: string): BasePlugin | undefined;
+    getPluginConfig(pluginName: string): PluginConfig | undefined;
+    updatePluginConfig(pluginName: string, config: Partial<PluginConfig>): Promise<void>;
+}
+
+interface PluginConfig {
+    name: string;
+    version: string;
+    enabled: boolean;
+    dependencies?: string[];
+    config?: Record<string, unknown>;
+}
+interface PluginContext<EM extends Record<string, unknown> = Record<string, unknown>, HM extends Record<string, {
+    input: unknown;
+    output: unknown;
+}> = Record<string, {
+    input: unknown;
+    output: unknown;
+}>> {
+    eventBus: EventBus<EM>;
+    logger: Logger;
+    config: PluginConfig;
+    serviceContainer: ServiceContainer;
+    hookSystem: Hook<HM>;
+    stateManager: StateManager;
+}
+interface PluginMetadata {
+    name: string;
+    version: string;
+    description?: string;
+    author?: string;
+    dependencies?: string[];
+    hooks: string[];
+    events: string[];
+}
+type PluginLifecycle = "beforeInit" | "afterInit" | "beforeStart" | "afterStart" | "beforeStop" | "afterStop" | "beforeDestroy" | "afterDestroy";
+declare abstract class BasePlugin<T extends Record<string, unknown> = Record<string, unknown>, EM extends Record<string, unknown> = Record<string, unknown>, HM extends Record<string, {
+    input: unknown;
+    output: unknown;
+}> = Record<string, {
+    input: unknown;
+    output: unknown;
+}>> {
+    protected config: PluginConfig & {
+        config: T;
+    };
+    protected context: PluginContext<EM, HM>;
+    protected metadata: PluginMetadata;
+    protected isInitialized: boolean;
+    protected isRunning: boolean;
+    private managedEventHandlers;
+    private managedHookHandlers;
+    private lock;
+    constructor(config: PluginConfig & {
+        config: T;
+    });
+    abstract getMetadata(): PluginMetadata;
+    initialize(context: PluginContext<EM, HM>): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    destroy(): Promise<void>;
+    protected abstract onInitialize(): Promise<void>;
+    protected abstract onStart(): Promise<void>;
+    protected abstract onStop(): Promise<void>;
+    protected abstract onDestroy(): Promise<void>;
+    private executeLifecycleHook;
+    getConfig(): PluginConfig & {
+        config: T;
+    };
+    getContext(): PluginContext<EM, HM>;
+    isPluginInitialized(): boolean;
+    isPluginRunning(): boolean;
+    protected emit<K extends keyof EM>(event: K, data: EM[K]): Promise<void>;
+    protected on<K extends keyof EM>(event: K, listener: (payload: EM[K], event: EventData<K & string, EM[K]>) => Promise<void> | void): string;
+    protected once<K extends keyof EM>(event: K, listener: (payload: EM[K], event: EventData<K & string, EM[K]>) => Promise<void> | void): string;
+    protected onManaged<K extends keyof EM>(event: K, listener: (payload: EM[K], event: EventData<K & string, EM[K]>) => Promise<void> | void): string;
+    protected onceManaged<K extends keyof EM>(event: K, listener: (payload: EM[K], event: EventData<K & string, EM[K]>) => Promise<void> | void): string;
+    protected off<K extends keyof EM>(event: K, handlerId: string): void;
+    protected executeHook<K extends keyof HM>(hook: K, input: HM[K]["input"]): Promise<HM[K]["output"]>;
+    protected executeHookSeries<K extends keyof HM>(hook: K, input: HM[K]["input"]): Promise<HookResult<HM[K]["output"]>[]>;
+    protected executeHookSeriesWithContext<K extends keyof HM>(hook: K, input: HM[K]["input"], context: Record<string, unknown>): Promise<HookResult<HM[K]["output"]>[]>;
+    protected registerHook<K extends keyof HM>(hook: K, handler: (data: HM[K]["input"], context?: Record<string, unknown>) => HM[K]["output"] | Promise<HM[K]["output"]> | HookResult<HM[K]["output"]> | Promise<HookResult<HM[K]["output"]>>, priority?: number, customId?: string): Promise<string>;
+    protected registerHookManaged<K extends keyof HM>(hook: K, handler: (data: HM[K]["input"], context?: Record<string, unknown>) => HM[K]["output"] | Promise<HM[K]["output"]> | HookResult<HM[K]["output"]> | Promise<HookResult<HM[K]["output"]>>, priority?: number, customId?: string): Promise<string>;
+    protected unregisterHook<K extends keyof HM>(hook: K, handlerId: string): Promise<boolean>;
+    protected getStatus(): {
+        initialized: boolean;
+        running: boolean;
+    };
+    protected getName(): string;
+    protected getVersion(): string;
+    protected isEnabled(): boolean;
+    protected getState(key: string): unknown;
+    protected setState(key: string, value: unknown): void;
+    protected deleteState(key: string): void;
+    protected get logger(): Logger;
+    updateConfig(update: Partial<PluginConfig & {
+        config: T;
+    }>): void;
+    private cleanupManagedHandlers;
+    private cleanupManagedHooks;
+    private withLock;
+}
+
+declare class ConfigManager {
+    private config;
+    private pluginConfigs;
+    private isInitialized;
+    initialize(config: Record<string, unknown>): Promise<void>;
+    shutdown(): Promise<void>;
+    get<T>(key: string, defaultValue?: T): T | undefined;
+    set<T>(key: string, value: T): void;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    loadConfig(config: Record<string, unknown>): void;
+    clearConfig(): void;
+    getPluginConfig(pluginName: string): PluginConfig | undefined;
+    setPluginConfig(pluginName: string, config: PluginConfig): void;
+    updatePluginConfig(pluginName: string, updates: Partial<PluginConfig>): void;
+    hasPluginConfig(pluginName: string): boolean;
+    deletePluginConfig(pluginName: string): boolean;
+    getAllPluginConfigs(): Record<string, PluginConfig>;
+    loadPluginConfigs(configs: Record<string, PluginConfig>): void;
+    validateConfig(schema: z.ZodTypeAny, config: unknown): {
+        valid: boolean;
+        errors: string[];
+    };
+    exportConfig(format?: "json"): string;
+    importConfig(configJson: string): void;
+    getPluginConfigNames(): string[];
+    getStats(): {
+        totalConfigKeys: number;
+        totalPluginConfigs: number;
+        configKeys: string[];
+        pluginConfigNames: string[];
+    };
+    watchConfig(key: string, callback: (value: unknown) => void): () => void;
+}
+
+export { BasePlugin, ConfigManager, EventBus, Hook, HookResult, PluginManager, ServiceContainer, StateManager };
+export type { PluginConfig, PluginContext, PluginLifecycle, PluginMetadata, PluginStatus };