conduithub 1.0.1 → 1.1.0

package/dist/shared/{conduithub.cvEjE62V.cjs → conduithub.DhMIxMx2.cjs}

@@ -1,38 +1,21 @@
 'use strict';
 
+require('node:fs');
+require('node:fs/promises');
+require('node:path');
+require('./conduithub.BNQsddJO.cjs');
+const schema = require('./conduithub.jH-df3Zd.cjs');
+const core_conduitHub_index = require('../core/conduit-hub/index.cjs');
+require('process');
+require('readline');
+require('uuid');
 const Redis = require('ioredis');
 const core_plugin_index = require('../core/plugin/index.cjs');
-const zod = require('zod');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const Redis__default = /*#__PURE__*/_interopDefaultCompat(Redis);
 
-const redisConfigSchema = zod.z.object({
-  host: zod.z.string().default("localhost"),
-  port: zod.z.number().default(6379),
-  password: zod.z.string().optional(),
-  db: zod.z.number().default(0),
-  username: zod.z.string().optional(),
-  url: zod.z.string().url().optional(),
-  keyPrefix: zod.z.string().optional(),
-  tls: zod.z.object({
-    ca: zod.z.string().optional(),
-    cert: zod.z.string().optional(),
-    key: zod.z.string().optional(),
-    rejectUnauthorized: zod.z.boolean().default(true)
-  }).optional(),
-  connectionTimeout: zod.z.number().default(5e4),
-  commandTimeout: zod.z.number().default(5e4),
-  maxRetriesPerRequest: zod.z.number().default(3),
-  retryDelayOnFailover: zod.z.number().default(100),
-  enableReadyCheck: zod.z.boolean().default(true),
-  enableOfflineQueue: zod.z.boolean().default(true),
-  keepAlive: zod.z.boolean().default(true),
-  lazyConnect: zod.z.boolean().default(false),
-  family: zod.z.enum(["IPv4", "IPv6"]).default("IPv4")
-});
-
 function createNoopRedisClient() {
   return {
     set: async () => "OK",
@@ -106,7 +89,7 @@ class RedisPlugin extends core_plugin_index.BasePlugin {
     }
   }
   constructor(config) {
-    const normalized = redisConfigSchema.parse(config ?? {});
+    const normalized = schema.redisConfigSchema.parse(config ?? {});
     super({
       name: "redis",
       version: "1.0.0",
@@ -121,12 +104,20 @@ class RedisPlugin extends core_plugin_index.BasePlugin {
         if (!options || Object.keys(options).length === 0) {
           return redisClient.set(key, String(value));
         }
-        const setOptions = {};
-        if (options.EX) setOptions.EX = options.EX;
-        if (options.PX) setOptions.PX = options.PX;
-        if (options.NX) setOptions.GET = false;
-        if (options.XX) setOptions.GET = false;
-        return redisClient.set(key, String(value), setOptions);
+        const args = [];
+        if (typeof options.EX === "number") {
+          args.push("EX", options.EX);
+        }
+        if (typeof options.PX === "number") {
+          args.push("PX", options.PX);
+        }
+        if (options.NX) {
+          args.push("NX");
+        }
+        if (options.XX) {
+          args.push("XX");
+        }
+        return redisClient.set(key, String(value), ...args);
       },
       get: (key) => redisClient.get(key),
       del: (key) => Array.isArray(key) ? redisClient.del(...key) : redisClient.del(key),
@@ -177,17 +168,17 @@ class RedisPlugin extends core_plugin_index.BasePlugin {
         retryDelayOnFailover: config.retryDelayOnFailover,
         maxRetriesPerRequest: config.maxRetriesPerRequest,
         connectTimeout: config.connectionTimeout,
-        commandTimeout: config.commandTimeout
+        commandTimeout: config.commandTimeout,
+        lazyConnect: config.lazyConnect ?? (process.env.VITEST === "true" || process.env.NODE_ENV === "test")
       };
       if (config.password) redisOptions.password = config.password;
       if (config.username) redisOptions.username = config.username;
       if (config.keyPrefix) redisOptions.keyPrefix = config.keyPrefix;
       if (config.tls) redisOptions.tls = config.tls;
       const redisClient = new Redis__default(redisOptions);
-      await redisClient.ping();
       this.ioredisClient = redisClient;
       this.redis = this.createRedisWrapper(redisClient);
-      this.logger.log?.("info", "Successfully connected to Redis server");
+      this.logger.log?.("info", "Redis client initialized");
     } catch (error) {
       this.logger.log?.(
         "error",
@@ -772,4 +763,219 @@ class RedisPlugin extends core_plugin_index.BasePlugin {
   }
 }
 
+let hub = null;
+let redisPlugin = null;
+function readRedisConfigFromEnv() {
+  const toNumber = (v) => v !== void 0 && v !== null && v !== "" && !Number.isNaN(Number(v)) ? Number(v) : void 0;
+  const toBoolean = (v) => v === "true" ? true : v === "false" ? false : void 0;
+  const host = process.env.REDIS_HOST;
+  const port = toNumber(process.env.REDIS_PORT);
+  const password = process.env.REDIS_PASSWORD;
+  const db = toNumber(process.env.REDIS_DB);
+  const username = process.env.REDIS_USERNAME;
+  const keyPrefix = process.env.REDIS_KEY_PREFIX;
+  const connectionTimeout = toNumber(process.env.REDIS_CONNECTION_TIMEOUT);
+  const commandTimeout = toNumber(process.env.REDIS_COMMAND_TIMEOUT);
+  const maxRetriesPerRequest = toNumber(
+    process.env.REDIS_MAX_RETRIES_PER_REQUEST
+  );
+  const retryDelayOnFailover = toNumber(
+    process.env.REDIS_RETRY_DELAY_ON_FAILOVER
+  );
+  const enableReadyCheck = toBoolean(process.env.REDIS_ENABLE_READY_CHECK);
+  const enableOfflineQueue = toBoolean(process.env.REDIS_ENABLE_OFFLINE_QUEUE);
+  const keepAlive = toBoolean(process.env.REDIS_KEEP_ALIVE);
+  const lazyConnect = toBoolean(process.env.REDIS_LAZY_CONNECT);
+  const familyEnv = process.env.REDIS_FAMILY;
+  const family = familyEnv === "IPv6" ? "IPv6" : familyEnv === "IPv4" ? "IPv4" : void 0;
+  const tlsCa = process.env.REDIS_TLS_CA;
+  const tlsCert = process.env.REDIS_TLS_CERT;
+  const tlsKey = process.env.REDIS_TLS_KEY;
+  const tlsRejectUnauthorized = toBoolean(
+    process.env.REDIS_TLS_REJECT_UNAUTHORIZED
+  );
+  const cfg = {};
+  if (host) cfg.host = host;
+  if (port !== void 0) cfg.port = port;
+  if (password) cfg.password = password;
+  if (db !== void 0) cfg.db = db;
+  if (username) cfg.username = username;
+  if (keyPrefix) cfg.keyPrefix = keyPrefix;
+  if (connectionTimeout !== void 0)
+    cfg.connectionTimeout = connectionTimeout;
+  if (commandTimeout !== void 0) cfg.commandTimeout = commandTimeout;
+  if (maxRetriesPerRequest !== void 0)
+    cfg.maxRetriesPerRequest = maxRetriesPerRequest;
+  if (retryDelayOnFailover !== void 0)
+    cfg.retryDelayOnFailover = retryDelayOnFailover;
+  if (enableReadyCheck !== void 0) cfg.enableReadyCheck = enableReadyCheck;
+  if (enableOfflineQueue !== void 0)
+    cfg.enableOfflineQueue = enableOfflineQueue;
+  if (keepAlive !== void 0) cfg.keepAlive = keepAlive;
+  if (lazyConnect !== void 0) cfg.lazyConnect = lazyConnect;
+  if (family !== void 0) cfg.family = family;
+  if (tlsCa || tlsCert || tlsKey || tlsRejectUnauthorized !== void 0) {
+    const tls = {
+      rejectUnauthorized: tlsRejectUnauthorized ?? true
+    };
+    if (tlsCa) tls.ca = tlsCa;
+    if (tlsCert) tls.cert = tlsCert;
+    if (tlsKey) tls.key = tlsKey;
+    cfg.tls = tls;
+  }
+  return cfg;
+}
+async function initRedis(override) {
+  if (redisPlugin) return redisPlugin;
+  const cfg = {
+    ...readRedisConfigFromEnv(),
+    ...override ?? {}
+  };
+  if (!hub) hub = core_conduitHub_index.ConduitHub.getInstance();
+  if (!hub.isInitialized) await hub.initialize({});
+  const plugin = new RedisPlugin(cfg);
+  await hub.registerPlugin(plugin);
+  await hub.startPlugin("RedisPlugin");
+  redisPlugin = plugin;
+  return plugin;
+}
+function getRedis() {
+  if (!redisPlugin)
+    throw new Error("RedisPlugin is not initialized. Call initRedis() first.");
+  return redisPlugin;
+}
+async function shutdownRedis() {
+  if (!hub) return;
+  try {
+    if (hub.isInitialized && hub.isPluginRegistered("RedisPlugin")) {
+      if (hub.isPluginRunning("RedisPlugin"))
+        await hub.stopPlugin("RedisPlugin");
+      await hub.unregisterPlugin("RedisPlugin");
+    }
+  } finally {
+    redisPlugin = null;
+  }
+}
+const redis = {
+  init: initRedis,
+  getPlugin: getRedis,
+  shutdown: shutdownRedis,
+  set: async (key, value, options) => {
+    const client = await initRedis();
+    return client.set(key, value, options);
+  },
+  get: async (key) => {
+    const client = await initRedis();
+    return client.get(key);
+  },
+  del: async (key) => {
+    const client = await initRedis();
+    return client.del(key);
+  },
+  exists: async (key) => {
+    const client = await initRedis();
+    return client.exists(key);
+  },
+  expire: async (key, seconds) => {
+    const client = await initRedis();
+    return client.expire(key, seconds);
+  },
+  ttl: async (key) => {
+    const client = await initRedis();
+    return client.ttl(key);
+  },
+  hset: async (key, field, value) => {
+    const client = await initRedis();
+    return client.hset(key, field, value);
+  },
+  hget: async (key, field) => {
+    const client = await initRedis();
+    return client.hget(key, field);
+  },
+  hgetall: async (key) => {
+    const client = await initRedis();
+    return client.hgetall(key);
+  },
+  hdel: async (key, field) => {
+    const client = await initRedis();
+    return client.hdel(key, field);
+  },
+  lpush: async (key, ...elements) => {
+    const client = await initRedis();
+    return client.lpush(key, ...elements);
+  },
+  rpush: async (key, ...elements) => {
+    const client = await initRedis();
+    return client.rpush(key, ...elements);
+  },
+  lpop: async (key) => {
+    const client = await initRedis();
+    return client.lpop(key);
+  },
+  rpop: async (key) => {
+    const client = await initRedis();
+    return client.rpop(key);
+  },
+  llen: async (key) => {
+    const client = await initRedis();
+    return client.llen(key);
+  },
+  lrange: async (key, start, stop) => {
+    const client = await initRedis();
+    return client.lrange(key, start, stop);
+  },
+  sadd: async (key, ...members) => {
+    const client = await initRedis();
+    return client.sadd(key, ...members);
+  },
+  srem: async (key, ...members) => {
+    const client = await initRedis();
+    return client.srem(key, ...members);
+  },
+  smembers: async (key) => {
+    const client = await initRedis();
+    return client.smembers(key);
+  },
+  sismember: async (key, member) => {
+    const client = await initRedis();
+    return client.sismember(key, member);
+  },
+  scard: async (key) => {
+    const client = await initRedis();
+    return client.scard(key);
+  },
+  zadd: async (key, score, member) => {
+    const client = await initRedis();
+    return client.zadd(key, score, member);
+  },
+  zrange: async (key, start, stop) => {
+    const client = await initRedis();
+    return client.zrange(key, start, stop);
+  },
+  ping: async () => {
+    const client = await initRedis();
+    return client.ping();
+  },
+  flushdb: async () => {
+    const client = await initRedis();
+    return client.flushdb();
+  },
+  flushall: async () => {
+    const client = await initRedis();
+    return client.flushall();
+  },
+  getConnectionInfo: async () => {
+    const client = await initRedis();
+    return client.getConnectionInfo();
+  },
+  getStats: async () => {
+    const client = await initRedis();
+    return client.getStats();
+  }
+};
+
 exports.RedisPlugin = RedisPlugin;
+exports.getRedis = getRedis;
+exports.initRedis = initRedis;
+exports.redis = redis;
+exports.shutdownRedis = shutdownRedis;

package/dist/shared/conduithub.GrtzQn_7.d.mts

@@ -0,0 +1,181 @@
+import { z } from 'zod';
+import { Hook, HookResult } from '../core/hook/index.mjs';
+import { a as Logger } from './conduithub.B7aryjPG.mjs';
+import { E as EventBus, a as EventData } from './conduithub.BzLwccre.mjs';
+import { ServiceContainer } from '../core/service-container/index.mjs';
+import { StateManager } from '../core/state-manager/index.mjs';
+
+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 as B, ConfigManager as C, PluginManager as e };
+export type { PluginConfig as P, PluginContext as a, PluginMetadata as b, PluginLifecycle as c, PluginStatus as d };

package/dist/shared/conduithub.jH-df3Zd.cjs

@@ -0,0 +1,181 @@
+'use strict';
+
+const zod = require('zod');
+
+const redisConfigSchema = zod.z.object({
+  host: zod.z.string().default("localhost"),
+  port: zod.z.number().default(6379),
+  password: zod.z.string().optional(),
+  db: zod.z.number().default(0),
+  username: zod.z.string().optional(),
+  url: zod.z.string().url().optional(),
+  keyPrefix: zod.z.string().optional(),
+  tls: zod.z.object({
+    ca: zod.z.string().optional(),
+    cert: zod.z.string().optional(),
+    key: zod.z.string().optional(),
+    rejectUnauthorized: zod.z.boolean().default(true)
+  }).optional(),
+  connectionTimeout: zod.z.number().default(5e4),
+  commandTimeout: zod.z.number().default(5e4),
+  maxRetriesPerRequest: zod.z.number().default(3),
+  retryDelayOnFailover: zod.z.number().default(100),
+  enableReadyCheck: zod.z.boolean().default(true),
+  enableOfflineQueue: zod.z.boolean().default(true),
+  keepAlive: zod.z.boolean().default(true),
+  lazyConnect: zod.z.boolean().default(false),
+  family: zod.z.enum(["IPv4", "IPv6"]).default("IPv4")
+});
+
+const conduithubConfigSchema = zod.z.object({
+  logLevel: zod.z.enum(["debug", "info", "warn", "error"]).default("info"),
+  autoEnable: zod.z.boolean().default(true),
+  strictMode: zod.z.boolean().default(true),
+  enableHotReload: zod.z.boolean().default(false),
+  plugins: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  redis: redisConfigSchema.optional()
+});
+function createConfigSchema(shape) {
+  return zod.z.object(shape);
+}
+function extendConfigSchema(baseSchema, extensions) {
+  return baseSchema.extend(extensions);
+}
+function mergeConfigSchemas(...schemas) {
+  return schemas.reduce(
+    (merged, schema) => merged.extend(schema.shape),
+    zod.z.object({})
+  );
+}
+
+const KafkaPluginConfigSchema = zod.z.object({
+  clientId: zod.z.string().default("conduithub-kafka-client"),
+  brokers: zod.z.array(zod.z.string()).default(["localhost:9092"]),
+  ssl: zod.z.boolean().default(false),
+  sasl: zod.z.object({
+    mechanism: zod.z.enum([
+      "plain",
+      "scram-sha-256",
+      "scram-sha-512",
+      "aws",
+      "oauthbearer"
+    ]),
+    username: zod.z.string().optional(),
+    password: zod.z.string().optional()
+  }).optional(),
+  connectionTimeout: zod.z.number().default(3e3),
+  requestTimeout: zod.z.number().default(3e4),
+  authenticationTimeout: zod.z.number().default(1e3),
+  reauthenticationThreshold: zod.z.number().default(1e4),
+  enforceRequestTimeout: zod.z.boolean().default(true),
+  retry: zod.z.object({
+    initialRetryTime: zod.z.number().default(300),
+    retries: zod.z.number().default(5),
+    maxRetryTime: zod.z.number().default(3e4),
+    factor: zod.z.number().default(2),
+    multiplier: zod.z.number().default(2)
+  }).default(() => ({
+    initialRetryTime: 300,
+    retries: 5,
+    maxRetryTime: 3e4,
+    factor: 2,
+    multiplier: 2
+  })),
+  producer: zod.z.object({
+    allowAutoTopicCreation: zod.z.boolean().default(true),
+    idempotent: zod.z.boolean().default(false),
+    maxInFlightRequests: zod.z.number().default(5),
+    acks: zod.z.union([zod.z.literal(-1), zod.z.literal(0), zod.z.literal(1)]).default(1),
+    compression: zod.z.enum(["none", "gzip", "snappy", "lz4", "zstd"]).default("none"),
+    maxBatchSize: zod.z.number().default(1048576),
+    linger: zod.z.number().default(0),
+    partitioner: zod.z.enum(["random", "murmur2", "murmur2_random", "consistent"]).default("murmur2")
+  }).default({
+    allowAutoTopicCreation: true,
+    idempotent: false,
+    maxInFlightRequests: 5,
+    acks: 1,
+    compression: "none",
+    maxBatchSize: 1048576,
+    linger: 0,
+    partitioner: "murmur2"
+  }),
+  consumer: zod.z.object({
+    groupId: zod.z.string().default("conduithub-kafka-group"),
+    groupInstanceId: zod.z.string().optional(),
+    sessionTimeout: zod.z.number().default(3e4),
+    rebalanceTimeout: zod.z.number().default(6e4),
+    heartbeatInterval: zod.z.number().default(3e3),
+    maxBytesPerPartition: zod.z.number().default(1048576),
+    minBytes: zod.z.number().default(1),
+    maxBytes: zod.z.number().default(10485760),
+    maxWaitTimeInMs: zod.z.number().default(5e3),
+    retryBackoffMs: zod.z.number().default(100),
+    autoCommit: zod.z.boolean().default(true),
+    autoCommitInterval: zod.z.number().default(5e3),
+    autoOffsetReset: zod.z.enum(["earliest", "latest", "none"]).default("latest"),
+    allowAutoTopicCreation: zod.z.boolean().default(true),
+    maxPollRecords: zod.z.number().default(500),
+    maxPollIntervalMs: zod.z.number().default(3e5),
+    readUncommitted: zod.z.boolean().default(false)
+  }).default({
+    groupId: "conduithub-kafka-group",
+    sessionTimeout: 3e4,
+    rebalanceTimeout: 6e4,
+    heartbeatInterval: 3e3,
+    maxBytesPerPartition: 1048576,
+    minBytes: 1,
+    maxBytes: 10485760,
+    maxWaitTimeInMs: 5e3,
+    retryBackoffMs: 100,
+    autoCommit: true,
+    autoCommitInterval: 5e3,
+    autoOffsetReset: "latest",
+    allowAutoTopicCreation: true,
+    maxPollRecords: 500,
+    maxPollIntervalMs: 3e5,
+    readUncommitted: false
+  }),
+  admin: zod.z.object({
+    clientTimeout: zod.z.number().default(3e4),
+    requestTimeout: zod.z.number().default(3e4),
+    retry: zod.z.object({
+      initialRetryTime: zod.z.number().default(300),
+      retries: zod.z.number().default(5),
+      maxRetryTime: zod.z.number().default(3e4),
+      factor: zod.z.number().default(2),
+      multiplier: zod.z.number().default(2)
+    }).default(() => ({
+      initialRetryTime: 300,
+      retries: 5,
+      maxRetryTime: 3e4,
+      factor: 2,
+      multiplier: 2
+    }))
+  }).default(() => ({
+    clientTimeout: 3e4,
+    requestTimeout: 3e4,
+    retry: {
+      initialRetryTime: 300,
+      retries: 5,
+      maxRetryTime: 3e4,
+      factor: 2,
+      multiplier: 2
+    }
+  })),
+  // Logging controls
+  kafkaLogLevel: zod.z.enum(["NOTHING", "ERROR", "WARN", "INFO", "DEBUG"]).default("INFO"),
+  verboseLogging: zod.z.boolean().default(false),
+  redactSensitiveLogs: zod.z.boolean().default(true),
+  topics: zod.z.array(zod.z.string()).default([]),
+  autoCreateTopics: zod.z.boolean().default(true),
+  defaultTopicPartitions: zod.z.number().default(1),
+  defaultTopicReplicationFactor: zod.z.number().default(1)
+});
+
+exports.KafkaPluginConfigSchema = KafkaPluginConfigSchema;
+exports.conduithubConfigSchema = conduithubConfigSchema;
+exports.createConfigSchema = createConfigSchema;
+exports.extendConfigSchema = extendConfigSchema;
+exports.mergeConfigSchemas = mergeConfigSchemas;
+exports.redisConfigSchema = redisConfigSchema;