tickflow-assist 0.2.0

package/dist/bootstrap.js

@@ -0,0 +1,214 @@
+import { TickFlowClient } from "./services/tickflow-client.js";
+import { InstrumentService } from "./services/instrument-service.js";
+import { KlineService } from "./services/kline-service.js";
+import { IndicatorService } from "./services/indicator-service.js";
+import { FinancialService } from "./services/financial-service.js";
+import { FinancialLiteService } from "./services/financial-lite-service.js";
+import { MxApiService } from "./services/mx-search-service.js";
+import { Database } from "./storage/db.js";
+import { WatchlistRepository } from "./storage/repositories/watchlist-repo.js";
+import { KlinesRepository } from "./storage/repositories/klines-repo.js";
+import { IntradayKlinesRepository } from "./storage/repositories/intraday-klines-repo.js";
+import { IndicatorsRepository } from "./storage/repositories/indicators-repo.js";
+import { KeyLevelsRepository } from "./storage/repositories/key-levels-repo.js";
+import { KeyLevelsHistoryRepository } from "./storage/repositories/key-levels-history-repo.js";
+import { AnalysisLogRepository } from "./storage/repositories/analysis-log-repo.js";
+import { AlertLogRepository } from "./storage/repositories/alert-log-repo.js";
+import { TechnicalAnalysisRepository } from "./storage/repositories/technical-analysis-repo.js";
+import { FinancialAnalysisRepository } from "./storage/repositories/financial-analysis-repo.js";
+import { NewsAnalysisRepository } from "./storage/repositories/news-analysis-repo.js";
+import { CompositeAnalysisRepository } from "./storage/repositories/composite-analysis-repo.js";
+import { WatchlistService } from "./services/watchlist-service.js";
+import { WatchlistProfileService } from "./services/watchlist-profile-service.js";
+import { AnalysisService } from "./services/analysis-service.js";
+import { AnalysisViewService } from "./services/analysis-view-service.js";
+import { QuoteService } from "./services/quote-service.js";
+import { TradingCalendarService } from "./services/trading-calendar-service.js";
+import { MonitorService } from "./services/monitor-service.js";
+import { AlertService } from "./services/alert-service.js";
+import { UpdateService } from "./services/update-service.js";
+import { KeyLevelsBacktestService } from "./services/key-levels-backtest-service.js";
+import { PostCloseReviewService } from "./services/post-close-review-service.js";
+import { ReviewMemoryService } from "./services/review-memory-service.js";
+import { CompositeAnalysisOrchestrator } from "./analysis/orchestrators/composite-analysis.orchestrator.js";
+import { MarketAnalysisProvider } from "./analysis/providers/market-analysis.provider.js";
+import { FinancialAnalysisProvider } from "./analysis/providers/financial-analysis.provider.js";
+import { NewsAnalysisProvider } from "./analysis/providers/news-analysis.provider.js";
+import { KlineTechnicalSignalTask } from "./analysis/tasks/kline-technical-signal.task.js";
+import { FinancialFundamentalTask } from "./analysis/tasks/financial-fundamental.task.js";
+import { FinancialFundamentalLiteTask } from "./analysis/tasks/financial-fundamental-lite.task.js";
+import { NewsCatalystTask } from "./analysis/tasks/news-catalyst.task.js";
+import { CompositeStockAnalysisTask } from "./analysis/tasks/composite-stock-analysis.task.js";
+import { PostCloseReviewTask } from "./analysis/tasks/post-close-review.task.js";
+import { addStockTool } from "./tools/add-stock.tool.js";
+import { analyzeTool } from "./tools/analyze.tool.js";
+import { fetchKlinesTool } from "./tools/fetch-klines.tool.js";
+import { fetchIntradayKlinesTool } from "./tools/fetch-intraday-klines.tool.js";
+import { fetchFinancialsTool } from "./tools/fetch-financials.tool.js";
+import { mxSearchTool } from "./tools/mx-search.tool.js";
+import { mxSelectStockTool } from "./tools/mx-select-stock.tool.js";
+import { listWatchlistTool } from "./tools/list-watchlist.tool.js";
+import { dailyUpdateStatusTool } from "./tools/daily-update-status.tool.js";
+import { monitorStatusTool } from "./tools/monitor-status.tool.js";
+import { refreshWatchlistNamesTool } from "./tools/refresh-watchlist-names.tool.js";
+import { refreshWatchlistProfilesTool } from "./tools/refresh-watchlist-profiles.tool.js";
+import { queryDatabaseTool } from "./tools/query-database.tool.js";
+import { removeStockTool } from "./tools/remove-stock.tool.js";
+import { startDailyUpdateTool } from "./tools/start-daily-update.tool.js";
+import { startMonitorTool } from "./tools/start-monitor.tool.js";
+import { stopDailyUpdateTool } from "./tools/stop-daily-update.tool.js";
+import { stopMonitorTool } from "./tools/stop-monitor.tool.js";
+import { testAlertTool } from "./tools/test-alert.tool.js";
+import { updateAllTool } from "./tools/update-all.tool.js";
+import { viewAnalysisTool } from "./tools/view-analysis.tool.js";
+import { backtestKeyLevelsTool } from "./tools/backtest-key-levels.tool.js";
+import { RealtimeMonitorWorker } from "./background/realtime-monitor.worker.js";
+import { DailyUpdateWorker } from "./background/daily-update.worker.js";
+export function createAppContext(config, options = {}) {
+    const runtime = {
+        configSource: options.configSource ?? "local_config",
+        pluginManagedServices: options.pluginManagedServices ?? false,
+        openclawConfig: options.openclawConfig,
+        pluginRuntime: options.pluginRuntime,
+    };
+    const tickflowClient = new TickFlowClient(config.tickflowApiUrl, config.tickflowApiKey);
+    const database = new Database(config.databasePath);
+    const watchlistRepository = new WatchlistRepository(database);
+    const klinesRepository = new KlinesRepository(database);
+    const intradayKlinesRepository = new IntradayKlinesRepository(database);
+    const indicatorsRepository = new IndicatorsRepository(database);
+    const keyLevelsRepository = new KeyLevelsRepository(database);
+    const keyLevelsHistoryRepository = new KeyLevelsHistoryRepository(database);
+    const analysisLogRepository = new AnalysisLogRepository(database);
+    const alertLogRepository = new AlertLogRepository(database);
+    const technicalAnalysisRepository = new TechnicalAnalysisRepository(database);
+    const financialAnalysisRepository = new FinancialAnalysisRepository(database);
+    const newsAnalysisRepository = new NewsAnalysisRepository(database);
+    const compositeAnalysisRepository = new CompositeAnalysisRepository(database);
+    const instrumentService = new InstrumentService(tickflowClient);
+    const klineService = new KlineService(tickflowClient);
+    const quoteService = new QuoteService(tickflowClient);
+    const financialService = new FinancialService(tickflowClient);
+    const mxApiService = new MxApiService(config.mxSearchApiUrl, config.mxSearchApiKey);
+    const financialLiteService = new FinancialLiteService(mxApiService);
+    const analysisService = new AnalysisService(config.llmBaseUrl, config.llmApiKey, config.llmModel, analysisLogRepository);
+    const watchlistProfileService = new WatchlistProfileService(mxApiService, analysisService);
+    const tradingCalendarService = new TradingCalendarService(config.calendarFile);
+    const alertService = new AlertService({
+        openclawCliBin: config.openclawCliBin,
+        channel: config.alertChannel,
+        account: config.alertAccount,
+        target: config.alertTarget,
+        runtime: runtime.openclawConfig && runtime.pluginRuntime
+            ? {
+                config: runtime.openclawConfig,
+                runtime: runtime.pluginRuntime,
+            }
+            : undefined,
+    });
+    const indicatorService = new IndicatorService(config.pythonBin, config.pythonArgs, config.pythonWorkdir);
+    const watchlistService = new WatchlistService(watchlistRepository, instrumentService, watchlistProfileService);
+    const keyLevelsBacktestService = new KeyLevelsBacktestService(keyLevelsHistoryRepository, klinesRepository, intradayKlinesRepository, watchlistService);
+    const reviewMemoryService = new ReviewMemoryService(keyLevelsBacktestService);
+    const analysisViewService = new AnalysisViewService(analysisLogRepository, keyLevelsRepository, technicalAnalysisRepository, financialAnalysisRepository, newsAnalysisRepository, compositeAnalysisRepository);
+    const marketAnalysisProvider = new MarketAnalysisProvider(config.tickflowApiKeyLevel, watchlistService, klineService, quoteService, indicatorService, reviewMemoryService, tradingCalendarService, klinesRepository, intradayKlinesRepository, indicatorsRepository);
+    const financialAnalysisProvider = new FinancialAnalysisProvider(config.tickflowApiKeyLevel, financialService, financialLiteService);
+    const newsAnalysisProvider = new NewsAnalysisProvider(mxApiService);
+    const klineTechnicalSignalTask = new KlineTechnicalSignalTask();
+    const financialFundamentalTask = new FinancialFundamentalTask();
+    const financialFundamentalLiteTask = new FinancialFundamentalLiteTask();
+    const newsCatalystTask = new NewsCatalystTask();
+    const postCloseReviewTask = new PostCloseReviewTask();
+    const compositeStockAnalysisTask = new CompositeStockAnalysisTask(keyLevelsRepository, analysisLogRepository);
+    const compositeAnalysisOrchestrator = new CompositeAnalysisOrchestrator(analysisService, marketAnalysisProvider, financialAnalysisProvider, newsAnalysisProvider, klineTechnicalSignalTask, financialFundamentalTask, financialFundamentalLiteTask, newsCatalystTask, compositeStockAnalysisTask, technicalAnalysisRepository, financialAnalysisRepository, newsAnalysisRepository, compositeAnalysisRepository);
+    const monitorService = new MonitorService(config.databasePath, config.requestInterval, config.alertChannel, watchlistService, quoteService, tradingCalendarService, keyLevelsRepository, alertLogRepository, klinesRepository, alertService);
+    const updateService = new UpdateService(klineService, config.tickflowApiKeyLevel, indicatorService, klinesRepository, indicatorsRepository, intradayKlinesRepository, watchlistService, tradingCalendarService);
+    const postCloseReviewService = new PostCloseReviewService(watchlistService, compositeAnalysisOrchestrator, analysisService, postCloseReviewTask, keyLevelsRepository, keyLevelsHistoryRepository, klinesRepository, intradayKlinesRepository);
+    const realtimeMonitorWorker = new RealtimeMonitorWorker(monitorService, config.requestInterval * 1000);
+    const dailyUpdateWorker = new DailyUpdateWorker(updateService, postCloseReviewService, tradingCalendarService, config.databasePath, alertService, config.dailyUpdateNotify, runtime.configSource);
+    let managedLoopAbortController = null;
+    let managedLoopPromise = null;
+    return {
+        config,
+        tools: [
+            addStockTool(watchlistService, klineService, klinesRepository, indicatorService, indicatorsRepository),
+            analyzeTool(compositeAnalysisOrchestrator),
+            backtestKeyLevelsTool(keyLevelsBacktestService),
+            dailyUpdateStatusTool(dailyUpdateWorker, runtime.configSource),
+            fetchIntradayKlinesTool(config.tickflowApiKeyLevel, klineService, intradayKlinesRepository, tradingCalendarService),
+            fetchFinancialsTool(financialService),
+            fetchKlinesTool(klineService, klinesRepository, indicatorService, indicatorsRepository),
+            listWatchlistTool(watchlistService),
+            monitorStatusTool(monitorService),
+            mxSearchTool(mxApiService),
+            mxSelectStockTool(mxApiService),
+            queryDatabaseTool(database),
+            refreshWatchlistNamesTool(watchlistService),
+            refreshWatchlistProfilesTool(watchlistService),
+            removeStockTool(watchlistService),
+            startDailyUpdateTool(dailyUpdateWorker, config, runtime.configSource, runtime),
+            startMonitorTool(monitorService, runtime),
+            stopDailyUpdateTool(dailyUpdateWorker, runtime),
+            stopMonitorTool(monitorService, runtime),
+            testAlertTool(alertService),
+            updateAllTool(dailyUpdateWorker),
+            viewAnalysisTool(analysisViewService),
+        ],
+        backgroundServices: [
+            {
+                id: "tickflow-assist.managed-loop",
+                start: async () => {
+                    if (managedLoopAbortController) {
+                        return;
+                    }
+                    const abortController = new AbortController();
+                    managedLoopAbortController = abortController;
+                    await dailyUpdateWorker.bindManagedServiceRuntime(runtime.configSource);
+                    await monitorService.bindManagedServiceRuntime();
+                    managedLoopPromise = Promise.all([
+                        dailyUpdateWorker
+                            .runLoop(abortController.signal, "plugin_service", runtime.configSource)
+                            .catch(() => { }),
+                        realtimeMonitorWorker
+                            .runLoop(abortController.signal, "plugin_service")
+                            .catch(() => { }),
+                    ]).then(() => undefined);
+                },
+                stop: async () => {
+                    const abortController = managedLoopAbortController;
+                    const runPromise = managedLoopPromise;
+                    managedLoopAbortController = null;
+                    managedLoopPromise = null;
+                    if (!abortController) {
+                        return;
+                    }
+                    abortController.abort();
+                    await runPromise;
+                },
+            },
+        ],
+        runtime,
+        services: {
+            alertService,
+            monitorService,
+            realtimeMonitorWorker,
+            dailyUpdateWorker,
+            watchlistService,
+            database,
+        },
+    };
+}
+export async function buildWatchlistDebugSnapshot(app) {
+    const watchlistTableExists = await app.services.database.hasTable("watchlist");
+    const watchlistPreview = await app.services.watchlistService.list();
+    return {
+        databasePath: app.config.databasePath,
+        calendarFile: app.config.calendarFile,
+        requestInterval: app.config.requestInterval,
+        configSource: app.runtime.configSource,
+        pid: process.pid,
+        watchlistTableExists,
+        watchlistCount: watchlistPreview.length,
+        watchlistPreview: watchlistPreview.slice(0, 5),
+    };
+}

