conduithub 0.1.0 → 1.0.1

package/dist/shared/conduithub.DyQQrHW9.mjs

@@ -0,0 +1,267 @@
+class PluginManager {
+  constructor(eventBus, logger, serviceContainer, stateManager, hookSystem, configManager) {
+    this.eventBus = eventBus;
+    this.logger = logger;
+    this.serviceContainer = serviceContainer;
+    this.stateManager = stateManager;
+    this.hookSystem = hookSystem;
+    this.configManager = configManager;
+  }
+  plugins = /* @__PURE__ */ new Map();
+  pluginStatuses = /* @__PURE__ */ new Map();
+  pluginConfigs = /* @__PURE__ */ new Map();
+  log(level, message, ...args) {
+    const l = this.logger;
+    if (l && typeof l.log === "function") {
+      l.log(level, message, ...args);
+      return;
+    }
+    const anyLogger = l;
+    const fn = anyLogger?.[level];
+    if (typeof fn === "function") fn(message, ...args);
+  }
+  async registerPlugin(plugin, config) {
+    const pluginName = plugin.constructor.name;
+    if (this.plugins.has(pluginName)) {
+      throw new Error(`Plugin ${pluginName} already registered`);
+    }
+    try {
+      const existing = this.pluginConfigs.get(pluginName) ?? await this.configManager.getPluginConfig(pluginName);
+      const metaVersion = plugin.getMetadata().version;
+      const pluginConfig = {
+        name: pluginName,
+        version: config?.version ?? existing?.version ?? metaVersion,
+        enabled: config?.enabled ?? existing?.enabled ?? true,
+        dependencies: config?.dependencies ?? existing?.dependencies ?? [],
+        config: { ...existing?.config ?? {}, ...config?.config ?? {} }
+      };
+      plugin.updateConfig(pluginConfig);
+      this.plugins.set(pluginName, plugin);
+      this.pluginConfigs.set(pluginName, pluginConfig);
+      this.pluginStatuses.set(pluginName, {
+        name: pluginName,
+        version: pluginConfig.version,
+        status: "registered",
+        config: pluginConfig,
+        lastActivity: Date.now()
+      });
+      this.log("info", `Plugin ${pluginName} registered successfully`);
+      await this.hookSystem.executeHook("plugin:registered", {
+        plugin: pluginName,
+        config: pluginConfig
+      });
+      await this.eventBus.emit("plugin:registered", {
+        plugin: pluginName,
+        config: pluginConfig
+      });
+    } catch (error) {
+      this.log("error", `Failed to register plugin ${pluginName}`, error);
+      throw error;
+    }
+  }
+  async unregisterPlugin(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) {
+      throw new Error(`Plugin ${pluginName} is not registered`);
+    }
+    try {
+      if (plugin.isPluginRunning()) {
+        await this.stopPlugin(pluginName);
+      }
+      if (plugin.isPluginInitialized()) {
+        await plugin.destroy();
+      }
+      this.plugins.delete(pluginName);
+      this.pluginConfigs.delete(pluginName);
+      this.pluginStatuses.delete(pluginName);
+      this.log("info", `Plugin ${pluginName} unregistered successfully`);
+      await this.eventBus.emit("plugin:unregistered", {
+        plugin: pluginName
+      });
+      await this.hookSystem.executeHook("plugin:unregistered", {
+        plugin: pluginName
+      });
+    } catch (error) {
+      this.log("error", `Failed to unregister plugin ${pluginName}`, error);
+      throw error;
+    }
+  }
+  async initializePlugin(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) {
+      throw new Error(`Plugin ${pluginName} is not registered`);
+    }
+    const status = this.pluginStatuses.get(pluginName);
+    if (status?.status === "initialized" || status?.status === "running") {
+      return;
+    }
+    try {
+      const context = {
+        eventBus: this.eventBus,
+        logger: this.logger,
+        config: this.pluginConfigs.get(pluginName),
+        serviceContainer: this.serviceContainer,
+        stateManager: this.stateManager,
+        hookSystem: this.hookSystem
+      };
+      await plugin.initialize(context);
+      this.pluginStatuses.set(pluginName, {
+        ...status,
+        status: "initialized",
+        lastActivity: Date.now()
+      });
+      this.log("info", `Plugin ${pluginName} initialized successfully`);
+      await this.eventBus.emit("plugin:initialized", { plugin: pluginName });
+      await this.hookSystem.executeHook("plugin:initialized", {
+        plugin: pluginName
+      });
+    } catch (error) {
+      this.log("error", `Failed to initialize plugin ${pluginName}`, error);
+      throw error;
+    }
+  }
+  async startPlugin(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) {
+      throw new Error(`Plugin ${pluginName} is not registered`);
+    }
+    const status = this.pluginStatuses.get(pluginName);
+    if (status?.status === "running") {
+      return;
+    }
+    try {
+      if (!plugin.isPluginInitialized()) {
+        await this.initializePlugin(pluginName);
+      }
+      await plugin.start();
+      this.pluginStatuses.set(pluginName, {
+        ...status,
+        status: "running",
+        lastActivity: Date.now()
+      });
+      this.log("info", `Plugin ${pluginName} started successfully`);
+      await this.eventBus.emit("plugin:started", { plugin: pluginName });
+      await this.hookSystem.executeHook("plugin:started", {
+        plugin: pluginName
+      });
+    } catch (error) {
+      this.pluginStatuses.set(pluginName, {
+        ...this.pluginStatuses.get(pluginName),
+        status: "error",
+        error: error instanceof Error ? error.message : String(error),
+        lastActivity: Date.now()
+      });
+      this.log("error", `Failed to start plugin ${pluginName}`, error);
+      throw error;
+    }
+  }
+  async stopPlugin(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) {
+      throw new Error(`Plugin ${pluginName} is not registered`);
+    }
+    const status = this.pluginStatuses.get(pluginName);
+    if (status?.status !== "running") {
+      return;
+    }
+    try {
+      await plugin.stop();
+      this.pluginStatuses.set(pluginName, {
+        ...status,
+        status: "stopped",
+        lastActivity: Date.now()
+      });
+      this.log("info", `Plugin ${pluginName} stopped successfully`);
+      await this.eventBus.emit("plugin:stopped", { plugin: pluginName });
+      await this.hookSystem.executeHook("plugin:stopped", {
+        plugin: pluginName
+      });
+    } catch (error) {
+      this.pluginStatuses.set(pluginName, {
+        ...this.pluginStatuses.get(pluginName),
+        status: "error",
+        error: error instanceof Error ? error.message : String(error),
+        lastActivity: Date.now()
+      });
+    }
+  }
+  async shutdownAll() {
+    this.log("info", "Shutting down all plugins...");
+    const shutdownPromises = Array.from(this.plugins.keys()).map(
+      async (pluginName) => {
+        try {
+          await this.unregisterPlugin(pluginName);
+        } catch (error) {
+          this.log("error", `Failed to shutdown plugin ${pluginName}`, error);
+        }
+      }
+    );
+    await Promise.all(shutdownPromises);
+    this.log("info", "All plugins shutdown successfully");
+  }
+  isPluginRegistered(pluginName) {
+    return this.plugins.has(pluginName);
+  }
+  isPluginRunning(pluginName) {
+    const status = this.pluginStatuses.get(pluginName);
+    return status?.status === "running";
+  }
+  getPluginStatus(pluginName) {
+    return this.pluginStatuses.get(pluginName);
+  }
+  listPlugins() {
+    return Array.from(this.plugins.keys());
+  }
+  getAllPluginStatuses() {
+    return Array.from(this.pluginStatuses.values());
+  }
+  getPlugin(pluginName) {
+    return this.plugins.get(pluginName);
+  }
+  getPluginConfig(pluginName) {
+    return this.pluginConfigs.get(pluginName);
+  }
+  async updatePluginConfig(pluginName, config) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) {
+      throw new Error(`Plugin ${pluginName} is not registered`);
+    }
+    try {
+      const currentConfig = this.pluginConfigs.get(pluginName);
+      if (!currentConfig) {
+        throw new Error(`Plugin config not found for ${pluginName}`);
+      }
+      const newConfig = {
+        name: currentConfig.name,
+        version: config?.version ?? currentConfig.version,
+        enabled: config?.enabled ?? currentConfig.enabled,
+        dependencies: config?.dependencies ?? currentConfig.dependencies ?? [],
+        config: { ...currentConfig.config ?? {}, ...config?.config ?? {} }
+      };
+      this.pluginConfigs.set(pluginName, newConfig);
+      plugin.updateConfig(newConfig);
+      const status = this.pluginStatuses.get(pluginName);
+      if (status) {
+        this.pluginStatuses.set(pluginName, {
+          ...status,
+          config: newConfig,
+          lastActivity: Date.now()
+        });
+      }
+      this.log("info", `Plugin ${pluginName} config updated successfully`);
+      await this.eventBus.emit("plugin:configUpdated", {
+        plugin: pluginName,
+        config: newConfig
+      });
+      await this.hookSystem.executeHook("plugin:configUpdated", {
+        plugin: pluginName,
+        config: newConfig
+      });
+    } catch (error) {
+      this.log("error", `Failed to update plugin ${pluginName} config`, error);
+      throw error;
+    }
+  }
+}
+
+export { PluginManager as P };

