@backtest-kit/ui 5.6.0 → 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, 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,
@@ -440,6 +503,7 @@ const MOCK_DIR = "./mock/markdown";
 const makeReader = (fileName) => singleshot(() => fs.readFile(path.join(MOCK_DIR, fileName), "utf-8"));
 const makeDataReader = (fileName) => singleshot(async () => JSON.parse(await fs.readFile(path.join(MOCK_DIR, "data", fileName), "utf-8")));
 const readBacktest = makeReader("backtest.md");
+const readStrategy = makeReader("strategy.md");
 const readLive = makeReader("live.md");
 const readBreakeven = makeReader("breakeven.md");
 const readRisk = makeReader("risk.md");
@@ -451,6 +515,7 @@ const readSync = makeReader("sync.md");
 const readHeat = makeReader("heat.md");
 const readWalker = makeReader("walker.md");
 const readBacktestData = makeDataReader("backtest.json");
+const readStrategyData = makeDataReader("strategy.json");
 const readLiveData = makeDataReader("live.json");
 const readBreakevenData = makeDataReader("breakeven.json");
 const readRiskData = makeDataReader("risk.json");
@@ -464,6 +529,15 @@ const readWalkerData = makeDataReader("walker.json");
 class MarkdownMockService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
+        // Strategy
+        this.getStrategyData = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getStrategyData", { symbol, strategyName, exchangeName, frameName });
+            return readStrategyData();
+        };
+        this.getStrategyReport = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getStrategyReport", { symbol, strategyName, exchangeName, frameName });
+            return readStrategy();
+        };
         // Backtest
         this.getBacktestData = async (symbol, strategyName, exchangeName, frameName) => {
             this.loggerService.log("markdownMockService getBacktestData", { symbol, strategyName, exchangeName, frameName });
@@ -566,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]));
@@ -710,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,
@@ -750,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}`);
         };
     }
 }
@@ -822,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) {
@@ -884,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,
@@ -904,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;
+        };
     }
 }
 
@@ -916,6 +1226,21 @@ class MarkdownViewService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.markdownMockService = inject(TYPES.markdownMockService);
+        // Strategy
+        this.getStrategyData = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getStrategyData", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getStrategyData(symbol, strategyName, exchangeName, frameName);
+            }
+            return await Strategy.getData(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        this.getStrategyReport = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getStrategyReport", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getStrategyReport(symbol, strategyName, exchangeName, frameName);
+            }
+            return await Strategy.getReport(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
         // Backtest
         this.getBacktestData = async (symbol, strategyName, exchangeName, frameName) => {
             this.loggerService.log("markdownViewService getBacktestData", { symbol, strategyName, exchangeName, frameName });
@@ -1084,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",
@@ -1280,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());
@@ -1288,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 = {
@@ -1310,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),
@@ -1318,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,
@@ -1328,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;
@@ -1360,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;
@@ -1394,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;
@@ -1422,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;
@@ -1451,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;
@@ -1480,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;
@@ -1509,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;
@@ -1537,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;
@@ -1566,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;
@@ -1594,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;
@@ -1623,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;
@@ -1651,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;
@@ -1679,12 +2195,11 @@ router$8.post("/api/v1/mock/candles_live", async (req, res) => {
         });
     }
 });
-// StatusMockService endpoints
-router$8.post("/api/v1/mock/status_list", async (req, res) => {
+router$a.post("/api/v1/mock/candles_last", async (req, res) => {
     try {
         const request = await micro.json(req);
-        const { requestId, serviceName } = request;
-        const data = await ioc.statusMockService.getStatusList();
+        const { symbol, interval, requestId, serviceName } = request;
+        const data = await ioc.exchangeMockService.getLastCandles(symbol, interval);
         const result = {
             data,
             status: "ok",
@@ -1692,14 +2207,14 @@ router$8.post("/api/v1/mock/status_list", async (req, res) => {
             requestId,
             serviceName,
         };
-        ioc.loggerService.log("/api/v1/mock/status_list ok", {
+        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/status_list error", {
+        ioc.loggerService.log("/api/v1/mock/candles_last error", {
             error: errorData(error),
         });
         return await micro.send(res, 200, {
@@ -1708,12 +2223,13 @@ router$8.post("/api/v1/mock/status_list", async (req, res) => {
         });
     }
 });
-router$8.post("/api/v1/mock/status_one/:id", async (req, res) => {
+// 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 id = req.params.id;
-        const data = await ioc.statusMockService.getStatusOne(id);
+        const signalId = req.params.id;
+        const data = await ioc.signalMockService.getLastUpdateTimestamp(signalId);
         const result = {
             data,
             status: "ok",
@@ -1721,14 +2237,14 @@ router$8.post("/api/v1/mock/status_one/:id", async (req, res) => {
             requestId,
             serviceName,
         };
-        ioc.loggerService.log("/api/v1/mock/status_one/:id ok", {
+        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/status_one/:id error", {
+        ioc.loggerService.log("/api/v1/mock/signal_last_update/:id error", {
             error: errorData(error),
         });
         return await micro.send(res, 200, {
@@ -1737,16 +2253,11 @@ router$8.post("/api/v1/mock/status_one/:id", async (req, res) => {
         });
     }
 });
-
-const router$7 = Router({
-    params: true,
-});
-// ExchangeViewService endpoints
-router$7.post("/api/v1/view/candles_signal", async (req, res) => {
+router$a.post("/api/v1/mock/signal_pending", async (req, res) => {
     try {
         const request = await micro.json(req);
-        const { signalId, interval, requestId, serviceName } = request;
-        const data = await ioc.exchangeViewService.getSignalCandles(signalId, interval);
+        const { symbol, requestId, serviceName } = request;
+        const data = await ioc.signalMockService.getPendingSignal(symbol);
         const result = {
             data,
             status: "ok",
@@ -1754,14 +2265,14 @@ router$7.post("/api/v1/view/candles_signal", async (req, res) => {
             requestId,
             serviceName,
         };
-        ioc.loggerService.log("/api/v1/view/candles_signal ok", {
+        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/view/candles_signal error", {
+        ioc.loggerService.log("/api/v1/mock/signal_pending error", {
             error: errorData(error),
         });
         return await micro.send(res, 200, {
@@ -1770,16 +2281,12 @@ router$7.post("/api/v1/view/candles_signal", async (req, res) => {
         });
     }
 });
-router$7.post("/api/v1/view/candles_point", async (req, res) => {
+// StatusMockService endpoints
+router$a.post("/api/v1/mock/status_list", async (req, res) => {
     try {
         const request = await micro.json(req);
-        const { currentTime, interval, requestId, serviceName, symbol, exchangeName } = request;
-        const data = await ioc.exchangeService.getPointCandles({
-            currentTime,
-            interval,
-            symbol,
-            exchangeName,
-        });
+        const { requestId, serviceName } = request;
+        const data = await ioc.statusMockService.getStatusList();
         const result = {
             data,
             status: "ok",
@@ -1787,14 +2294,14 @@ router$7.post("/api/v1/view/candles_point", async (req, res) => {
             requestId,
             serviceName,
         };
-        ioc.loggerService.log("/api/v1/view/candles_point ok", {
+        ioc.loggerService.log("/api/v1/mock/status_list ok", {
             request,
             result: omit(result, "data"),
         });
         return await micro.send(res, 200, result);
     }
     catch (error) {
-        ioc.loggerService.log("/api/v1/view/candles_point error", {
+        ioc.loggerService.log("/api/v1/mock/status_list error", {
             error: errorData(error),
         });
         return await micro.send(res, 200, {
@@ -1803,11 +2310,12 @@ router$7.post("/api/v1/view/candles_point", async (req, res) => {
         });
     }
 });
-router$7.post("/api/v1/view/candles_live", async (req, res) => {
+router$a.post("/api/v1/mock/status_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
-        const { signalId, interval, requestId, serviceName } = request;
-        const data = await ioc.exchangeViewService.getLiveCandles(signalId, interval);
+        const { requestId, serviceName } = request;
+        const id = req.params.id;
+        const data = await ioc.statusMockService.getStatusOne(id);
         const result = {
             data,
             status: "ok",
@@ -1815,14 +2323,14 @@ router$7.post("/api/v1/view/candles_live", async (req, res) => {
             requestId,
             serviceName,
         };
-        ioc.loggerService.log("/api/v1/view/candles_live ok", {
+        ioc.loggerService.log("/api/v1/mock/status_one/:id ok", {
             request,
             result: omit(result, "data"),
         });
         return await micro.send(res, 200, result);
     }
     catch (error) {
-        ioc.loggerService.log("/api/v1/view/candles_live error", {
+        ioc.loggerService.log("/api/v1/mock/status_one/:id error", {
             error: errorData(error),
         });
         return await micro.send(res, 200, {
@@ -1831,12 +2339,12 @@ router$7.post("/api/v1/view/candles_live", async (req, res) => {
         });
     }
 });
-// NotificationViewService endpoints
-router$7.post("/api/v1/view/notification_list", 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.notificationViewService.getList();
+        const data = await ioc.heatMockService.getStrategyHeatData();
         const result = {
             data,
             status: "ok",
@@ -1844,14 +2352,14 @@ router$7.post("/api/v1/view/notification_list", async (req, res) => {
             requestId,
             serviceName,
         };
-        ioc.loggerService.log("/api/v1/view/notification_list ok", {
+        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/view/notification_list error", {
+        ioc.loggerService.log("/api/v1/mock/heat_data error", {
             error: errorData(error),
         });
         return await micro.send(res, 200, {
@@ -1860,12 +2368,11 @@ router$7.post("/api/v1/view/notification_list", async (req, res) => {
         });
     }
 });
-router$7.post("/api/v1/view/notification_one/:id", async (req, res) => {
+router$a.post("/api/v1/mock/heat_report", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
-        const id = req.params.id;
-        const data = await ioc.notificationViewService.getOne(id);
+        const data = await ioc.heatMockService.getStrategyHeatReport();
         const result = {
             data,
             status: "ok",
@@ -1873,14 +2380,14 @@ router$7.post("/api/v1/view/notification_one/:id", async (req, res) => {
             requestId,
             serviceName,
         };
-        ioc.loggerService.log("/api/v1/view/notification_one/:id ok", {
+        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/view/notification_one/:id error", {
+        ioc.loggerService.log("/api/v1/mock/heat_report error", {
             error: errorData(error),
         });
         return await micro.send(res, 200, {
@@ -1889,11 +2396,11 @@ router$7.post("/api/v1/view/notification_one/:id", async (req, res) => {
         });
     }
 });
-router$7.post("/api/v1/view/notification_filter", async (req, res) => {
+router$a.post("/api/v1/mock/status_info", async (req, res) => {
     try {
         const request = await micro.json(req);
-        const { requestId, serviceName, filterData, limit, offset } = request;
-        const data = await ioc.notificationViewService.findByFilter(filterData, limit, offset);
+        const { requestId, serviceName } = request;
+        const data = await ioc.statusMockService.getStatusInfo();
         const result = {
             data,
             status: "ok",
@@ -1901,14 +2408,14 @@ router$7.post("/api/v1/view/notification_filter", async (req, res) => {
             requestId,
             serviceName,
         };
-        ioc.loggerService.log("/api/v1/view/notification_filter ok", {
+        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/view/notification_filter error", {
+        ioc.loggerService.log("/api/v1/mock/status_info error", {
             error: errorData(error),
         });
         return await micro.send(res, 200, {
@@ -1917,13 +2424,16 @@ 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) => {
+
+const router$9 = Router({
+    params: true,
+});
+// ExchangeViewService endpoints
+router$9.post("/api/v1/view/candles_signal", async (req, res) => {
     try {
         const request = await micro.json(req);
-        const { requestId, serviceName } = request;
-        const signalId = req.params.id;
-        const data = await ioc.storageViewService.findSignalById(signalId);
+        const { signalId, interval, requestId, serviceName } = request;
+        const data = await ioc.exchangeViewService.getSignalCandles(signalId, interval);
         const result = {
             data,
             status: "ok",
@@ -1931,14 +2441,14 @@ router$7.post("/api/v1/view/storage_one/:id", async (req, res) => {
             requestId,
             serviceName,
         };
-        ioc.loggerService.log("/api/v1/view/storage_one/:id ok", {
+        ioc.loggerService.log("/api/v1/view/candles_signal ok", {
             request,
             result: omit(result, "data"),
         });
         return await micro.send(res, 200, result);
     }
     catch (error) {
-        ioc.loggerService.log("/api/v1/view/storage_one/:id error", {
+        ioc.loggerService.log("/api/v1/view/candles_signal error", {
             error: errorData(error),
         });
         return await micro.send(res, 200, {
@@ -1947,11 +2457,16 @@ 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/candles_point", async (req, res) => {
     try {
         const request = await micro.json(req);
-        const { requestId, serviceName } = request;
-        const data = await ioc.storageViewService.listSignalLive();
+        const { currentTime, interval, requestId, serviceName, symbol, exchangeName } = request;
+        const data = await ioc.exchangeService.getPointCandles({
+            currentTime,
+            interval,
+            symbol,
+            exchangeName,
+        });
         const result = {
             data,
             status: "ok",
@@ -1959,14 +2474,14 @@ router$7.post("/api/v1/view/storage_list/live", async (req, res) => {
             requestId,
             serviceName,
         };
-        ioc.loggerService.log("/api/v1/view/storage_list/live ok", {
+        ioc.loggerService.log("/api/v1/view/candles_point ok", {
             request,
             result: omit(result, "data"),
         });
         return await micro.send(res, 200, result);
     }
     catch (error) {
-        ioc.loggerService.log("/api/v1/view/storage_list/live error", {
+        ioc.loggerService.log("/api/v1/view/candles_point error", {
             error: errorData(error),
         });
         return await micro.send(res, 200, {
@@ -1975,11 +2490,11 @@ 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/candles_live", async (req, res) => {
     try {
         const request = await micro.json(req);
-        const { requestId, serviceName } = request;
-        const data = await ioc.storageViewService.listSignalBacktest();
+        const { signalId, interval, requestId, serviceName } = request;
+        const data = await ioc.exchangeViewService.getLiveCandles(signalId, interval);
         const result = {
             data,
             status: "ok",
@@ -1987,14 +2502,14 @@ router$7.post("/api/v1/view/storage_list/backtest", async (req, res) => {
             requestId,
             serviceName,
         };
-        ioc.loggerService.log("/api/v1/view/storage_list/backtest ok", {
+        ioc.loggerService.log("/api/v1/view/candles_live ok", {
             request,
             result: omit(result, "data"),
         });
         return await micro.send(res, 200, result);
     }
     catch (error) {
-        ioc.loggerService.log("/api/v1/view/storage_list/backtest error", {
+        ioc.loggerService.log("/api/v1/view/candles_live error", {
             error: errorData(error),
         });
         return await micro.send(res, 200, {
@@ -2003,11 +2518,211 @@ 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/candles_last", async (req, res) => {
     try {
         const request = await micro.json(req);
-        const { requestId, serviceName } = request;
+        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$9.post("/api/v1/view/notification_list", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.notificationViewService.getList();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/notification_list ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/notification_list error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+router$9.post("/api/v1/view/notification_one/:id", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const id = req.params.id;
+        const data = await ioc.notificationViewService.getOne(id);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/notification_one/:id ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/notification_one/:id error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+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;
+        const data = await ioc.notificationViewService.findByFilter(filterData, limit, offset);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/notification_filter ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/notification_filter error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+// StorageViewService endpoints
+router$9.post("/api/v1/view/storage_one/:id", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const signalId = req.params.id;
+        const data = await ioc.storageViewService.findSignalById(signalId);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/storage_one/:id ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/storage_one/:id error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+router$9.post("/api/v1/view/storage_list/live", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.storageViewService.listSignalLive();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/storage_list/live ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/storage_list/live error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+router$9.post("/api/v1/view/storage_list/backtest", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.storageViewService.listSignalBacktest();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/storage_list/backtest ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/storage_list/backtest error", {
+            error: errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: getErrorMessage(error),
+        });
+    }
+});
+// LogViewService endpoints
+router$9.post("/api/v1/view/log_list", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
         const data = await ioc.logViewService.getList();
         const result = {
             data,
@@ -2032,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;
@@ -2061,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;
@@ -2089,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;
@@ -2118,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;
@@ -2147,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() {
@@ -2155,7 +3013,7 @@ function getModulesPath() {
     return join(basePath, "../../../");
 }
 
-const router$6 = Router({
+const router$8 = Router({
     params: true,
 });
 // getModulesPath
@@ -2172,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)) {
@@ -2188,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)) {
@@ -2204,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)) {
@@ -2220,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)) {
@@ -2237,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;
@@ -2268,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;
@@ -2296,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;
@@ -2325,10 +3183,38 @@ 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/backtest_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;
+        const data = await ioc.markdownMockService.getStrategyData(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/strategy_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/strategy_data error", { error: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: getErrorMessage(error) });
+    }
+});
+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;
+        const data = await ioc.markdownMockService.getStrategyReport(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/strategy_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/strategy_report error", { error: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: getErrorMessage(error) });
+    }
+});
+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;
@@ -2342,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;
@@ -2356,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;
@@ -2370,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;
@@ -2384,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;
@@ -2398,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;
@@ -2412,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;
@@ -2426,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;
@@ -2440,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;
@@ -2454,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;
@@ -2468,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;
@@ -2482,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;
@@ -2496,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;
@@ -2510,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;
@@ -2524,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;
@@ -2538,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;
@@ -2552,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;
@@ -2566,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;
@@ -2580,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;
@@ -2594,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;
@@ -2608,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;
@@ -2622,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;
@@ -2637,10 +3523,38 @@ 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/backtest_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;
+        const data = await ioc.markdownViewService.getStrategyData(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/strategy_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/strategy_data error", { error: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: getErrorMessage(error) });
+    }
+});
+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;
+        const data = await ioc.markdownViewService.getStrategyReport(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/strategy_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/strategy_report error", { error: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: getErrorMessage(error) });
+    }
+});
+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;
@@ -2654,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;
@@ -2668,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;
@@ -2682,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;
@@ -2696,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;
@@ -2710,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;
@@ -2724,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;
@@ -2738,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;
@@ -2752,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;
@@ -2766,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;
@@ -2780,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;
@@ -2794,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;
@@ -2808,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;
@@ -2822,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;
@@ -2836,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;
@@ -2850,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;
@@ -2864,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;
@@ -2878,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;
@@ -2892,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;
@@ -2906,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;
@@ -2920,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;
@@ -2934,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;
@@ -2949,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,
 });
@@ -3020,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));