package/dist/config/normalize.d.ts

@@ -0,0 +1,4 @@
+import { type PluginConfig } from "./schema.js";
+export declare function normalizePluginConfig(input: unknown): PluginConfig;
+export declare function resolvePluginConfigPaths(config: PluginConfig, baseDir: string): PluginConfig;
+export declare function validatePluginConfig(config: PluginConfig): string[];

package/dist/config/normalize.js

@@ -0,0 +1,99 @@
+import path from "node:path";
+import { normalizeTickflowApiKeyLevel } from "./tickflow-access.js";
+import { DEFAULT_PLUGIN_CONFIG } from "./schema.js";
+function normalizeString(value, fallback = "") {
+    if (typeof value === "string") {
+        return value.trim();
+    }
+    if (value == null) {
+        return fallback;
+    }
+    return String(value).trim();
+}
+function normalizeInteger(value, fallback) {
+    const parsed = Number(value ?? fallback);
+    return Number.isFinite(parsed) ? Math.max(1, Math.trunc(parsed)) : fallback;
+}
+function normalizeStringArray(value, fallback) {
+    if (Array.isArray(value)) {
+        return value.map((item) => String(item).trim()).filter(Boolean);
+    }
+    return fallback;
+}
+function normalizeBoolean(value, fallback) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (["true", "1", "yes", "on"].includes(normalized)) {
+            return true;
+        }
+        if (["false", "0", "no", "off"].includes(normalized)) {
+            return false;
+        }
+    }
+    if (typeof value === "number") {
+        return value !== 0;
+    }
+    return fallback;
+}
+export function normalizePluginConfig(input) {
+    const raw = (input ?? {});
+    const envMxSearchApiUrl = normalizeString(process.env.MX_SEARCH_API_URL);
+    const envMxSearchApiKey = normalizeString(process.env.MX_APIKEY);
+    return {
+        tickflowApiUrl: normalizeString(raw.tickflowApiUrl, DEFAULT_PLUGIN_CONFIG.tickflowApiUrl),
+        tickflowApiKey: normalizeString(raw.tickflowApiKey),
+        tickflowApiKeyLevel: normalizeTickflowApiKeyLevel(raw.tickflowApiKeyLevel, DEFAULT_PLUGIN_CONFIG.tickflowApiKeyLevel),
+        mxSearchApiUrl: normalizeString(raw.mxSearchApiUrl, envMxSearchApiUrl || DEFAULT_PLUGIN_CONFIG.mxSearchApiUrl),
+        mxSearchApiKey: normalizeString(raw.mxSearchApiKey, envMxSearchApiKey || DEFAULT_PLUGIN_CONFIG.mxSearchApiKey),
+        llmBaseUrl: normalizeString(raw.llmBaseUrl, DEFAULT_PLUGIN_CONFIG.llmBaseUrl),
+        llmApiKey: normalizeString(raw.llmApiKey),
+        llmModel: normalizeString(raw.llmModel, DEFAULT_PLUGIN_CONFIG.llmModel),
+        databasePath: normalizeString(raw.databasePath, DEFAULT_PLUGIN_CONFIG.databasePath),
+        calendarFile: normalizeString(raw.calendarFile, DEFAULT_PLUGIN_CONFIG.calendarFile),
+        requestInterval: normalizeInteger(raw.requestInterval, DEFAULT_PLUGIN_CONFIG.requestInterval),
+        dailyUpdateNotify: normalizeBoolean(raw.dailyUpdateNotify, DEFAULT_PLUGIN_CONFIG.dailyUpdateNotify),
+        alertChannel: normalizeString(raw.alertChannel, DEFAULT_PLUGIN_CONFIG.alertChannel),
+        openclawCliBin: normalizeString(raw.openclawCliBin, DEFAULT_PLUGIN_CONFIG.openclawCliBin),
+        alertAccount: normalizeString(raw.alertAccount, DEFAULT_PLUGIN_CONFIG.alertAccount),
+        alertTarget: normalizeString(raw.alertTarget),
+        pythonBin: normalizeString(raw.pythonBin, DEFAULT_PLUGIN_CONFIG.pythonBin),
+        pythonArgs: normalizeStringArray(raw.pythonArgs, DEFAULT_PLUGIN_CONFIG.pythonArgs),
+        pythonWorkdir: normalizeString(raw.pythonWorkdir, DEFAULT_PLUGIN_CONFIG.pythonWorkdir),
+    };
+}
+export function resolvePluginConfigPaths(config, baseDir) {
+    return {
+        ...config,
+        databasePath: resolveConfigPath(config.databasePath, baseDir),
+        calendarFile: resolveConfigPath(config.calendarFile, baseDir),
+        pythonWorkdir: resolveConfigPath(config.pythonWorkdir, baseDir),
+    };
+}
+export function validatePluginConfig(config) {
+    const errors = [];
+    if (!config.tickflowApiKey) {
+        errors.push("tickflowApiKey is required");
+    }
+    if (!config.llmApiKey) {
+        errors.push("llmApiKey is required");
+    }
+    if (!config.alertTarget) {
+        errors.push("alertTarget is required");
+    }
+    if (!config.tickflowApiUrl.startsWith("http://") && !config.tickflowApiUrl.startsWith("https://")) {
+        errors.push("tickflowApiUrl must be an absolute http(s) URL");
+    }
+    if (config.requestInterval < 5) {
+        errors.push("requestInterval must be at least 5 seconds");
+    }
+    return errors;
+}
+function resolveConfigPath(value, baseDir) {
+    if (!value) {
+        return value;
+    }
+    return path.isAbsolute(value) ? value : path.resolve(baseDir, value);
+}

