npm - @backtest-kit/ui - Versions diffs - 5.6.2 → 5.9.1 - Mend

@backtest-kit/ui 5.6.2 → 5.9.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (70) hide show

package/build/index.cjs CHANGED Viewed

@@ -11,6 +11,8 @@ var diKit = require('di-kit');
 var backtestKit = require('backtest-kit');
 var fs = require('fs/promises');
 var path = require('path');
+var mime = require('mime-types');
+var crypto = require('crypto');
 var module$1 = require('module');
 var fs$1 = require('fs');
@@ -20,10 +22,10 @@ const CC_WWWROOT_HOST = process.env.CC_WWWROOT_HOST || "0.0.0.0";
 const CC_WWWROOT_PORT = parseInt(process.env.CC_WWWROOT_PORT) || 60050;
 const CC_ENABLE_MOCK = !!parseInt(process.env.CC_ENABLE_MOCK) || false;
-const router$9 = Router({
+const router$b = Router({
     params: true,
 });
-router$9.get("/api/v1/health/health_check", async (req, res) => {
+router$b.get("/api/v1/health/health_check", async (req, res) => {
     const [cpuLoad] = os.loadavg();
     return await micro.send(res, 200, {
         uptime: process.uptime(),
@@ -72,6 +74,9 @@ const mockServices$1 = {
     logMockService: Symbol("logMockService"),
     statusMockService: Symbol("statusMockService"),
     markdownMockService: Symbol("markdownMockService"),
+    explorerMockService: Symbol("explorerMockService"),
+    signalMockService: Symbol("signalMockService"),
+    heatMockService: Symbol("heatMockService"),
 };
 const viewServices$1 = {
     notificationViewService: Symbol("notificationViewService"),
@@ -80,6 +85,9 @@ const viewServices$1 = {
     logViewService: Symbol("logViewService"),
     statusViewService: Symbol("statusViewService"),
     markdownViewService: Symbol("markdownViewService"),
+    explorerViewService: Symbol("explorerViewService"),
+    signalViewService: Symbol("signalViewService"),
+    heatViewService: Symbol("heatViewService"),
 };
 const TYPES = {
     ...baseServices$1,
@@ -148,6 +156,14 @@ class ExchangeService {
                 exchangeName: dto.exchangeName,
             }, undefined, sDate, eDate);
         };
+        this.getLastCandles = async (dto) => {
+            this.loggerService.log("exchangeService getLastCandles", {
+                dto,
+            });
+            return await backtestKit.Exchange.getCandles(dto.symbol, dto.interval, dto.limit, {
+                exchangeName: dto.exchangeName,
+            });
+        };
     }
 }
@@ -182,9 +198,9 @@ class LoggerService {
     }
 }
-const MOCK_PATH$3 = "./mock/notifications.json";
+const MOCK_PATH$5 = "./mock/notifications.json";
 const READ_NOTIFICATION_LIST_FN = functoolsKit.singleshot(async () => {
-    const data = await fs.readFile(MOCK_PATH$3, "utf-8");
+    const data = await fs.readFile(MOCK_PATH$5, "utf-8");
     return JSON.parse(data);
 });
 const DEFAULT_LIMIT$3 = 25;
@@ -244,9 +260,9 @@ class NotificationMockService {
     }
 }
-const MOCK_PATH$2 = "./mock/db";
+const MOCK_PATH$4 = "./mock/db";
 const READ_BACKTEST_STORAGE_FN = functoolsKit.singleshot(async () => {
-    const dbPath = path.join(process.cwd(), MOCK_PATH$2);
+    const dbPath = path.join(process.cwd(), MOCK_PATH$4);
     const files = await fs.readdir(dbPath);
     const signals = [];
     for (const file of files) {
@@ -281,7 +297,7 @@ class StorageMockService {
     }
 }
-const MS_PER_MINUTE$1 = 60000;
+const HISTORY_LAST_CANDLES_LIMIT$1 = 200;
 class ExchangeMockService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
@@ -314,22 +330,56 @@ class ExchangeMockService {
             if (!signal) {
                 throw new Error(`Signal with ID ${signalId} not found`);
             }
-            const { pendingAt, scheduledAt, minuteEstimatedTime, } = signal;
+            const { pendingAt, scheduledAt, updatedAt } = signal;
             const eventAt = pendingAt || scheduledAt;
             return await this.exchangeService.getRangeCandles({
                 symbol: signal.symbol,
                 exchangeName: signal.exchangeName,
                 signalStartTime: eventAt,
-                signalStopTime: eventAt + minuteEstimatedTime * MS_PER_MINUTE$1,
+                signalStopTime: backtestKit.alignToInterval(new Date(updatedAt), interval).getTime(),
+                interval,
+            });
+        };
+        this.getLastCandles = async (symbol, interval) => {
+            this.loggerService.log("exchangeMockService getLastCandles", {
+                symbol,
                 interval,
             });
+            const [backtestItem] = await backtestKit.Backtest.list();
+            const [liveItem] = await backtestKit.Live.list();
+            const [exchangeItem] = await backtestKit.listExchangeSchema();
+            if (backtestItem) {
+                return await this.exchangeService.getLastCandles({
+                    symbol,
+                    limit: HISTORY_LAST_CANDLES_LIMIT$1,
+                    exchangeName: backtestItem.exchangeName,
+                    interval,
+                });
+            }
+            if (liveItem) {
+                return await this.exchangeService.getLastCandles({
+                    symbol,
+                    limit: HISTORY_LAST_CANDLES_LIMIT$1,
+                    exchangeName: liveItem.exchangeName,
+                    interval,
+                });
+            }
+            if (exchangeItem) {
+                return await this.exchangeService.getLastCandles({
+                    symbol,
+                    limit: HISTORY_LAST_CANDLES_LIMIT$1,
+                    exchangeName: exchangeItem.exchangeName,
+                    interval,
+                });
+            }
+            throw new Error(`exchangeMockService getLastCandles no pending strategy symbol=${symbol} interval=${interval}`);
         };
     }
 }
-const MOCK_PATH$1 = "./mock/logs.json";
+const MOCK_PATH$3 = "./mock/logs.json";
 const READ_LOG_LIST_FN = functoolsKit.singleshot(async () => {
-    const data = await fs.readFile(MOCK_PATH$1, "utf-8");
+    const data = await fs.readFile(MOCK_PATH$3, "utf-8");
     return JSON.parse(data);
 });
 const DEFAULT_LIMIT$2 = 25;
@@ -377,14 +427,24 @@ class LogMockService {
     }
 }
-const MOCK_PATH = "./mock/status.json";
+const MOCK_PATH$2 = "./mock/status.json";
+const MOCK_INFO_PATH = "./mock/status-info.json";
 const READ_STATUS_LIST_FN = functoolsKit.singleshot(async () => {
-    const data = await fs.readFile(MOCK_PATH, "utf-8");
+    const data = await fs.readFile(MOCK_PATH$2, "utf-8");
+    return JSON.parse(data);
+});
+const READ_STATUS_INFO_FN = functoolsKit.singleshot(async () => {
+    const data = await fs.readFile(MOCK_INFO_PATH, "utf-8");
     return JSON.parse(data);
 });
 class StatusMockService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
+        this.signalMockService = inject(TYPES.signalMockService);
+        this.getStatusInfo = async () => {
+            this.loggerService.log("statusMockService getStatusInfo");
+            return await READ_STATUS_INFO_FN();
+        };
         this.getStatusList = async () => {
             this.loggerService.log("statusMockService getStatusList");
             const list = await READ_STATUS_LIST_FN();
@@ -404,33 +464,36 @@ class StatusMockService {
         this.getStatusOne = async (id) => {
             this.loggerService.log("statusMockService getStatusOne", { id });
             const list = await READ_STATUS_LIST_FN();
-            const signal = list.find((s) => s.id === id);
-            if (!signal) {
+            const status = list.find((s) => s.id === id);
+            if (!status) {
                 return null;
             }
-            const positionEntries = signal._entry ?? [];
+            const updatedAt = await this.signalMockService.getLastUpdateTimestamp(status.signalId);
+            const positionEntries = status._entry ?? [];
             const positionLevels = positionEntries.map((e) => e.price);
-            const positionPartials = signal._partial ?? [];
+            const positionPartials = status._partial ?? [];
             return {
-                signalId: signal.signalId,
-                position: signal.position,
-                symbol: signal.symbol,
-                exchangeName: signal.exchangeName,
-                strategyName: signal.strategyName,
-                totalEntries: signal.totalEntries,
-                totalPartials: signal.totalPartials,
-                originalPriceStopLoss: signal.originalPriceStopLoss,
-                originalPriceTakeProfit: signal.originalPriceTakeProfit,
-                originalPriceOpen: signal.originalPriceOpen,
-                priceOpen: signal.priceOpen,
-                priceTakeProfit: signal.priceTakeProfit,
-                priceStopLoss: signal.priceStopLoss,
-                pnlPercentage: signal.pnl.pnlPercentage,
-                pnlCost: signal.pnl.pnlCost,
-                pnlEntries: signal.pnl.pnlEntries,
-                partialExecuted: signal.partialExecuted,
-                minuteEstimatedTime: signal.minuteEstimatedTime,
-                pendingAt: signal.pendingAt,
+                signalId: status.signalId,
+                position: status.position,
+                symbol: status.symbol,
+                exchangeName: status.exchangeName,
+                strategyName: status.strategyName,
+                totalEntries: status.totalEntries,
+                totalPartials: status.totalPartials,
+                originalPriceStopLoss: status.originalPriceStopLoss,
+                originalPriceTakeProfit: status.originalPriceTakeProfit,
+                originalPriceOpen: status.originalPriceOpen,
+                priceOpen: status.priceOpen,
+                priceTakeProfit: status.priceTakeProfit,
+                priceStopLoss: status.priceStopLoss,
+                pnlPercentage: status.pnl.pnlPercentage,
+                pnlCost: status.pnl.pnlCost,
+                pnlEntries: status.pnl.pnlEntries,
+                partialExecuted: status.partialExecuted,
+                minuteEstimatedTime: status.minuteEstimatedTime,
+                pendingAt: status.pendingAt,
+                timestamp: status.timestamp,
+                updatedAt,
                 positionLevels,
                 positionEntries,
                 positionPartials,
@@ -580,6 +643,127 @@ class MarkdownMockService {
     }
 }
+const deepFlat = (arr) => {
+    const result = [];
+    const seen = new Set();
+    const process = (entries = []) => entries.forEach((entry) => {
+        if (seen.has(entry)) {
+            return;
+        }
+        seen.add(entry);
+        if (entry.type === "directory") {
+            process(entry.nodes);
+        }
+        result.push(entry);
+    });
+    process(arr);
+    return result;
+};
+const MOCK_PATH$1 = "./mock/explorer.json";
+const READ_EXPLORER_TREE_FN = functoolsKit.singleshot(async () => {
+    const data = await fs.readFile(MOCK_PATH$1, "utf-8");
+    return JSON.parse(data);
+});
+const READ_EXPLORER_INDEX_FN = functoolsKit.singleshot(async () => {
+    const tree = await READ_EXPLORER_TREE_FN();
+    const treeList = deepFlat(tree);
+    if (treeList.length === 0) {
+        return {};
+    }
+    return treeList.reduce((acm, cur) => {
+        if (cur.type === "file" && "content" in cur) {
+            return { ...acm, [cur.path]: cur };
+        }
+        return acm;
+    }, {});
+});
+class ExplorerMockService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getNode = async (nodePath) => {
+            this.loggerService.log("explorerMockService getNode", {
+                nodePath,
+            });
+            const index = await READ_EXPLORER_INDEX_FN();
+            return index[nodePath]?.content ?? "";
+        };
+        this.getTree = async () => {
+            this.loggerService.log("explorerMockService getTree");
+            return await READ_EXPLORER_TREE_FN();
+        };
+    }
+}
+const MOCK_PATH = "./mock/db";
+const MOCK_SIGNAL_PATH = "./mock/signal.json";
+const READ_SIGNAL_STORAGE_FN = functoolsKit.singleshot(async () => {
+    const dbPath = path.join(process.cwd(), MOCK_PATH);
+    const files = await fs.readdir(dbPath);
+    const signals = [];
+    for (const file of files) {
+        if (!file.endsWith(".json")) {
+            continue;
+        }
+        const filePath = path.join(dbPath, file);
+        signals.push(JSON.parse(await fs.readFile(filePath, "utf-8")));
+    }
+    return signals;
+});
+const READ_PENDING_SIGNAL_FN = functoolsKit.singleshot(async () => {
+    const filePath = path.join(process.cwd(), MOCK_SIGNAL_PATH);
+    return JSON.parse(await fs.readFile(filePath, "utf-8"));
+});
+class SignalMockService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getLastUpdateTimestamp = async (signalId) => {
+            this.loggerService.log("signalMockService getLastUpdateTimestamp", {
+                signalId,
+            });
+            const signalList = await READ_SIGNAL_STORAGE_FN();
+            const signalMap = new Map(signalList.map((signal) => [signal.id, signal]));
+            const signal = signalMap.get(signalId);
+            if (!signal) {
+                throw new Error(`SignalMockService getLastUpdateTimestamp signal not found signalId=${signalId}`);
+            }
+            return signal.updatedAt;
+        };
+        this.getPendingSignal = async (symbol) => {
+            this.loggerService.log("signalMockService getPendingSignal", {
+                symbol,
+            });
+            const signal = await READ_PENDING_SIGNAL_FN();
+            if (signal.symbol !== symbol) {
+                return null;
+            }
+            return signal;
+        };
+    }
+}
+const MOCK_DATA_PATH = "./mock/heat.json";
+const MOCK_REPORT_PATH = "./mock/heat-report.md";
+const READ_HEAT_DATA_FN = functoolsKit.singleshot(async () => {
+    const data = await fs.readFile(MOCK_DATA_PATH, "utf-8");
+    return JSON.parse(data);
+});
+const READ_HEAT_REPORT_FN = functoolsKit.singleshot(async () => {
+    return await fs.readFile(MOCK_REPORT_PATH, "utf-8");
+});
+class HeatMockService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getStrategyHeatData = async () => {
+            this.loggerService.log("heatMockService getStrategyHeatData");
+            return await READ_HEAT_DATA_FN();
+        };
+        this.getStrategyHeatReport = async () => {
+            this.loggerService.log("heatMockService getStrategyHeatReport");
+            return await READ_HEAT_REPORT_FN();
+        };
+    }
+}
 const DEFAULT_LIMIT$1 = 25;
 const DEFAULT_OFFSET$1 = 0;
 const CREATE_FILTER_LIST_FN$1 = (filterData) => Object.keys(filterData).map((key) => (row) => new RegExp(filterData[key], "i").test(row[key]));
@@ -724,13 +908,14 @@ class StorageViewService {
     }
 }
