akeyless-server-commons 1.0.191 → 1.0.192

package/dist/helpers/global_helpers.js

@@ -1,147 +0,0 @@
-import { readFileSync } from "fs";
-import { cache_manager, logger } from "../managers";
-import { LanguageOptions } from "akeyless-types-commons";
-import axios from "axios";
-import https from "https";
-export const init_env_variables = (required_vars = []) => {
-    required_vars.forEach((varName) => {
-        const env_val = process.env[varName];
-        if (!env_val) {
-            logger.error(`--- Error: Missing mandatory environment variable: ${varName}. ---`);
-            process.exit(1);
-        }
-    });
-    const env_vars = {};
-    Object.keys(process.env).forEach((var_name) => {
-        const env_val = process.env[var_name];
-        env_vars[var_name] = env_val;
-    });
-    return env_vars;
-};
-export const json_ok = (data) => {
-    return {
-        success: true,
-        data,
-    };
-};
-export const json_failed = (error, msg) => {
-    return {
-        success: false,
-        error: error.message || error || "general error: something happened ",
-        msg: msg,
-    };
-};
-export const parse_error = (error) => {
-    return error instanceof Error ? { name: error.name, message: error.message } : error;
-};
-export const get_version = (packageJsonPath) => {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-    return packageJson.version;
-};
-export const sleep = (ms = 2500) => new Promise((resolve) => setTimeout(resolve, ms));
-const BASE_URLS = {
-    local: {
-        bi: "http://localhost:9002/api/bi",
-        call_center: "http://localhost:9003/api/call-center",
-        dashboard: "http://localhost",
-        devices: "http://localhost:9001/api/devices",
-        end_users: "http://10.100.102.9:9011/api/end-users",
-        notifications: "http://localhost:9006/api/notifications",
-        installer: "http://localhost",
-        ox_server: "http://localhost",
-        toolbox: "http://localhost",
-    },
-    prod: {
-        bi: "https://nx-api.info/api/bi",
-        call_center: "https://nx-api.info/api/call-center",
-        dashboard: "https://akeyless-dashboard.online",
-        devices: "https://nx-api.info/api/devices",
-        end_users: "https://nx-api.info/api/end-users",
-        notifications: "https://nx-api.info/api/notifications",
-        installer: "https://installerapp.online",
-        ox_server: "https://akeyless-online.info",
-        toolbox: "https://akeyless-toolbox.online",
-    },
-    qa: {
-        bi: "https://nx-api.xyz/api/bi",
-        call_center: "https://nx-api.xyz/api/call-center",
-        dashboard: "https://akeyless-dashboard.xyz",
-        devices: "https://nx-api.xyz/api/devices",
-        end_users: "https://nx-api.xyz/api/end-users",
-        notifications: "https://nx-api.xyz/api/notifications",
-        installer: "https://installerapp.xyz",
-        ox_server: "https://akeyless-online.xyz",
-        toolbox: "https://akeyless-toolbox.xyz",
-    },
-};
-export function get_nx_service_urls(env_name = "mode") {
-    const env_value = process.env[env_name]?.toLowerCase();
-    if (!env_value)
-        throw new Error(`missing [${env_name}] environment variable`);
-    const env_key = ["production", "prod"].includes(env_value) ? "prod" : env_value === "qa" ? "qa" : "local";
-    return BASE_URLS[env_key];
-}
-export const get_address_by_geo = async ({ lat, lng }, currentLanguage) => {
-    const address_not_found = "";
-    if (lat < -90 || lat > 90 || lng < -180 || lng > 180) {
-        return address_not_found;
-    }
-    const language = currentLanguage === LanguageOptions.He ? "iw" : "en";
-    const google_setting = cache_manager.getObjectData("nx-settings")["google"];
-    const geocode_api_key = google_setting["geocode_api_key"];
-    if (!geocode_api_key) {
-        throw new Error("missing env google api key");
-    }
-    const url = `https://maps.googleapis.com/maps/api/geocode/json?latlng=${lat},${lng}&key=${geocode_api_key}&language=${language}`;
-    try {
-        const response = await axios.get(url);
-        if (response?.data?.results[0]) {
-            return response.data.results[0].formatted_address.slice(0, 35);
-        }
-        else {
-            return address_not_found;
-        }
-    }
-    catch (error) {
-        logger.error("getAddressByGeo error:", error);
-        return address_not_found;
-    }
-};
-export const validate_and_cast = (variable, condition) => !!condition;
-export const get_or_default = (value, default_value) => {
-    if (value !== undefined) {
-        return value;
-    }
-    return typeof default_value === "function" ? default_value() : default_value;
-};
-export const trim_strings = (input) => {
-    if (typeof input === "string") {
-        return input.trim();
-    }
-    if (Array.isArray(input)) {
-        return input.map(trim_strings);
-    }
-    if (input instanceof Date || input instanceof RegExp || input instanceof Map || input instanceof Set) {
-        return input;
-    }
-    if (input !== null && typeof input === "object") {
-        const trimmed_object = {};
-        for (const key of Object.getOwnPropertyNames(input)) {
-            if (Object.prototype.hasOwnProperty.call(input, key)) {
-                trimmed_object[key] = trim_strings(input[key]);
-            }
-        }
-        return trimmed_object;
-    }
-    return input;
-};
-export const remove_nulls_and_undefined = (obj) => {
-    return Object.fromEntries(Object.entries(obj).filter(([_, value]) => value !== undefined && value !== null));
-};
-export const ignore_ssl_request = async (config) => {
-    const { mode } = init_env_variables(["mode"]);
-    if (mode === "qa") {
-        config.httpsAgent = new https.Agent({ rejectUnauthorized: false });
-    }
-    return await axios(config);
-};