package/dist/config/schema.d.ts

@@ -0,0 +1,23 @@
+import type { TickflowApiKeyLevel } from "./tickflow-access.js";
+export interface PluginConfig {
+    tickflowApiUrl: string;
+    tickflowApiKey: string;
+    tickflowApiKeyLevel: TickflowApiKeyLevel;
+    mxSearchApiUrl: string;
+    mxSearchApiKey: string;
+    llmBaseUrl: string;
+    llmApiKey: string;
+    llmModel: string;
+    databasePath: string;
+    calendarFile: string;
+    requestInterval: number;
+    dailyUpdateNotify: boolean;
+    alertChannel: string;
+    openclawCliBin: string;
+    alertAccount: string;
+    alertTarget: string;
+    pythonBin: string;
+    pythonArgs: string[];
+    pythonWorkdir: string;
+}
+export declare const DEFAULT_PLUGIN_CONFIG: Omit<PluginConfig, "tickflowApiKey" | "llmApiKey" | "alertTarget">;

package/dist/config/schema.js

@@ -0,0 +1,18 @@
+export const DEFAULT_PLUGIN_CONFIG = {
+    tickflowApiUrl: "https://api.tickflow.org",
+    tickflowApiKeyLevel: "free",
+    mxSearchApiUrl: "https://mkapi2.dfcfs.com/finskillshub/api/claw",
+    mxSearchApiKey: "",
+    llmBaseUrl: "https://api.openai.com/v1",
+    llmModel: "gpt-4o",
+    databasePath: "./data/lancedb",
+    calendarFile: "./day_future.txt",
+    requestInterval: 30,
+    dailyUpdateNotify: true,
+    alertChannel: "telegram",
+    openclawCliBin: "openclaw",
+    alertAccount: "",
+    pythonBin: "uv",
+    pythonArgs: ["run", "python"],
+    pythonWorkdir: "./python",
+};

