@backtest-kit/ui 5.6.2 → 5.9.0

package/build/index.mjs

@@ -6,9 +6,11 @@ import finalhandler from 'finalhandler';
 import serveHandler from 'serve-handler';
 import os from 'os';
 import { createActivator } from 'di-kit';
-import { alignToInterval, Exchange, Notification, Storage, Log, Live, Strategy, Backtest, Breakeven, Risk, Partial, HighestProfit, Schedule, Performance, Sync, Heat, Walker, lib } from 'backtest-kit';
+import { alignToInterval, Exchange, Backtest, Live, listExchangeSchema, Notification, Storage, Log, lib, Heat, Strategy, Breakeven, Risk, Partial, HighestProfit, Schedule, Performance, Sync, Walker, StorageLive, StorageBacktest } from 'backtest-kit';
 import fs, { readdir, readFile } from 'fs/promises';
 import path, { join, dirname } from 'path';
+import mime from 'mime-types';
+import { createHash } from 'crypto';
 import { createRequire } from 'module';
 import { existsSync } from 'fs';
 
@@ -17,10 +19,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(),
@@ -69,6 +71,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"),
@@ -77,6 +82,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,
@@ -145,6 +153,14 @@ class ExchangeService {
                 exchangeName: dto.exchangeName,
             }, undefined, sDate, eDate);
         };
+        this.getLastCandles = async (dto) => {
+            this.loggerService.log("exchangeService getLastCandles", {
+                dto,
+            });
+            return await Exchange.getCandles(dto.symbol, dto.interval, dto.limit, {
+                exchangeName: dto.exchangeName,
+            });
+        };
     }
 }
 
@@ -179,9 +195,9 @@ class LoggerService {
     }
 }
 
-const MOCK_PATH$3 = "./mock/notifications.json";
+const MOCK_PATH$5 = "./mock/notifications.json";
 const READ_NOTIFICATION_LIST_FN = 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;
@@ -241,9 +257,9 @@ class NotificationMockService {
     }
 }
 