package/dist/helpers/index.js

@@ -1,12 +0,0 @@
-export * from "./global_helpers";
-export * from "./firebase_helpers";
-export * from "./start";
-export * from "./time_helpers";
-export * from "./login_helpers";
-export * from "./notification_helpers";
-export * from "./email_helpers";
-export * from "./phone_number_helpers";
-export * from "./tasks_helpers";
-export * from "./boards_helpers";
-export * from "./redis";
-export * from "./location_helpers";

package/dist/helpers/location_helpers.js

@@ -1,15 +0,0 @@
-export const get_distance_in_meters_between_geo_points = (location1, location2) => {
-    const toRadians = (angle) => angle * (Math.PI / 180);
-    const R = 6371e3;
-    const φ1 = toRadians(location1.lat);
-    const φ2 = toRadians(location2.lat);
-    const Δφ = toRadians(location2.lat - location1.lat);
-    const Δλ = toRadians(location2.lng - location1.lng);
-    const a = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) + Math.cos(φ1) * Math.cos(φ2) * Math.sin(Δλ / 2) * Math.sin(Δλ / 2);
-    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-    // distance in meters
-    return R * c;
-};
-export const get_location_url = (location) => {
-    return `https://www.google.com/maps?q=${location.lat},${location.lng}`;
-};

package/dist/helpers/login_helpers.js

@@ -1,18 +0,0 @@
-import { query_document_optional } from "./firebase_helpers";
-export const convert_to_short_phone_number = (phone_number) => {
-    return `0${phone_number.split("+972")[1]}`;
-};
-/// nx user
-export const get_user_by_identifier = async (identifier, ignore_log = false) => {
-    if (identifier.includes("@") && identifier.includes(".")) {
-        const email_query = await query_document_optional("nx-users", "email", "==", identifier, ignore_log);
-        return email_query;
-    }
-    const phone_query = await query_document_optional("nx-users", "phone_number", "in", [convert_to_short_phone_number(identifier), identifier], ignore_log);
-    return phone_query;
-};
-/// mobile app user
-export const get_mobile_app_user_by_uid = async (uid, ignore_log = false) => {
-    const user = (await query_document_optional("mobile_users_app_pro", "uid", "==", uid, ignore_log));
-    return user;
-};

package/dist/helpers/notification_helpers.js