package/dist/shared/conduithub.G7ICpZIy.mjs

@@ -0,0 +1,36 @@
+const ERROR_CODE = {
+  // Configuration errors
+  INVALID_JSON: "Invalid JSON format",
+  INVALID_CONFIG: "Configuration validation failed",
+  UNSUPPORTED_CONFIG_FORMAT: "JavaScript config files are not supported. Use JSON format.",
+  // Initialization errors
+  STATE_MANAGER_NOT_INITIALIZED: "StateManager is not initialized",
+  SERVICE_CONTAINER_NOT_INITIALIZED: "Service Container is not initialized",
+  EVENT_BUS_NOT_INITIALIZED: "EventBus is not initialized",
+  HOOK_SYSTEM_NOT_INITIALIZED: "Hook system is not initialized",
+  // Handler limit errors
+  EVENT_HANDLER_LIMIT_EXCEEDED: "Handler limit exceeded for event",
+  HOOK_HANDLER_LIMIT_EXCEEDED: "Handler limit exceeded for hook",
+  // Duplicate ID errors
+  DUPLICATE_EVENT_HANDLER_ID: "Duplicate custom ID for event",
+  DUPLICATE_HOOK_HANDLER_ID: "Duplicate custom ID for hook",
+  // State management errors
+  INVALID_STATE_JSON_FORMAT: "Invalid state JSON format",
+  // Execution errors
+  HOOK_EXECUTION_FAILED: "Hook execution failed",
+  UNKNOWN_ERROR: "Unknown error",
+  // Service container errors
+  CIRCULAR_DEPENDENCY_DETECTED: "Circular dependency detected",
+  SERVICE_NOT_FOUND: "Service not found",
+  SERVICE_CREATION_FAILED: "Service creation failed",
+  SERVICE_IS_SINGLETON: "Service is a singleton and cannot be registered again",
+  // Plugin errors
+  PLUGIN_NOT_INITIALIZED: "Plugin is not initialized",
+  PLUGIN_ALREADY_INITIALIZED: "Plugin is already initialized",
+  PLUGIN_NOT_RUNNING: "Plugin is not running",
+  // ConfigManager errors
+  CONFIG_MANAGER_NOT_INITIALIZED: "ConfigManager is not initialized",
+  CONFIG_MANAGER_ALREADY_INITIALIZED: "ConfigManager is already initialized"
+};
+
+export { ERROR_CODE as E };

