tickflow-assist 0.3.3 → 0.3.5

package/README.md

@@ -2,9 +2,21 @@
 
 基于 [OpenClaw](https://openclaw.ai) 的 A 股监控与分析插件。它使用 [TickFlow](https://tickflow.org/auth/register?ref=BUJ54JEDGE) 获取行情与财务数据，并可选接入 [金十数据 MCP](https://mcp.jin10.com/app/) 快讯流，结合 LLM 生成技术面、基本面、资讯面的综合判断，并把结果持久化到本地 LanceDB。
 
-最近更新：`v0.3.3` 修复监控告警图片在去重前高频生成与重复告警风险，并收敛价格告警触发噪声。完整发布记录见 <https://github.com/robinspt/tickflow-assist/blob/main/CHANGELOG.md>。
+最近更新：`v0.3.5` 对齐 OpenClaw `2026.4.11` metadata 与社区安装提示，修复源码升级时本地链接扫描 `node_modules` 失败的问题，并支持通过环境变量回退 TickFlow / LLM / MX / Jin10 配置。完整发布记录见 <https://github.com/robinspt/tickflow-assist/blob/main/CHANGELOG.md>。
 
-当前主线按 OpenClaw `v2026.3.31+` 对齐，并已验证社区安装在 `v2026.4.5` 上兼容。
+当前主线按 OpenClaw `v2026.3.31+` 对齐，并已验证社区安装在 `v2026.4.11` 上兼容。
+
+## 安装前准备
+
+在执行社区安装前，建议先确认你已经准备好以下配置：
+
+- 核心必需：`tickflowApiKey`、`llmApiKey`、`llmBaseUrl`、`llmModel`
+- 告警投递：`alertChannel`、`alertTarget`、`alertAccount`
+- 可选增强：`mxSearchApiKey`、`jin10ApiToken`
+
+其中，`configure-openclaw` 会把上述配置写入 `~/.openclaw/openclaw.json` 的 `plugins.entries["tickflow-assist"].config`，插件启用后会在本地 `databasePath` 下持久化 LanceDB 数据，并运行监控 / 日更等后台服务。
+如果你不想把密钥写进配置文件，运行时也支持环境变量回退，优先级是 `openclaw.json / local.config.json` > 环境变量 > 默认值。
+常用环境变量：`TICKFLOW_ASSIST_TICKFLOW_API_KEY` / `TICKFLOW_API_KEY`、`TICKFLOW_ASSIST_LLM_API_KEY` / `LLM_API_KEY`、`TICKFLOW_ASSIST_LLM_BASE_URL` / `LLM_BASE_URL`、`TICKFLOW_ASSIST_LLM_MODEL` / `LLM_MODEL`、`TICKFLOW_ASSIST_MX_SEARCH_API_KEY` / `MX_SEARCH_API_KEY` / `MX_APIKEY`、`TICKFLOW_ASSIST_JIN10_API_TOKEN` / `JIN10_API_TOKEN`。
 
 ## 安装
 
@@ -19,8 +31,8 @@ openclaw config validate
 openclaw gateway restart
 ```
 
-安装阶段允许先落插件，再通过第二条命令写入 `tickflowApiKey`、`llmApiKey` 等正式配置。
-`configure-openclaw` 会写入 `~/.openclaw/openclaw.json` 中的 `plugins.entries["tickflow-assist"].config`，并打印后续建议执行的命令；它不再自动执行 `openclaw`、`uv` 或系统包安装命令。
+安装阶段允许先落插件，再通过第二条命令写入 `tickflowApiKey`、`llmApiKey`、`llmBaseUrl`、`llmModel` 等正式配置。
+`configure-openclaw` 会写入 `~/.openclaw/openclaw.json` 中的 `plugins.entries["tickflow-assist"].config`，并打印后续建议执行的命令；它不再自动执行 `openclaw`、`uv` 或系统包安装命令，也不会重新执行插件安装；如果你已经设置了环境变量，密钥项可留空，输入 `-` 可主动清空已有配置并切回环境变量。
 如果检测到 `plugins.installs["tickflow-assist"]` 来自 `clawhub`，向导还会把被旧版本钉死的 `spec` 归一化为 `clawhub:tickflow-assist`，避免后续升级继续锁在旧版本。
 
 如果你希望先审阅配置，再只打印最少的后续步骤，可使用：
@@ -84,6 +96,18 @@ plugins.entries["tickflow-assist"].config
 - 能力补充：`mxSearchApiKey`、`jin10ApiToken`
 
 其中，`mxSearchApiKey` 用于 `mx_search`、`mx_select_stock` 以及非 `Expert` 财务链路的 lite 补充；`jin10ApiToken` 用于 24 小时金十数据快讯监控；`jin10FlashNightAlert` 默认 `false`（开启夜间静默），设为 `true` 可恢复 24 小时快讯告警；`alertTarget`、`alertAccount` 建议在准备启用 `test_alert`、实时监控告警、金十数据快讯告警和定时通知前一并配好，避免配置不完整导致功能缺失。
+如果你使用环境变量，运行时支持以下回退：
+
+- `tickflowApiUrl`：`TICKFLOW_ASSIST_TICKFLOW_API_URL` / `TICKFLOW_API_URL`
+- `tickflowApiKey`：`TICKFLOW_ASSIST_TICKFLOW_API_KEY` / `TICKFLOW_API_KEY`
+- `tickflowApiKeyLevel`：`TICKFLOW_ASSIST_TICKFLOW_API_KEY_LEVEL` / `TICKFLOW_API_KEY_LEVEL`
+- `llmBaseUrl`：`TICKFLOW_ASSIST_LLM_BASE_URL` / `LLM_BASE_URL`
+- `llmApiKey`：`TICKFLOW_ASSIST_LLM_API_KEY` / `LLM_API_KEY`
+- `llmModel`：`TICKFLOW_ASSIST_LLM_MODEL` / `LLM_MODEL`
+- `mxSearchApiUrl`：`TICKFLOW_ASSIST_MX_SEARCH_API_URL` / `MX_SEARCH_API_URL`
+- `mxSearchApiKey`：`TICKFLOW_ASSIST_MX_SEARCH_API_KEY` / `MX_SEARCH_API_KEY` / `MX_APIKEY`
+- `jin10McpUrl`：`TICKFLOW_ASSIST_JIN10_MCP_URL` / `JIN10_MCP_URL`
+- `jin10ApiToken`：`TICKFLOW_ASSIST_JIN10_API_TOKEN` / `JIN10_API_TOKEN`
 
 ## 功能
 
@@ -107,4 +131,4 @@ plugins.entries["tickflow-assist"].config
 
 ## 仓库
 
-- GitHub: <https://github.com/robinspt/tickflow-assist>
+- GitHub: [robinspt/tickflow-assist](https://github.com/robinspt/tickflow-assist)

package/dist/background/daily-update.worker.d.ts

@@ -1,10 +1,12 @@
 import { UpdateService } from "../services/update-service.js";
 import { AlertService } from "../services/alert-service.js";
 import { PostCloseReviewService } from "../services/post-close-review-service.js";
+import { PreMarketBriefService } from "../services/pre-market-brief-service.js";
 import { TradingCalendarService } from "../services/trading-calendar-service.js";
 import type { DailyUpdateState } from "../types/daily-update.js";
 export declare class DailyUpdateWorker {
     private readonly updateService;
+    private readonly preMarketBriefService;
     private readonly postCloseReviewService;
     private readonly tradingCalendarService;
     private readonly baseDir;
@@ -12,7 +14,7 @@ export declare class DailyUpdateWorker {
     private readonly notifyEnabled;
     private readonly configSource;
     private readonly intervalMs;
-    constructor(updateService: UpdateService, postCloseReviewService: PostCloseReviewService | null, tradingCalendarService: TradingCalendarService, baseDir: string, alertService: AlertService, notifyEnabled: boolean, configSource: "openclaw_plugin" | "local_config", intervalMs?: number);
+    constructor(updateService: UpdateService, preMarketBriefService: PreMarketBriefService, postCloseReviewService: PostCloseReviewService | null, tradingCalendarService: TradingCalendarService, baseDir: string, alertService: AlertService, notifyEnabled: boolean, configSource: "openclaw_plugin" | "local_config", intervalMs?: number);
     run(force?: boolean): Promise<string>;
     runLoop(signal?: AbortSignal, runtimeHost?: "project_scheduler" | "plugin_service", runtimeConfigSource?: "openclaw_plugin" | "local_config"): Promise<void>;
     stopLoop(): Promise<{
@@ -30,17 +32,21 @@ export declare class DailyUpdateWorker {
     getState(): Promise<DailyUpdateState>;
     getStatusReport(): Promise<string>;
     private runScheduledPasses;
+    private runScheduledPreMarketBriefPass;
     private runScheduledUpdatePass;
     private runScheduledReviewPass;
     private getScheduledReviewReadiness;
     private recordReviewSkip;
+    private recordPreMarketSkip;
     private executeDailyUpdateAndRecord;
     private executeReviewAndRecord;
+    private executePreMarketBriefAndRecord;
     private getStateFilePath;
     private recordHeartbeat;
     private readState;
     private writeState;
     private maybeSendDailyUpdateNotification;
+    private maybeSendPreMarketBriefNotification;
     private maybeSendReviewNotification;
 }
 export declare function isPidAlive(pid: number): boolean;

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

@@ -2,6 +2,7 @@ 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";
+const PRE_MARKET_BRIEF_READY_TIME = "09:20";
 const DAILY_UPDATE_READY_TIME = "15:25";
 const POST_CLOSE_REVIEW_READY_TIME = "20:00";
 const DEFAULT_STATE = {
@@ -28,9 +29,17 @@ const DEFAULT_STATE = {
     lastReviewResultType: null,
     lastReviewResultSummary: null,
     reviewConsecutiveFailures: 0,
+    lastPreMarketAttemptAt: null,
+    lastPreMarketAttemptDate: null,
+    lastPreMarketSuccessAt: null,
+    lastPreMarketSuccessDate: null,
+    lastPreMarketResultType: null,
+    lastPreMarketResultSummary: null,
+    preMarketConsecutiveFailures: 0,
 };
 export class DailyUpdateWorker {
     updateService;
+    preMarketBriefService;
     postCloseReviewService;
     tradingCalendarService;
     baseDir;
@@ -38,8 +47,9 @@ export class DailyUpdateWorker {
     notifyEnabled;
     configSource;
     intervalMs;
-    constructor(updateService, postCloseReviewService, tradingCalendarService, baseDir, alertService, notifyEnabled, configSource, intervalMs = 15 * 60 * 1000) {
+    constructor(updateService, preMarketBriefService, postCloseReviewService, tradingCalendarService, baseDir, alertService, notifyEnabled, configSource, intervalMs = 15 * 60 * 1000) {
         this.updateService = updateService;
+        this.preMarketBriefService = preMarketBriefService;
         this.postCloseReviewService = postCloseReviewService;
         this.tradingCalendarService = tradingCalendarService;
         this.baseDir = baseDir;
@@ -150,19 +160,31 @@ export class DailyUpdateWorker {
         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} 后执行`,
+            `调度: ${Math.floor(this.intervalMs / 60_000)} 分钟对齐轮询 | 盘前资讯 ${PRE_MARKET_BRIEF_READY_TIME} 后执行 | 日更 ${DAILY_UPDATE_READY_TIME} 后执行 | 复盘 ${POST_CLOSE_REVIEW_READY_TIME} 后执行`,
             `最近心跳: ${state.lastHeartbeatAt ?? "暂无"}`,
             "",
+            "盘前资讯:",
+            `• 今日已推送: ${state.lastPreMarketSuccessDate === today ? "是" : "否"}`,
+            `• 最近尝试: ${state.lastPreMarketAttemptAt ?? "暂无"}`,
+            `• 最近成功: ${state.lastPreMarketSuccessAt ?? "暂无"}`,
+            `• 最近结果: ${formatResultType(state.lastPreMarketResultType)}`,
+            "",
             "日更执行:",
             `• 今日已更新: ${state.lastSuccessDate === today ? "是" : "否"}`,
             `• 最近尝试: ${state.lastAttemptAt ?? "暂无"}`,
             `• 最近成功: ${state.lastSuccessAt ?? "暂无"}`,
             `• 最近结果: ${formatResultType(state.lastResultType)}`,
         ];