@@ -1,234 +0,0 @@
-import axios from "axios";
-import { cache_manager, logger, translation_manager } from "../managers";
-import { add_document, messaging, add_audit_record } from "./firebase_helpers";
-import { is_iccid, is_international_phone_number, is_israel_long_phone_number, is_thailand_long_phone_number } from "./phone_number_helpers";
-import { Twilio } from "twilio";
-import { Timestamp } from "firebase-admin/firestore";
-import { v4 as uniqId } from "uuid";
-import FormData from "form-data";
-const send_local_sms = async (recepient, text, details) => {
-    const { sms_provider: { multisend }, } = cache_manager.getObjectData("nx-settings");
-    const msgId = uniqId();
-    let data = new FormData();
-    data.append("user", multisend.user);
-    data.append("password", multisend.password);
-    data.append("from", multisend.from);
-    data.append("recipient", recepient);
-    data.append("message", text);
-    data.append("customermessageid", msgId);
-    if (is_international_phone_number(recepient)) {
-        data.append("international", "1");
-    }
-    const config = {
-        method: "post",
-        maxBodyLength: Infinity,
-        url: "https://api.multisend.co.il/v2/sendsms",
-        data: data,
-    };
-    const response = await axios(config);
-    if (response.status !== 200) {
-        throw `multisend request failed , status: ${response.status} , data: ${JSON.stringify(response.data)}`;
-    }
-    if (!response.data.success) {
-        throw `http request to multisend error ${JSON.stringify(response.data.error)}`;
-    }
-    await keep_outgoing_sms(recepient, text, "multisend", msgId, details);
-    logger.log("send_local_sms. message sent successfully", { number: recepient, text, response: response.data });
-    return "multisend";
-};
-const send_international_sms = async (recepient, text, details) => {
-    const { sms_provider: { twilio }, } = cache_manager.getObjectData("nx-settings");
-    const twilioClient = new Twilio(twilio.account_sid, twilio.token);
-    const message = await twilioClient.messages.create({
-        messagingServiceSid: twilio.messaging_service_sid,
-        body: text,
-        to: recepient,
-    });
-    logger.log("twilio response", message);
-    if (message.errorMessage) {
-        throw `twilioClient.messages.create failed: ${message.errorMessage} `;
-    }
-    await keep_outgoing_sms(recepient, text, "twilio", message.sid, details);
-    logger.log("send_international_sms. message sent successfully", { number: recepient, text, response: message });
-    return "twilio";
-};
-const login_to_monogoto = async () => {
-    try {
-        const { sms_provider: { monogoto }, } = cache_manager.getObjectData("nx-settings");
-        const data = { UserName: monogoto.user, Password: monogoto.password };
-        const response = await axios({
-            method: "post",
-            url: `https://console.monogoto.io/Auth`,
-            data,
-        });
-        return response.data;
-    }
-    catch (error) {
-        throw `login_to_monogoto failed: ` + error;
-    }
-};
-const send_iccid_sms = async (recepient, text, details) => {
-    const { sms_provider: { monogoto }, } = cache_manager.getObjectData("nx-settings");
-    const monogoto_auth = await login_to_monogoto();
-    const data = { Message: text, From: monogoto.from };
-    const response = await axios({
-        method: "post",
-        url: `https://console.monogoto.io/thing/ThingId_ICCID_${recepient}/sms`,
-        data: data,
-        headers: {
-            Authorization: `Bearer ${monogoto_auth.token}`,
-            apikey: monogoto_auth.CustomerId,
-        },
-    });
-    if (response.status !== 200) {
-        throw `monogoto request failed , status: ${response.status} , data: ${JSON.stringify(response.data)}`;
-    }
-    await keep_outgoing_sms(recepient, text, "monogoto", response.data, details);
-    logger.log("send_iccid_sms. message sent successfully", { number: recepient, text, response: response.data });
-    return "monogoto";
-};
-export const send_sms = async (recepient, text, entity_for_audit, details) => {
-    try {
-        const send = async () => {
-            if (is_iccid(recepient)) {
-                return await send_iccid_sms(recepient, text, details);
-            }
-            const is_international = is_international_phone_number(recepient) && !is_thailand_long_phone_number(recepient) && !is_israel_long_phone_number(recepient);
-            if (is_international) {
-                return send_international_sms(recepient, text, details);
-            }
-            return await send_local_sms(recepient, text, details);
-        };
-        const service = await send();
-        await add_audit_record("send_sms", entity_for_audit || "general", {
-            recepient,
-            message: text,
-            service,
-        });
-    }
-    catch (error) {
-        logger.error(`${entity_for_audit}, send_sms failed:`, error);
-        throw `${entity_for_audit}, send_sms failed: ` + error;
-    }
-};
-const keep_outgoing_sms = async (recepient, content, service, external_id, details) => {
-    const timestamp = Timestamp.now();
-    const data = {
-        external_id,
-        content,
-        recipient: recepient,
-        service,
-        timestamp,
-        status: "new",
-    };
-    if (details) {
-        data.details = details;
-    }
-    await add_document("nx-sms-out", data);
-};
-export const push_event_to_mobile_users = async (event) => {
-    const units = cache_manager.getArrayData("units");
-    const users_units = cache_manager.getArrayData("usersUnits");
-    const mobile_users_app_pro = cache_manager.getArrayData("mobile_users_app_pro");
-    const app_pro_extra_pushes = cache_manager.getArrayData("app_pro_extra_pushes");
-    console.log(`units: ${units.length}, users_units: ${users_units.length}, mobile_users_app_pro: ${mobile_users_app_pro.length}, app_pro_extra_pushes: ${app_pro_extra_pushes.length}`);
-    if (!units.length || !users_units.length || !mobile_users_app_pro.length) {
-        throw "push_event_to_mobile_users. missing cached data for any of the following: units, usersUnits, mobile_users_app_pro, app_pro_extra_pushes";
-    }
-    ///-- main driver
-    const unit = units.find((unit) => unit.carId == event.car_number);
-    const main_driver = mobile_users_app_pro.find((user) => user.short_phone_number == unit.userPhone);
-    ///-- secondary drivers
-    const secondary_units = users_units.filter((unit) => unit.carId == event.car_number);
-    const secondary_phone_numbers = secondary_units.map((unit) => unit.phone);
-    const secondary_drivers = mobile_users_app_pro.filter((user) => secondary_phone_numbers.includes(user.long_phone_number));
-    ///-- extra users
-    const extra_uids = app_pro_extra_pushes.filter((doc) => doc.car_number == event.car_number).map((doc) => doc.uid);
-    const extra_drivers = extra_uids.length > 0 ? mobile_users_app_pro.filter((user) => extra_uids.includes(user.uid)) : [];
-    const drivers = [main_driver, ...secondary_drivers, ...extra_drivers];
-    for (const mobile_user of drivers) {
-        const source = event.source == "erm" || event.source == "erm2" ? "erm" : event.source;
-        if (mobile_user.disabled_events?.[event.car_number]?.[source]?.includes(event.event_id)) {
-            logger.log(`push_event_to_mobile_users. event ${event.event_id} / ${event.event_name} is disabled for user ${mobile_user.uid} / ${mobile_user.short_phone_number}`);
-            continue;
-        }
-        const mobile_user_language = mobile_user.language;
-        const language = { heb: "he", en: "en", ru: "ru" }[mobile_user_language];
-        const message_title = translation_manager.get_translation("push_notifications", language, "title", "event_from_device");
-        const message_body = translation_manager.get_translation("events_from_device", language, "", event.event_name);
-        await send_fcm_message(message_title, message_body, [mobile_user.fcm_token], "");
-    }
-};
-export const send_fcm_message = async (title, body, fcm_tokens, custom_sound) => {
-    fcm_tokens = [...new Set(fcm_tokens)];
-    if (fcm_tokens.length == 0) {
-        return {
-            success: false,
-            response: "No recipients",
-        };
-    }
-    if (fcm_tokens.length == 0) {
-        return {
-            success: false,
-            response: "No recipients",
-            success_count: 0,
-            failure_count: 0,
-        };
-    }
-    const message = {
-        tokens: fcm_tokens,
-        notification: {
-            title: title,
-            body: body,
-        },
-        android: {
-            ttl: 3600 * 1000,
-            priority: "high",
-            notification: {
-                sound: custom_sound || "default",
-                channelId: custom_sound,
-                title: title,
-                body: body,
-            },
-        },
-        apns: {
-            payload: {
-                aps: {
-                    sound: custom_sound ? `${custom_sound}.wav` : "default",
-                    alert: {
-                        title: title,
-                        body: body,
-                    },
-                },
-            },
-        },
-    };
-    try {
-        const response = await messaging.sendEachForMulticast(message);
-        const { successCount: success_count, failureCount: failure_count, responses } = response;
-        if (success_count && !failure_count) {
-            logger.log(`send_fcm_message. Successfully sent to all ${success_count} recipients. `, { title, body });
-        }
-        else if (success_count && failure_count) {
-            logger.log(`send_fcm_message. Successfully sent to ${success_count} recipients, but failed to sent to ${failure_count} recipients`, {
-                title,
-                body,
-                responses,
-            });
-        }
-        else {
-            logger.log(`send_fcm_message. Failed to sent to ${failure_count} recipients`, { title, body, responses: response.responses });
-        }
-        return {
-            success: success_count > 0 && failure_count == 0,
-            response: JSON.stringify(response.responses),
-        };
-    }
-    catch (error) {
-        logger.error("Exception", error.message);
-        return {
-            success: false,
-            response: `Exception: ${error.message}`,
-        };
-    }
-};

