tickflow-assist 0.2.0

package/dist/background/daily-update.worker.js

@@ -0,0 +1,546 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { chinaToday, formatChinaDateTime } from "../utils/china-time.js";
+import { sleepWithAbort } from "../utils/abortable-sleep.js";
+import { isPidAlive, spawnDailyUpdateLoop } from "../runtime/daily-update-process.js";
+const DAILY_UPDATE_READY_TIME = "15:25";
+const POST_CLOSE_REVIEW_READY_TIME = "20:00";
+const DEFAULT_STATE = {
+    running: false,
+    startedAt: null,
+    lastStoppedAt: null,
+    workerPid: null,
+    expectedStop: false,
+    runtimeHost: null,
+    runtimeObservedAt: null,
+    runtimeConfigSource: null,
+    lastHeartbeatAt: null,
+    lastAttemptAt: null,
+    lastAttemptDate: null,
+    lastSuccessAt: null,
+    lastSuccessDate: null,
+    lastResultType: null,
+    lastResultSummary: null,
+    consecutiveFailures: 0,
+    lastReviewAttemptAt: null,
+    lastReviewAttemptDate: null,
+    lastReviewSuccessAt: null,
+    lastReviewSuccessDate: null,
+    lastReviewResultType: null,
+    lastReviewResultSummary: null,
+    reviewConsecutiveFailures: 0,
+};
+export class DailyUpdateWorker {
+    updateService;
+    postCloseReviewService;
+    tradingCalendarService;
+    baseDir;
+    alertService;
+    notifyEnabled;
+    configSource;
+    intervalMs;
+    constructor(updateService, postCloseReviewService, tradingCalendarService, baseDir, alertService, notifyEnabled, configSource, intervalMs = 15 * 60 * 1000) {
+        this.updateService = updateService;
+        this.postCloseReviewService = postCloseReviewService;
+        this.tradingCalendarService = tradingCalendarService;
+        this.baseDir = baseDir;
+        this.alertService = alertService;
+        this.notifyEnabled = notifyEnabled;
+        this.configSource = configSource;
+        this.intervalMs = intervalMs;
+    }
+    async run(force = false) {
+        const updateOutput = await this.executeDailyUpdateAndRecord(force, "manual", true);
+        if (updateOutput.resultType !== "success") {
+            return updateOutput.message;
+        }
+        const reviewOutput = await this.executeReviewAndRecord("manual");
+        return joinMessages(updateOutput.message, reviewOutput?.combinedText);
+    }
+    async runLoop(signal, runtimeHost, runtimeConfigSource) {
+        while (!signal?.aborted) {
+            await this.recordHeartbeat(runtimeHost, runtimeConfigSource);
+            const state = await this.readState();
+            if (state.running) {
+                await this.runScheduledPasses();
+            }
+            await sleepWithAbort(getNextAlignedDelayMs(this.intervalMs), signal);
+        }
+    }
+    async ensureLoopRunning(config, configSource) {
+        const state = await this.readState();
+        if (state.workerPid != null && isPidAlive(state.workerPid)) {
+            await this.markSchedulerRunning(state.workerPid, state.runtimeConfigSource ?? configSource);
+            return { started: false, pid: state.workerPid };
+        }
+        const workerPid = spawnDailyUpdateLoop(config, configSource);
+        if (workerPid == null) {
+            throw new Error("无法启动 TickFlow 日更定时进程");
+        }
+        await this.markSchedulerRunning(workerPid, configSource);
+        return { started: true, pid: workerPid };
+    }
+    async stopLoop() {
+        const state = await this.readState();
+        const workerPid = state.workerPid;
+        const alive = workerPid != null && isPidAlive(workerPid);
+        if (!alive) {
+            await this.markSchedulerStopped();
+            return { stopped: false, pid: null };
+        }
+        await this.setExpectedStop(true);
+        await this.markSchedulerStopped();
+        try {
+            process.kill(workerPid, "SIGTERM");
+        }
+        catch {
+            // Best-effort stop for the detached daily-update worker.
+        }
+        return { stopped: true, pid: workerPid };
+    }
+    async enableManagedLoop(configSource) {
+        const state = await this.readState();
+        const now = formatChinaDateTime();
+        await this.writeState({
+            ...state,
+            running: true,
+            startedAt: state.startedAt ?? now,
+            workerPid: null,
+            expectedStop: false,
+            runtimeHost: "plugin_service",
+            runtimeObservedAt: now,
+            runtimeConfigSource: configSource,
+        });
+        return { started: !state.running, pid: null };
+    }
+    async bindManagedServiceRuntime(configSource) {
+        const state = await this.readState();
+        const now = formatChinaDateTime();
+        await this.writeState({
+            ...state,
+            workerPid: null,
+            expectedStop: false,
+            runtimeHost: "plugin_service",
+            runtimeObservedAt: now,
+            runtimeConfigSource: configSource,
+        });
+    }
+    async markSchedulerRunning(workerPid, runtimeConfigSource) {
+        const state = await this.readState();
+        const now = formatChinaDateTime();
+        await this.writeState({
+            ...state,
+            running: true,
+            startedAt: state.startedAt ?? now,
+            workerPid,
+            expectedStop: false,
+            runtimeHost: "project_scheduler",
+            runtimeObservedAt: now,
+            runtimeConfigSource,
+        });
+    }
+    async markSchedulerStopped() {
+        const state = await this.readState();
+        await this.writeState({
+            ...state,
+            running: false,
+            startedAt: null,
+            lastStoppedAt: formatChinaDateTime(),
+            workerPid: null,
+            expectedStop: false,
+        });
+    }
+    async setExpectedStop(expectedStop) {
+        const state = await this.readState();
+        await this.writeState({
+            ...state,
+            expectedStop,
+        });
+    }
+    async getState() {
+        return this.readState();
+    }
+    async getStatusReport() {
+        const state = await this.readState();
+        const today = chinaToday();
+        const lines = [
+            "🕒 定时日更 / 收盘复盘状态",
+            `状态: ${formatProcessState(state)}`,
+            `运行方式: ${formatRuntimeHost(state)}`,
+            `配置来源: ${this.configSource}`,
+            `调度: ${Math.floor(this.intervalMs / 60_000)} 分钟对齐轮询 | 日更 ${DAILY_UPDATE_READY_TIME} 后执行 | 复盘 ${POST_CLOSE_REVIEW_READY_TIME} 后执行`,
+            `最近心跳: ${state.lastHeartbeatAt ?? "暂无"}`,
+            "",
+            "日更执行:",
+            `• 今日已更新: ${state.lastSuccessDate === today ? "是" : "否"}`,
+            `• 最近尝试: ${state.lastAttemptAt ?? "暂无"}`,
+            `• 最近成功: ${state.lastSuccessAt ?? "暂无"}`,
+            `• 最近结果: ${formatResultType(state.lastResultType)}`,
+        ];
+        if (state.consecutiveFailures > 0) {
+            lines.push(`• 连续失败: ${state.consecutiveFailures}`);
+        }
+        if (state.lastResultSummary) {
+            lines.push(`• 最近摘要: ${state.lastResultSummary}`);
+        }
+        lines.push("", "复盘执行:", `• 今日已复盘: ${state.lastReviewSuccessDate === today ? "是" : "否"}`, `• 最近尝试: ${state.lastReviewAttemptAt ?? "暂无"}`, `• 最近成功: ${state.lastReviewSuccessAt ?? "暂无"}`, `• 最近结果: ${formatResultType(state.lastReviewResultType)}`);
+        if (state.reviewConsecutiveFailures > 0) {
+            lines.push(`• 连续失败: ${state.reviewConsecutiveFailures}`);
+        }
+        if (state.lastReviewResultSummary) {
+            lines.push(`• 最近摘要: ${state.lastReviewResultSummary}`);
+        }
+        return lines.join("\n");
+    }
+    async runScheduledPasses() {
+        await this.runScheduledUpdatePass();
+        await this.runScheduledReviewPass();
+    }
+    async runScheduledUpdatePass() {
+        const today = chinaToday();
+        const state = await this.readState();
+        if (hasCompletedScheduledWindow(state.lastSuccessDate, state.lastSuccessAt, today, DAILY_UPDATE_READY_TIME)) {
+            return;
+        }
+        const readiness = await this.tradingCalendarService.canRunDailyUpdate();
+        if (!readiness.ok && readiness.reason.includes("须等到") && state.lastSuccessDate === today) {
+            return;
+        }
+        await this.executeDailyUpdateAndRecord(false, "scheduled", false);
+    }
+    async runScheduledReviewPass() {
+        if (!this.postCloseReviewService) {
+            return;
+        }
+        const today = chinaToday();
+        const state = await this.readState();
+        if (hasCompletedScheduledWindow(state.lastReviewSuccessDate, state.lastReviewSuccessAt, today, POST_CLOSE_REVIEW_READY_TIME)) {
+            return;
+        }
+        const readiness = await this.getScheduledReviewReadiness(state, today);
+        if (!readiness.ok) {
+            if (readiness.code === "waiting_time" && state.lastReviewSuccessDate === today) {
+                return;
+            }
+            await this.recordReviewSkip(state, today, readiness.reason);
+            return;
+        }
+        await this.executeReviewAndRecord("scheduled");
+    }
+    async getScheduledReviewReadiness(state, today) {
+        if (!hasCompletedScheduledWindow(state.lastSuccessDate, state.lastSuccessAt, today, DAILY_UPDATE_READY_TIME)) {
+            return {
+                ok: false,
+                reason: `今日日更尚未在 ${DAILY_UPDATE_READY_TIME} 后成功完成，暂不执行收盘复盘`,
+                code: "waiting_daily_update",
+            };
+        }
+        const readiness = await this.tradingCalendarService.canRunPostCloseReview();
+        if (!readiness.ok) {
+            return {
+                ok: false,
+                reason: readiness.reason,
+                code: readiness.reason.includes("须等到") ? "waiting_time" : "non_trading_day",
+            };
+        }
+        return {
+            ok: true,
+            reason: readiness.reason,
+            code: "ready",
+        };
+    }
+    async recordReviewSkip(state, today, reason) {
+        await this.writeState({
+            ...state,
+            lastReviewAttemptAt: formatChinaDateTime(),
+            lastReviewAttemptDate: today,
+            lastReviewResultType: "skipped",
+            lastReviewResultSummary: reason,
+            reviewConsecutiveFailures: 0,
+        });
+    }
+    async executeDailyUpdateAndRecord(force, trigger, throwOnError) {
+        const today = chinaToday();
+        const state = await this.readState();
+        const attemptedAt = formatChinaDateTime();
+        try {
+            const message = await this.updateService.updateAll(force);
+            const output = {
+                resultType: classifyResult(message),
+                message,
+            };
+            const nextState = {
+                ...state,
+                lastAttemptAt: attemptedAt,
+                lastAttemptDate: today,
+                lastResultType: output.resultType,
+                lastResultSummary: summarizeUpdateResult(output.message),
+                consecutiveFailures: output.resultType === "failed" ? state.consecutiveFailures + 1 : 0,
+            };
+            if (output.resultType === "success") {
+                nextState.lastSuccessAt = attemptedAt;
+                nextState.lastSuccessDate = today;
+            }
+            await this.writeState(nextState);
+            if (trigger === "scheduled") {
+                await this.maybeSendDailyUpdateNotification(output);
+            }
+            return output;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const failureText = `异常: ${message}`;
+            await this.writeState({
+                ...state,
+                lastAttemptAt: attemptedAt,
+                lastAttemptDate: today,
+                lastResultType: "failed",
+                lastResultSummary: failureText,
+                consecutiveFailures: state.consecutiveFailures + 1,
+            });
+            const output = {
+                resultType: "failed",
+                message: failureText,
+            };
+            if (trigger === "scheduled") {
+                await this.maybeSendDailyUpdateNotification(output);
+            }
+            if (throwOnError) {
+                throw error;
+            }
+            return output;
+        }
+    }
+    async executeReviewAndRecord(trigger) {
+        if (!this.postCloseReviewService) {
+            return null;
+        }
+        const today = chinaToday();
+        const state = await this.readState();
+        const attemptedAt = formatChinaDateTime();
+        try {
+            const reviewResult = await this.postCloseReviewService.run();
+            const output = createReviewExecutionOutput(reviewResult);
+            await this.writeState({
+                ...state,
+                lastReviewAttemptAt: attemptedAt,
+                lastReviewAttemptDate: today,
+                lastReviewSuccessAt: attemptedAt,
+                lastReviewSuccessDate: today,
+                lastReviewResultType: output.resultType,
+                lastReviewResultSummary: summarizeReviewResult(output.combinedText),
+                reviewConsecutiveFailures: 0,
+            });
+            if (trigger === "scheduled") {
+                await this.maybeSendReviewNotification(output);
+            }
+            return output;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const failureText = `⚠️ 收盘复盘失败: ${message}`;
+            await this.writeState({
+                ...state,
+                lastReviewAttemptAt: attemptedAt,
+                lastReviewAttemptDate: today,
+                lastReviewResultType: "failed",
+                lastReviewResultSummary: failureText,
+                reviewConsecutiveFailures: state.reviewConsecutiveFailures + 1,
+            });
+            const output = {
+                resultType: "failed",
+                overviewMessage: null,
+                detailMessages: [],
+                combinedText: failureText,
+            };
+            if (trigger === "scheduled") {
+                await this.maybeSendReviewNotification(output);
+            }
+            return output;
+        }
+    }
+    getStateFilePath() {
+        return path.join(this.baseDir, "daily-update-state.json");
+    }
+    async recordHeartbeat(runtimeHost, runtimeConfigSource) {
+        const state = await this.readState();
+        const observedAt = formatChinaDateTime();
+        await this.writeState({
+            ...state,
+            lastHeartbeatAt: observedAt,
+            runtimeHost: runtimeHost ?? state.runtimeHost,
+            runtimeObservedAt: observedAt,
+            runtimeConfigSource: runtimeConfigSource ?? state.runtimeConfigSource,
+        });
+    }
+    async readState() {
+        const file = this.getStateFilePath();
+        try {
+            const raw = await readFile(file, "utf-8");
+            return { ...DEFAULT_STATE, ...JSON.parse(raw) };
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return { ...DEFAULT_STATE };
+            }
+            throw error;
+        }
+    }
+    async writeState(state) {
+        const file = this.getStateFilePath();
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(file, JSON.stringify(state, null, 2), "utf-8");
+    }
+    async maybeSendDailyUpdateNotification(output) {
+        if (!this.notifyEnabled || output.resultType === "skipped") {
+            return;
+        }
+        if (output.resultType !== "success") {
+            const message = this.alertService.formatSystemNotification("❌ 定时日更失败", selectUpdateNotificationLines(output.message));
+            await this.alertService.send(message);
+            return;
+        }
+        const message = this.alertService.formatSystemNotification("📊 定时日更完成", normalizeResultLines(output.message));
+        await this.alertService.send(message);
+    }
+    async maybeSendReviewNotification(output) {
+        if (!this.notifyEnabled || output.resultType === "skipped") {
+            return;
+        }
+        if (output.resultType !== "success") {
+            const message = this.alertService.formatSystemNotification("❌ 收盘复盘失败", selectReviewNotificationLines(output.combinedText));
+            await this.alertService.send(message);
+            return;
+        }
+        const messages = [
+            this.alertService.formatSystemNotification("📘 收盘复盘完成", selectReviewNotificationLines(output.combinedText)),
+            output.overviewMessage,
+            ...output.detailMessages,
+        ].filter((message) => Boolean(message));
+        for (const message of messages) {
+            await this.alertService.send(message);
+        }
+    }
+}
+function createReviewExecutionOutput(reviewResult) {
+    return {
+        resultType: "success",
+        overviewMessage: reviewResult.overviewMessage,
+        detailMessages: reviewResult.detailMessages,
+        combinedText: joinMessages(reviewResult.overviewMessage, ...reviewResult.detailMessages),
+    };
+}
+function joinMessages(...parts) {
+    return parts
+        .map((part) => part?.trim())
+        .filter((part) => Boolean(part))
+        .join("\n\n");
+}
+function getNextAlignedDelayMs(intervalMs) {
+    const intervalMinutes = Math.max(1, Math.floor(intervalMs / 60_000));
+    const anchorMinute = 10;
+    const now = new Date();
+    const chinaNow = new Date(now.toLocaleString("en-US", { timeZone: "Asia/Shanghai" }));
+    const currentMinute = chinaNow.getMinutes();
+    const currentSecond = chinaNow.getSeconds();
+    const currentMillisecond = chinaNow.getMilliseconds();
+    const normalized = ((currentMinute - anchorMinute) % intervalMinutes + intervalMinutes) % intervalMinutes;
+    let minutesToAdd = intervalMinutes - normalized;
+    if (minutesToAdd === intervalMinutes && currentSecond === 0 && currentMillisecond === 0) {
+        minutesToAdd = intervalMinutes;
+    }
+    if (normalized === 0 && (currentSecond > 0 || currentMillisecond > 0)) {
+        minutesToAdd = intervalMinutes;
+    }
+    const next = new Date(chinaNow);
+    next.setSeconds(0, 0);
+    next.setMinutes(currentMinute + minutesToAdd);
+    return Math.max(1_000, next.getTime() - chinaNow.getTime());
+}
+function classifyResult(result) {
+    if (result.startsWith("📊") || result.startsWith("📋")) {
+        return "success";
+    }
+    if (result.startsWith("🚫")) {
+        return "skipped";
+    }
+    return "failed";
+}
+function summarizeUpdateResult(result) {
+    return selectUpdateSummaryLines(result).join(" | ");
+}
+function summarizeReviewResult(result) {
+    return selectReviewSummaryLines(result).join(" | ");
+}
+function selectUpdateSummaryLines(result) {
+    const lines = normalizeResultLines(result);
+    const head = lines.slice(0, 2);
+    const highlights = lines.filter((line) => /^🏁/.test(line));
+    return dedupeLines([...head, ...highlights]).slice(0, 6);
+}
+function selectReviewSummaryLines(result) {
+    const lines = normalizeResultLines(result);
+    const head = lines.slice(0, 2);
+    const highlights = lines.filter((line) => /^(🧭|复盘数量:|关键位验证:|明日处理:|⚠️ 收盘复盘失败|⚠️ 收盘分析\/回测失败)/.test(line));
+    return dedupeLines([...head, ...highlights]).slice(0, 6);
+}
+function selectUpdateNotificationLines(result) {
+    const lines = normalizeResultLines(result);
+    const head = lines.slice(0, 4);
+    const highlights = lines.filter((line) => /^🏁/.test(line));
+    return dedupeLines([...head, ...highlights]).slice(0, 12);
+}
+function selectReviewNotificationLines(result) {
+    const lines = normalizeResultLines(result);
+    const head = lines.slice(0, 4);
+    const highlights = lines.filter((line) => /^(🧭|复盘数量:|关键位验证:|明日处理:|⚠️ 收盘复盘失败|⚠️ 收盘分析\/回测失败)/.test(line));
+    return dedupeLines([...head, ...highlights]).slice(0, 12);
+}
+function normalizeResultLines(result) {
+    return result
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+function dedupeLines(lines) {
+    return [...new Set(lines)];
+}
+function formatResultType(type) {
+    switch (type) {
+        case "success":
+            return "成功";
+        case "skipped":
+            return "跳过";
+        case "failed":
+            return "失败";
+        default:
+            return "暂无";
+    }
+}
+function formatProcessState(state) {
+    if (!state.running) {
+        return "⭕ 未启动";
+    }
+    if (state.workerPid == null) {
+        return state.startedAt ? `✅ 运行中 (启动于 ${state.startedAt})` : "✅ 运行中";
+    }
+    if (!isPidAlive(state.workerPid)) {
+        return `⚠️ 状态残留 (PID=${state.workerPid} 已不存在)`;
+    }
+    return state.startedAt
+        ? `✅ 运行中 (PID=${state.workerPid}, 启动于 ${state.startedAt})`
+        : `✅ 运行中 (PID=${state.workerPid})`;
+}
+function formatRuntimeHost(state) {
+    return state.runtimeHost === "project_scheduler"
+        ? "project_scheduler"
+        : state.runtimeHost === "plugin_service"
+            ? "plugin_service"
+            : "unknown";
+}
+function hasCompletedScheduledWindow(successDate, successAt, today, readyTime) {
+    return successDate === today && extractChinaTime(successAt) >= readyTime;
+}
+function extractChinaTime(dateTime) {
+    return dateTime?.slice(11, 16) ?? "00:00";
+}

package/dist/background/realtime-monitor.worker.d.ts

@@ -0,0 +1,8 @@
+import { MonitorService } from "../services/monitor-service.js";
+export declare class RealtimeMonitorWorker {
+    private readonly monitorService;
+    private readonly intervalMs;
+    constructor(monitorService: MonitorService, intervalMs: number);
+    runOnce(): Promise<number>;
+    runLoop(signal?: AbortSignal, runtimeHost?: "plugin_service" | "fallback_process"): Promise<void>;
+}

package/dist/background/realtime-monitor.worker.js

@@ -0,0 +1,28 @@
+import { sleepWithAbort } from "../utils/abortable-sleep.js";
+export class RealtimeMonitorWorker {
+    monitorService;
+    intervalMs;
+    constructor(monitorService, intervalMs) {
+        this.monitorService = monitorService;
+        this.intervalMs = intervalMs;
+    }
+    async runOnce() {
+        const state = await this.monitorService.getState();
+        if (!state.running) {
+            return 0;
+        }
+        return this.monitorService.runMonitorOnce();
+    }
+    async runLoop(signal, runtimeHost) {
+        while (!signal?.aborted) {
+            await this.monitorService.recordHeartbeat(runtimeHost);
+            try {
+                await this.runOnce();
+            }
+            catch (error) {
+                await this.monitorService.recordLoopError(error);
+            }
+            await sleepWithAbort(this.intervalMs, signal);
+        }
+    }
+}

package/dist/bootstrap.d.ts

@@ -0,0 +1,45 @@
+import type { PluginConfig } from "./config/schema.js";
+import { Database } from "./storage/db.js";
+import { WatchlistService } from "./services/watchlist-service.js";
+import { MonitorService } from "./services/monitor-service.js";
+import { AlertService } from "./services/alert-service.js";
+import type { LocalTool, OpenClawPluginConfig, OpenClawPluginRuntime, RegisteredService } from "./runtime/plugin-api.js";
+import { RealtimeMonitorWorker } from "./background/realtime-monitor.worker.js";
+import { DailyUpdateWorker } from "./background/daily-update.worker.js";
+import type { WatchlistItem } from "./types/domain.js";
+export interface AppContext {
+    config: PluginConfig;
+    tools: LocalTool[];
+    backgroundServices: RegisteredService[];
+    runtime: {
+        configSource: "openclaw_plugin" | "local_config";
+        pluginManagedServices: boolean;
+        openclawConfig?: OpenClawPluginConfig;
+        pluginRuntime?: OpenClawPluginRuntime;
+    };
+    services: {
+        alertService: AlertService;
+        monitorService: MonitorService;
+        realtimeMonitorWorker: RealtimeMonitorWorker;
+        dailyUpdateWorker: DailyUpdateWorker;
+        watchlistService: WatchlistService;
+        database: Database;
+    };
+}
+export declare function createAppContext(config: PluginConfig, options?: {
+    pluginManagedServices?: boolean;
+    configSource?: "openclaw_plugin" | "local_config";
+    openclawConfig?: OpenClawPluginConfig;
+    pluginRuntime?: OpenClawPluginRuntime;
+}): AppContext;
+export interface WatchlistDebugSnapshot {
+    databasePath: string;
+    calendarFile: string;
+    requestInterval: number;
+    configSource: "openclaw_plugin" | "local_config";
+    pid: number;
+    watchlistTableExists: boolean;
+    watchlistCount: number;
+    watchlistPreview: WatchlistItem[];
+}
+export declare function buildWatchlistDebugSnapshot(app: AppContext): Promise<WatchlistDebugSnapshot>;