+        if (state.preMarketConsecutiveFailures > 0) {
+            lines.push(`• 连续失败: ${state.preMarketConsecutiveFailures}`);
+        }
+        if (state.lastPreMarketResultSummary) {
+            lines.push(`• 最近摘要: ${state.lastPreMarketResultSummary}`);
+        }
         if (state.consecutiveFailures > 0) {
             lines.push(`• 连续失败: ${state.consecutiveFailures}`);
         }
@@ -179,9 +201,26 @@ export class DailyUpdateWorker {
         return lines.join("\n");
     }
     async runScheduledPasses() {
+        await this.runScheduledPreMarketBriefPass();
         await this.runScheduledUpdatePass();
         await this.runScheduledReviewPass();
     }
+    async runScheduledPreMarketBriefPass() {
+        const today = chinaToday();
+        const state = await this.readState();
+        if (hasCompletedScheduledWindow(state.lastPreMarketSuccessDate, state.lastPreMarketSuccessAt, today, PRE_MARKET_BRIEF_READY_TIME)) {
+            return;
+        }
+        if (hasAttemptedScheduledWindow(state.lastPreMarketAttemptDate, state.lastPreMarketAttemptAt, today, PRE_MARKET_BRIEF_READY_TIME)) {
+            return;
+        }
+        const readiness = await this.tradingCalendarService.canRunPreMarketBrief();
+        if (!readiness.ok) {
+            await this.recordPreMarketSkip(state, today, readiness.reason);
+            return;
+        }
+        await this.executePreMarketBriefAndRecord("scheduled");
+    }
     async runScheduledUpdatePass() {
         const today = chinaToday();
         const state = await this.readState();
@@ -245,6 +284,16 @@ export class DailyUpdateWorker {
             reviewConsecutiveFailures: 0,
         });
     }
