@backtest-kit/cli 0.0.1

package/build/index.mjs

@@ -0,0 +1,1849 @@
+import { Storage, Notification, Markdown, Report, StorageLive, StorageBacktest, NotificationLive, NotificationBacktest, listExchangeSchema, addExchangeSchema, roundTicks, listFrameSchema, addFrameSchema, listenDoneLive, listenDoneBacktest, listStrategySchema, overrideExchangeSchema, Backtest, Live, getCandles, checkCandles, warmCandles, listenRisk, listenSignal, listenStrategyCommit } from 'backtest-kit';
+import { getErrorMessage, errorData, str, BehaviorSubject, singleshot, compose, execpool, queued, sleep, randomString, createAwaiter, TIMEOUT_SYMBOL, typo, retry, memoize } from 'functools-kit';
+import fs, { constants } from 'fs';
+import * as stackTrace from 'stack-trace';
+import { fileURLToPath, pathToFileURL } from 'url';
+import path from 'path';
+import fs$1, { access } from 'fs/promises';
+import dotenv from 'dotenv';
+import { createActivator } from 'di-kit';
+import ccxt from 'ccxt';
+import { parseArgs } from 'util';
+import { serve } from '@backtest-kit/ui';
+import QuickChart from 'quickchart-js';
+import { Telegraf, Input } from 'telegraf';
+import imageSize from 'image-size';
+import resizeImg from 'resize-image-buffer';
+import { Readable } from 'stream';
+import MarkdownIt from 'markdown-it';
+import sanitizeHtml from 'sanitize-html';
+import { JSDOM } from 'jsdom';
+import Mustache from 'mustache';
+import { createRequire } from 'module';
+
+/**
+ * Fix for `Attempted to assign to readonly property (at redactToken)`
+ * @see https://github.com/telegraf/telegraf/issues/2078
+ */
+{
+    const OriginalError = globalThis.Error;
+    globalThis.Error = new Proxy(OriginalError, {
+        construct(target, args) {
+            const instance = new target(...args);
+            let customMessage = instance.message;
+            const handler = {
+                get(target, prop, receiver) {
+                    if (prop === "message") {
+                        return customMessage;
+                    }
+                    return Reflect.get(target, prop, receiver);
+                },
+                set(target, prop, value, receiver) {
+                    if (prop === "message") {
+                        customMessage = value;
+                        return true;
+                    }
+                    return Reflect.set(target, prop, value, receiver);
+                },
+            };
+            return new Proxy(instance, handler);
+        },
+    });
+}
+
+{
+    Storage.enable();
+    Notification.enable();
+}
+{
+    Markdown.disable();
+    Report.enable();
+}
+{
+    StorageLive.usePersist();
+    StorageBacktest.useDummy();
+}
+{
+    NotificationLive.useDummy();
+    NotificationBacktest.useDummy();
+}
+
+const ERROR_HANDLER_INSTALLED = Symbol.for("error-handler-installed");
+function dumpStackTrace() {
+    const trace = stackTrace.get();
+    const result = [];
+    trace.forEach((callSite) => {
+        result.push(`File: ${callSite.getFileName()}`);
+        result.push(`Line: ${callSite.getLineNumber()}`);
+        result.push(`Function: ${callSite.getFunctionName() || "anonymous"}`);
+        result.push(`Method: ${callSite.getMethodName() || "none"}`);
+        result.push("---");
+    });
+    return str.newline(result);
+}
+const timeNow = () => {
+    const d = new Date();
+    const h = (d.getHours() < 10 ? "0" : "") + d.getHours();
+    const m = (d.getMinutes() < 10 ? "0" : "") + d.getMinutes();
+    return `${h}:${m}`;
+};
+class ErrorService {
+    constructor() {
+        this.handleGlobalError = async (error) => {
+            const today = new Date();
+            const dd = String(today.getDate()).padStart(2, "0");
+            const mm = String(today.getMonth() + 1).padStart(2, "0");
+            const yyyy = today.getFullYear();
+            const date = `${dd}/${mm}/${yyyy} ${timeNow()}`;
+            const msg = JSON.stringify({
+                message: getErrorMessage(error),
+                data: errorData(error),
+            }, null, 2);
+            const trace = dumpStackTrace();
+            fs.appendFileSync("./error.txt", `${date}\n${msg}\n${trace}\n\n`);
+        };
+        this._listenForError = () => {
+            process.on("uncaughtException", (err) => {
+                console.log(err);
+                this.handleGlobalError(err);
+            });
+            process.on("unhandledRejection", (err) => {
+                console.log(err);
+                this.handleGlobalError(err);
+            });
+        };
+        this.init = () => {
+            const global = globalThis;
+            if (global[ERROR_HANDLER_INSTALLED]) {
+                return;
+            }
+            this._listenForError();
+            global[ERROR_HANDLER_INSTALLED] = 1;
+        };
+    }
+}
+
+const NOOP_LOGGER = {
+    log() {
+    },
+    debug() {
+    },
+    info() {
+    },
+    warn() {
+    },
+};
+class LoggerService {
+    constructor() {
+        this._commonLogger = NOOP_LOGGER;
+        this.log = async (topic, ...args) => {
+            await this._commonLogger.log(topic, ...args);
+        };
+        this.debug = async (topic, ...args) => {
+            await this._commonLogger.debug(topic, ...args);
+        };
+        this.info = async (topic, ...args) => {
+            await this._commonLogger.info(topic, ...args);
+        };
+        this.warn = async (topic, ...args) => {
+            await this._commonLogger.warn(topic, ...args);
+        };
+        this.setLogger = (logger) => {
+            this._commonLogger = logger;
+        };
+    }
+}
+
+const { init, inject, provide } = createActivator("cli");
+
+const apiServices$1 = {
+    telegramApiService: Symbol('telegramApiService'),
+    quickchartApiService: Symbol('quickchartApiService'),
+};
+const baseServices$1 = {
+    errorService: Symbol('errorService'),
+    loggerService: Symbol('loggerService'),
+    resolveService: Symbol('resolveService'),
+};
+const connectionServices$1 = {
+    moduleConnectionService: Symbol('moduleConnectionService'),
+};
+const mainServices$1 = {
+    backtestMainService: Symbol('backtestMainService'),
+    paperMainService: Symbol('paperMainService'),
+    liveMainService: Symbol('liveMainService'),
+};
+const logicServices$1 = {
+    cacheLogicService: Symbol('cacheLogicService'),
+    telegramLogicService: Symbol('telegramLogicService'),
+};
+const schemaServices$1 = {
+    exchangeSchemaService: Symbol('exchangeSchemaService'),
+    symbolSchemaService: Symbol('symbolSchemaService'),
+    frameSchemaService: Symbol('frameSchemaService'),
+};
+const providerServices$1 = {
+    frontendProviderService: Symbol('frontendProviderService'),
+    telegramProviderService: Symbol('telegramProviderService'),
+    liveProviderService: Symbol('liveProviderService'),
+};
+const webServices$1 = {
+    telegramWebService: Symbol('telegramWebService'),
+};
+const templateServices$1 = {
+    telegramTemplateService: Symbol('telegramTemplateService'),
+};
+const TYPES = {
+    ...apiServices$1,
+    ...baseServices$1,
+    ...connectionServices$1,
+    ...mainServices$1,
+    ...logicServices$1,
+    ...schemaServices$1,
+    ...providerServices$1,
+    ...webServices$1,
+    ...templateServices$1,
+};
+
+const entrySubject = new BehaviorSubject();
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+let _is_launched = false;
+class ResolveService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.DEFAULT_TEMPLATE_DIR = path.resolve(__dirname, '..', 'template');
+        this.OVERRIDE_TEMPLATE_DIR = path.resolve(process.cwd(), 'template');
+        this.OVERRIDE_MODULES_DIR = path.resolve(process.cwd(), 'modules');
+        this.attachEntryPoint = async (entryPoint) => {
+            this.loggerService.log("resolveService attachEntryPoint");
+            if (_is_launched) {
+                throw new Error("Entry point is already attached. Multiple entry points are not allowed.");
+            }
+            const absolutePath = path.resolve(entryPoint);
+            await access(absolutePath, constants.F_OK | constants.R_OK);
+            const moduleRoot = path.dirname(absolutePath);
+            {
+                const cwd = process.cwd();
+                process.chdir(moduleRoot);
+                dotenv.config({ path: path.join(cwd, '.env') });
+                dotenv.config({ path: path.join(moduleRoot, '.env'), override: true });
+                await import(pathToFileURL(absolutePath).href);
+                await entrySubject.next(absolutePath);
+            }
+            _is_launched = true;
+        };
+    }
+}
+
+const getExchange = singleshot(async () => {
+    const exchange = new ccxt.binance({
+        options: {
+            defaultType: "spot",
+            adjustForTimeDifference: true,
+            recvWindow: 60000,
+        },
+        enableRateLimit: true,
+    });
+    await exchange.loadMarkets();
+    return exchange;
+});
+
+var ExchangeName;
+(function (ExchangeName) {
+    ExchangeName["DefaultExchange"] = "default_exchange";
+})(ExchangeName || (ExchangeName = {}));
+var ExchangeName$1 = ExchangeName;
+
+const ADD_EXCHANGE_FN = (self) => {
+    self.loggerService.log("Adding CCXT Binance as a default exchange schema");
+    console.warn("Warning: The default exchange schema is set to CCXT Binance. Please make sure to update it according to your needs using --exchange cli param.");
+    addExchangeSchema({
+        exchangeName: ExchangeName$1.DefaultExchange,
+        getCandles: async (symbol, interval, since, limit) => {
+            const exchange = await getExchange();
+            const candles = await exchange.fetchOHLCV(symbol, interval, since.getTime(), limit);
+            return candles.map(([timestamp, open, high, low, close, volume], idx) => ({
+                timestamp,
+                open,
+                high,
+                low,
+                close,
+                volume,
+            }));
+        },
+        formatPrice: async (symbol, price) => {
+            const exchange = await getExchange();
+            const market = exchange.market(symbol);
+            const tickSize = market.limits?.price?.min || market.precision?.price;
+            if (tickSize !== undefined) {
+                return roundTicks(price, tickSize);
+            }
+            return exchange.priceToPrecision(symbol, price);
+        },
+        formatQuantity: async (symbol, quantity) => {
+            const exchange = await getExchange();
+            const market = exchange.market(symbol);
+            const stepSize = market.limits?.amount?.min || market.precision?.amount;
+            if (stepSize !== undefined) {
+                return roundTicks(quantity, stepSize);
+            }
+            return exchange.amountToPrecision(symbol, quantity);
+        },
+        getOrderBook: async (symbol, depth, from, to, backtest) => {
+            if (backtest) {
+                throw new Error("Order book fetching is not supported in backtest mode for the default exchange schema. Please implement it according to your needs.");
+            }
+            const exchange = await getExchange();
+            const bookData = await exchange.fetchOrderBook(symbol, depth);
+            return {
+                symbol,
+                asks: bookData.asks.map(([price, quantity]) => ({
+                    price: String(price),
+                    quantity: String(quantity),
+                })),
+                bids: bookData.bids.map(([price, quantity]) => ({
+                    price: String(price),
+                    quantity: String(quantity),
+                })),
+            };
+        },
+    });
+};
+class ExchangeSchemaService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.init = singleshot(async () => {
+            this.loggerService.log("exchangeSchemaService init");
+            const { length } = await listExchangeSchema();
+            !length && ADD_EXCHANGE_FN(this);
+        });
+    }
+}
+
+var FrameName;
+(function (FrameName) {
+    FrameName["DefaultFrame"] = "default_frame";
+})(FrameName || (FrameName = {}));
+var FrameName$1 = FrameName;
+
+const getArgs = singleshot(() => {
+    const { values, positionals } = parseArgs({
+        args: process.argv,
+        options: {
+            symbol: {
+                type: "string",
+                default: "",
+            },
+            strategy: {
+                type: "string",
+                default: "",
+            },
+            exchange: {
+                type: "string",
+                default: "",
+            },
+            frame: {
+                type: "string",
+                default: "",
+            },
+            backtest: {
+                type: "boolean",
+                default: false,
+            },
+            live: {
+                type: "boolean",
+                default: false,
+            },
+            paper: {
+                type: "boolean",
+                default: false,
+            },
+            ui: {
+                type: "boolean",
+                default: false,
+            },
+            telegram: {
+                type: "boolean",
+                default: false,
+            },
+            verbose: {
+                type: "boolean",
+                default: false,
+            },
+            cache: {
+                type: "string",
+                default: "1m, 15m, 30m, 4h",
+            },
+        },
+        strict: false,
+        allowPositionals: true,
+    });
+    return {
+        values,
+        positionals,
+    };
+});
+
+const ADD_FRAME_FN = (self) => {
+    self.loggerService.log("Adding February 2024 as a default frame schema");
+    console.warn("Warning: The default frame schema is set to February 2024. Please make sure to update it according to your needs using --frame cli param.");
+    addFrameSchema({
+        frameName: FrameName$1.DefaultFrame,
+        interval: "1m",
+        startDate: new Date("2024-02-01T00:00:00Z"),
+        endDate: new Date("2024-02-29T23:59:59Z"),
+    });
+};
+class FrameSchemaService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.init = singleshot(async () => {
+            this.loggerService.log("frameSchemaService init");
+            if (!getArgs().values.backtest) {
+                return;
+            }
+            const { length } = await listFrameSchema();
+            !length && ADD_FRAME_FN(this);
+        });
+    }
+}
+
+class SymbolSchemaService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.init = singleshot(async () => {
+            this.loggerService.log("symbolSchemaService init");
+            if (!getArgs().values.symbol) {
+                console.warn("Warning: The default symbol is set to BTCUSDT. Please make sure to update it according to your needs using --symbol cli param.");
+            }
+        });
+    }
+}
+
+const notifyFinish = singleshot(() => {
+    let disposeRef;
+    const unLive = listenDoneLive(() => {
+        console.log("Live trading finished");
+        disposeRef && disposeRef();
+    });
+    const unBacktest = listenDoneBacktest(() => {
+        console.log("Backtest trading finished");
+        disposeRef && disposeRef();
+    });
+    disposeRef = compose(() => unLive(), () => unBacktest());
+});
+
+class BacktestMainService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
+        this.frameSchemaService = inject(TYPES.frameSchemaService);
+        this.cacheLogicService = inject(TYPES.cacheLogicService);
+        this.resolveService = inject(TYPES.resolveService);
+        this.frontendProviderService = inject(TYPES.frontendProviderService);
+        this.telegramProviderService = inject(TYPES.telegramProviderService);
+        this.init = singleshot(async () => {
+            this.loggerService.log("backtestMainService init");
+            {
+                this.frontendProviderService.init();
+                this.telegramProviderService.init();
+            }
+            const { values, positionals } = getArgs();
+            if (!values.backtest) {
+                return;
+            }
+            const [entryPoint = null] = positionals;
+            if (!entryPoint) {
+                throw new Error("Entry point is required");
+            }
+            await this.resolveService.attachEntryPoint(entryPoint);
+            {
+                this.exchangeSchemaService.init();
+                this.frameSchemaService.init();
+            }
+            const symbol = values.symbol || "BTCUSDT";
+            const [defaultStrategyName = null] = await listStrategySchema();
+            const [defaultExchangeName = null] = await listExchangeSchema();
+            const [defaultFrameName = null] = await listFrameSchema();
+            const strategyName = values.strategy || defaultStrategyName?.strategyName;
+            if (!strategyName) {
+                throw new Error("Strategy name is required");
+            }
+            const exchangeName = values.exchange || defaultExchangeName?.exchangeName;
+            if (!exchangeName) {
+                throw new Error("Exchange name is required");
+            }
+            const frameName = values.frame || defaultFrameName?.frameName;
+            if (!frameName) {
+                throw new Error("Frame name is required");
+            }
+            await this.cacheLogicService.execute({
+                exchangeName,
+                frameName,
+                symbol,
+            });
+            if (values.verbose) {
+                overrideExchangeSchema({
+                    exchangeName,
+                    callbacks: {
+                        onCandleData(symbol, interval, since) {
+                            console.log(`Received candle data for symbol: ${symbol}, interval: ${interval}, since: ${since.toUTCString()}`);
+                        },
+                    },
+                });
+            }
+            Backtest.background(symbol, {
+                strategyName,
+                frameName,
+                exchangeName,
+            });
+            notifyFinish();
+        });
+    }
+}
+
+class LiveMainService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
+        this.resolveService = inject(TYPES.resolveService);
+        this.frontendProviderService = inject(TYPES.frontendProviderService);
+        this.telegramProviderService = inject(TYPES.telegramProviderService);
+        this.init = singleshot(async () => {
+            this.loggerService.log("liveMainService init");
+            {
+                this.frontendProviderService.init();
+                this.telegramProviderService.init();
+            }
+            const { values, positionals } = getArgs();
+            if (!values.live) {
+                return;
+            }
+            const [entryPoint = null] = positionals;
+            if (!entryPoint) {
+                throw new Error("Entry point is required");
+            }
+            await this.resolveService.attachEntryPoint(entryPoint);
+            {
+                this.exchangeSchemaService.init();
+            }
+            const symbol = values.symbol || "BTCUSDT";
+            const [defaultStrategyName = null] = await listStrategySchema();
+            const [defaultExchangeName = null] = await listExchangeSchema();
+            const strategyName = values.strategy || defaultStrategyName?.strategyName;
+            if (!strategyName) {
+                throw new Error("Strategy name is required");
+            }
+            const exchangeName = values.exchange || defaultExchangeName?.exchangeName;
+            if (!exchangeName) {
+                throw new Error("Exchange name is required");
+            }
+            if (values.verbose) {
+                overrideExchangeSchema({
+                    exchangeName,
+                    callbacks: {
+                        onCandleData(symbol, interval, since) {
+                            console.log(`Received candle data for symbol: ${symbol}, interval: ${interval}, since: ${since.toUTCString()}`);
+                        },
+                    },
+                });
+            }
+            Live.background(symbol, {
+                strategyName,
+                exchangeName,
+            });
+            notifyFinish();
+        });
+    }
+}
+
+class PaperMainService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
+        this.resolveService = inject(TYPES.resolveService);
+        this.frontendProviderService = inject(TYPES.frontendProviderService);
+        this.telegramProviderService = inject(TYPES.telegramProviderService);
+        this.init = singleshot(async () => {
+            this.loggerService.log("paperMainService init");
+            {
+                this.frontendProviderService.init();
+                this.telegramProviderService.init();
+            }
+            const { values, positionals } = getArgs();
+            if (!values.paper) {
+                return;
+            }
+            const [entryPoint = null] = positionals;
+            if (!entryPoint) {
+                throw new Error("Entry point is required");
+            }
+            await this.resolveService.attachEntryPoint(entryPoint);
+            {
+                this.exchangeSchemaService.init();
+            }
+            const symbol = values.symbol || "BTCUSDT";
+            const [defaultStrategyName = null] = await listStrategySchema();
+            const [defaultExchangeName = null] = await listExchangeSchema();
+            const strategyName = values.strategy || defaultStrategyName?.strategyName;
+            if (!strategyName) {
+                throw new Error("Strategy name is required");
+            }
+            const exchangeName = values.exchange || defaultExchangeName?.exchangeName;
+            if (!exchangeName) {
+                throw new Error("Exchange name is required");
+            }
+            if (values.verbose) {
+                overrideExchangeSchema({
+                    exchangeName,
+                    callbacks: {
+                        onCandleData(symbol, interval, since) {
+                            console.log(`Received candle data for symbol: ${symbol}, interval: ${interval}, since: ${since.toUTCString()}`);
+                        },
+                    },
+                });
+            }
+            Live.background(symbol, {
+                strategyName,
+                exchangeName,
+            });
+            notifyFinish();
+        });
+    }
+}
+
+const getEnv = singleshot(() => {
+    if (!entrySubject.data) {
+        getEnv.clear();
+    }
+    return {
+        CC_TELEGRAM_TOKEN: process.env.CC_TELEGRAM_TOKEN || "",
+        CC_TELEGRAM_CHANNEL: process.env.CC_TELEGRAM_CHANNEL || "",
+        CC_WWWROOT_HOST: process.env.CC_WWWROOT_HOST || "0.0.0.0",
+        CC_WWWROOT_PORT: parseInt(process.env.CC_WWWROOT_PORT) || 60050,
+        CC_QUICKCHART_HOST: process.env.CC_QUICKCHART_HOST || "",
+    };
+});
+
+class FrontendProviderService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.enable = singleshot(() => {
+            this.loggerService.log("frontendProviderService enable");
+            const { CC_WWWROOT_HOST, CC_WWWROOT_PORT } = getEnv();
+            const unServer = serve(CC_WWWROOT_HOST, CC_WWWROOT_PORT);
+            return () => {
+                unServer();
+                this.enable.clear();
+            };
+        });
+        this.disable = () => {
+            this.loggerService.log("frontendProviderService disable");
+            if (this.enable.hasValue()) {
+                const lastSubscription = this.enable();
+                lastSubscription();
+            }
+        };
+        this.init = singleshot(async () => {
+            this.loggerService.log("frontendProviderService init");
+            if (!getArgs().values.ui) {
+                return;
+            }
+            entrySubject.subscribe(this.enable);
+        });
+    }
+}
+
+class TelegramProviderService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.telegramLogicService = inject(TYPES.telegramLogicService);
+        this.enable = singleshot(() => {
+            this.loggerService.log("telegramProviderService enable");
+            const { CC_TELEGRAM_CHANNEL, CC_TELEGRAM_TOKEN } = getEnv();
+            if (!CC_TELEGRAM_CHANNEL) {
+                console.log("CC_TELEGRAM_CHANNEL is not set, telegram provider disabled");
+                this.enable.clear();
+                return;
+            }
+            if (!CC_TELEGRAM_TOKEN) {
+                console.log("CC_TELEGRAM_TOKEN is not set, telegram provider disabled");
+                this.enable.clear();
+                return;
+            }
+            return this.telegramLogicService.connect();
+        });
+        this.disable = () => {
+            this.loggerService.log("telegramProviderService disable");
+            if (this.enable.hasValue()) {
+                const lastSubscription = this.enable();
+                lastSubscription();
+            }
+        };
+        this.init = singleshot(async () => {
+            this.loggerService.log("telegramProviderService init");
+            if (!getArgs().values.telegram) {
+                return;
+            }
+            entrySubject.subscribe(this.enable);
+        });
+    }
+}
+
+const CANDLES_LIMIT = 160;
+const GET_CONFIG_FN = async (symbol, interval) => {
+    const candles = await getCandles(symbol, interval, CANDLES_LIMIT);
+    const labels = candles.map(({ timestamp }) => new Date(timestamp).toLocaleTimeString("en-US", {
+        hour: "2-digit",
+        minute: "2-digit",
+    }));
+    const closes = candles.map(({ close }) => close);
+    const chartConfig = {
+        type: "line",
+        data: {
+            labels,
+            datasets: [
+                {
+                    label: `${symbol} ${interval}`,
+                    data: closes,
+                    borderColor: "rgb(75, 192, 192)",
+                    borderWidth: 2,
+                    pointRadius: 0,
+                    fill: false,
+                    tension: 0.2,
+                },
+            ],
+        },
+        options: {
+            plugins: {
+                title: {
+                    display: true,
+                    text: `${symbol} Closing Prices (${interval})`,
+                },
+                legend: { display: false },
+            },
+            scales: {
+                x: { display: false },
+                y: { display: true },
+            },
+        },
+    };
+    return chartConfig;
+};
+class QuickchartApiService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getChart = async (symbol, interval) => {
+            this.loggerService.log("quickchartApiService getChart", {
+                symbol,
+            });
+            const chartConfig = await GET_CONFIG_FN(symbol, interval);
+            const { CC_QUICKCHART_HOST } = getEnv();
+            const qc = new QuickChart();
+            if (CC_QUICKCHART_HOST) {
+                qc.setHost(CC_QUICKCHART_HOST);
+            }
+            {
+                qc.setConfig(chartConfig);
+                qc.setWidth(512);
+                qc.setHeight(512);
+                qc.setFormat("png");
+            }
+            return await qc.toBinary();
+        };
+    }
+}
+
+const HEALTH_CHECK_DELAY = 60000;
+let _is_stopped = false;
+const handleHealthCheck = singleshot(async (bot) => {
+    const fn = async () => {
+        if (_is_stopped) {
+            return;
+        }
+        try {
+            await bot.telegram.getMe();
+            setTimeout(fn, HEALTH_CHECK_DELAY);
+        }
+        catch (error) {
+            console.log("Bot is offline");
+            throw new Error("Telegram goes offline");
+        }
+    };
+    await fn();
+});
+const getTelegram = singleshot(async () => {
+    if (_is_stopped) {
+        throw new Error("Telegram provider is stopped. Restart the process to enable it again.");
+    }
+    const { CC_TELEGRAM_TOKEN } = await getEnv();
+    if (!CC_TELEGRAM_TOKEN) {
+        throw new Error("Telegram token is not set. Please set CC_TELEGRAM_TOKEN environment variable.");
+    }
+    const bot = new Telegraf(CC_TELEGRAM_TOKEN, {
+        handlerTimeout: Number.POSITIVE_INFINITY,
+    });
+    console.log("Bot launching");
+    bot.launch({
+        allowedUpdates: ["message", "callback_query"],
+        dropPendingUpdates: true,
+    });
+    await handleHealthCheck(bot);
+    console.log("Bot launched");
+    const sendMessage = async (chatId, html) => {
+        const { message_id } = await bot.telegram.sendMessage(chatId, html, {
+            parse_mode: "HTML",
+            disable_web_page_preview: true,
+        });
+        return message_id;
+    };
+    const removeMessage = async (chatId, messageId) => {
+        await bot.telegram.deleteMessage(chatId, messageId);
+    };
+    const sendDocument = async (chatId, document, filename, caption) => {
+        const { message_id } = await bot.telegram.sendDocument(chatId, {
+            source: document,
+            filename,
+        }, {
+            caption,
+            parse_mode: caption ? "HTML" : undefined,
+        });
+        return message_id;
+    };
+    const stopBot = singleshot(() => {
+        bot.stop();
+        _is_stopped = true;
+    });
+    return { bot, sendMessage, removeMessage, sendDocument, stopBot };
+});
+
+const MAX_CAPTION_SYMBOLS = 1024;
+const MAX_IMAGE_WIDTH = 1000;
+const MAX_IMAGE_HEIGHT = 1000;
+const MAX_IMAGE_COUNT = 10;
+const countAllTagsExceptBr = (html) => {
+    if (typeof html !== "string") {
+        return 0;
+    }
+    html = html.replace(/<(?!\/?br\s*\/?)[^>]+>/gi, "");
+    html = html.split("</br>").join("");
+    html = html.split("<br>").join("\n");
+    return html.length;
+};
+const PROTECT_CONTENT = false;
+const PREVENT_FLOOD = 30000;
+const FLOOD_MAX_RETRY = 5;
+const MAX_MSG_SYMBOLS = 4096;
+const MAX_TIMEOUT_COUNT = 30;
+const fetchImage = async (media) => {
+    const request = await fetch(media);
+    const arrayBuffer = await request.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+};
+const processImageBuffer = async (nodeBuffer) => {
+    const size = imageSize(nodeBuffer);
+    if (size.width > size.height && size.width > MAX_IMAGE_WIDTH) {
+        nodeBuffer = await resizeImg(nodeBuffer, { width: MAX_IMAGE_WIDTH });
+    }
+    if (size.height > size.width && size.height > MAX_IMAGE_HEIGHT) {
+        nodeBuffer = await resizeImg(nodeBuffer, { height: MAX_IMAGE_HEIGHT });
+    }
+    const stream = Readable.from(nodeBuffer);
+    return Input.fromReadableStream(stream, `${randomString()}.png`);
+};
+const getImageFromUrl = execpool(async (url) => {
+    console.log(`Image ${url} fetch begin`);
+    const nodeBuffer = await fetchImage(url);
+    console.log(`Image ${url} fetch end`);
+    return processImageBuffer(nodeBuffer);
+}, { maxExec: 3 });
+const processMedia = async (media) => {
+    if (typeof media === 'string') {
+        return getImageFromUrl(media);
+    }
+    return media;
+};
+const publishInternal = queued(async ({ channel, msg, images = [], onScheduled, }) => {
+    const { bot } = await getTelegram();
+    console.log("Bot sending");
+    onScheduled();
+    let isOk = true;
+    try {
+        const execute = async (retry = 0) => {
+            let isImagesPublished = false;
+            try {
+                if (images?.length) {
+                    console.log("Bot fetching images");
+                    const withCaption = countAllTagsExceptBr(msg) < MAX_CAPTION_SYMBOLS;
+                    console.log(`Bot publishing media group withCaption=${withCaption}`);
+                    const imageList = await Promise.all(images.slice(0, MAX_IMAGE_COUNT).map(async (media, idx) => ({
+                        type: "photo",
+                        media: await processMedia(media),
+                        ...(idx === 0 &&
+                            withCaption && { caption: msg, parse_mode: "HTML" }),
+                        disable_web_page_preview: true,
+                    })));
+                    if (!isImagesPublished) {
+                        await bot.telegram.sendMediaGroup(channel, imageList, {
+                            protect_content: PROTECT_CONTENT,
+                        });
+                        isImagesPublished = true;
+                    }
+                    if (!withCaption) {
+                        console.log("Bot publishing caption");
+                        await bot.telegram.sendMessage(channel, msg, {
+                            protect_content: PROTECT_CONTENT,
+                            parse_mode: "HTML",
+                            disable_web_page_preview: true,
+                        });
+                    }
+                }
+                else {
+                    console.log("Bot publishing message");
+                    await bot.telegram.sendMessage(channel, msg, {
+                        protect_content: PROTECT_CONTENT,
+                        parse_mode: "HTML",
+                        disable_web_page_preview: true,
+                    });
+                }
+            }
+            catch (error) {
+                if (retry >= FLOOD_MAX_RETRY) {
+                    console.log(`Telegram flood max retry reached retry=${retry}`);
+                    throw error;
+                }
+                const retry_after = error?.response?.parameters?.retry_after;
+                if (retry_after) {
+                    console.log(`Telegram flood retry=${retry} retry_after=${retry_after}`);
+                    await sleep(retry_after * 1000 + 1000);
+                    await execute(retry + 1);
+                }
+                else {
+                    throw error;
+                }
+            }
+        };
+        if (countAllTagsExceptBr(msg) >= MAX_MSG_SYMBOLS) {
+            console.log("Box max msg length reached");
+            console.log(msg);
+            console.log(msg.length);
+            throw new Error("Box max msg length reached");
+        }
+        await execute();
+    }
+    catch (error) {
+        console.error(error);
+        isOk = false;
+    }
+    finally {
+        await sleep(PREVENT_FLOOD);
+        if (isOk) {
+            console.log("Bot sent ok");
+        }
+        else {
+            console.log("Bot sent error");
+        }
+    }
+});
+let TIMEOUT_COUNTER = 0;
+class TelegramApiService {
+    constructor() {
+        this.publish = async (channel, msg, images) => {
+            const [waitForResult, { resolve }] = createAwaiter();
+            const task = publishInternal({
+                onScheduled: () => resolve(),
+                channel,
+                msg,
+                images,
+            })
+                .catch((error) => {
+                console.error("Telegram publish failure", {
+                    error,
+                });
+                setTimeout(() => process.exit(-1), 5000);
+            });
+            const result = await Promise.race([
+                waitForResult,
+                sleep(5000).then(() => TIMEOUT_SYMBOL),
+            ]);
+            if (result === TIMEOUT_SYMBOL) {
+                TIMEOUT_COUNTER += 1;
+                task.finally(() => {
+                    TIMEOUT_COUNTER -= 1;
+                });
+                return "Message scheduled for publication";
+            }
+            if (TIMEOUT_COUNTER > MAX_TIMEOUT_COUNT) {
+                setTimeout(() => process.exit(-1), 5000);
+            }
+            return "Message published successfully";
+        };
+    }
+}
+
+const TELEGAM_MAX_SYMBOLS = 4090;
+const TELEGRAM_SYMBOL_RESERVED = 96;
+// Function to convert Markdown to Telegram-compatible HTML
+function toTelegramHtml(markdown) {
+    const maxChars = TELEGAM_MAX_SYMBOLS - TELEGRAM_SYMBOL_RESERVED;
+    // Initialize markdown-it with options
+    const md = new MarkdownIt({
+        html: false,
+        breaks: true,
+        linkify: true,
+        typographer: true,
+    });
+    // Prevent removing of \u00a0
+    markdown = markdown.replaceAll(typo.nbsp, "&nbsp;");
+    markdown = markdown.replaceAll(typo.bullet, "&bull;");
+    // Render Markdown to HTML
+    let telegramHtml = md.render(markdown);
+    // Post-process with sanitize-html to ensure Telegram compatibility
+    telegramHtml = sanitizeHtml(telegramHtml, {
+        allowedTags: [
+            "b",
+            "i",
+            "a",
+            "code",
+            "pre",
+            "s",
+            "u",
+            "tg-spoiler",
+            "blockquote",
+            "br",
+        ],
+        allowedAttributes: {
+            a: ["href"], // Allow href for links
+        },
+        transformTags: {
+            // Transform headings to bold text
+            h1: "b",
+            h2: "b",
+            h3: "b",
+            h4: "b",
+            h5: "b",
+            h6: "b",
+            // Transform strong to b
+            strong: "b",
+            // Transform em to i
+            em: "i",
+            // Remove p tags, replace with newlines
+            p: () => "",
+            // Emulate unordered lists with bullets
+            ul: () => "",
+            li: () => "- ",
+            // Emulate ordered lists with numbers
+            ol: () => "",
+            // Remove hr, replace with text-based separator
+            hr: () => "\n",
+            // Remove br, replace with text-based separator
+            br: () => "\n",
+            // Remove divs
+            div: () => "",
+        },
+    });
+    {
+        telegramHtml = telegramHtml.replaceAll(typo.bullet, "#").trim();
+    }
+    {
+        telegramHtml = telegramHtml.replaceAll(typo.nbsp, "<br>\n").trim();
+        telegramHtml = telegramHtml.replaceAll(/\n[\s\n]*\n/g, "\n").trim();
+        telegramHtml = telegramHtml.replaceAll("<br>", "").trim();
+    }
+    // Check Telegram message length limit (4096 characters)
+    if (telegramHtml.length > maxChars) {
+        console.warn("HTML exceeds Telegram's 4096-character limit. Truncating...");
+        telegramHtml = telegramHtml.substring(0, maxChars);
+    }
+    const telegramDom = new JSDOM(telegramHtml, {
+        contentType: "text/html",
+        resources: "usable",
+        runScripts: "outside-only",
+        pretendToBeVisual: false,
+    });
+    const document = telegramDom.window.document;
+    const fragment = document.createDocumentFragment();
+    const body = document.body;
+    while (body.firstChild) {
+        fragment.appendChild(body.firstChild);
+    }
+    const tempDiv = document.createElement("div");
+    tempDiv.appendChild(fragment);
+    return tempDiv.innerHTML;
+}
+
+class TelegramWebService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.telegramApiService = inject(TYPES.telegramApiService);
+        this.quickchartApiService = inject(TYPES.quickchartApiService);
+        this.publishNotify = async (dto) => {
+            this.loggerService.log("telegramWebService publishNotify", {
+                dto,
+            });
+            const { CC_TELEGRAM_TOKEN, CC_TELEGRAM_CHANNEL } = getEnv();
+            if (!CC_TELEGRAM_TOKEN || !CC_TELEGRAM_CHANNEL) {
+                return;
+            }
+            const html = toTelegramHtml(dto.markdown);
+            try {
+                const images = await Promise.all([
+                    this.quickchartApiService.getChart(dto.symbol, "1m"),
+                    this.quickchartApiService.getChart(dto.symbol, "15m"),
+                    this.quickchartApiService.getChart(dto.symbol, "1h"),
+                ]);
+                await this.telegramApiService.publish(CC_TELEGRAM_CHANNEL, html, images.map((imageBuffer) => {
+                    const stream = Readable.from(imageBuffer);
+                    return Input.fromReadableStream(stream, `${randomString()}.png`);
+                }));
+            }
+            catch (error) {
+                this.loggerService.log(`telegramWebService publishConfirmNotify Error publishing ${dto.symbol} confirm notify: ${getErrorMessage(error)}`, {
+                    error: errorData(error),
+                });
+                await this.telegramApiService.publish(CC_TELEGRAM_CHANNEL, html);
+            }
+        };
+    }
+}
+
+const DEFAULT_TIMEFRAME_LIST = ["1m", "15m", "30m", "1h", "4h"];
+const GET_TIMEFRAME_LIST_FN = async () => {
+    const { values } = getArgs();
+    if (!values.cache) {
+        console.warn(`Warning: No cache timeframes provided. Using default timeframes: ${DEFAULT_TIMEFRAME_LIST.join(", ")}`);
+        return DEFAULT_TIMEFRAME_LIST;
+    }
+    return String(values.cache)
+        .split(",")
+        .map((timeframe) => timeframe.trim());
+};
+const GET_TIMEFRAME_RANGE_FN = async (frameName) => {
+    const frameList = await listFrameSchema();
+    const frameSchema = frameList.find((frameSchema) => frameSchema.frameName === frameName);
+    if (!frameSchema) {
+        throw new Error(`Frame with name ${frameName} not found`);
+    }
+    const { startDate, endDate } = frameSchema;
+    return { startDate, endDate };
+};
+const CACHE_CANDLES_FN = retry(async (interval, dto) => {
+    try {
+        console.log(`Checking candles cache for ${dto.symbol} ${interval} from ${dto.from} to ${dto.to}`);
+        await checkCandles({
+            exchangeName: dto.exchangeName,
+            from: dto.from,
+            to: dto.to,
+            symbol: dto.symbol,
+            interval: interval,
+        });
+    }
+    catch (error) {
+        console.log(`Caching candles for ${dto.symbol} ${interval} from ${dto.from} to ${dto.to}`);
+        await warmCandles({
+            symbol: dto.symbol,
+            exchangeName: dto.exchangeName,
+            from: dto.from,
+            to: dto.to,
+            interval: interval,
+        });
+        throw error;
+    }
+}, 2);
+class CacheLogicService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.execute = async (dto) => {
+            this.loggerService.log("cacheLogicService execute", {
+                dto,
+            });
+            const { startDate, endDate } = await GET_TIMEFRAME_RANGE_FN(dto.frameName);
+            const intervalList = await GET_TIMEFRAME_LIST_FN();
+            try {
+                for (const interval of intervalList) {
+                    await CACHE_CANDLES_FN(interval, {
+                        symbol: dto.symbol,
+                        exchangeName: dto.exchangeName,
+                        from: startDate,
+                        to: endDate,
+                    });
+                }
+            }
+            catch (error) {
+                console.log(getErrorMessage(error));
+                throw error;
+            }
+        };
+    }
+}
+
+const STOP_BOT_FN = singleshot(async () => {
+    const { stopBot } = await getTelegram();
+    stopBot();
+});
+class TelegramLogicService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.telegramTemplateService = inject(TYPES.telegramTemplateService);
+        this.telegramWebService = inject(TYPES.telegramWebService);
+        this.notifyTrailingTake = async (event) => {
+            this.loggerService.log("telegramLogicService notifyTrailingTake", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getTrailingTakeMarkdown(event);
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        };
+        this.notifyTrailingStop = async (event) => {
+            this.loggerService.log("telegramLogicService notifyTrailingStop", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getTrailingStopMarkdown(event);
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        };
+        this.notifyBreakeven = async (event) => {
+            this.loggerService.log("telegramLogicService notifyBreakeven", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getBreakevenMarkdown(event);
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        };
+        this.notifyPartialProfit = async (event) => {
+            this.loggerService.log("telegramLogicService notifyPartialProfit", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getPartialProfitMarkdown(event);
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        };
+        this.notifyPartialLoss = async (event) => {
+            this.loggerService.log("telegramLogicService notifyPartialLoss", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getPartialLossMarkdown(event);
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        };
+        this.notifyScheduled = async (event) => {
+            this.loggerService.log("telegramLogicService notifyScheduled", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getScheduledMarkdown(event);
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        };
+        this.notifyCancelled = async (event) => {
+            this.loggerService.log("telegramLogicService notifyCancelled", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getCancelledMarkdown(event);
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        };
+        this.notifyOpened = async (event) => {
+            this.loggerService.log("telegramLogicService notifyOpened", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getOpenedMarkdown(event);
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        };
+        this.notifyClosed = async (event) => {
+            this.loggerService.log("telegramLogicService notifyClosed", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getClosedMarkdown(event);
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        };
+        this.notifyRisk = async (event) => {
+            this.loggerService.log("telegramLogicService notifyClosed", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getRiskMarkdown(event);
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        };
+        this.connect = singleshot(() => {
+            this.loggerService.log("telegramLogicService connect");
+            const unRisk = listenRisk(async (event) => {
+                await this.notifyRisk(event);
+            });
+            const unSignal = listenSignal(async (event) => {
+                if (event.action === "scheduled") {
+                    await this.notifyScheduled(event);
+                    return;
+                }
+                if (event.action === "cancelled") {
+                    await this.notifyCancelled(event);
+                    return;
+                }
+                if (event.action === "opened") {
+                    await this.notifyOpened(event);
+                    return;
+                }
+                if (event.action === "closed") {
+                    await this.notifyClosed(event);
+                    return;
+                }
+            });
+            const unCommit = listenStrategyCommit(async (event) => {
+                if (event.action === "trailing-take") {
+                    await this.notifyTrailingTake(event);
+                    return;
+                }
+                if (event.action === "trailing-stop") {
+                    await this.notifyTrailingStop(event);
+                    return;
+                }
+                if (event.action === "breakeven") {
+                    await this.notifyBreakeven(event);
+                    return;
+                }
+                if (event.action === "partial-profit") {
+                    await this.notifyPartialProfit(event);
+                    return;
+                }
+                if (event.action === "partial-loss") {
+                    await this.notifyPartialLoss(event);
+                    return;
+                }
+            });
+            const unListen = compose(() => unRisk(), () => unSignal(), () => unCommit());
+            return () => {
+                STOP_BOT_FN();
+                unListen();
+            };
+        });
+    }
+}
+
+const READ_TEMPLATE_FN = memoize(([fileName]) => `${fileName}`, async (fileName, self) => {
+    const overridePath = path.join(self.resolveService.OVERRIDE_TEMPLATE_DIR, fileName);
+    const hasOverride = await fs$1
+        .access(overridePath, constants.F_OK | constants.R_OK)
+        .then(() => true)
+        .catch(() => false);
+    if (hasOverride) {
+        return await fs$1.readFile(overridePath, "utf-8");
+    }
+    const defaultPath = path.join(self.resolveService.DEFAULT_TEMPLATE_DIR, fileName);
+    return await fs$1.readFile(defaultPath, "utf-8");
+});
+const RENDER_TEMPLATE_FN = async (fileName, event, self) => {
+    const template = await READ_TEMPLATE_FN(fileName, self);
+    return Mustache.render(template, event);
+};
+class TelegramTemplateService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.resolveService = inject(TYPES.resolveService);
+        this.getTrailingTakeMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getTrailingTakeMarkdown", {
+                event,
+            });
+            return await RENDER_TEMPLATE_FN("trailing-take.mustache", event, this);
+        };
+        this.getTrailingStopMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getTrailingStopMarkdown", {
+                event,
+            });
+            return await RENDER_TEMPLATE_FN("trailing-stop.mustache", event, this);
+        };
+        this.getBreakevenMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getBreakevenMarkdown", {
+                event,
+            });
+            return await RENDER_TEMPLATE_FN("breakeven.mustache", event, this);
+        };
+        this.getPartialProfitMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getPartialProfitMarkdown", {
+                event,
+            });
+            return await RENDER_TEMPLATE_FN("partial-profit.mustache", event, this);
+        };
+        this.getPartialLossMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getPartialLossMarkdown", {
+                event,
+            });
+            return await RENDER_TEMPLATE_FN("partial-loss.mustache", event, this);
+        };
+        this.getScheduledMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getScheduledMarkdown", {
+                event,
+            });
+            return await RENDER_TEMPLATE_FN("scheduled.mustache", event, this);
+        };
+        this.getCancelledMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getCancelledMarkdown", {
+                event,
+            });
+            return await RENDER_TEMPLATE_FN("cancelled.mustache", event, this);
+        };
+        this.getOpenedMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getOpenedMarkdown", {
+                event,
+            });
+            return await RENDER_TEMPLATE_FN("opened.mustache", event, this);
+        };
+        this.getClosedMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getClosedMarkdown", {
+                event,
+            });
+            return await RENDER_TEMPLATE_FN("closed.mustache", event, this);
+        };
+        this.getRiskMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getRiskMarkdown", {
+                event,
+            });
+            return await RENDER_TEMPLATE_FN("risk.mustache", event, this);
+        };
+    }
+}
+
+const require = createRequire(import.meta.url);
+const getExtVariants = (fileName) => {
+    const ext = path.extname(fileName);
+    const base = ext ? fileName.slice(0, -ext.length) : fileName;
+    return [fileName, `${base}.cjs`, `${base}.mjs`];
+};
+const REQUIRE_MODULE_FACTORY = (fileName) => {
+    for (const variant of getExtVariants(fileName)) {
+        try {
+            return require(variant);
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+};
+const IMPORT_MODULE_FACTORY = async (fileName) => {
+    for (const variant of getExtVariants(fileName)) {
+        try {
+            return await import(variant);
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+};
+const LOAD_MODULE_MODULE_FN = async (fileName, self) => {
+    let Ctor = null;
+    const overridePath = path.join(self.resolveService.OVERRIDE_MODULES_DIR, fileName);
+    const targetPath = path.join(process.cwd(), "modules", fileName);
+    const hasOverride = await fs$1
+        .access(overridePath, constants.F_OK | constants.R_OK)
+        .then(() => true)
+        .catch(() => false);
+    const resolvedFile = hasOverride ? overridePath : targetPath;
+    if ((Ctor = REQUIRE_MODULE_FACTORY(resolvedFile))) {
+        return typeof Ctor === "function" ? new Ctor() : Ctor;
+    }
+    if ((Ctor = await IMPORT_MODULE_FACTORY(resolvedFile))) {
+        return typeof Ctor === "function" ? new Ctor() : Ctor;
+    }
+    throw new Error(`Module module import failed for file: ${resolvedFile}`);
+};
+class ModuleConnectionService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.resolveService = inject(TYPES.resolveService);
+        this.getInstance = memoize(([fileName]) => `${fileName}`, async (fileName) => {
+            this.loggerService.log("moduleConnectionService getInstance", {
+                fileName,
+            });
+            return await LOAD_MODULE_MODULE_FN(fileName, this);
+        });
+    }
+}
+
+const LOAD_INSTANCE_FN = singleshot(async (self) => {
+    const module = (await self.moduleConnectionService.getInstance("./live.module"));
+    return module;
+});
+class LiveProviderService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.moduleConnectionService = inject(TYPES.moduleConnectionService);
+        this.handleTrailingTake = async (event) => {
+            this.loggerService.log("liveProviderService handleTrailingTake", {
+                event,
+            });
+            const instance = await LOAD_INSTANCE_FN(this);
+            if (instance.onTrailingTake) {
+                await instance.onTrailingTake(event);
+            }
+        };
+        this.handleTrailingStop = async (event) => {
+            this.loggerService.log("liveProviderService handleTrailingStop", {
+                event,
+            });
+            const instance = await LOAD_INSTANCE_FN(this);
+            if (instance.onTrailingStop) {
+                await instance.onTrailingStop(event);
+            }
+        };
+        this.handleBreakeven = async (event) => {
+            this.loggerService.log("liveProviderService handleBreakeven", {
+                event,
+            });
+            const instance = await LOAD_INSTANCE_FN(this);
+            if (instance.onBreakeven) {
+                await instance.onBreakeven(event);
+            }
+        };
+        this.handlePartialProfit = async (event) => {
+            this.loggerService.log("liveProviderService handlePartialProfit", {
+                event,
+            });
+            const instance = await LOAD_INSTANCE_FN(this);
+            if (instance.onPartialProfit) {
+                await instance.onPartialProfit(event);
+            }
+        };
+        this.handlePartialLoss = async (event) => {
+            this.loggerService.log("liveProviderService handlePartialLoss", {
+                event,
+            });
+            const instance = await LOAD_INSTANCE_FN(this);
+            if (instance.onPartialLoss) {
+                await instance.onPartialLoss(event);
+            }
+        };
+        this.handleScheduled = async (event) => {
+            this.loggerService.log("liveProviderService handleScheduled", {
+                event,
+            });
+            const instance = await LOAD_INSTANCE_FN(this);
+            if (instance.onScheduled) {
+                await instance.onScheduled(event);
+            }
+        };
+        this.handleCancelled = async (event) => {
+            this.loggerService.log("liveProviderService handleCancelled", {
+                event,
+            });
+            const instance = await LOAD_INSTANCE_FN(this);
+            if (instance.onCancelled) {
+                await instance.onCancelled(event);
+            }
+        };
+        this.handleOpened = async (event) => {
+            this.loggerService.log("liveProviderService handleOpened", {
+                event,
+            });
+            const instance = await LOAD_INSTANCE_FN(this);
+            if (instance.onOpened) {
+                await instance.onOpened(event);
+            }
+        };
+        this.handleClosed = async (event) => {
+            this.loggerService.log("liveProviderService handleClosed", {
+                event,
+            });
+            const instance = await LOAD_INSTANCE_FN(this);
+            if (instance.onClosed) {
+                await instance.onClosed(event);
+            }
+        };
+        this.handleRisk = async (event) => {
+            this.loggerService.log("liveProviderService handleClosed", {
+                event,
+            });
+            const instance = await LOAD_INSTANCE_FN(this);
+            if (instance.onRisk) {
+                await instance.onRisk(event);
+            }
+        };
+        this.enable = singleshot(() => {
+            this.loggerService.log("liveProviderService enable");
+            const unRisk = listenRisk(async (event) => {
+                await this.handleRisk(event);
+            });
+            const unSignal = listenSignal(async (event) => {
+                if (event.action === "scheduled") {
+                    await this.handleScheduled(event);
+                    return;
+                }
+                if (event.action === "cancelled") {
+                    await this.handleCancelled(event);
+                    return;
+                }
+                if (event.action === "opened") {
+                    await this.handleOpened(event);
+                    return;
+                }
+                if (event.action === "closed") {
+                    await this.handleClosed(event);
+                    return;
+                }
+            });
+            const unCommit = listenStrategyCommit(async (event) => {
+                if (event.action === "trailing-take") {
+                    await this.handleTrailingTake(event);
+                    return;
+                }
+                if (event.action === "trailing-stop") {
+                    await this.handleTrailingStop(event);
+                    return;
+                }
+                if (event.action === "breakeven") {
+                    await this.handleBreakeven(event);
+                    return;
+                }
+                if (event.action === "partial-profit") {
+                    await this.handlePartialProfit(event);
+                    return;
+                }
+                if (event.action === "partial-loss") {
+                    await this.handlePartialLoss(event);
+                    return;
+                }
+            });
+            return compose(() => unRisk(), () => unSignal(), () => unCommit());
+        });
+        this.disable = () => {
+            this.loggerService.log("liveProviderService disable");
+            if (this.enable.hasValue()) {
+                const lastSubscription = this.enable();
+                lastSubscription();
+            }
+        };
+        this.init = singleshot(async () => {
+            this.loggerService.log("liveProviderService init");
+            if (!getArgs().values.live) {
+                return;
+            }
+            entrySubject.subscribe(this.enable);
+        });
+    }
+}
+
+{
+    provide(TYPES.quickchartApiService, () => new QuickchartApiService());
+    provide(TYPES.telegramApiService, () => new TelegramApiService());
+}
+{
+    provide(TYPES.errorService, () => new ErrorService());
+    provide(TYPES.loggerService, () => new LoggerService());
+    provide(TYPES.resolveService, () => new ResolveService());
+}
+{
+    provide(TYPES.moduleConnectionService, () => new ModuleConnectionService());
+}
+{
+    provide(TYPES.backtestMainService, () => new BacktestMainService());
+    provide(TYPES.paperMainService, () => new PaperMainService());
+    provide(TYPES.liveMainService, () => new LiveMainService());
+}
+{
+    provide(TYPES.cacheLogicService, () => new CacheLogicService());
+    provide(TYPES.telegramLogicService, () => new TelegramLogicService());
+}
+{
+    provide(TYPES.exchangeSchemaService, () => new ExchangeSchemaService());
+    provide(TYPES.symbolSchemaService, () => new SymbolSchemaService());
+    provide(TYPES.frameSchemaService, () => new FrameSchemaService());
+}
+{
+    provide(TYPES.telegramProviderService, () => new TelegramProviderService());
+    provide(TYPES.frontendProviderService, () => new FrontendProviderService());
+    provide(TYPES.liveProviderService, () => new LiveProviderService());
+}
+{
+    provide(TYPES.telegramWebService, () => new TelegramWebService());
+}
+{
+    provide(TYPES.telegramTemplateService, () => new TelegramTemplateService());
+}
+
+const apiServices = {
+    telegramApiService: inject(TYPES.telegramApiService),
+    quickchartApiService: inject(TYPES.quickchartApiService),
+};
+const baseServices = {
+    errorService: inject(TYPES.errorService),
+    loggerService: inject(TYPES.loggerService),
+    resolveService: inject(TYPES.resolveService),
+};
+const connectionServices = {
+    moduleConnectionService: inject(TYPES.moduleConnectionService),
+};
+const mainServices = {
+    backtestMainService: inject(TYPES.backtestMainService),
+    paperMainService: inject(TYPES.paperMainService),
+    liveMainService: inject(TYPES.liveMainService),
+};
+const logicServices = {
+    cacheLogicService: inject(TYPES.cacheLogicService),
+    telegramLogicService: inject(TYPES.telegramLogicService),
+};
+const schemaServices = {
+    exchangeSchemaService: inject(TYPES.exchangeSchemaService),
+    symbolSchemaService: inject(TYPES.symbolSchemaService),
+    frameSchemaService: inject(TYPES.frameSchemaService),
+};
+const providerServices = {
+    frontendProviderService: inject(TYPES.frontendProviderService),
+    telegramProviderService: inject(TYPES.telegramProviderService),
+    liveProviderService: inject(TYPES.liveProviderService),
+};
+const webServices = {
+    telegramWebService: inject(TYPES.telegramWebService),
+};
+const templateServices = {
+    telegramTemplateService: inject(TYPES.telegramTemplateService),
+};
+const cli = {
+    ...apiServices,
+    ...baseServices,
+    ...connectionServices,
+    ...mainServices,
+    ...logicServices,
+    ...schemaServices,
+    ...providerServices,
+    ...webServices,
+    ...templateServices,
+};
+init();
+
+const notifyShutdown = singleshot(async () => {
+    console.log("Graceful shutdown initiated. Press Ctrl+C again to force quit.");
+});
+
+const BEFORE_EXIT_FN$4 = singleshot(async () => {
+    process.off("SIGINT", BEFORE_EXIT_FN$4);
+    const [running = null] = await Backtest.list();
+    if (!running) {
+        return;
+    }
+    notifyShutdown();
+    const { exchangeName, frameName, strategyName, symbol, status } = running;
+    if (status === "fulfilled") {
+        return;
+    }
+    Backtest.stop(symbol, {
+        exchangeName,
+        strategyName,
+        frameName,
+    });
+});
+const main$4 = async () => {
+    const { values } = getArgs();
+    if (!values.backtest) {
+        return;
+    }
+    process.on("SIGINT", BEFORE_EXIT_FN$4);
+};
+main$4();
+
+const BEFORE_EXIT_FN$3 = singleshot(async () => {
+    process.off("SIGINT", BEFORE_EXIT_FN$3);
+    const [running = null] = await Live.list();
+    if (!running) {
+        return;
+    }
+    notifyShutdown();
+    const { exchangeName, strategyName, symbol, status } = running;
+    if (status === "fulfilled") {
+        return;
+    }
+    Live.stop(symbol, {
+        exchangeName,
+        strategyName,
+    });
+});
+const main$3 = async () => {
+    const { values } = getArgs();
+    if (!values.paper) {
+        return;
+    }
+    process.on("SIGINT", BEFORE_EXIT_FN$3);
+};
+main$3();
+
+const BEFORE_EXIT_FN$2 = singleshot(async () => {
+    process.off("SIGINT", BEFORE_EXIT_FN$2);
+    const [running = null] = await Live.list();
+    if (!running) {
+        return;
+    }
+    notifyShutdown();
+    const { exchangeName, strategyName, symbol, status } = running;
+    if (status === "fulfilled") {
+        return;
+    }
+    Live.stop(symbol, {
+        exchangeName,
+        strategyName,
+    });
+    listenDoneLive(cli.liveProviderService.disable);
+});
+const main$2 = async () => {
+    const { values } = getArgs();
+    if (!values.live) {
+        return;
+    }
+    process.on("SIGINT", BEFORE_EXIT_FN$2);
+};
+main$2();
+
+const BEFORE_EXIT_FN$1 = singleshot(async () => {
+    process.off("SIGINT", BEFORE_EXIT_FN$1);
+    notifyShutdown();
+    cli.frontendProviderService.disable();
+});
+const main$1 = async () => {
+    const { values } = getArgs();
+    if (!values.ui) {
+        return;
+    }
+    process.on("SIGINT", BEFORE_EXIT_FN$1);
+};
+main$1();
+
+const BEFORE_EXIT_FN = singleshot(async () => {
+    process.off("SIGINT", BEFORE_EXIT_FN);
+    notifyShutdown();
+    cli.telegramProviderService.disable();
+});
+const main = async () => {
+    const { values } = getArgs();
+    if (!values.telegram) {
+        return;
+    }
+    process.on("SIGINT", BEFORE_EXIT_FN);
+};
+main();
+
+function setLogger(logger) {
+    cli.loggerService.setLogger(logger);
+}
+
+export { cli, setLogger };