package/dist/helpers/phone_number_helpers.js

@@ -1,91 +0,0 @@
-import { SimProvider } from "../types/enums";
-export const is_long_phone_number = (phone_number) => {
-    return phone_number.startsWith("+");
-};
-export const is_israel_long_phone_number = (phone_number) => {
-    return phone_number.startsWith("+9725") || phone_number.startsWith("+972 5");
-};
-export const is_thailand_long_phone_number = (phone_number) => {
-    return phone_number.startsWith("+66");
-};
-export const is_international_phone_number = (phone_number) => {
-    return is_long_phone_number(phone_number) && !is_israel_long_phone_number(phone_number);
-};
-export const is_iccid = (number) => {
-    if (number.length < 19 || number.length > 22)
-        return false;
-    if (!/^\d+$/.test(number))
-        return false;
-    if (!number.startsWith("89"))
-        return false;
-    return true;
-};
-export const convert_to_short_israel_phone = (international_number) => {
-    return international_number.replace("+972", "0");
-};
-export const is_sim_provider_partner = (phone_number) => {
-    const { short_phone_number } = long_short_phone_numbers(phone_number);
-    return short_phone_number.startsWith("054");
-};
-export const is_sim_provider_pelephone = (phone_number) => {
-    const { short_phone_number } = long_short_phone_numbers(phone_number);
-    return short_phone_number.startsWith("050");
-};
-export const is_sim_provider_celcom = (phone_number) => {
-    const { short_phone_number } = long_short_phone_numbers(phone_number);
-    return short_phone_number.startsWith("052");
-};
-export const is_sim_provider_monogoto = (phone_number) => {
-    return is_iccid(phone_number);
-};
-export const get_sim_provider = (phone_number) => {
-    if (is_sim_provider_partner(phone_number)) {
-        return SimProvider.partner;
-    }
-    if (is_sim_provider_pelephone(phone_number)) {
-        return SimProvider.pelephone;
-    }
-    if (is_sim_provider_celcom(phone_number)) {
-        return SimProvider.celcom;
-    }
-    if (is_sim_provider_monogoto(phone_number)) {
-        return SimProvider.monogoto;
-    }
-    return SimProvider.unknown;
-};
-export const long_short_phone_numbers = (phone_number) => {
-    phone_number = phone_number.trim();
-    if (!phone_number.length) {
-        return {
-            short_phone_number: phone_number,
-            long_phone_number: phone_number,
-            is_israeli: true,
-        };
-    }
-    if (is_iccid(phone_number)) {
-        return {
-            short_phone_number: phone_number,
-            long_phone_number: phone_number,
-            is_israeli: false,
-        };
-    }
-    let short_phone_number = phone_number;
-    let long_phone_number = phone_number;
-    if (phone_number.startsWith("05")) {
-        short_phone_number = phone_number;
-        long_phone_number = `+9725${short_phone_number.slice(2)}`;
-    }
-    else if (phone_number.startsWith("+972")) {
-        long_phone_number = phone_number;
-        short_phone_number = long_phone_number.replace("+9725", "05");
-    }
-    else if (phone_number.startsWith("+1")) {
-        long_phone_number = phone_number;
-        short_phone_number = long_phone_number.replace("+1", "");
-    }
-    return {
-        short_phone_number,
-        long_phone_number,
-        is_israeli: long_phone_number.startsWith("+972"),
-    };
-};