+    async recordPreMarketSkip(state, today, reason) {
+        await this.writeState({
+            ...state,
+            lastPreMarketAttemptAt: formatChinaDateTime(),
+            lastPreMarketAttemptDate: today,
+            lastPreMarketResultType: "skipped",
+            lastPreMarketResultSummary: reason,
+            preMarketConsecutiveFailures: 0,
+        });
+    }
     async executeDailyUpdateAndRecord(force, trigger, throwOnError) {
         const today = chinaToday();
         const state = await this.readState();
@@ -345,6 +394,52 @@ export class DailyUpdateWorker {
             return output;
         }
     }
+    async executePreMarketBriefAndRecord(trigger) {
+        const today = chinaToday();
+        const state = await this.readState();
+        const attemptedAt = formatChinaDateTime();
+        try {
+            const result = await this.preMarketBriefService.run();
+            const output = createPreMarketBriefExecutionOutput(result);
+            const nextState = {
+                ...state,
+                lastPreMarketAttemptAt: attemptedAt,
+                lastPreMarketAttemptDate: today,
+                lastPreMarketResultType: output.resultType,
+                lastPreMarketResultSummary: summarizePreMarketBriefResult(output.message),
+                preMarketConsecutiveFailures: output.resultType === "failed" ? state.preMarketConsecutiveFailures + 1 : 0,
+            };
+            if (output.resultType === "success") {
+                nextState.lastPreMarketSuccessAt = attemptedAt;
+                nextState.lastPreMarketSuccessDate = today;
+            }
+            await this.writeState(nextState);
+            if (trigger === "scheduled") {
+                await this.maybeSendPreMarketBriefNotification(output);
+            }
+            return output;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const failureText = `⚠️ 开盘前资讯简报失败: ${message}`;
+            await this.writeState({
+                ...state,
+                lastPreMarketAttemptAt: attemptedAt,
+                lastPreMarketAttemptDate: today,
+                lastPreMarketResultType: "failed",
+                lastPreMarketResultSummary: failureText,
+                preMarketConsecutiveFailures: state.preMarketConsecutiveFailures + 1,
+            });
+            const output = {
+                resultType: "failed",
+                message: failureText,
+            };
+            if (trigger === "scheduled") {
+                await this.maybeSendPreMarketBriefNotification(output);
+            }
+            return output;
+        }
+    }
     getStateFilePath() {
         return path.join(this.baseDir, "daily-update-state.json");
     }