package/dist/config/tickflow-access.d.ts

@@ -0,0 +1,4 @@
+export type TickflowApiKeyLevel = "free" | "start" | "pro" | "expert";
+export declare function normalizeTickflowApiKeyLevel(value: unknown, fallback?: TickflowApiKeyLevel): TickflowApiKeyLevel;
+export declare function supportsIntradayKlines(level: TickflowApiKeyLevel): boolean;
+export declare function formatTickflowApiKeyLevel(level: TickflowApiKeyLevel): string;

package/dist/config/tickflow-access.js

@@ -0,0 +1,28 @@
+const INTRADAY_ENABLED_LEVELS = new Set(["pro", "expert"]);
+export function normalizeTickflowApiKeyLevel(value, fallback = "free") {
+    const normalized = String(value ?? "")
+        .trim()
+        .toLowerCase();
+    if (normalized === "export") {
+        return "expert";
+    }
+    if (normalized === "free" || normalized === "start" || normalized === "pro" || normalized === "expert") {
+        return normalized;
+    }
+    return fallback;
+}
+export function supportsIntradayKlines(level) {
+    return INTRADAY_ENABLED_LEVELS.has(level);
+}
+export function formatTickflowApiKeyLevel(level) {
+    switch (level) {
+        case "free":
+            return "Free";
+        case "start":
+            return "Start";
+        case "pro":
+            return "Pro";
+        case "expert":
+            return "Expert";
+    }
+}

