tickflow-assist 0.2.13 → 0.2.14

package/README.md

@@ -2,7 +2,9 @@
 
 基于 [OpenClaw](https://openclaw.ai) 的 A 股监控与分析插件。它使用 [TickFlow](https://tickflow.org/auth/register?ref=BUJ54JEDGE) 获取行情与财务数据，结合 LLM 生成技术面、基本面、资讯面的综合判断，并把结果持久化到本地 LanceDB。
 
-最近更新：`v0.2.13` 在 `configure-openclaw` 与一键安装脚本中加入 Linux 中文字体自动安装，减少 VPS 上 PNG 告警卡中文乱码；并补充 GitHub README 效果预览图。
+最近更新：`v0.2.14` 对齐 OpenClaw `v2026.3.31` 兼容声明与开发依赖，更新 QQ Bot 内置通道说明，并将 PNG 告警卡临时文件迁移到 OpenClaw 共享 temp root，修复新版本地媒体 allowlist 下的图片投递失败。
+
+当前主线按 OpenClaw `v2026.3.31+` 对齐。
 
 ## 安装
 

package/dist/bootstrap.d.ts

@@ -3,6 +3,7 @@ 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 { AlertMediaService } from "./services/alert-media-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";
@@ -19,6 +20,7 @@ export interface AppContext {
     };
     services: {
         alertService: AlertService;
+        alertMediaService: AlertMediaService;
         monitorService: MonitorService;
         realtimeMonitorWorker: RealtimeMonitorWorker;
         dailyUpdateWorker: DailyUpdateWorker;

package/dist/bootstrap.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { TickFlowClient } from "./services/tickflow-client.js";
 import { InstrumentService } from "./services/instrument-service.js";
 import { KlineService } from "./services/kline-service.js";
@@ -63,6 +64,7 @@ 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 { resolvePreferredOpenClawTmpDir } from "./runtime/openclaw-temp-dir.js";
 import { RealtimeMonitorWorker } from "./background/realtime-monitor.worker.js";
 import { DailyUpdateWorker } from "./background/daily-update.worker.js";
 export function createAppContext(config, options = {}) {
@@ -107,7 +109,7 @@ export function createAppContext(config, options = {}) {
             }
             : undefined,
     });
-    const alertMediaService = new AlertMediaService(config.databasePath);
+    const alertMediaService = new AlertMediaService(config.databasePath, undefined, undefined, resolveAlertMediaTempRootDir());
     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);
@@ -152,7 +154,7 @@ export function createAppContext(config, options = {}) {
             startMonitorTool(monitorService, runtime),
             stopDailyUpdateTool(dailyUpdateWorker, runtime),
             stopMonitorTool(monitorService, runtime),
-            testAlertTool(alertService, alertMediaService),
+            testAlertTool(alertService, alertMediaService, runtime.configSource),
             updateAllTool(dailyUpdateWorker),
             viewAnalysisTool(analysisViewService),
         ],
@@ -192,6 +194,7 @@ export function createAppContext(config, options = {}) {
         runtime,
         services: {
             alertService,
+            alertMediaService,
             monitorService,
             realtimeMonitorWorker,
             dailyUpdateWorker,
@@ -200,6 +203,12 @@ export function createAppContext(config, options = {}) {
         },
     };
 }