@@ -389,6 +484,17 @@ export class DailyUpdateWorker {
         const message = this.alertService.formatSystemNotification("📊 定时日更完成", normalizeResultLines(output.message));
         await this.alertService.send(message);
     }
+    async maybeSendPreMarketBriefNotification(output) {
+        if (!this.notifyEnabled || output.resultType === "skipped") {
+            return;
+        }
+        if (output.resultType !== "success") {
+            const message = this.alertService.formatSystemNotification("❌ 开盘前资讯简报失败", selectPreMarketBriefNotificationLines(output.message));
+            await this.alertService.send(message);
+            return;
+        }
+        await this.alertService.send(output.message);
+    }
     async maybeSendReviewNotification(output) {
         if (!this.notifyEnabled || output.resultType === "skipped") {
             return;
@@ -425,6 +531,12 @@ function createReviewExecutionOutput(reviewResult) {
         combinedText: joinMessages(reviewResult.overviewMessage, ...reviewResult.detailMessages),
     };
 }
+function createPreMarketBriefExecutionOutput(result) {
+    return {
+        resultType: result.resultType,
+        message: result.message,
+    };
+}
 function joinMessages(...parts) {
     return parts
         .map((part) => part?.trim())
@@ -467,6 +579,9 @@ function summarizeUpdateResult(result) {
 function summarizeReviewResult(result) {
     return selectReviewSummaryLines(result).join(" | ");
 }
+function summarizePreMarketBriefResult(result) {
+    return selectPreMarketBriefNotificationLines(result).join(" | ");
+}
 function selectUpdateSummaryLines(result) {
     const lines = normalizeResultLines(result);
     const head = lines.slice(0, 2);
@@ -491,6 +606,12 @@ function selectReviewNotificationLines(result) {
     const highlights = lines.filter((line) => /^(🧭|复盘数量:|关键位验证:|明日处理:|⚠️ 收盘复盘失败|⚠️ 收盘分析\/回测失败)/.test(line));
     return dedupeLines([...head, ...highlights]).slice(0, 12);
 }
+function selectPreMarketBriefNotificationLines(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")
@@ -536,6 +657,9 @@ function formatRuntimeHost(state) {
 function hasCompletedScheduledWindow(successDate, successAt, today, readyTime) {
     return successDate === today && extractChinaTime(successAt) >= readyTime;
 }
+function hasAttemptedScheduledWindow(attemptDate, attemptAt, today, readyTime) {
+    return attemptDate === today && extractChinaTime(attemptAt) >= readyTime;
+}
 function extractChinaTime(dateTime) {
     return dateTime?.slice(11, 16) ?? "00:00";
 }

package/dist/bootstrap.js

@@ -35,6 +35,7 @@ import { AlertMediaService } from "./services/alert-media-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 { PreMarketBriefService } from "./services/pre-market-brief-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";
@@ -140,9 +141,10 @@ export function createAppContext(config, options = {}) {
     const jin10FlashMonitorService = new Jin10FlashMonitorService(config.databasePath, config.jin10FlashPollInterval, config.jin10FlashRetentionDays, config.jin10FlashNightAlert, watchlistService, jin10McpService, analysisService, alertService, jin10FlashRepository, jin10FlashDeliveryRepository);
     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, jin10FlashDeliveryRepository, jin10FlashRepository);
+    const preMarketBriefService = new PreMarketBriefService(watchlistService, jin10McpService, jin10FlashRepository, analysisService);
     const realtimeMonitorWorker = new RealtimeMonitorWorker(monitorService, config.requestInterval * 1000);
     const jin10FlashWorker = new Jin10FlashWorker(jin10FlashMonitorService, config.jin10FlashPollInterval * 1000);
-    const dailyUpdateWorker = new DailyUpdateWorker(updateService, postCloseReviewService, tradingCalendarService, config.databasePath, alertService, config.dailyUpdateNotify, runtime.configSource);
+    const dailyUpdateWorker = new DailyUpdateWorker(updateService, preMarketBriefService, postCloseReviewService, tradingCalendarService, config.databasePath, alertService, config.dailyUpdateNotify, runtime.configSource);
     let managedLoopAbortController = null;
     let managedLoopPromise = null;
     return {

package/dist/config/env.d.ts

@@ -0,0 +1,17 @@
+export declare const CONFIG_ENV_FALLBACKS: {
+    readonly tickflowApiUrl: readonly ["TICKFLOW_ASSIST_TICKFLOW_API_URL", "TICKFLOW_API_URL"];
+    readonly tickflowApiKey: readonly ["TICKFLOW_ASSIST_TICKFLOW_API_KEY", "TICKFLOW_API_KEY"];
+    readonly tickflowApiKeyLevel: readonly ["TICKFLOW_ASSIST_TICKFLOW_API_KEY_LEVEL", "TICKFLOW_API_KEY_LEVEL"];
+    readonly mxSearchApiUrl: readonly ["TICKFLOW_ASSIST_MX_SEARCH_API_URL", "MX_SEARCH_API_URL"];
+    readonly mxSearchApiKey: readonly ["TICKFLOW_ASSIST_MX_SEARCH_API_KEY", "MX_SEARCH_API_KEY", "MX_APIKEY"];
+    readonly jin10McpUrl: readonly ["TICKFLOW_ASSIST_JIN10_MCP_URL", "JIN10_MCP_URL"];
+    readonly jin10ApiToken: readonly ["TICKFLOW_ASSIST_JIN10_API_TOKEN", "JIN10_API_TOKEN"];
+    readonly llmBaseUrl: readonly ["TICKFLOW_ASSIST_LLM_BASE_URL", "LLM_BASE_URL"];
+    readonly llmApiKey: readonly ["TICKFLOW_ASSIST_LLM_API_KEY", "LLM_API_KEY"];
+    readonly llmModel: readonly ["TICKFLOW_ASSIST_LLM_MODEL", "LLM_MODEL"];
+};
+export type EnvBackedConfigKey = keyof typeof CONFIG_ENV_FALLBACKS;
+export declare function getEnvFallbackValue(names: readonly string[], env?: NodeJS.ProcessEnv): string;
+export declare function getConfigEnvFallback(key: EnvBackedConfigKey, env?: NodeJS.ProcessEnv): string;
+export declare function hasConfigEnvFallback(key: EnvBackedConfigKey, env?: NodeJS.ProcessEnv): boolean;
+export declare function formatConfigEnvFallback(key: EnvBackedConfigKey): string;

package/dist/config/env.js

@@ -0,0 +1,30 @@
+export const CONFIG_ENV_FALLBACKS = {
+    tickflowApiUrl: ["TICKFLOW_ASSIST_TICKFLOW_API_URL", "TICKFLOW_API_URL"],
+    tickflowApiKey: ["TICKFLOW_ASSIST_TICKFLOW_API_KEY", "TICKFLOW_API_KEY"],
+    tickflowApiKeyLevel: ["TICKFLOW_ASSIST_TICKFLOW_API_KEY_LEVEL", "TICKFLOW_API_KEY_LEVEL"],
+    mxSearchApiUrl: ["TICKFLOW_ASSIST_MX_SEARCH_API_URL", "MX_SEARCH_API_URL"],
+    mxSearchApiKey: ["TICKFLOW_ASSIST_MX_SEARCH_API_KEY", "MX_SEARCH_API_KEY", "MX_APIKEY"],
+    jin10McpUrl: ["TICKFLOW_ASSIST_JIN10_MCP_URL", "JIN10_MCP_URL"],
+    jin10ApiToken: ["TICKFLOW_ASSIST_JIN10_API_TOKEN", "JIN10_API_TOKEN"],
+    llmBaseUrl: ["TICKFLOW_ASSIST_LLM_BASE_URL", "LLM_BASE_URL"],
+    llmApiKey: ["TICKFLOW_ASSIST_LLM_API_KEY", "LLM_API_KEY"],
+    llmModel: ["TICKFLOW_ASSIST_LLM_MODEL", "LLM_MODEL"],
+};
+export function getEnvFallbackValue(names, env = process.env) {
+    for (const name of names) {
+        const value = env[name];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return "";
+}
+export function getConfigEnvFallback(key, env = process.env) {
+    return getEnvFallbackValue(CONFIG_ENV_FALLBACKS[key], env);
+}
+export function hasConfigEnvFallback(key, env = process.env) {
+    return Boolean(getConfigEnvFallback(key, env));
+}
+export function formatConfigEnvFallback(key) {
+    return CONFIG_ENV_FALLBACKS[key].join(" / ");
+}

package/dist/config/normalize.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { getConfigEnvFallback } from "./env.js";
 import { normalizeTickflowApiKeyLevel } from "./tickflow-access.js";
 import { DEFAULT_PLUGIN_CONFIG } from "./schema.js";
 function normalizeString(value, fallback = "") {
@@ -10,6 +11,10 @@ function normalizeString(value, fallback = "") {
     }
     return String(value).trim();
 }
+function normalizeStringWithFallback(value, fallback = "") {
+    const normalized = normalizeString(value);
+    return normalized || fallback;
+}
 function normalizeInteger(value, fallback) {
     const parsed = Number(value ?? fallback);
     return Number.isFinite(parsed) ? Math.max(1, Math.trunc(parsed)) : fallback;
@@ -40,22 +45,30 @@ function normalizeBoolean(value, fallback) {
 }
 export function normalizePluginConfig(input) {
     const raw = (input ?? {});
-    const envMxSearchApiUrl = normalizeString(process.env.MX_SEARCH_API_URL);
-    const envMxSearchApiKey = normalizeString(process.env.MX_APIKEY);
+    const envTickflowApiUrl = getConfigEnvFallback("tickflowApiUrl");
+    const envTickflowApiKey = getConfigEnvFallback("tickflowApiKey");
+    const envTickflowApiKeyLevel = getConfigEnvFallback("tickflowApiKeyLevel");
+    const envMxSearchApiUrl = getConfigEnvFallback("mxSearchApiUrl");
+    const envMxSearchApiKey = getConfigEnvFallback("mxSearchApiKey");
+    const envJin10McpUrl = getConfigEnvFallback("jin10McpUrl");
+    const envJin10ApiToken = getConfigEnvFallback("jin10ApiToken");
+    const envLlmBaseUrl = getConfigEnvFallback("llmBaseUrl");
+    const envLlmApiKey = getConfigEnvFallback("llmApiKey");
+    const envLlmModel = getConfigEnvFallback("llmModel");
     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),
-        jin10McpUrl: normalizeString(raw.jin10McpUrl, DEFAULT_PLUGIN_CONFIG.jin10McpUrl),
-        jin10ApiToken: normalizeString(raw.jin10ApiToken),
+        tickflowApiUrl: normalizeStringWithFallback(raw.tickflowApiUrl, envTickflowApiUrl || DEFAULT_PLUGIN_CONFIG.tickflowApiUrl),
+        tickflowApiKey: normalizeStringWithFallback(raw.tickflowApiKey, envTickflowApiKey),
+        tickflowApiKeyLevel: normalizeTickflowApiKeyLevel(normalizeStringWithFallback(raw.tickflowApiKeyLevel, envTickflowApiKeyLevel), DEFAULT_PLUGIN_CONFIG.tickflowApiKeyLevel),
+        mxSearchApiUrl: normalizeStringWithFallback(raw.mxSearchApiUrl, envMxSearchApiUrl || DEFAULT_PLUGIN_CONFIG.mxSearchApiUrl),
+        mxSearchApiKey: normalizeStringWithFallback(raw.mxSearchApiKey, envMxSearchApiKey || DEFAULT_PLUGIN_CONFIG.mxSearchApiKey),
+        jin10McpUrl: normalizeStringWithFallback(raw.jin10McpUrl, envJin10McpUrl || DEFAULT_PLUGIN_CONFIG.jin10McpUrl),
+        jin10ApiToken: normalizeStringWithFallback(raw.jin10ApiToken, envJin10ApiToken),
         jin10FlashPollInterval: normalizeInteger(raw.jin10FlashPollInterval, DEFAULT_PLUGIN_CONFIG.jin10FlashPollInterval),
         jin10FlashRetentionDays: normalizeInteger(raw.jin10FlashRetentionDays, DEFAULT_PLUGIN_CONFIG.jin10FlashRetentionDays),
         jin10FlashNightAlert: normalizeBoolean(raw.jin10FlashNightAlert, DEFAULT_PLUGIN_CONFIG.jin10FlashNightAlert),
-        llmBaseUrl: normalizeString(raw.llmBaseUrl, DEFAULT_PLUGIN_CONFIG.llmBaseUrl),
-        llmApiKey: normalizeString(raw.llmApiKey),
-        llmModel: normalizeString(raw.llmModel, DEFAULT_PLUGIN_CONFIG.llmModel),
+        llmBaseUrl: normalizeStringWithFallback(raw.llmBaseUrl, envLlmBaseUrl || DEFAULT_PLUGIN_CONFIG.llmBaseUrl),
+        llmApiKey: normalizeStringWithFallback(raw.llmApiKey, envLlmApiKey),
+        llmModel: normalizeStringWithFallback(raw.llmModel, envLlmModel || 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),

package/dist/dev/tickflow-assist-cli.js

@@ -6,6 +6,7 @@ import path from "node:path";
 import process from "node:process";
 import { createInterface } from "node:readline/promises";
 import JSON5 from "json5";
+import { formatConfigEnvFallback, hasConfigEnvFallback, } from "../config/env.js";
 const PLUGIN_ID = "tickflow-assist";
 const DEFAULT_CONFIG_PATH = path.join(os.homedir(), ".openclaw", "openclaw.json");
 const DEFAULTS = {
@@ -59,6 +60,14 @@ Options:
   --alert-account <name>
   --alert-target <target>
   -h, --help                  Show this help
+
+Environment fallback:
+  tickflowApiKey      ${formatConfigEnvFallback("tickflowApiKey")}
+  llmApiKey           ${formatConfigEnvFallback("llmApiKey")}
+  llmBaseUrl          ${formatConfigEnvFallback("llmBaseUrl")}
+  llmModel            ${formatConfigEnvFallback("llmModel")}
+  mxSearchApiKey      ${formatConfigEnvFallback("mxSearchApiKey")}
+  jin10ApiToken       ${formatConfigEnvFallback("jin10ApiToken")}
 `);
 }
 function parseArgs(argv) {
@@ -390,7 +399,7 @@ async function promptAlertChannel(rl, configPath, defaultChannel) {
         choices.push({ value: "__manual__", label: "手动输入其他通道" });
         selectedChannel = await promptSelect(rl, "检测到 openclaw.json 中已有配置，请选择推送通道", choices, defaultChannel);
         if (selectedChannel === "__manual__") {
-            selectedChannel = await promptString(rl, "Alert Channel", defaultChannel, true);
+            selectedChannel = await promptString(rl, "Alert Channel", defaultChannel, { required: true });
         }
     }
     else {
@@ -467,15 +476,29 @@ async function promptForConfig(options, existing, pluginDir, configPath) {
         console.log(`OpenClaw 配置文件: ${configPath}`);
         console.log(`插件目录: ${pluginDir}`);
         console.log("");
-        seed.tickflowApiKey = await promptString(rl, "TickFlow API Key", seed.tickflowApiKey, true);
+        console.log("为避免后续运行时反复补配置，下面这些字段建议一次性填完整。");
+        console.log("");
+        seed.tickflowApiKey = await promptString(rl, buildEnvAwarePromptLabel("TickFlow API Key", "tickflowApiKey", seed.tickflowApiKey), seed.tickflowApiKey, {
+            required: !hasConfigEnvFallback("tickflowApiKey"),
+            maskDefault: true,
+            allowClear: true,
+        });
         seed.tickflowApiKeyLevel = normalizeApiKeyLevel(await promptSelect(rl, "TickFlow 订阅等级", [
             { value: "Free", label: "Free" },
             { value: "Start", label: "Start" },
             { value: "Pro", label: "Pro" },
             { value: "Expert", label: "Expert" },
         ], seed.tickflowApiKeyLevel));
-        seed.mxSearchApiKey = await promptString(rl, "MX Search API Key (可留空)", seed.mxSearchApiKey, false);
-        seed.jin10ApiToken = await promptString(rl, "Jin10 API Token (可留空)", seed.jin10ApiToken, false);
+        seed.mxSearchApiKey = await promptString(rl, buildEnvAwarePromptLabel("MX Search API Key（建议填写）", "mxSearchApiKey", seed.mxSearchApiKey), seed.mxSearchApiKey, {
+            required: false,
+            maskDefault: true,
+            allowClear: true,
+        });
+        seed.jin10ApiToken = await promptString(rl, buildEnvAwarePromptLabel("Jin10 API Token（建议填写）", "jin10ApiToken", seed.jin10ApiToken), seed.jin10ApiToken, {
+            required: false,
+            maskDefault: true,
+            allowClear: true,
+        });
         seed.jin10FlashPollInterval = await promptInteger(rl, "Jin10 快讯轮询间隔（秒）", seed.jin10FlashPollInterval, 10);
         seed.jin10FlashRetentionDays = await promptInteger(rl, "Jin10 快讯保留天数", seed.jin10FlashRetentionDays, 1);
         const nightAlertChoice = await promptSelect(rl, "Jin10 夜间静默", [
@@ -483,21 +506,31 @@ async function promptForConfig(options, existing, pluginDir, configPath) {
             { value: "false", label: "开启夜间静默（22:00~06:00 不告警）" },
         ], seed.jin10FlashNightAlert ? "true" : "false");
         seed.jin10FlashNightAlert = nightAlertChoice === "true";
-        seed.llmBaseUrl = await promptString(rl, "LLM Base URL", seed.llmBaseUrl, true);
-        seed.llmApiKey = await promptString(rl, "LLM API Key", seed.llmApiKey, true);
-        seed.llmModel = await promptString(rl, "LLM Model", seed.llmModel, true);
+        seed.llmBaseUrl = await promptString(rl, buildEnvAwarePromptLabel("LLM Base URL", "llmBaseUrl", seed.llmBaseUrl), seed.llmBaseUrl, {
+            required: true,
+            allowClear: hasConfigEnvFallback("llmBaseUrl"),
+        });
+        seed.llmApiKey = await promptString(rl, buildEnvAwarePromptLabel("LLM API Key", "llmApiKey", seed.llmApiKey), seed.llmApiKey, {
+            required: !hasConfigEnvFallback("llmApiKey"),
+            maskDefault: true,
+            allowClear: true,
+        });
+        seed.llmModel = await promptString(rl, buildEnvAwarePromptLabel("LLM Model", "llmModel", seed.llmModel), seed.llmModel, {
+            required: true,
+            allowClear: hasConfigEnvFallback("llmModel"),
+        });
         console.log("");
         const alertResult = await promptAlertChannel(rl, configPath, seed.alertChannel);
         seed.alertChannel = alertResult.channel;
         seed.alertAccount = alertResult.account;
         let targetLabel = "Alert Target";
         if (seed.alertAccount) {
-            targetLabel = `已选通道 [${seed.alertChannel}] 及账号 [${seed.alertAccount}]，请输入 Alert Target`;
+            targetLabel = `已选通道 [${seed.alertChannel}] 及账号 [${seed.alertAccount}]，请输入 Alert Target（建议填写）`;
         }
         else {
-            targetLabel = `已选通道 [${seed.alertChannel}]，请输入 Alert Target`;
+            targetLabel = `已选通道 [${seed.alertChannel}]，请输入 Alert Target（建议填写）`;
         }
-        seed.alertTarget = await promptString(rl, targetLabel, seed.alertTarget, false);
+        seed.alertTarget = await promptString(rl, targetLabel, seed.alertTarget, { required: false });
         seed.requestInterval = await promptInteger(rl, "Request Interval (seconds)", seed.requestInterval, 5);
         seed.dailyUpdateNotify = await promptBoolean(rl, "Daily Update Notify", seed.dailyUpdateNotify);
     }
@@ -507,12 +540,17 @@ async function promptForConfig(options, existing, pluginDir, configPath) {
     assertRequired(seed);
     return seed;
 }
-async function promptString(rl, label, defaultValue, required) {
+async function promptString(rl, label, defaultValue, options) {
     while (true) {
-        const suffix = defaultValue ? ` [${defaultValue}]` : "";
+        const suffix = defaultValue
+            ? options.maskDefault ? " [已存在]" : ` [${defaultValue}]`
+            : "";
         const answer = (await rl.question(`${label}${suffix}: `)).trim();
+        if (options.allowClear && answer === "-") {
+            return "";
+        }
         const value = answer || defaultValue;
-        if (!required || value) {
+        if (!options.required || value) {
             return value;
         }
         console.error(`${label} 不能为空`);
@@ -544,11 +582,11 @@ async function promptBoolean(rl, label, defaultValue) {
     }
 }
 function assertRequired(config) {
-    if (!config.tickflowApiKey) {
-        throw new Error("tickflowApiKey is required");
+    if (!config.tickflowApiKey && !hasConfigEnvFallback("tickflowApiKey")) {
+        throw new Error(`tickflowApiKey is required (or set ${formatConfigEnvFallback("tickflowApiKey")})`);
     }
-    if (!config.llmApiKey) {
-        throw new Error("llmApiKey is required");
+    if (!config.llmApiKey && !hasConfigEnvFallback("llmApiKey")) {
+        throw new Error(`llmApiKey is required (or set ${formatConfigEnvFallback("llmApiKey")})`);
     }
 }
 function normalizeCommunityInstallSpec(root) {
@@ -806,6 +844,7 @@ async function configureOpenClaw(options) {
     if (normalizedInstallSpec) {
         console.log(`Community install spec normalized: clawhub:${PLUGIN_ID}`);
     }
+    printActiveEnvFallbacks(config);
     printNextSteps(options, config);
 }
 async function main() {
@@ -823,3 +862,30 @@ async function main() {
     }
 }
 void main();
+function buildEnvAwarePromptLabel(label, key, currentValue) {
+    if (!hasConfigEnvFallback(key)) {
+        return label;
+    }
+    const fallback = formatConfigEnvFallback(key);
+    if (currentValue) {
+        return `${label}（留空保留当前值；输入 - 清空并改用环境变量 ${fallback}）`;
+    }
+    return `${label}（留空则使用环境变量 ${fallback}）`;
+}
+function printActiveEnvFallbacks(config) {
+    const activeFallbacks = [
+        { key: "tickflowApiKey", label: "TickFlow API Key", value: config.tickflowApiKey },
+        { key: "mxSearchApiKey", label: "MX Search API Key", value: config.mxSearchApiKey },
+        { key: "jin10ApiToken", label: "Jin10 API Token", value: config.jin10ApiToken },
+        { key: "llmBaseUrl", label: "LLM Base URL", value: config.llmBaseUrl },
+        { key: "llmApiKey", label: "LLM API Key", value: config.llmApiKey },
+        { key: "llmModel", label: "LLM Model", value: config.llmModel },
+    ].filter(({ key, value }) => !value && hasConfigEnvFallback(key));
+    if (activeFallbacks.length === 0) {
+        return;
+    }
+    console.log("Active env fallback:");
+    for (const entry of activeFallbacks) {
+        console.log(`  ${entry.label}: ${formatConfigEnvFallback(entry.key)}`);
+    }
+}

package/dist/prompts/analysis/index.d.ts

@@ -7,3 +7,4 @@ export { COMPOSITE_ANALYSIS_SYSTEM_PROMPT, buildCompositeAnalysisUserPrompt, } f
 export { POST_CLOSE_REVIEW_SYSTEM_PROMPT, buildPostCloseReviewUserPrompt, } from "./post-close-review-user-prompt.js";
 export { WATCHLIST_PROFILE_EXTRACTION_SYSTEM_PROMPT, buildWatchlistProfileExtractionUserPrompt, } from "./watchlist-profile-extraction-prompt.js";
 export { FLASH_MONITOR_ALERT_SYSTEM_PROMPT, buildFlashMonitorAlertUserPrompt, } from "./flash-monitor-alert-prompt.js";
+export { PRE_MARKET_BRIEF_SYSTEM_PROMPT, buildPreMarketBriefUserPrompt, } from "./pre-market-brief-prompt.js";