@openfinclaw/openfinclaw-strategy 2026.3.274 → 2026.3.276

package/src/http/routes.ts

@@ -9,8 +9,10 @@ import { fileURLToPath } from "node:url";
 import {
   queryActivityLog,
   queryAgentEvents,
-  queryStrategies,
   queryBacktestResults,
+  queryPriceAlerts,
+  queryScanHistory,
+  queryStrategies,
 } from "../db/repositories.js";
 
 // Resolve path to web/index.html relative to this file's location
@@ -103,5 +105,21 @@ export function handleRoute(db: DatabaseSync, req: IncomingMessage, res: ServerR
     return;
   }
 
+  if (pathname === "/api/scan-history") {
+    const limit = parseQueryParam(url, "limit", 20);
+    const offset = parseQueryParam(url, "offset", 0);
+    const scanType = parseStringParam(url, "scan_type");
+    sendJson(res, queryScanHistory(db, { scanType, limit, offset }));
+    return;
+  }
+
+  if (pathname === "/api/price-alerts") {
+    const limit = parseQueryParam(url, "limit", 50);
+    const offset = parseQueryParam(url, "offset", 0);
+    const strategyId = parseStringParam(url, "strategy_id");
+    sendJson(res, queryPriceAlerts(db, { strategyId, limit, offset }));
+    return;
+  }
+
   send404(res);
 }

package/src/http/server.ts