package/dist/constants/market-indexes.d.ts

@@ -0,0 +1,5 @@
+export interface MarketIndexSpec {
+    symbol: string;
+    name: string;
+}
+export declare const DEFAULT_MARKET_INDEXES: MarketIndexSpec[];

package/dist/constants/market-indexes.js

@@ -0,0 +1,4 @@
+export const DEFAULT_MARKET_INDEXES = [
+    { symbol: "000001.SH", name: "上证指数" },
+    { symbol: "399001.SZ", name: "深证成指" },
+];

package/dist/dev/run-daily-update-loop.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dev/run-daily-update-loop.js

@@ -0,0 +1,48 @@
+import { createAppContext } from "../bootstrap.js";
+import { loadProcessConfig } from "../runtime/process-config.js";
+async function main() {
+    const { config, configSource } = await loadProcessConfig();
+    const app = createAppContext(config, { configSource });
+    const worker = app.services.dailyUpdateWorker;
+    const alertService = app.services.alertService;
+    await worker.markSchedulerRunning(process.pid, configSource);
+    process.stdout.write("TickFlow daily update loop started\n");
+    const controller = new AbortController();
+    const shutdown = async (signal) => {
+        controller.abort();
+        const state = await worker.getState();
+        const isCurrentWorker = state.workerPid === process.pid;
+        await worker.markSchedulerStopped();
+        if (isCurrentWorker && state.running && !state.expectedStop) {
+            await alertService.send(alertService.formatSystemNotification("⚠️ TickFlow 日更退出通知", [
+                `时间: ${new Date().toISOString()}`,
+                `原因: 收到信号 ${signal}`,
+            ]));
+        }
+        process.exit(0);
+    };
+    process.on("SIGINT", () => void shutdown("SIGINT"));
+    process.on("SIGTERM", () => void shutdown("SIGTERM"));
+    try {
+        await worker.runLoop(controller.signal);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const state = await worker.getState();
+        const isCurrentWorker = state.workerPid === process.pid;
+        await worker.markSchedulerStopped();
+        if (isCurrentWorker) {
+            await alertService.send(alertService.formatSystemNotification("⚠️ TickFlow 日更退出通知", [
+                `时间: ${new Date().toISOString()}`,
+                "原因: 日更循环异常退出",
+                `详情: ${message}`,
+            ]));
+        }
+        throw error;
+    }
+}
+void main().catch((error) => {
+    const message = error instanceof Error ? error.stack ?? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+});

