@backtest-kit/ui 5.6.2 → 5.9.0

package/build/index.cjs

@@ -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,
+                    });
+                    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: "",
+                    });
+                    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,
+                });
+            }
+            if (liveItem) {
+                return await backtestKit.Heat.getData({
+                    strategyName: liveItem.strategyName,
+                    exchangeName: liveItem.exchangeName,
+                    frameName: "",
+                });
+            }
+            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));