package/dist/shared/conduithub.Up0QYVao.mjs

@@ -0,0 +1,59 @@
+import { stdout, stdin } from 'process';
+import * as readline from 'readline';
+import { setPkgManager, MissingDependencyError } from '../error/index.mjs';
+import { c as createLogger } from './conduithub.BNefRQsK.mjs';
+import 'uuid';
+
+class PackageManagerUtil {
+  logger = createLogger();
+  /**
+   * Prompts the user to select their package manager and saves the choice.
+   * This is a standalone utility that can be used anywhere in your app.
+   *
+   * @returns Promise that resolves with the selected package manager
+   * @throws MissingDependencyError if there's an issue with the selection process
+   */
+  async promptAndSetPackageManager() {
+    try {
+      const rl = readline.createInterface({ input: stdin, output: stdout });
+      const manager = await new Promise((resolve) => {
+        rl.question(
+          "Which package manager are you using? (npm/pnpm/yarn): ",
+          (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase());
+          }
+        );
+      });
+      const validManagers = ["npm", "pnpm", "yarn"];
+      if (!validManagers.includes(manager)) {
+        throw new Error(
+          `Invalid package manager: ${manager}. Supported: ${validManagers.join(", ")}`
+        );
+      }
+      setPkgManager(manager);
+      this.logger.info(`Package manager set to: ${manager}`);
+      return manager;
+    } catch (err) {
+      this.logger.error(
+        `Package manager setup failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      throw new MissingDependencyError("package-manager");
+    }
+  }
+  /**
+   * Creates a handler function that can be used with Hook or EventBus systems.
+   * This allows you to integrate package manager setup into your event/hook workflows
+   * without duplicating the logic.
+   *
+   * @returns A handler function that sets up the package manager
+   */
+  createHandler() {
+    return async () => {
+      await this.promptAndSetPackageManager();
+    };
+  }
+}
+const packageManagerUtil = new PackageManagerUtil();
+
+export { PackageManagerUtil as P, packageManagerUtil as p };

package/dist/shared/conduithub.alPiaJax.mjs

@@ -0,0 +1,29 @@
+const ISO8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
+function parseJson(data) {
+  try {
+    return JSON.parse(data, dateReviver);
+  } catch {
+    return null;
+  }
+}
+function stringifyJson(value, replacer, space) {
+  return JSON.stringify(value, replacer, space);
+}
+function safeStringifyJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "[Circular or Non-Serializable Object]";
+  }
+}
+function dateReviver(_, value) {
+  if (typeof value === "string" && ISO8601_REGEX.test(value)) {
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) {
+      return date;
+    }
+  }
+  return value;
+}
+
+export { safeStringifyJson as a, parseJson as p, stringifyJson as s };