-const MS_PER_MINUTE = 60000;
+const HISTORY_LAST_CANDLES_LIMIT = 200;
 class ExchangeViewService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.storageViewService = inject(TYPES.storageViewService);
         this.exchangeService = inject(TYPES.exchangeService);
         this.exchangeMockService = inject(TYPES.exchangeMockService);
+        this.signalViewService = inject(TYPES.signalViewService);
         this.getSignalCandles = async (signalId, interval) => {
             this.loggerService.log("exchangeViewService getCandles", {
                 signalId,
@@ -764,15 +949,53 @@ class ExchangeViewService {
             if (!signal) {
                 throw new Error(`Signal with ID ${signalId} not found`);
             }
-            const { pendingAt, scheduledAt, minuteEstimatedTime, } = signal;
+            const { pendingAt, scheduledAt } = signal;
             const eventAt = pendingAt || scheduledAt;
+            const updatedAt = await this.signalViewService.getLastUpdateTimestamp(signalId);
             return await this.exchangeService.getRangeCandles({
                 symbol: signal.symbol,
                 exchangeName: signal.exchangeName,
                 signalStartTime: eventAt,
-                signalStopTime: eventAt + minuteEstimatedTime * MS_PER_MINUTE,
+                signalStopTime: backtestKit.alignToInterval(new Date(updatedAt), interval).getTime(),
+                interval,
+            });
+        };
+        this.getLastCandles = async (symbol, interval) => {
+            this.loggerService.log("exchangeViewService getLastCandles", {
+                symbol,
                 interval,
             });
+            if (CC_ENABLE_MOCK) {
+                return await this.exchangeMockService.getLastCandles(symbol, interval);
+            }
+            const [backtestItem] = await backtestKit.Backtest.list();
+            const [liveItem] = await backtestKit.Live.list();
+            const [exchangeItem] = await backtestKit.listExchangeSchema();
+            if (backtestItem) {
+                return await this.exchangeService.getLastCandles({
+                    symbol,
+                    limit: HISTORY_LAST_CANDLES_LIMIT,
+                    exchangeName: backtestItem.exchangeName,
+                    interval,
+                });
+            }
+            if (liveItem) {
+                return await this.exchangeService.getLastCandles({
+                    symbol,
+                    limit: HISTORY_LAST_CANDLES_LIMIT,
+                    exchangeName: liveItem.exchangeName,
+                    interval,
+                });
+            }
+            if (exchangeItem) {
+                return await this.exchangeService.getLastCandles({
+                    symbol,
+                    limit: HISTORY_LAST_CANDLES_LIMIT,
+                    exchangeName: exchangeItem.exchangeName,
+                    interval,
+                });
+            }
+            throw new Error(`exchangeViewService getLastCandles no pending strategy symbol=${symbol} interval=${interval}`);
         };
     }
 }
@@ -836,6 +1059,7 @@ class StatusViewService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.statusMockService = inject(TYPES.statusMockService);
+        this.signalViewService = inject(TYPES.signalViewService);
         this.getStatusList = async () => {
             this.loggerService.log("statusViewService getStatusList");
             if (CC_ENABLE_MOCK) {
@@ -898,6 +1122,12 @@ class StatusViewService {
             if (!positionPartials) {
                 return null;
             }
+            const timestamp = await backtestKit.lib.timeMetaService.getTimestamp(pendingSignal.symbol, {
+                strategyName: pendingSignal.strategyName,
+                exchangeName: pendingSignal.exchangeName,
+                frameName: pendingSignal.frameName,
+            }, false);
+            const updatedAt = await this.signalViewService.getLastUpdateTimestamp(pendingSignal.id);
             return {
                 signalId: pendingSignal.id,
                 position: pendingSignal.position,
@@ -918,11 +1148,80 @@ class StatusViewService {
                 partialExecuted: pendingSignal.partialExecuted,
                 pendingAt: pendingSignal.pendingAt,
                 minuteEstimatedTime: pendingSignal.minuteEstimatedTime,
+                timestamp,
+                updatedAt,
                 positionEntries,
                 positionLevels,
                 positionPartials,
             };
         };
+        this.getStatusInfo = async () => {
+            this.loggerService.log("statusViewService getStatusInfo");
+            if (CC_ENABLE_MOCK) {
+                return this.statusMockService.getStatusInfo();
+            }
+            {
+                const [backtestTarget = null] = await backtestKit.Backtest.list();
+                if (backtestTarget) {
+                    const currentHeat = await backtestKit.Heat.getData({
+                        strategyName: backtestTarget.strategyName,
+                        exchangeName: backtestTarget.exchangeName,
+                        frameName: backtestTarget.frameName,
+                    }, true);
+                    return {
+                        context: {
+                            strategyName: backtestTarget.strategyName,
+                            exchangeName: backtestTarget.exchangeName,
+                            frameName: backtestTarget.frameName,
+                        },
+                        portfolioTotalPnl: currentHeat.portfolioTotalPnl,
+                        portfolioSharpeRatio: currentHeat.portfolioSharpeRatio,
+                        portfolioTotalTrades: currentHeat.portfolioTotalTrades,
+                        symbols: currentHeat.symbols.map(({ symbol, totalPnl, winRate, profitFactor, maxDrawdown, expectancy, totalTrades }) => ({
+                            symbol,
+                            totalPnl,
+                            winRate,
+                            profitFactor,
+                            maxDrawdown,
+                            expectancy,
+                            totalTrades,
+                        })),
+                        backtest: true,
+                    };
+                }
+            }
+            {
+                const [liveTarget = null] = await backtestKit.Live.list();
+                if (liveTarget) {
+                    const currentHeat = await backtestKit.Heat.getData({
+                        strategyName: liveTarget.strategyName,
+                        exchangeName: liveTarget.exchangeName,
+                        frameName: "",
+                    }, false);
+                    return {
+                        context: {
+                            strategyName: liveTarget.strategyName,
+                            exchangeName: liveTarget.exchangeName,
+                            frameName: "",
+                        },
+                        portfolioTotalPnl: currentHeat.portfolioTotalPnl,
+                        portfolioSharpeRatio: currentHeat.portfolioSharpeRatio,
+                        portfolioTotalTrades: currentHeat.portfolioTotalTrades,
+                        symbols: currentHeat.symbols.map(({ symbol, totalPnl, winRate, profitFactor, maxDrawdown, expectancy, totalTrades }) => ({
+                            symbol,
+                            totalPnl,
+                            winRate,
+                            profitFactor,
+                            maxDrawdown,
+                            expectancy,
+                            totalTrades,
+                        })),
+                        backtest: false,
+                    };
+                }
+            }
+            return null;
+        };
     }
 }
@@ -1113,6 +1412,185 @@ class MarkdownViewService {
     }
 }
+const pathId = (p) => crypto.createHash("sha1").update(p).digest("hex").slice(0, 16);
+const buildTree = async (dir, visited) => {
+    const realDir = await fs.realpath(dir);
+    if (visited.has(realDir)) {
+        return [];
+    }
+    visited.add(realDir);
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const nodes = [];
+    for (const entry of entries) {
+        const childPath = path.join(dir, entry.name);
+        const childRelPath = path.relative(process.cwd(), childPath).replace(/\\/g, "/");
+        if (entry.isDirectory()) {
+            nodes.push({
+                id: pathId(childRelPath),
+                path: childRelPath,
+                label: entry.name,
+                type: "directory",
+                nodes: await buildTree(childPath, visited),
+            });
+        }
+        else {
+            nodes.push({
+                id: pathId(childRelPath),
+                path: childRelPath,
+                label: entry.name,
+                type: "file",
+                mimeType: mime.lookup(entry.name) || "application/octet-stream",
+            });
+        }
+    }
+    return nodes;
+};
+class ExplorerViewService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.explorerMockService = inject(TYPES.explorerMockService);
+        this.getDir = functoolsKit.singleshot(async () => {
+            this.loggerService.log("explorerViewService getDir");
+            const dir = path.join(process.cwd(), "dump");
+            await fs.mkdir(dir, { recursive: true });
+            return dir;
+        });
+        this.getNode = async (nodePath) => {
+            this.loggerService.log("explorerViewService getNode", {
+                nodePath,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.explorerMockService.getNode(nodePath);
+            }
+            const dir = await this.getDir();
+            const absPath = path.resolve(process.cwd(), nodePath);
+            if (!absPath.startsWith(dir + path.sep) && !absPath.startsWith(dir + "/") && absPath !== dir) {
+                throw new Error(`Path is outside of dump dir: ${nodePath}`);
+            }
+            return await fs.readFile(absPath, "utf-8");
+        };
+        this.getTree = async () => {
+            this.loggerService.log("explorerViewService getTree");
+            if (CC_ENABLE_MOCK) {
+                return await this.explorerMockService.getTree();
+            }
+            const dir = await this.getDir();
+            const root = path.relative(process.cwd(), dir).replace(/\\/g, "/");
+            const rootNode = {
+                id: pathId(root),
+                path: root,
+                label: path.basename(root),
+                type: "directory",
+                nodes: await buildTree(dir, new Set([path.join(dir, "data")])),
+            };
+            return [rootNode];
+        };
+    }
+}
+class SignalViewService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.signalMockService = inject(TYPES.signalMockService);
+        this.getLastUpdateTimestamp = async (signalId) => {
+            this.loggerService.log("signalViewService getLastUpdateTimestamp", {
+                signalId,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.signalMockService.getLastUpdateTimestamp(signalId);
+            }
+            {
+                const liveSignal = await backtestKit.StorageLive.findById(signalId);
+                if (liveSignal) {
+                    return liveSignal.updatedAt;
+                }
+            }
+            {
+                const backtestSignal = await backtestKit.StorageBacktest.findById(signalId);
+                if (backtestSignal) {
+                    return backtestSignal.updatedAt;
+                }
+            }
+            throw new Error(`SignalViewService getLastUpdateTimestamp signal not found signalId=${signalId}`);
+        };
+        this.getPendingSignal = async (symbol) => {
+            this.loggerService.log("signalViewService getPendingSignal", {
+                symbol,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.signalMockService.getPendingSignal(symbol);
+            }
+            {
+                const liveList = await backtestKit.Live.list();
+                const liveTarget = liveList.find((live) => live.symbol === symbol);
+                if (liveTarget) {
+                    const currentPrice = await backtestKit.Exchange.getAveragePrice(symbol, {
+                        exchangeName: liveTarget.exchangeName,
+                    });
+                    return await backtestKit.Live.getPendingSignal(symbol, currentPrice, {
+                        strategyName: liveTarget.strategyName,
+                        exchangeName: liveTarget.exchangeName,
+                    });
+                }
+            }
+            return null;
+        };
+    }
+}
+class HeatViewService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.heatMockService = inject(TYPES.heatMockService);
+        this.getStrategyHeatData = async () => {
+            this.loggerService.log("heatViewService getStrategyHeatData");
+            if (CC_ENABLE_MOCK) {
+                return await this.heatMockService.getStrategyHeatData();
+            }
+            const [backtestItem] = await backtestKit.Backtest.list();
+            const [liveItem] = await backtestKit.Live.list();
+            if (backtestItem) {
+                return await backtestKit.Heat.getData({
+                    strategyName: backtestItem.strategyName,
+                    exchangeName: backtestItem.exchangeName,
+                    frameName: backtestItem.frameName,
+                }, true);
+            }
+            if (liveItem) {
+                return await backtestKit.Heat.getData({
+                    strategyName: liveItem.strategyName,
+                    exchangeName: liveItem.exchangeName,
+                    frameName: "",
+                }, false);
+            }
+            return null;
+        };
+        this.getStrategyHeatReport = async () => {
+            this.loggerService.log("heatViewService getStrategyHeatReport");
+            if (CC_ENABLE_MOCK) {
+                return await this.heatMockService.getStrategyHeatReport();
+            }
+            const [backtestItem] = await backtestKit.Backtest.list();
+            const [liveItem] = await backtestKit.Live.list();
+            if (backtestItem) {
+                return await backtestKit.Heat.getReport({
+                    strategyName: backtestItem.strategyName,
+                    exchangeName: backtestItem.exchangeName,
+                    frameName: backtestItem.frameName,
+                });
+            }
+            if (liveItem) {
+                return await backtestKit.Heat.getReport({
+                    strategyName: liveItem.strategyName,
+                    exchangeName: liveItem.exchangeName,
+                    frameName: "",
+                });
+            }
+            return null;
+        };
+    }
+}
 const symbol_list = [
     {
         icon: "/icon/btc.png",
@@ -1309,6 +1787,9 @@ class LiveMetaService {
     provide(TYPES.logMockService, () => new LogMockService());
     provide(TYPES.statusMockService, () => new StatusMockService());
     provide(TYPES.markdownMockService, () => new MarkdownMockService());
+    provide(TYPES.explorerMockService, () => new ExplorerMockService());
+    provide(TYPES.signalMockService, () => new SignalMockService());
+    provide(TYPES.heatMockService, () => new HeatMockService());
 }
 {
     provide(TYPES.notificationViewService, () => new NotificationViewService());
@@ -1317,6 +1798,9 @@ class LiveMetaService {
     provide(TYPES.logViewService, () => new LogViewService());
     provide(TYPES.statusViewService, () => new StatusViewService());
     provide(TYPES.markdownViewService, () => new MarkdownViewService());
+    provide(TYPES.explorerViewService, () => new ExplorerViewService());
+    provide(TYPES.signalViewService, () => new SignalViewService());
+    provide(TYPES.heatViewService, () => new HeatViewService());
 }
 const baseServices = {
@@ -1339,6 +1823,9 @@ const mockServices = {
     logMockService: inject(TYPES.logMockService),
     statusMockService: inject(TYPES.statusMockService),
     markdownMockService: inject(TYPES.markdownMockService),
+    explorerMockService: inject(TYPES.explorerMockService),
+    signalMockService: inject(TYPES.signalMockService),
+    heatMockService: inject(TYPES.heatMockService),
 };
 const viewServices = {
     notificationViewService: inject(TYPES.notificationViewService),
@@ -1347,6 +1834,9 @@ const viewServices = {
     logViewService: inject(TYPES.logViewService),
     statusViewService: inject(TYPES.statusViewService),
     markdownViewService: inject(TYPES.markdownViewService),
+    explorerViewService: inject(TYPES.explorerViewService),
+    signalViewService: inject(TYPES.signalViewService),
+    heatViewService: inject(TYPES.heatViewService),
 };
 const ioc = {
     ...baseServices,
@@ -1357,11 +1847,11 @@ const ioc = {
 };
 init();
-const router$8 = Router({
+const router$a = Router({
     params: true,
 });
 // ExchangeMockService endpoints
-router$8.post("/api/v1/mock/candles_signal", async (req, res) => {
+router$a.post("/api/v1/mock/candles_signal", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { signalId, interval, requestId, serviceName } = request;
@@ -1389,7 +1879,7 @@ router$8.post("/api/v1/mock/candles_signal", async (req, res) => {
         });
     }
 });
-router$8.post("/api/v1/mock/candles_point", async (req, res) => {
+router$a.post("/api/v1/mock/candles_point", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { currentTime, interval, requestId, serviceName, symbol, exchangeName } = request;
@@ -1423,7 +1913,7 @@ router$8.post("/api/v1/mock/candles_point", async (req, res) => {
     }
 });
 // NotificationMockService endpoints
-router$8.post("/api/v1/mock/notification_list", async (req, res) => {
+router$a.post("/api/v1/mock/notification_list", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1451,7 +1941,7 @@ router$8.post("/api/v1/mock/notification_list", async (req, res) => {
         });
     }
 });
-router$8.post("/api/v1/mock/notification_one/:id", async (req, res) => {
+router$a.post("/api/v1/mock/notification_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1480,7 +1970,7 @@ router$8.post("/api/v1/mock/notification_one/:id", async (req, res) => {
         });
     }
 });
-router$8.post("/api/v1/mock/notification_filter", async (req, res) => {
+router$a.post("/api/v1/mock/notification_filter", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, filterData, limit, offset } = request;
@@ -1509,7 +1999,7 @@ router$8.post("/api/v1/mock/notification_filter", async (req, res) => {
     }
 });
 // StorageMockService endpoints
-router$8.post("/api/v1/mock/storage_one/:id", async (req, res) => {
+router$a.post("/api/v1/mock/storage_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1538,7 +2028,7 @@ router$8.post("/api/v1/mock/storage_one/:id", async (req, res) => {
         });
     }
 });
-router$8.post("/api/v1/mock/storage_list/live", async (req, res) => {
+router$a.post("/api/v1/mock/storage_list/live", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1566,7 +2056,7 @@ router$8.post("/api/v1/mock/storage_list/live", async (req, res) => {
         });
     }
 });
-router$8.post("/api/v1/mock/storage_list/backtest", async (req, res) => {
+router$a.post("/api/v1/mock/storage_list/backtest", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1595,7 +2085,7 @@ router$8.post("/api/v1/mock/storage_list/backtest", async (req, res) => {
     }
 });
 // LogMockService endpoints
-router$8.post("/api/v1/mock/log_list", async (req, res) => {
+router$a.post("/api/v1/mock/log_list", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1623,7 +2113,7 @@ router$8.post("/api/v1/mock/log_list", async (req, res) => {
         });
     }
 });
-router$8.post("/api/v1/mock/log_one/:id", async (req, res) => {
+router$a.post("/api/v1/mock/log_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1652,7 +2142,7 @@ router$8.post("/api/v1/mock/log_one/:id", async (req, res) => {
         });
     }
 });
-router$8.post("/api/v1/mock/log_filter", async (req, res) => {
+router$a.post("/api/v1/mock/log_filter", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, filterData, limit, offset } = request;
@@ -1680,7 +2170,7 @@ router$8.post("/api/v1/mock/log_filter", async (req, res) => {
         });
     }
 });
-router$8.post("/api/v1/mock/candles_live", async (req, res) => {
+router$a.post("/api/v1/mock/candles_live", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { signalId, interval, requestId, serviceName } = request;
@@ -1708,8 +2198,94 @@ router$8.post("/api/v1/mock/candles_live", async (req, res) => {
         });
     }
 });
+router$a.post("/api/v1/mock/candles_last", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, interval, requestId, serviceName } = request;
+        const data = await ioc.exchangeMockService.getLastCandles(symbol, interval);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/candles_last ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/candles_last error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+// SignalMockService endpoints
+router$a.post("/api/v1/mock/signal_last_update/:id", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const signalId = req.params.id;
+        const data = await ioc.signalMockService.getLastUpdateTimestamp(signalId);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/signal_last_update/:id ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/signal_last_update/:id error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$a.post("/api/v1/mock/signal_pending", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, requestId, serviceName } = request;
+        const data = await ioc.signalMockService.getPendingSignal(symbol);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/signal_pending ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/signal_pending error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 // StatusMockService endpoints
-router$8.post("/api/v1/mock/status_list", async (req, res) => {
+router$a.post("/api/v1/mock/status_list", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1737,7 +2313,7 @@ router$8.post("/api/v1/mock/status_list", async (req, res) => {
         });
     }
 });
-router$8.post("/api/v1/mock/status_one/:id", async (req, res) => {
+router$a.post("/api/v1/mock/status_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1766,12 +2342,97 @@ router$8.post("/api/v1/mock/status_one/:id", async (req, res) => {
         });
     }
 });
+// HeatMockService endpoints
+router$a.post("/api/v1/mock/heat_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.heatMockService.getStrategyHeatData();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/heat_data ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/heat_data error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$a.post("/api/v1/mock/heat_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.heatMockService.getStrategyHeatReport();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/heat_report ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/heat_report error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$a.post("/api/v1/mock/status_info", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.statusMockService.getStatusInfo();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/status_info ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/status_info error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
-const router$7 = Router({
+const router$9 = Router({
     params: true,
 });
 // ExchangeViewService endpoints
-router$7.post("/api/v1/view/candles_signal", async (req, res) => {
+router$9.post("/api/v1/view/candles_signal", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { signalId, interval, requestId, serviceName } = request;
@@ -1799,7 +2460,7 @@ router$7.post("/api/v1/view/candles_signal", async (req, res) => {
         });
     }
 });
-router$7.post("/api/v1/view/candles_point", async (req, res) => {
+router$9.post("/api/v1/view/candles_point", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { currentTime, interval, requestId, serviceName, symbol, exchangeName } = request;
@@ -1832,7 +2493,7 @@ router$7.post("/api/v1/view/candles_point", async (req, res) => {
         });
     }
 });
-router$7.post("/api/v1/view/candles_live", async (req, res) => {
+router$9.post("/api/v1/view/candles_live", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { signalId, interval, requestId, serviceName } = request;
@@ -1860,8 +2521,36 @@ router$7.post("/api/v1/view/candles_live", async (req, res) => {
         });
     }
 });
+router$9.post("/api/v1/view/candles_last", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, interval, requestId, serviceName } = request;
+        const data = await ioc.exchangeViewService.getLastCandles(symbol, interval);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/candles_last ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/candles_last error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 // NotificationViewService endpoints
-router$7.post("/api/v1/view/notification_list", async (req, res) => {
+router$9.post("/api/v1/view/notification_list", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1889,7 +2578,7 @@ router$7.post("/api/v1/view/notification_list", async (req, res) => {
         });
     }
 });
-router$7.post("/api/v1/view/notification_one/:id", async (req, res) => {
+router$9.post("/api/v1/view/notification_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1918,7 +2607,7 @@ router$7.post("/api/v1/view/notification_one/:id", async (req, res) => {
         });
     }
 });
-router$7.post("/api/v1/view/notification_filter", async (req, res) => {
+router$9.post("/api/v1/view/notification_filter", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, filterData, limit, offset } = request;
@@ -1947,7 +2636,7 @@ router$7.post("/api/v1/view/notification_filter", async (req, res) => {
     }
 });
 // StorageViewService endpoints
-router$7.post("/api/v1/view/storage_one/:id", async (req, res) => {
+router$9.post("/api/v1/view/storage_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1976,7 +2665,7 @@ router$7.post("/api/v1/view/storage_one/:id", async (req, res) => {
         });
     }
 });
-router$7.post("/api/v1/view/storage_list/live", async (req, res) => {
+router$9.post("/api/v1/view/storage_list/live", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -2004,7 +2693,7 @@ router$7.post("/api/v1/view/storage_list/live", async (req, res) => {
         });
     }
 });
-router$7.post("/api/v1/view/storage_list/backtest", async (req, res) => {
+router$9.post("/api/v1/view/storage_list/backtest", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -2033,7 +2722,7 @@ router$7.post("/api/v1/view/storage_list/backtest", async (req, res) => {
     }
 });
 // LogViewService endpoints
-router$7.post("/api/v1/view/log_list", async (req, res) => {
+router$9.post("/api/v1/view/log_list", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -2061,7 +2750,7 @@ router$7.post("/api/v1/view/log_list", async (req, res) => {
         });
     }
 });
-router$7.post("/api/v1/view/log_one/:id", async (req, res) => {
+router$9.post("/api/v1/view/log_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -2090,7 +2779,7 @@ router$7.post("/api/v1/view/log_one/:id", async (req, res) => {
         });
     }
 });
-router$7.post("/api/v1/view/log_filter", async (req, res) => {
+router$9.post("/api/v1/view/log_filter", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, filterData, limit, offset } = request;
@@ -2118,8 +2807,66 @@ router$7.post("/api/v1/view/log_filter", async (req, res) => {
         });
     }
 });
+// SignalViewService endpoints
+router$9.post("/api/v1/view/signal_last_update/:id", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const signalId = req.params.id;
+        const data = await ioc.signalViewService.getLastUpdateTimestamp(signalId);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/signal_last_update/:id ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/signal_last_update/:id error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$9.post("/api/v1/view/signal_pending", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, requestId, serviceName } = request;
+        const data = await ioc.signalViewService.getPendingSignal(symbol);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/signal_pending ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/signal_pending error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 // StatusViewService endpoints
-router$7.post("/api/v1/view/status_list", async (req, res) => {
+router$9.post("/api/v1/view/status_list", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -2147,7 +2894,7 @@ router$7.post("/api/v1/view/status_list", async (req, res) => {
         });
     }
 });
-router$7.post("/api/v1/view/status_one/:id", async (req, res) => {
+router$9.post("/api/v1/view/status_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -2176,6 +2923,91 @@ router$7.post("/api/v1/view/status_one/:id", async (req, res) => {
         });
     }
 });
+// HeatViewService endpoints
+router$9.post("/api/v1/view/heat_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.heatViewService.getStrategyHeatData();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/heat_data ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/heat_data error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$9.post("/api/v1/view/heat_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.heatViewService.getStrategyHeatReport();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/heat_report ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/heat_report error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$9.post("/api/v1/view/status_info", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.statusViewService.getStatusInfo();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/status_info ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/status_info error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 const require$2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
 function getModulesPath() {
@@ -2184,7 +3016,7 @@ function getModulesPath() {
     return path.join(basePath, "../../../");
 }
-const router$6 = Router({
+const router$8 = Router({
     params: true,
 });
 // getModulesPath
@@ -2201,7 +3033,7 @@ const ASSET_32 = CC_ENABLE_MOCK
 const cache128 = new Map();
 const cache32 = new Map();
 const cacheSvg = new Map();
-router$6.get("/icon/128/:filename", async (req, res) => {
+router$8.get("/icon/128/:filename", async (req, res) => {
     const filename = req.params.filename;
     // Check cache first
     if (cache128.has(filename)) {
@@ -2217,7 +3049,7 @@ router$6.get("/icon/128/:filename", async (req, res) => {
     }
     return await micro.send(res, 404, "File not found (128)");
 });
-router$6.get("/icon/32/:filename", async (req, res) => {
+router$8.get("/icon/32/:filename", async (req, res) => {
     const filename = req.params.filename;
     // Check cache first
     if (cache32.has(filename)) {
@@ -2233,7 +3065,7 @@ router$6.get("/icon/32/:filename", async (req, res) => {
     }
     return await micro.send(res, 404, "File not found (32)");
 });
-router$6.get("/icon/svg/:filename", async (req, res) => {
+router$8.get("/icon/svg/:filename", async (req, res) => {
     const filename = req.params.filename;
     // Check cache first
     if (cacheSvg.has(filename)) {
@@ -2249,7 +3081,7 @@ router$6.get("/icon/svg/:filename", async (req, res) => {
     }
     return await micro.send(res, 404, "File not found (svg)");
 });
-router$6.get("/icon/:filename", async (req, res) => {
+router$8.get("/icon/:filename", async (req, res) => {
     const filename = req.params.filename;
     // Check cache first
     if (cache32.has(filename)) {
@@ -2266,10 +3098,10 @@ router$6.get("/icon/:filename", async (req, res) => {
     return await micro.send(res, 404, "File not found (root)");
 });
-const router$5 = Router({
+const router$7 = Router({
     params: true,
 });
-router$5.post("/api/v1/dict/symbol/list", async (req, res) => {
+router$7.post("/api/v1/dict/symbol/list", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -2297,7 +3129,7 @@ router$5.post("/api/v1/dict/symbol/list", async (req, res) => {
         });
     }
 });
-router$5.post("/api/v1/dict/symbol/map", async (req, res) => {
+router$7.post("/api/v1/dict/symbol/map", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -2325,7 +3157,7 @@ router$5.post("/api/v1/dict/symbol/map", async (req, res) => {
         });
     }
 });
-router$5.post("/api/v1/dict/symbol/one", async (req, res) => {
+router$7.post("/api/v1/dict/symbol/one", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, id } = request;
@@ -2354,10 +3186,10 @@ router$5.post("/api/v1/dict/symbol/one", async (req, res) => {
     }
 });
-const router$4 = Router({
+const router$6 = Router({
     params: true,
 });
-router$4.post("/api/v1/markdown_mock/strategy_data", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/strategy_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2371,7 +3203,7 @@ router$4.post("/api/v1/markdown_mock/strategy_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/strategy_report", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/strategy_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2385,7 +3217,7 @@ router$4.post("/api/v1/markdown_mock/strategy_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/backtest_data", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/backtest_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2399,7 +3231,7 @@ router$4.post("/api/v1/markdown_mock/backtest_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/backtest_report", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/backtest_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2413,7 +3245,7 @@ router$4.post("/api/v1/markdown_mock/backtest_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/live_data", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/live_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName } = request;
@@ -2427,7 +3259,7 @@ router$4.post("/api/v1/markdown_mock/live_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/live_report", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/live_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName } = request;
@@ -2441,7 +3273,7 @@ router$4.post("/api/v1/markdown_mock/live_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/breakeven_data", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/breakeven_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2455,7 +3287,7 @@ router$4.post("/api/v1/markdown_mock/breakeven_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/breakeven_report", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/breakeven_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2469,7 +3301,7 @@ router$4.post("/api/v1/markdown_mock/breakeven_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/risk_data", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/risk_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2483,7 +3315,7 @@ router$4.post("/api/v1/markdown_mock/risk_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/risk_report", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/risk_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2497,7 +3329,7 @@ router$4.post("/api/v1/markdown_mock/risk_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/partial_data", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/partial_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2511,7 +3343,7 @@ router$4.post("/api/v1/markdown_mock/partial_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/partial_report", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/partial_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2525,7 +3357,7 @@ router$4.post("/api/v1/markdown_mock/partial_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/highest_profit_data", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/highest_profit_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2539,7 +3371,7 @@ router$4.post("/api/v1/markdown_mock/highest_profit_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/highest_profit_report", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/highest_profit_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2553,7 +3385,7 @@ router$4.post("/api/v1/markdown_mock/highest_profit_report", async (req, res) =>
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/schedule_data", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/schedule_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2567,7 +3399,7 @@ router$4.post("/api/v1/markdown_mock/schedule_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/schedule_report", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/schedule_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2581,7 +3413,7 @@ router$4.post("/api/v1/markdown_mock/schedule_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/performance_data", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/performance_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2595,7 +3427,7 @@ router$4.post("/api/v1/markdown_mock/performance_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/performance_report", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/performance_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2609,7 +3441,7 @@ router$4.post("/api/v1/markdown_mock/performance_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/sync_data", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/sync_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2623,7 +3455,7 @@ router$4.post("/api/v1/markdown_mock/sync_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/sync_report", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/sync_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2637,7 +3469,7 @@ router$4.post("/api/v1/markdown_mock/sync_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/heat_data", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/heat_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, strategyName, exchangeName, frameName } = request;
@@ -2651,7 +3483,7 @@ router$4.post("/api/v1/markdown_mock/heat_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/heat_report", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/heat_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, strategyName, exchangeName, frameName } = request;
@@ -2665,7 +3497,7 @@ router$4.post("/api/v1/markdown_mock/heat_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/walker_data", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/walker_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, walkerName } = request;
@@ -2679,7 +3511,7 @@ router$4.post("/api/v1/markdown_mock/walker_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$4.post("/api/v1/markdown_mock/walker_report", async (req, res) => {
+router$6.post("/api/v1/markdown_mock/walker_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, walkerName } = request;
@@ -2694,10 +3526,10 @@ router$4.post("/api/v1/markdown_mock/walker_report", async (req, res) => {
     }
 });
-const router$3 = Router({
+const router$5 = Router({
     params: true,
 });
-router$3.post("/api/v1/markdown_view/strategy_data", async (req, res) => {
+router$5.post("/api/v1/markdown_view/strategy_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2711,7 +3543,7 @@ router$3.post("/api/v1/markdown_view/strategy_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/strategy_report", async (req, res) => {
+router$5.post("/api/v1/markdown_view/strategy_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2725,7 +3557,7 @@ router$3.post("/api/v1/markdown_view/strategy_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/backtest_data", async (req, res) => {
+router$5.post("/api/v1/markdown_view/backtest_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2739,7 +3571,7 @@ router$3.post("/api/v1/markdown_view/backtest_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/backtest_report", async (req, res) => {
+router$5.post("/api/v1/markdown_view/backtest_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
@@ -2753,7 +3585,7 @@ router$3.post("/api/v1/markdown_view/backtest_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/live_data", async (req, res) => {
+router$5.post("/api/v1/markdown_view/live_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName } = request;
@@ -2767,7 +3599,7 @@ router$3.post("/api/v1/markdown_view/live_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/live_report", async (req, res) => {
+router$5.post("/api/v1/markdown_view/live_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName } = request;
@@ -2781,7 +3613,7 @@ router$3.post("/api/v1/markdown_view/live_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/breakeven_data", async (req, res) => {
+router$5.post("/api/v1/markdown_view/breakeven_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2795,7 +3627,7 @@ router$3.post("/api/v1/markdown_view/breakeven_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/breakeven_report", async (req, res) => {
+router$5.post("/api/v1/markdown_view/breakeven_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2809,7 +3641,7 @@ router$3.post("/api/v1/markdown_view/breakeven_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/risk_data", async (req, res) => {
+router$5.post("/api/v1/markdown_view/risk_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2823,7 +3655,7 @@ router$3.post("/api/v1/markdown_view/risk_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/risk_report", async (req, res) => {
+router$5.post("/api/v1/markdown_view/risk_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2837,7 +3669,7 @@ router$3.post("/api/v1/markdown_view/risk_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/partial_data", async (req, res) => {
+router$5.post("/api/v1/markdown_view/partial_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2851,7 +3683,7 @@ router$3.post("/api/v1/markdown_view/partial_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/partial_report", async (req, res) => {
+router$5.post("/api/v1/markdown_view/partial_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2865,7 +3697,7 @@ router$3.post("/api/v1/markdown_view/partial_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/highest_profit_data", async (req, res) => {
+router$5.post("/api/v1/markdown_view/highest_profit_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2879,7 +3711,7 @@ router$3.post("/api/v1/markdown_view/highest_profit_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/highest_profit_report", async (req, res) => {
+router$5.post("/api/v1/markdown_view/highest_profit_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2893,7 +3725,7 @@ router$3.post("/api/v1/markdown_view/highest_profit_report", async (req, res) =>
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/schedule_data", async (req, res) => {
+router$5.post("/api/v1/markdown_view/schedule_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2907,7 +3739,7 @@ router$3.post("/api/v1/markdown_view/schedule_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/schedule_report", async (req, res) => {
+router$5.post("/api/v1/markdown_view/schedule_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2921,7 +3753,7 @@ router$3.post("/api/v1/markdown_view/schedule_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/performance_data", async (req, res) => {
+router$5.post("/api/v1/markdown_view/performance_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2935,7 +3767,7 @@ router$3.post("/api/v1/markdown_view/performance_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/performance_report", async (req, res) => {
+router$5.post("/api/v1/markdown_view/performance_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2949,7 +3781,7 @@ router$3.post("/api/v1/markdown_view/performance_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/sync_data", async (req, res) => {
+router$5.post("/api/v1/markdown_view/sync_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2963,7 +3795,7 @@ router$3.post("/api/v1/markdown_view/sync_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/sync_report", async (req, res) => {
+router$5.post("/api/v1/markdown_view/sync_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
@@ -2977,7 +3809,7 @@ router$3.post("/api/v1/markdown_view/sync_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/heat_data", async (req, res) => {
+router$5.post("/api/v1/markdown_view/heat_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, strategyName, exchangeName, frameName, backtest } = request;
@@ -2991,7 +3823,7 @@ router$3.post("/api/v1/markdown_view/heat_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/heat_report", async (req, res) => {
+router$5.post("/api/v1/markdown_view/heat_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, strategyName, exchangeName, frameName, backtest } = request;
@@ -3005,7 +3837,7 @@ router$3.post("/api/v1/markdown_view/heat_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/walker_data", async (req, res) => {
+router$5.post("/api/v1/markdown_view/walker_data", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, walkerName } = request;
@@ -3019,7 +3851,7 @@ router$3.post("/api/v1/markdown_view/walker_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
     }
 });
-router$3.post("/api/v1/markdown_view/walker_report", async (req, res) => {
+router$5.post("/api/v1/markdown_view/walker_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, symbol, walkerName } = request;
@@ -3034,6 +3866,70 @@ router$3.post("/api/v1/markdown_view/walker_report", async (req, res) => {
     }
 });
+const router$4 = Router({
+    params: true,
+});
+router$4.post("/api/v1/explorer_mock/tree", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.explorerMockService.getTree();
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/explorer_mock/tree ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/explorer_mock/tree error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/explorer_mock/node", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, path } = request;
+        const data = await ioc.explorerMockService.getNode(path);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/explorer_mock/node ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/explorer_mock/node error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+const router$3 = Router({
+    params: true,
+});
+router$3.post("/api/v1/explorer_view/tree", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.explorerViewService.getTree();
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/explorer_view/tree ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/explorer_view/tree error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/explorer_view/node", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, path } = request;
+        const data = await ioc.explorerViewService.getNode(path);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/explorer_view/node ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/explorer_view/node error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
 const router$2 = Router({
     params: true,
 });
@@ -3105,25 +4001,31 @@ const router = Router({
     params: true,
 });
 router.all("/api/v1/health/*", (req, res) => {
-    return router$9(req, res, finalhandler(req, res));
+    return router$b(req, res, finalhandler(req, res));
 });
 router.all("/api/v1/mock/*", (req, res) => {
-    return router$8(req, res, finalhandler(req, res));
+    return router$a(req, res, finalhandler(req, res));
 });
 router.all("/api/v1/view/*", (req, res) => {
-    return router$7(req, res, finalhandler(req, res));
+    return router$9(req, res, finalhandler(req, res));
 });
 router.all("/api/v1/markdown_mock/*", (req, res) => {
-    return router$4(req, res, finalhandler(req, res));
+    return router$6(req, res, finalhandler(req, res));
 });
 router.all("/api/v1/markdown_view/*", (req, res) => {
+    return router$5(req, res, finalhandler(req, res));
+});
+router.all("/api/v1/explorer_mock/*", (req, res) => {
+    return router$4(req, res, finalhandler(req, res));
+});
+router.all("/api/v1/explorer_view/*", (req, res) => {
     return router$3(req, res, finalhandler(req, res));
 });
 router.all("/icon/*", (req, res) => {
-    return router$6(req, res, finalhandler(req, res));
+    return router$8(req, res, finalhandler(req, res));
 });
 router.all("/api/v1/dict/*", (req, res) => {
-    return router$5(req, res, finalhandler(req, res));
+    return router$7(req, res, finalhandler(req, res));
 });
 router.all("/api/v1/global/*", (req, res) => {
     return router$2(req, res, finalhandler(req, res));