package/dist/helpers/redis/index.js

@@ -1,3 +0,0 @@
-export * from "./initialize";
-export * from "./keys";
-export * from "./snapshot";

package/dist/helpers/redis/initialize.js

@@ -1,139 +0,0 @@
-import Redis from "ioredis";
-import { REDIS_UPDATES_PREFIX } from "akeyless-types-commons";
-import { get_collection_keys } from "./keys";
-import { init_env_variables } from "../global_helpers";
-import { logger } from "../../managers";
-import dotenv from "dotenv";
-dotenv.config();
-export let redis_commander_connected = false;
-export let redis_listener_connected = false;
-const MAX_RETRY_ATTEMPTS = 2;
-let redis_commander;
-let redis_listener;
-let redis_initialized = false;
-function create_redis_instance(role) {
-    let retry_attempts = 0;
-    const base_config = {
-        host: init_env_variables(["redis_ip"]).redis_ip,
-        lazyConnect: true,
-        enableOfflineQueue: false,
-        maxRetriesPerRequest: 0,
-        reconnectOnError: () => false,
-        retryStrategy(times) {
-            retry_attempts = times;
-            if (retry_attempts >= MAX_RETRY_ATTEMPTS) {
-                logger.error(`❌ Redis ${role} failed after ${MAX_RETRY_ATTEMPTS} attempts. Stopping retries.`);
-                return null;
-            }
-            const delay = 1000;
-            logger.warn(`⚠️ Redis ${role} retry attempt ${retry_attempts}/${MAX_RETRY_ATTEMPTS} in ${delay}ms...`);
-            return delay;
-        },
-    };
-    // Listener needs enableReadyCheck: false because it will be in subscriber mode
-    // and cannot respond to PING commands
-    const config = role === "listener"
-        ? { ...base_config, enableReadyCheck: false }
-        : base_config;
-    const client = new Redis(config);
-    client.on("connect", () => {
-        logger.log(`✅ Redis ${role} connected`);
-        if (role === "commander")
-            redis_commander_connected = true;
-        if (role === "listener")
-            redis_listener_connected = true;
-    });
-    client.on("error", (err) => logger.error(`❌ Redis ${role} error`, err));
-    client.on("close", () => {
-        logger.warn(`ℹ️ Redis ${role} connection closed`);
-        if (role === "commander")
-            redis_commander_connected = false;
-        if (role === "listener")
-            redis_listener_connected = false;
-    });
-    client.on("end", () => {
-        logger.warn(`ℹ️ Redis ${role} connection ended`);
-        if (role === "commander")
-            redis_commander_connected = false;
-        if (role === "listener")
-            redis_listener_connected = false;
-    });
-    client.connect().catch((err) => {
-        logger.error(`❌ Redis ${role} initial connect failed`, err);
-    });
-    return client;
-}
-export const init_redis = () => {
-    return new Promise((resolve, reject) => {
-        if (redis_initialized) {
-            resolve();
-            return;
-        }
-        redis_commander = create_redis_instance("commander");
-        redis_listener = create_redis_instance("listener");
-        redis_initialized = true;
-        let commander_ready = false;
-        let listener_ready = false;
-        let listener_subscribed = false;
-        const check_and_resolve = () => {
-            if (commander_ready && listener_ready) {
-                resolve();
-            }
-        };
-        redis_commander.on("connect", () => {
-            commander_ready = true;
-            check_and_resolve();
-        });
-        redis_listener.on("connect", () => {
-            listener_ready = true;
-            // Only subscribe once, not on every reconnect
-            // ioredis will automatically resubscribe on reconnection
-            if (!listener_subscribed) {
-                listener_subscribed = true;
-                const redis_pattern = get_collection_keys(REDIS_UPDATES_PREFIX);
-                redis_listener
-                    .psubscribe(redis_pattern)
-                    .then(() => logger.log(`✅ Subscribed to Redis pattern: ${redis_pattern}`))
-                    .catch((err) => logger.error(`❌ Failed to psubscribe to ${redis_pattern}`, err));
-            }
-            check_and_resolve();
-        });
-        // Handle case where Redis connections fail
-        const connection_timeout = setTimeout(() => {
-            if (!commander_ready || !listener_ready) {
-                logger.warn("⚠️ Redis connection timeout, proceeding without Redis");
-                resolve();
-            }
-        }, 5000);
-        redis_commander.on("error", () => {
-            if (!commander_ready && !listener_ready) {
-                clearTimeout(connection_timeout);
-                reject();
-            }
-        });
-        redis_listener.on("error", () => {
-            if (!commander_ready && !listener_ready) {
-                clearTimeout(connection_timeout);
-                reject();
-            }
-        });
-        process.on("unhandledRejection", (err) => {
-            logger.error("❌ Unhandled promise rejection", err);
-        });
-        process.on("uncaughtException", (err) => {
-            logger.error("❌ Uncaught exception", err);
-        });
-    });
-};
-export const get_redis_commander = () => {
-    if (!redis_commander) {
-        throw new Error("Redis commander not initialized. Call init_redis() first.");
-    }
-    return redis_commander;
-};
-export const get_redis_listener = () => {
-    if (!redis_listener) {
-        throw new Error("Redis listener not initialized. Call init_redis() first.");
-    }
-    return redis_listener;
-};