-const MOCK_PATH$2 = "./mock/db";
+const MOCK_PATH$4 = "./mock/db";
 const READ_BACKTEST_STORAGE_FN = singleshot(async () => {
-    const dbPath = join(process.cwd(), MOCK_PATH$2);
+    const dbPath = join(process.cwd(), MOCK_PATH$4);
     const files = await readdir(dbPath);
     const signals = [];
     for (const file of files) {
@@ -278,7 +294,7 @@ class StorageMockService {
     }
 }
 
-const MS_PER_MINUTE$1 = 60000;
+const HISTORY_LAST_CANDLES_LIMIT$1 = 200;
 class ExchangeMockService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
@@ -311,22 +327,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: alignToInterval(new Date(updatedAt), interval).getTime(),
+                interval,
+            });
+        };
+        this.getLastCandles = async (symbol, interval) => {
+            this.loggerService.log("exchangeMockService getLastCandles", {
+                symbol,
                 interval,
             });
+            const [backtestItem] = await Backtest.list();
+            const [liveItem] = await Live.list();
+            const [exchangeItem] = await 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 = 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;
@@ -374,14 +424,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 = 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 = 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();
@@ -401,33 +461,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,
@@ -577,6 +640,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 = singleshot(async () => {
+    const data = await fs.readFile(MOCK_PATH$1, "utf-8");
+    return JSON.parse(data);
+});
+const READ_EXPLORER_INDEX_FN = 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 = singleshot(async () => {
+    const dbPath = join(process.cwd(), MOCK_PATH);
+    const files = await readdir(dbPath);
+    const signals = [];
+    for (const file of files) {
+        if (!file.endsWith(".json")) {
+            continue;
+        }
+        const filePath = join(dbPath, file);
+        signals.push(JSON.parse(await readFile(filePath, "utf-8")));
+    }
+    return signals;
+});
+const READ_PENDING_SIGNAL_FN = singleshot(async () => {
+    const filePath = join(process.cwd(), MOCK_SIGNAL_PATH);
+    return JSON.parse(await 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 = singleshot(async () => {
+    const data = await fs.readFile(MOCK_DATA_PATH, "utf-8");
+    return JSON.parse(data);
+});
+const READ_HEAT_REPORT_FN = 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]));
@@ -721,13 +905,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,
@@ -761,15 +946,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: 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 Backtest.list();
+            const [liveItem] = await Live.list();
+            const [exchangeItem] = await 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}`);
         };
     }
 }
@@ -833,6 +1056,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) {
@@ -895,6 +1119,12 @@ class StatusViewService {
             if (!positionPartials) {
                 return null;
             }
+            const timestamp = await 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,
@@ -915,11 +1145,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 Backtest.list();
+                if (backtestTarget) {
+                    const currentHeat = await 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 Live.list();
+                if (liveTarget) {
+                    const currentHeat = await 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;
+        };
     }
 }
 
@@ -1110,6 +1409,185 @@ class MarkdownViewService {
     }
 }
 
+const pathId = (p) => 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 = 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 StorageLive.findById(signalId);
+                if (liveSignal) {
+                    return liveSignal.updatedAt;
+                }
+            }
+            {
+                const backtestSignal = await 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 Live.list();
+                const liveTarget = liveList.find((live) => live.symbol === symbol);
+                if (liveTarget) {
+                    const currentPrice = await Exchange.getAveragePrice(symbol, {
+                        exchangeName: liveTarget.exchangeName,
+                    });
+                    return await 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 Backtest.list();
+            const [liveItem] = await Live.list();
+            if (backtestItem) {
+                return await Heat.getData({
+                    strategyName: backtestItem.strategyName,
+                    exchangeName: backtestItem.exchangeName,
+                    frameName: backtestItem.frameName,
+                });
+            }
+            if (liveItem) {
+                return await 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 Backtest.list();
+            const [liveItem] = await Live.list();
+            if (backtestItem) {
+                return await Heat.getReport({
+                    strategyName: backtestItem.strategyName,
+                    exchangeName: backtestItem.exchangeName,
+                    frameName: backtestItem.frameName,
+                });
+            }
+            if (liveItem) {
+                return await Heat.getReport({
+                    strategyName: liveItem.strategyName,
+                    exchangeName: liveItem.exchangeName,
+                    frameName: "",
+                });
+            }
+            return null;
+        };
+    }
+}
+
 const symbol_list = [
     {
         icon: "/icon/btc.png",
@@ -1306,6 +1784,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());
@@ -1314,6 +1795,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 = {
@@ -1336,6 +1820,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),
@@ -1344,6 +1831,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,
@@ -1354,11 +1844,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;
@@ -1386,7 +1876,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;
@@ -1420,7 +1910,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;
@@ -1448,7 +1938,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;
@@ -1477,7 +1967,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;
@@ -1506,7 +1996,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;
@@ -1535,7 +2025,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;
@@ -1563,7 +2053,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;
@@ -1592,7 +2082,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;
@@ -1620,7 +2110,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;
@@ -1649,7 +2139,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;
@@ -1677,7 +2167,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;
@@ -1705,8 +2195,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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: 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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: 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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: 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;
@@ -1734,7 +2310,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;
@@ -1763,12 +2339,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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: 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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: 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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: 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;
@@ -1796,7 +2457,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;
@@ -1829,7 +2490,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;
@@ -1857,8 +2518,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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: 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;
@@ -1886,7 +2575,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;
@@ -1915,7 +2604,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;
@@ -1944,7 +2633,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;
@@ -1973,7 +2662,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;
@@ -2001,7 +2690,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;
@@ -2030,7 +2719,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;
@@ -2058,7 +2747,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;
@@ -2087,7 +2776,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;
@@ -2115,8 +2804,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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: 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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: 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;
@@ -2144,7 +2891,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;
@@ -2173,6 +2920,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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: 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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: 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: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
 
 const require$1 = createRequire(import.meta.url);
 function getModulesPath() {
@@ -2181,7 +3013,7 @@ function getModulesPath() {
     return join(basePath, "../../../");
 }
 
-const router$6 = Router({
+const router$8 = Router({
     params: true,
 });
 // getModulesPath
@@ -2198,7 +3030,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)) {
@@ -2214,7 +3046,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)) {
@@ -2230,7 +3062,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)) {
@@ -2246,7 +3078,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)) {
@@ -2263,10 +3095,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;
@@ -2294,7 +3126,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;
@@ -2322,7 +3154,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;
@@ -2351,10 +3183,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;
@@ -2368,7 +3200,7 @@ router$4.post("/api/v1/markdown_mock/strategy_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2382,7 +3214,7 @@ router$4.post("/api/v1/markdown_mock/strategy_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2396,7 +3228,7 @@ router$4.post("/api/v1/markdown_mock/backtest_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2410,7 +3242,7 @@ router$4.post("/api/v1/markdown_mock/backtest_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2424,7 +3256,7 @@ router$4.post("/api/v1/markdown_mock/live_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2438,7 +3270,7 @@ router$4.post("/api/v1/markdown_mock/live_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2452,7 +3284,7 @@ router$4.post("/api/v1/markdown_mock/breakeven_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2466,7 +3298,7 @@ router$4.post("/api/v1/markdown_mock/breakeven_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2480,7 +3312,7 @@ router$4.post("/api/v1/markdown_mock/risk_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2494,7 +3326,7 @@ router$4.post("/api/v1/markdown_mock/risk_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2508,7 +3340,7 @@ router$4.post("/api/v1/markdown_mock/partial_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2522,7 +3354,7 @@ router$4.post("/api/v1/markdown_mock/partial_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2536,7 +3368,7 @@ router$4.post("/api/v1/markdown_mock/highest_profit_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2550,7 +3382,7 @@ router$4.post("/api/v1/markdown_mock/highest_profit_report", async (req, res) =>
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2564,7 +3396,7 @@ router$4.post("/api/v1/markdown_mock/schedule_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2578,7 +3410,7 @@ router$4.post("/api/v1/markdown_mock/schedule_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2592,7 +3424,7 @@ router$4.post("/api/v1/markdown_mock/performance_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2606,7 +3438,7 @@ router$4.post("/api/v1/markdown_mock/performance_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2620,7 +3452,7 @@ router$4.post("/api/v1/markdown_mock/sync_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2634,7 +3466,7 @@ router$4.post("/api/v1/markdown_mock/sync_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2648,7 +3480,7 @@ router$4.post("/api/v1/markdown_mock/heat_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2662,7 +3494,7 @@ router$4.post("/api/v1/markdown_mock/heat_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2676,7 +3508,7 @@ router$4.post("/api/v1/markdown_mock/walker_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2691,10 +3523,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;
@@ -2708,7 +3540,7 @@ router$3.post("/api/v1/markdown_view/strategy_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2722,7 +3554,7 @@ router$3.post("/api/v1/markdown_view/strategy_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2736,7 +3568,7 @@ router$3.post("/api/v1/markdown_view/backtest_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2750,7 +3582,7 @@ router$3.post("/api/v1/markdown_view/backtest_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2764,7 +3596,7 @@ router$3.post("/api/v1/markdown_view/live_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2778,7 +3610,7 @@ router$3.post("/api/v1/markdown_view/live_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2792,7 +3624,7 @@ router$3.post("/api/v1/markdown_view/breakeven_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2806,7 +3638,7 @@ router$3.post("/api/v1/markdown_view/breakeven_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2820,7 +3652,7 @@ router$3.post("/api/v1/markdown_view/risk_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2834,7 +3666,7 @@ router$3.post("/api/v1/markdown_view/risk_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2848,7 +3680,7 @@ router$3.post("/api/v1/markdown_view/partial_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2862,7 +3694,7 @@ router$3.post("/api/v1/markdown_view/partial_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2876,7 +3708,7 @@ router$3.post("/api/v1/markdown_view/highest_profit_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2890,7 +3722,7 @@ router$3.post("/api/v1/markdown_view/highest_profit_report", async (req, res) =>
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2904,7 +3736,7 @@ router$3.post("/api/v1/markdown_view/schedule_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2918,7 +3750,7 @@ router$3.post("/api/v1/markdown_view/schedule_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2932,7 +3764,7 @@ router$3.post("/api/v1/markdown_view/performance_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2946,7 +3778,7 @@ router$3.post("/api/v1/markdown_view/performance_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2960,7 +3792,7 @@ router$3.post("/api/v1/markdown_view/sync_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2974,7 +3806,7 @@ router$3.post("/api/v1/markdown_view/sync_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -2988,7 +3820,7 @@ router$3.post("/api/v1/markdown_view/heat_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -3002,7 +3834,7 @@ router$3.post("/api/v1/markdown_view/heat_report", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -3016,7 +3848,7 @@ router$3.post("/api/v1/markdown_view/walker_data", async (req, res) => {
         return await micro.send(res, 200, { status: "error", error: 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;
@@ -3031,6 +3863,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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: getErrorMessage(error) });
+    }
+});
+
 const router$2 = Router({
     params: true,
 });
@@ -3102,25 +3998,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));