package/dist/dev/run-monitor-loop.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dev/run-monitor-loop.js

@@ -0,0 +1,60 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { createAppContext } from "../bootstrap.js";
+import { normalizePluginConfig, resolvePluginConfigPaths } from "../config/normalize.js";
+async function main() {
+    const config = await loadLocalConfig();
+    const app = createAppContext(config, { configSource: "local_config" });
+    const worker = app.services.realtimeMonitorWorker;
+    const alertService = app.services.alertService;
+    const monitorService = app.services.monitorService;
+    await monitorService.recordHeartbeat("fallback_process");
+    await monitorService.setWorkerPid(process.pid);
+    process.stdout.write(`TickFlow monitor loop started, interval=${config.requestInterval}s\n`);
+    const controller = new AbortController();
+    const shutdown = async (signal) => {
+        controller.abort();
+        const state = await monitorService.getState();
+        const isCurrentWorker = state.workerPid === process.pid;
+        await monitorService.setWorkerPid(null);
+        if (isCurrentWorker && state.running && !state.expectedStop) {
+            await alertService.send(alertService.formatSystemNotification("⚠️ TickFlow 监控退出通知", [
+                `时间: ${new Date().toISOString()}`,
+                `原因: 收到信号 ${signal}`,
+            ]));
+        }
+        await monitorService.setExpectedStop(false);
+        process.exit(0);
+    };
+    process.on("SIGINT", () => void shutdown("SIGINT"));
+    process.on("SIGTERM", () => void shutdown("SIGTERM"));
+    try {
+        await worker.runLoop(controller.signal, "fallback_process");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const state = await monitorService.getState();
+        const isCurrentWorker = state.workerPid === process.pid;
+        await monitorService.setWorkerPid(null);
+        await monitorService.setExpectedStop(false);
+        if (isCurrentWorker) {
+            await alertService.send(alertService.formatSystemNotification("⚠️ TickFlow 监控退出通知", [
+                `时间: ${new Date().toISOString()}`,
+                "原因: 监控循环异常退出",
+                `详情: ${message}`,
+            ]));
+        }
+        throw error;
+    }
+}
+async function loadLocalConfig() {
+    const configPath = path.resolve("local.config.json");
+    const raw = await readFile(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return resolvePluginConfigPaths(normalizePluginConfig(parsed.plugin ?? {}), process.cwd());
+}
+void main().catch((error) => {
+    const message = error instanceof Error ? error.stack ?? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+});

package/dist/dev/run-tool.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dev/run-tool.js

@@ -0,0 +1,49 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { createAppContext } from "../bootstrap.js";
+import { normalizePluginConfig, resolvePluginConfigPaths } from "../config/normalize.js";
+async function main() {
+    const [, , toolName, ...rest] = process.argv;
+    if (!toolName) {
+        throw new Error("usage: npm run tool -- <tool-name> [json-or-plain-args]");
+    }
+    const config = await loadLocalConfig();
+    const app = createAppContext(config, { configSource: "local_config" });
+    const normalizedToolName = normalizeToolName(toolName);
+    const tool = app.tools.find((entry) => entry.name === normalizedToolName);
+    if (!tool) {
+        throw new Error(`tool not found: ${toolName}`);
+    }
+    const rawInput = parseToolInput(rest);
+    const output = await tool.run({ rawInput });
+    process.stdout.write(`${output}\n`);
+}
+async function loadLocalConfig() {
+    const configPath = path.resolve("local.config.json");
+    const raw = await readFile(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return resolvePluginConfigPaths(normalizePluginConfig(parsed.plugin ?? {}), process.cwd());
+}
+function parseToolInput(args) {
+    if (args.length === 0) {
+        return undefined;
+    }
+    const joined = args.join(" ").trim();
+    if (!joined) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(joined);
+    }
+    catch {
+        return joined;
+    }
+}
+function normalizeToolName(name) {
+    return name.replace(/-/g, "_");
+}
+void main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+});

package/dist/dev/tickflow-assist-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};