+function resolveAlertMediaTempRootDir() {
+    // OpenClaw 2026.3.31 no longer widens local media roots from tool-created files.
+    // Keep PNG alerts under the shared OpenClaw temp root so both runtime sends and
+    // `openclaw message send --media ...` can read them without extra allowlist config.
+    return path.join(resolvePreferredOpenClawTmpDir(), "tickflow-assist", "alert-media", "tmp");
+}
 export async function buildWatchlistDebugSnapshot(app) {
     const watchlistTableExists = await app.services.database.hasTable("watchlist");
     const watchlistPreview = await app.services.watchlistService.list();

package/dist/runtime/openclaw-temp-dir.d.ts

@@ -0,0 +1,21 @@
+export declare const POSIX_OPENCLAW_TMP_DIR = "/tmp/openclaw";
+interface TempDirStatLike {
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+    mode?: number;
+    uid?: number;
+}
+interface ResolvePreferredOpenClawTmpDirOptions {
+    accessSync?: (path: string, mode?: number) => void;
+    chmodSync?: (path: string, mode: number) => void;
+    lstatSync?: (path: string) => TempDirStatLike;
+    mkdirSync?: (path: string, opts: {
+        recursive: boolean;
+        mode?: number;
+    }) => void;
+    getuid?: () => number | undefined;
+    tmpdir?: () => string;
+    warn?: (message: string) => void;
+}
+export declare function resolvePreferredOpenClawTmpDir(options?: ResolvePreferredOpenClawTmpDirOptions): string;
+export {};

package/dist/runtime/openclaw-temp-dir.js

@@ -0,0 +1,124 @@
+import fsSync from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export const POSIX_OPENCLAW_TMP_DIR = "/tmp/openclaw";
+const TMP_DIR_ACCESS_MODE = fsSync.constants.W_OK | fsSync.constants.X_OK;
+function isNodeErrorWithCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+export function resolvePreferredOpenClawTmpDir(options = {}) {
+    const accessSync = options.accessSync ?? fsSync.accessSync;
+    const chmodSync = options.chmodSync ?? fsSync.chmodSync;
+    const lstatSync = options.lstatSync ?? fsSync.lstatSync;
+    const mkdirSync = options.mkdirSync ?? fsSync.mkdirSync;
+    const warn = options.warn ?? ((message) => console.warn(message));
+    const getuid = options.getuid ?? (() => {
+        try {
+            return typeof process.getuid === "function" ? process.getuid() : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    });
+    const resolveTmpdir = options.tmpdir ?? os.tmpdir;
+    const uid = getuid();
+    const isSecureDirForUser = (stats) => {
+        if (uid === undefined) {
+            return true;
+        }
+        if (typeof stats.uid === "number" && stats.uid !== uid) {
+            return false;
+        }
+        if (typeof stats.mode === "number" && (stats.mode & 0o022) !== 0) {
+            return false;
+        }
+        return true;
+    };
+    const fallback = () => {
+        const suffix = uid === undefined ? "openclaw" : `openclaw-${uid}`;
+        return path.join(resolveTmpdir(), suffix);
+    };
+    const isTrustedTmpDir = (stats) => stats.isDirectory() && !stats.isSymbolicLink() && isSecureDirForUser(stats);
+    const resolveDirState = (candidatePath) => {
+        try {
+            if (!isTrustedTmpDir(lstatSync(candidatePath))) {
+                return "invalid";
+            }
+            accessSync(candidatePath, TMP_DIR_ACCESS_MODE);
+            return "available";
+        }
+        catch (error) {
+            if (isNodeErrorWithCode(error, "ENOENT")) {
+                return "missing";
+            }
+            return "invalid";
+        }
+    };
+    const tryRepairWritableBits = (candidatePath) => {
+        try {
+            const stats = lstatSync(candidatePath);
+            if (!stats.isDirectory() || stats.isSymbolicLink()) {
+                return false;
+            }
+            if (uid !== undefined && typeof stats.uid === "number" && stats.uid !== uid) {
+                return false;
+            }
+            if (typeof stats.mode !== "number" || (stats.mode & 0o022) === 0) {
+                return false;
+            }
+            chmodSync(candidatePath, 0o700);
+            warn(`[tickflow-assist] tightened permissions on temp dir: ${candidatePath}`);
+            return resolveDirState(candidatePath) === "available";
+        }
+        catch {
+            return false;
+        }
+    };
+    const ensureTrustedFallbackDir = () => {
+        const fallbackPath = fallback();
+        const state = resolveDirState(fallbackPath);
+        if (state === "available") {
+            return fallbackPath;
+        }
+        if (state === "invalid") {
+            if (tryRepairWritableBits(fallbackPath)) {
+                return fallbackPath;
+            }
+            throw new Error(`Unsafe fallback OpenClaw temp dir: ${fallbackPath}`);
+        }
+        try {
+            mkdirSync(fallbackPath, { recursive: true, mode: 0o700 });
+            chmodSync(fallbackPath, 0o700);
+        }
+        catch {
+            throw new Error(`Unable to create fallback OpenClaw temp dir: ${fallbackPath}`);
+        }
+        if (resolveDirState(fallbackPath) !== "available" && !tryRepairWritableBits(fallbackPath)) {
+            throw new Error(`Unsafe fallback OpenClaw temp dir: ${fallbackPath}`);
+        }
+        return fallbackPath;
+    };
+    const existingPreferredState = resolveDirState(POSIX_OPENCLAW_TMP_DIR);
+    if (existingPreferredState === "available") {
+        return POSIX_OPENCLAW_TMP_DIR;
+    }
+    if (existingPreferredState === "invalid") {
+        if (tryRepairWritableBits(POSIX_OPENCLAW_TMP_DIR)) {
+            return POSIX_OPENCLAW_TMP_DIR;
+        }
+        return ensureTrustedFallbackDir();
+    }
+    try {
+        accessSync("/tmp", TMP_DIR_ACCESS_MODE);
+        mkdirSync(POSIX_OPENCLAW_TMP_DIR, { recursive: true, mode: 0o700 });
+        chmodSync(POSIX_OPENCLAW_TMP_DIR, 0o700);
+        if (resolveDirState(POSIX_OPENCLAW_TMP_DIR) !== "available"
+            && !tryRepairWritableBits(POSIX_OPENCLAW_TMP_DIR)) {
+            return ensureTrustedFallbackDir();
+        }
+        return POSIX_OPENCLAW_TMP_DIR;
+    }
+    catch {
+        return ensureTrustedFallbackDir();
+    }
+}

package/dist/runtime/plugin-api.d.ts

@@ -12,7 +12,7 @@ export interface PluginEntryResult {
     id: string;
     name: string;
     description: string;
-    kind?: string;
+    kind?: OpenClawPluginDefinition["kind"];
     register: (api: OpenClawPluginApi) => void;
 }
 export declare function definePluginEntry({ id, name, description, kind, register, }: DefinePluginEntryOptions): PluginEntryResult;

package/dist/services/alert-media-service.d.ts

@@ -8,8 +8,9 @@ export declare class AlertMediaService {
     private readonly baseDir;
     private readonly retentionHours;
     private readonly cleanupIntervalMs;
+    private readonly tempRootDir?;
     private lastCleanupAt;
-    constructor(baseDir: string, retentionHours?: number, cleanupIntervalMs?: number);
+    constructor(baseDir: string, retentionHours?: number, cleanupIntervalMs?: number, tempRootDir?: string | undefined);
     getTempRootDir(): string;
     writeAlertCard(params: {
         symbol: string;

package/dist/services/alert-media-service.js

@@ -8,14 +8,18 @@ export class AlertMediaService {
     baseDir;
     retentionHours;
     cleanupIntervalMs;
+    tempRootDir;
     lastCleanupAt = 0;
-    constructor(baseDir, retentionHours = DEFAULT_RETENTION_HOURS, cleanupIntervalMs = DEFAULT_CLEANUP_INTERVAL_MS) {
+    constructor(baseDir, retentionHours = DEFAULT_RETENTION_HOURS, cleanupIntervalMs = DEFAULT_CLEANUP_INTERVAL_MS, tempRootDir) {
         this.baseDir = baseDir;
         this.retentionHours = retentionHours;
         this.cleanupIntervalMs = cleanupIntervalMs;
+        this.tempRootDir = tempRootDir;
     }
     getTempRootDir() {
-        return path.resolve(this.baseDir, "..", "alert-media", "tmp");
+        return this.tempRootDir
+            ? path.resolve(this.tempRootDir)
+            : path.resolve(this.baseDir, "..", "alert-media", "tmp");
     }
     async writeAlertCard(params) {
         await this.maybeCleanupExpired();

package/dist/services/alert-service.js

@@ -25,6 +25,21 @@ export class AlertService {
             };
         }
         if (payload.mediaPath) {
+            if (payload.message.trim()) {
+                const mediaOnlyError = await this.trySendPayload({
+                    ...payload,
+                    message: "",
+                });
+                if (mediaOnlyError === null) {
+                    const textFollowupError = await this.trySendPayload({ message: payload.message });
+                    return {
+                        ok: textFollowupError === null,
+                        mediaAttempted: true,
+                        mediaDelivered: true,
+                        error: textFollowupError,
+                    };
+                }
+            }
             const textFallback = normalizeSendInput(payload.message);
             const textFallbackError = await this.trySendPayload(textFallback);
             if (textFallbackError === null) {
@@ -32,7 +47,7 @@ export class AlertService {
                     ok: true,
                     mediaAttempted: true,
                     mediaDelivered: false,
-                    error: null,
+                    error: primaryError,
                 };
             }
             return {
@@ -137,9 +152,6 @@ export class AlertService {
         };
         try {
             switch (this.channel) {
-                case "telegram":
-                    await runtimeContext.runtime.channel.telegram.sendMessageTelegram(this.options.target, payload.message, baseOptions);
-                    return null;
                 case "discord":
                     await runtimeContext.runtime.channel.discord.sendMessageDiscord(this.options.target, payload.message, {
                         ...baseOptions,
@@ -156,24 +168,9 @@ export class AlertService {
                 case "signal":
                     await runtimeContext.runtime.channel.signal.sendMessageSignal(this.options.target, payload.message, baseOptions);
                     return null;
-                case "imessage":
-                    await runtimeContext.runtime.channel.imessage.sendMessageIMessage(this.options.target, payload.message, {
-                        accountId: this.options.account || undefined,
-                        config: runtimeContext.config,
-                        mediaUrl: payload.mediaPath,
-                        mediaLocalRoots: payload.mediaLocalRoots,
-                    });
-                    return null;
-                case "whatsapp":
-                    await runtimeContext.runtime.channel.whatsapp.sendMessageWhatsApp(this.options.target, payload.message, {
-                        verbose: false,
-                        cfg: runtimeContext.config,
-                        accountId: this.options.account || undefined,
-                        mediaUrl: payload.mediaPath,
-                        mediaLocalRoots: payload.mediaLocalRoots,
-                    });
-                    return null;
                 default:
+                    // OpenClaw 2026.3.31 narrows the typed runtime channel surface.
+                    // Fall back to `openclaw message send` for channels not exposed here.
                     return `runtime delivery not supported for channel: ${this.channel}`;
             }
         }
@@ -237,9 +234,10 @@ export class AlertService {
             "send",
             "--channel",
             this.channel,
-            "--message",
-            payload.message,
         ];
+        if (payload.message) {
+            args.push("--message", payload.message);
+        }
         if (payload.mediaPath) {
             args.push("--media", payload.mediaPath);
         }

package/dist/tools/test-alert.tool.d.ts

@@ -1,6 +1,6 @@
 import { AlertService } from "../services/alert-service.js";
 import { AlertMediaService } from "../services/alert-media-service.js";
-export declare function testAlertTool(alertService: AlertService, alertMediaService: AlertMediaService): {
+export declare function testAlertTool(alertService: AlertService, alertMediaService: AlertMediaService, configSource?: "openclaw_plugin" | "local_config"): {
     name: string;
     description: string;
     optional: boolean;

package/dist/tools/test-alert.tool.js

@@ -1,8 +1,8 @@
 import { formatChinaDateTime } from "../utils/china-time.js";
-export function testAlertTool(alertService, alertMediaService) {
+export function testAlertTool(alertService, alertMediaService, configSource = "openclaw_plugin") {
     return {
         name: "test_alert",
-        description: "Send a text plus PNG test alert through the configured OpenClaw alert delivery path.",
+        description: "Send a test alert through the configured OpenClaw alert delivery path. Plugin mode includes PNG; local mode sends text only.",
         optional: true,
         async run() {
             const now = formatChinaDateTime();
@@ -10,6 +10,19 @@ export function testAlertTool(alertService, alertMediaService) {
                 `时间: ${now}`,
                 "说明: 这是一条手动触发的测试消息，用于验证文本与 PNG 告警卡投递链路正常。",
             ]);
+            if (configSource === "local_config") {
+                const result = await alertService.sendWithResult({ message });
+                if (result.ok) {
+                    return [
+                        "✅ 测试告警文本已发送（本地命令模式）",
+                        "说明: `npm run tool -- test_alert` 仅验证文本链路；请通过 `/ta_testalert` 验证 PNG 图片链路。",
+                    ].join("\n");
+                }
+                const detail = result.error ?? alertService.getLastError();
+                return detail
+                    ? `❌ 测试告警发送失败\n原因: ${detail}`
+                    : "❌ 测试告警发送失败";
+            }
             let mediaFile = null;
             try {
                 mediaFile = await alertMediaService.writeAlertCard({
@@ -41,10 +54,18 @@ export function testAlertTool(alertService, alertMediaService) {
                     filename: mediaFile.filename,
                 });
                 if (result.ok && result.mediaDelivered) {
+                    if (result.error) {
+                        return [
+                            "⚠️ PNG 告警卡已发送，但文本补发失败",
+                            `原因: ${result.error}`,
+                        ].join("\n");
+                    }
                     return "✅ 测试告警发送成功（文本 + PNG）";
                 }
                 if (result.ok) {
-                    return "⚠️ 测试告警文本已发送，但 PNG 未送达，已回退为纯文本";
+                    return result.error
+                        ? `⚠️ 测试告警文本已发送，但 PNG 未送达，已回退为纯文本\n原因: ${result.error}`
+                        : "⚠️ 测试告警文本已发送，但 PNG 未送达，已回退为纯文本";
                 }
                 const detail = result.error ?? alertService.getLastError();
                 return detail

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "tickflow-assist",
   "name": "TickFlow Assist",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "description": "A-share watchlist analysis, monitoring, and alert delivery powered by TickFlow and OpenClaw.",
   "skills": [
     "skills"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tickflow-assist",
-  "version": "0.2.13",
-  "description": "OpenClaw plugin for TickFlow-based A-share analysis, monitoring, and alerting.",
+  "version": "0.2.14",
+  "description": "OpenClaw smart stock plugin for A-share investing and watchlist workflows, powered by TickFlow API for realtime monitoring, post-close review, multi-dimensional analysis, key level tracking, and alerts. 面向 A 股投资与盯盘场景的 OpenClaw 智能股票插件，基于 TickFlow API 提供实时监控、收盘后复盘、多维综合分析、关键价位跟踪与告警能力。",
   "license": "MIT",
   "type": "module",
   "main": "dist/plugin.js",
@@ -38,12 +38,12 @@
   },
   "openclaw": {
     "build": {
-      "openclawVersion": "2026.3.28"
+      "openclawVersion": "2026.3.31"
     },
     "compat": {
-      "pluginApi": "2026.3.28",
-      "minGatewayVersion": "2026.3.28",
-      "builtWithOpenClawVersion": "2026.3.28"
+      "pluginApi": "2026.3.31",
+      "minGatewayVersion": "2026.3.31",
+      "builtWithOpenClawVersion": "2026.3.31"
     },
     "extensions": [
       "dist/plugin.js"
@@ -61,7 +61,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.13.11",
-    "openclaw": "^2026.3.28",
+    "openclaw": "^2026.3.31",
     "typescript": "^5.8.2"
   }
 }