@@ -24,13 +24,6 @@ const GLOBAL_SERVER_KEY = "__openfinclaw_http_server__" as const;
  * it is closed first so the port is released.
  */
 export function startHttpServer(port: number, logger: DashboardLogger): void {
-  // Close previous server left over from a hot-reload
-  const prev = (globalThis as Record<string, unknown>)[GLOBAL_SERVER_KEY] as Server | undefined;
-  if (prev) {
-    logger.info("[OpenFinClaw] Closing previous Dashboard server (hot-reload)");
-    prev.close();
-  }
-
   const server = createServer((req, res) => {
     try {
       handleRoute(getDb(), req, res);
@@ -42,13 +35,24 @@ export function startHttpServer(port: number, logger: DashboardLogger): void {
     }
   });
 
-  (globalThis as Record<string, unknown>)[GLOBAL_SERVER_KEY] = server;
-
   server.on("error", (err) => {
     logger.info(`[OpenFinClaw] Dashboard server error: ${String(err)}`);
   });
 
-  server.listen(port, "127.0.0.1", () => {
-    logger.info(`[OpenFinClaw] Dashboard available at http://127.0.0.1:${port}`);
-  });
+  /** Bind server after ensuring the port is free. */
+  function listen() {
+    (globalThis as Record<string, unknown>)[GLOBAL_SERVER_KEY] = server;
+    server.listen(port, "127.0.0.1", () => {
+      logger.info(`[OpenFinClaw] Dashboard available at http://127.0.0.1:${port}`);
+    });
+  }
+
+  // Close previous server left over from a hot-reload, then bind
+  const prev = (globalThis as Record<string, unknown>)[GLOBAL_SERVER_KEY] as Server | undefined;
+  if (prev) {
+    logger.info("[OpenFinClaw] Closing previous Dashboard server (hot-reload)");
+    prev.close(listen);
+  } else {
+    listen();
+  }
 }

package/src/middleware/with-logging.ts

@@ -22,14 +22,14 @@ type AnyExecuteFn = (
 /**
  * Wrap a tool execute function with automatic activity logging.
  *
- * @param db        - The SQLite database instance.
+ * @param getDb     - Lazy database getter (called at execution time, not registration).
  * @param toolName  - Name used as the `action` column value.
  * @param category  - Broad category, e.g. "market-data" or "strategy".
  * @param fn        - The original execute function to wrap.
  * @param opts      - Optional: extract strategy_id from params for context.
  */
 export function withLogging<T extends AnyExecuteFn>(
-  db: DatabaseSync,
+  getDb: () => DatabaseSync,
   toolName: string,
   category: string,
   fn: T,
@@ -45,7 +45,7 @@ export function withLogging<T extends AnyExecuteFn>(
 
     try {
       const result = await fn(toolCallId, params, ...rest);
-      insertActivityLog(db, {
+      insertActivityLog(getDb(), {
         id: logId,
         timestamp: new Date().toISOString(),
         category,
@@ -56,7 +56,7 @@ export function withLogging<T extends AnyExecuteFn>(
       });
       return result;
     } catch (err) {
-      insertActivityLog(db, {
+      insertActivityLog(getDb(), {
         id: logId,
         timestamp: new Date().toISOString(),
         category,

package/src/prompt-guidance.ts

@@ -8,4 +8,18 @@ export const OPENFINCLAW_AGENT_GUIDANCE = [
   "当用户需要市场行情数据（价格、K线、加密货币、对比、搜索）时，必须使用 fin_price, fin_kline, fin_crypto, fin_compare, fin_slim_search 等 tool。",
   "只有通过 tool 执行的操作才会写入 SQLite 数据库并在 Dashboard 中展示，绕过 tool 调用的数据不会落库。",
   "tool 调用失败时优先检查 API Key 是否配置（OPENFINCLAW_API_KEY 环境变量或插件配置 apiKey）。",
+  "",
+  "## 定时扫描任务",
+  "系统通过 Gateway Cron 自动触发以下定时任务：",
+  "- 每日扫描（08:00）：调用 strategy_daily_scan 扫描策略标的的新闻和行情",
+  "- 价格监控（每30分钟）：调用 strategy_price_monitor 检测价格异动",
+  "- 周报（每周日 20:00）/ 月报（每月1日 20:00）：调用 strategy_periodic_report",
+  "",
+  "收到每日扫描报告后，按以下步骤处理：",
+  "1. 分析每条新闻对策略的影响（利好/利空/中性）",
+  "2. 使用 fin_kline 获取最新行情确认趋势",
+  "3. 如有重大影响，调整策略参数后用 skill_publish 提交回测",
+  "4. 用 skill_publish_verify 确认回测完成",
+  "5. 将分析报告发送给用户",
+  "查看扫描历史：使用 strategy_scan_history",
 ].join("\n");

package/src/scheduler/cron-setup.ts

@@ -0,0 +1,181 @@
+/**
+ * Gateway Cron job registration for openfinclaw-strategy.
+ *
+ * Directly reads/writes the Gateway cron store (~/.openclaw/cron/jobs.json)
+ * so jobs can be registered at plugin startup via the gateway_start hook
+ * without requiring a CronService API reference.
+ *
+ * The running CronService watches the store file and picks up new jobs
+ * on its next tick.
+ *
+ * Idempotent: safe to call multiple times (skips existing jobs by name).
+ *
+ * Jobs:
+ * - openfinclaw:daily-scan      (0 8 * * *)       每日策略扫描
+ * - openfinclaw:price-monitor   (every 30 min)     价格异动监控
+ * - openfinclaw:weekly-report   (0 20 * * 0)       周报
+ * - openfinclaw:monthly-report  (0 20 1 * *)       月报
+ */
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import type { UnifiedPluginConfig } from "../types.js";
+
+// ── Cron store types (mirrors src/cron/types.ts subset) ──────────────────
+
+/** Minimal stored cron job shape. */
+interface StoredCronJob {
+  id: string;
+  name: string;
+  enabled: boolean;
+  schedule: { kind: "cron"; expr: string; tz?: string };
+  payload: { kind: "systemEvent"; text: string };
+  sessionTarget: string;
+  wakeMode: string;
+  delivery: { mode: string };
+  createdAtMs: number;
+  updatedAtMs: number;
+  state: Record<string, unknown>;
+}
+
+interface CronStoreFile {
+  version: 1;
+  jobs: StoredCronJob[];
+}
+
+// ── File I/O ──────────────────────────────────────────────────────────────
+
+/** Resolve default cron store path: ~/.openclaw/cron/jobs.json */
+function defaultStorePath(): string {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return path.join(home, ".openclaw", "cron", "jobs.json");
+}
+
+/** Load cron store. Returns empty store when file doesn't exist. */
+async function loadStore(storePath: string): Promise<CronStoreFile> {
+  try {
+    const raw = await fs.promises.readFile(storePath, "utf-8");
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    const jobs = Array.isArray(parsed.jobs) ? (parsed.jobs as StoredCronJob[]) : [];
+    return { version: 1, jobs };
+  } catch (err) {
+    if ((err as { code?: string }).code === "ENOENT") {
+      return { version: 1, jobs: [] };
+    }
+    throw err;
+  }
+}
+
+/** Atomic save: write to tmp then rename. */
+async function saveStore(storePath: string, store: CronStoreFile): Promise<void> {
+  const dir = path.dirname(storePath);
+  await fs.promises.mkdir(dir, { recursive: true });
+  const json = JSON.stringify(store, null, 2);
+  const tmp = `${storePath}.${process.pid}.${Date.now()}.tmp`;
+  await fs.promises.writeFile(tmp, json, "utf-8");
+  await fs.promises.rename(tmp, storePath);
+}
+
+// ── Job definitions ──────────────────────────────────────────────────────
+
+/** Build cron job definitions from plugin config. */
+function buildCronJobDefs(config: UnifiedPluginConfig): Array<{
+  name: string;
+  schedule: { kind: "cron"; expr: string; tz?: string };
+  payload: { kind: "systemEvent"; text: string };
+}> {
+  return [
+    {
+      name: "openfinclaw:daily-scan",
+      schedule: { kind: "cron", expr: config.scanCronExpr, tz: config.scanTimezone },
+      payload: {
+        kind: "systemEvent",
+        text: [
+          "[openfinclaw-strategy 每日扫描]",
+          "1. 调用 strategy_daily_scan 获取策略扫描报告",
+          "2. 分析每条新闻对策略的影响（利好/利空/中性）",
+          "3. 如果发现重大影响，调整策略参数并用 skill_publish 提交回测",
+          "4. 用 skill_publish_verify 确认回测完成",
+          "5. 将分析报告和建议操作发送给用户",
+        ].join("\n"),
+      },
+    },
+    {
+      name: "openfinclaw:price-monitor",
+      schedule: { kind: "cron", expr: config.monitorCronExpr, tz: config.scanTimezone },
+      payload: {
+        kind: "systemEvent",
+        text: [
+          "[openfinclaw-strategy 价格监控]",
+          "调用 strategy_price_monitor 检查所有策略标的的价格异动。",
+          "如有告警（涨跌幅超阈值），分析可能的原因并通知用户。",
+        ].join("\n"),
+      },
+    },
+    {
+      name: "openfinclaw:weekly-report",
+      schedule: { kind: "cron", expr: config.weeklyReportCronExpr, tz: config.scanTimezone },
+      payload: {
+        kind: "systemEvent",
+        text: [
+          "[openfinclaw-strategy 周报]",
+          '调用 strategy_periodic_report(period="weekly") 生成策略绩效周报。',
+          "汇总本周回测结果、价格告警和扫描记录，发送给用户。",
+        ].join("\n"),
+      },
+    },
+    {
+      name: "openfinclaw:monthly-report",
+      schedule: { kind: "cron", expr: config.monthlyReportCronExpr, tz: config.scanTimezone },
+      payload: {
+        kind: "systemEvent",
+        text: [
+          "[openfinclaw-strategy 月报]",
+          '调用 strategy_periodic_report(period="monthly") 生成策略绩效月报。',
+          "汇总本月回测结果、价格告警和扫描记录，发送给用户。",
+        ].join("\n"),
+      },
+    },
+  ];
+}
+
+// ── Public API ────────────────────────────────────────────────────────────
+
+/**
+ * Idempotently register openfinclaw cron jobs by writing to the
+ * Gateway cron store file. Safe to call at plugin startup.
+ */
+export async function setupOpenfinclawCronJobs(
+  config: UnifiedPluginConfig,
+): Promise<{ ok: boolean; created: number; existing: number }> {
+  const storePath = defaultStorePath();
+  const store = await loadStore(storePath);
+  const existingNames = new Set(store.jobs.map((j) => j.name));
+  const defs = buildCronJobDefs(config);
+  const now = Date.now();
+
+  let created = 0;
+  for (const def of defs) {
+    if (existingNames.has(def.name)) continue;
+    store.jobs.push({
+      id: randomUUID(),
+      name: def.name,
+      enabled: true,
+      schedule: def.schedule,
+      payload: def.payload,
+      sessionTarget: "main",
+      wakeMode: "now",
+      delivery: { mode: "none" },
+      createdAtMs: now,
+      updatedAtMs: now,
+      state: {},
+    });
+    created++;
+  }
+
+  if (created > 0) {
+    await saveStore(storePath, store);
+  }
+
+  return { ok: true, created, existing: existingNames.size };
+}

package/src/scheduler/news-provider.ts

@@ -0,0 +1,295 @@
+import { guessMarket } from "../datahub/client.js";
+/**
+ * External news providers for strategy symbol monitoring.
+ *
+ * Provider priority:
+ * 1. CoinGecko Trending — free, no API key required (crypto only)
+ * 2. Finnhub — free tier 60 calls/min, requires API key
+ * 3. NewsAPI — free tier 100 calls/day, requires API key
+ *
+ * Default: CoinGecko (zero-config, works out of the box).
+ */
+import type { MarketType } from "../types.js";
+import type { NewsItem, NewsProvider, SymbolNewsResult } from "./types.js";
+
+// ── CoinGecko Trending (no key required) ─────────────────────────────────
+
+/** CoinGecko trending + search. Free, no API key. Crypto only. */
+export class CoinGeckoTrendingProvider implements NewsProvider {
+  readonly name = "coingecko";
+  private readonly baseUrl = "https://api.coingecko.com/api/v3";
+
+  async fetchNews(symbols: string[], market: MarketType): Promise<NewsItem[]> {
+    if (market !== "crypto") return [];
+
+    try {
+      const resp = await fetch(`${this.baseUrl}/search/trending`, {
+        signal: AbortSignal.timeout(15_000),
+      });
+      if (!resp.ok) return [];
+      const data = (await resp.json()) as {
+        coins?: Array<{
+          item: {
+            id: string;
+            coin_id: number;
+            name: string;
+            symbol: string;
+            market_cap_rank?: number;
+            price_btc?: number;
+            score: number;
+          };
+        }>;
+      };
+
+      const trendingCoins = data.coins ?? [];
+      const symbolSet = new Set(symbols.map((s) => s.split("/")[0]?.toUpperCase()));
+      const now = new Date().toISOString();
+
+      return trendingCoins
+        .filter((c) => symbolSet.has(c.item.symbol.toUpperCase()))
+        .map((c) => ({
+          id: `cg-trending-${c.item.id}`,
+          title: `${c.item.name} (${c.item.symbol.toUpperCase()}) is trending on CoinGecko`,
+          summary: `Rank #${c.item.market_cap_rank ?? "N/A"}, trending score: ${c.item.score}`,
+          source: "CoinGecko Trending",
+          url: `https://www.coingecko.com/en/coins/${c.item.id}`,
+          publishedAt: now,
+          symbols: [`${c.item.symbol.toUpperCase()}/USDT`],
+          relevanceScore: Math.max(0, 1 - c.item.score * 0.1),
+        }));
+    } catch {
+      return [];
+    }
+  }
+}
+
+// ── Finnhub (requires API key) ───────────────────────────────────────────
+
+/** Finnhub company news + market news. Requires API key. */
+export class FinnhubNewsProvider implements NewsProvider {
+  readonly name = "finnhub";
+  private readonly baseUrl = "https://finnhub.io/api/v1";
+
+  constructor(private readonly apiKey: string) {}
+
+  async fetchNews(symbols: string[], market: MarketType): Promise<NewsItem[]> {
+    if (market === "crypto") {
+      return this.fetchMarketNews("crypto");
+    }
+    const results: NewsItem[] = [];
+    for (const symbol of symbols.slice(0, 5)) {
+      const items = await this.fetchCompanyNews(symbol);
+      results.push(...items);
+    }
+    return results;
+  }
+
+  private async fetchCompanyNews(symbol: string): Promise<NewsItem[]> {
+    const cleanSymbol = symbol.replace(/\.(SH|SZ|BJ|HK)$/i, "");
+    const to = new Date().toISOString().slice(0, 10);
+    const from = new Date(Date.now() - 86_400_000).toISOString().slice(0, 10);
+
+    try {
+      const url = `${this.baseUrl}/company-news?symbol=${cleanSymbol}&from=${from}&to=${to}&token=${this.apiKey}`;
+      const resp = await fetch(url, { signal: AbortSignal.timeout(15_000) });
+      if (!resp.ok) return [];
+      const data = (await resp.json()) as Array<{
+        id: number;
+        headline: string;
+        summary: string;
+        source: string;
+        url: string;
+        datetime: number;
+        related: string;
+      }>;
+
+      return data.slice(0, 10).map((item) => ({
+        id: `finnhub-${item.id}`,
+        title: item.headline,
+        summary: item.summary.slice(0, 300),
+        source: item.source,
+        url: item.url,
+        publishedAt: new Date(item.datetime * 1000).toISOString(),
+        symbols: [symbol],
+        relevanceScore: 0.8,
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  private async fetchMarketNews(category: string): Promise<NewsItem[]> {
+    try {
+      const url = `${this.baseUrl}/news?category=${category}&token=${this.apiKey}`;
+      const resp = await fetch(url, { signal: AbortSignal.timeout(15_000) });
+      if (!resp.ok) return [];
+      const data = (await resp.json()) as Array<{
+        id: number;
+        headline: string;
+        summary: string;
+        source: string;
+        url: string;
+        datetime: number;
+      }>;
+
+      return data.slice(0, 10).map((item) => ({
+        id: `finnhub-mkt-${item.id}`,
+        title: item.headline,
+        summary: item.summary.slice(0, 300),
+        source: item.source,
+        url: item.url,
+        publishedAt: new Date(item.datetime * 1000).toISOString(),
+        symbols: [],
+        relevanceScore: 0.5,
+      }));
+    } catch {
+      return [];
+    }
+  }
+}
+
+// ── NewsAPI (requires API key) ───────────────────────────────────────────
+
+/** NewsAPI.org everything search. Requires API key. */
+export class NewsApiProvider implements NewsProvider {
+  readonly name = "newsapi";
+  private readonly baseUrl = "https://newsapi.org/v2";
+
+  constructor(private readonly apiKey: string) {}
+
+  async fetchNews(symbols: string[], _market: MarketType): Promise<NewsItem[]> {
+    const query = symbols
+      .slice(0, 3)
+      .map((s) => s.split("/")[0]?.replace(/\.(SH|SZ|BJ|HK)$/i, ""))
+      .join(" OR ");
+    if (!query) return [];
+
+    try {
+      const url = `${this.baseUrl}/everything?q=${encodeURIComponent(query)}&sortBy=publishedAt&pageSize=10&apiKey=${this.apiKey}`;
+      const resp = await fetch(url, { signal: AbortSignal.timeout(15_000) });
+      if (!resp.ok) return [];
+      const data = (await resp.json()) as {
+        articles?: Array<{
+          title: string;
+          description: string;
+          source: { name: string };
+          url: string;
+          publishedAt: string;
+        }>;
+      };
+
+      return (data.articles ?? []).map((a, i) => ({
+        id: `newsapi-${Date.now()}-${i}`,
+        title: a.title,
+        summary: (a.description ?? "").slice(0, 300),
+        source: a.source.name,
+        url: a.url,
+        publishedAt: a.publishedAt,
+        symbols,
+        relevanceScore: 0.6,
+      }));
+    } catch {
+      return [];
+    }
+  }
+}
+
+// ── Aggregated provider ──────────────────────────────────────────────────
+
+/**
+ * Aggregates multiple news providers with fallback.
+ * Deduplicates by news ID and sorts by publish time.
+ */
+export class AggregatedNewsProvider {
+  private readonly providers: NewsProvider[];
+
+  constructor(providers: NewsProvider[]) {
+    this.providers = providers;
+  }
+
+  /** Fetch news for a list of symbols, grouped by symbol. */
+  async fetchNewsForSymbols(symbols: string[]): Promise<SymbolNewsResult[]> {
+    const symbolsByMarket = new Map<MarketType, string[]>();
+    for (const sym of symbols) {
+      const market = guessMarket(sym);
+      const list = symbolsByMarket.get(market) ?? [];
+      list.push(sym);
+      symbolsByMarket.set(market, list);
+    }
+
+    const allNews: NewsItem[] = [];
+    for (const [market, syms] of symbolsByMarket) {
+      for (const provider of this.providers) {
+        try {
+          const items = await provider.fetchNews(syms, market);
+          allNews.push(...items);
+          if (items.length > 0) break; // first successful provider wins
+        } catch {
+          continue;
+        }
+      }
+    }
+
+    // Deduplicate by id
+    const seen = new Set<string>();
+    const unique = allNews.filter((item) => {
+      if (seen.has(item.id)) return false;
+      seen.add(item.id);
+      return true;
+    });
+
+    // Group by symbol
+    const resultMap = new Map<string, SymbolNewsResult>();
+    for (const sym of symbols) {
+      resultMap.set(sym, {
+        symbol: sym,
+        market: guessMarket(sym),
+        news: [],
+      });
+    }
+
+    for (const item of unique) {
+      if (item.symbols.length === 0) {
+        // Market-wide news: attach to all symbols of matching market
+        for (const [sym, result] of resultMap) {
+          result.news.push(item);
+        }
+      } else {
+        for (const sym of item.symbols) {
+          const result = resultMap.get(sym);
+          if (result) result.news.push(item);
+        }
+      }
+    }
+
+    // Sort each symbol's news by publish time (newest first)
+    for (const result of resultMap.values()) {
+      result.news.sort((a, b) => b.publishedAt.localeCompare(a.publishedAt));
+    }
+
+    return [...resultMap.values()];
+  }
+}
+
+// ── Factory ──────────────────────────────────────────────────────────────
+
+/** Create news providers based on config. Always includes CoinGecko as fallback. */
+export function createNewsProviders(config: {
+  newsProvider: string;
+  newsApiKey?: string;
+}): NewsProvider[] {
+  const providers: NewsProvider[] = [];
+
+  if (config.newsApiKey) {
+    if (config.newsProvider === "finnhub") {
+      providers.push(new FinnhubNewsProvider(config.newsApiKey));
+    } else if (config.newsProvider === "newsapi") {
+      providers.push(new NewsApiProvider(config.newsApiKey));
+    }
+  }
+
+  // CoinGecko is always available as fallback (no key required)
+  providers.push(new CoinGeckoTrendingProvider());
+
+  return providers;
+}