tickflow-assist 0.2.12 → 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.12` 调整社区安装清单，允许先安装插件再执行 `configure-openclaw` 写入密钥配置；同时将 `test_alert` 升级为文本 + PNG 告警卡链路测试。
+最近更新：`v0.2.14` 对齐 OpenClaw `v2026.3.31` 兼容声明与开发依赖，更新 QQ Bot 内置通道说明，并将 PNG 告警卡临时文件迁移到 OpenClaw 共享 temp root，修复新版本地媒体 allowlist 下的图片投递失败。
+
+当前主线按 OpenClaw `v2026.3.31+` 对齐。
 
 ## 安装
 
@@ -14,6 +16,7 @@ npx -y tickflow-assist configure-openclaw
 ```
 
 安装阶段允许先落插件，再通过第二条命令写入 `tickflowApiKey`、`llmApiKey` 等正式配置。
+在 Linux 上，`configure-openclaw` 还会 best-effort 安装 PNG 告警卡所需的中文字体；如需跳过，可追加 `--no-font-setup`。
 
 第二条命令会写入 `~/.openclaw/openclaw.json` 中的 `plugins.entries["tickflow-assist"].config`，并默认执行：
 

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/dev/tickflow-assist-cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -38,6 +39,7 @@ Options:
   --no-enable                 Do not run 'openclaw plugins enable'
   --no-restart                Do not run 'openclaw gateway restart'
   --no-python-setup           Do not run 'uv sync' for Python dependencies
+  --no-font-setup             Do not try to install Linux Chinese fonts for PNG alerts
   --openclaw-bin <path>       OpenClaw CLI binary, default: openclaw
   --tickflow-api-key <key>
   --tickflow-api-key-level <Free|Start|Pro|Expert>
@@ -61,6 +63,7 @@ function parseArgs(argv) {
         restart: true,
         enable: true,
         pythonSetup: true,
+        fontSetup: true,
         openclawBin: DEFAULTS.openclawCliBin,
         overrides: {},
     };
@@ -115,6 +118,9 @@ function parseArgs(argv) {
             case "--no-python-setup":
                 options.pythonSetup = false;
                 break;
+            case "--no-font-setup":
+                options.fontSetup = false;
+                break;
             case "--no-enable":
                 options.enable = false;
                 break;
@@ -623,6 +629,162 @@ async function setupPythonDeps(pythonWorkdir, nonInteractive) {
     }
     console.log("Python dependencies installed successfully.");
 }
+function isCommandAvailable(command) {
+    const result = spawnSync("which", [command], { stdio: "ignore" });
+    return result.status === 0;
+}
+function isRootUser() {
+    return typeof process.getuid === "function" && process.getuid() === 0;
+}
+function hasChineseFonts() {
+    const result = spawnSync("fc-list", [":lang=zh", "family"], { encoding: "utf-8" });
+    return result.status === 0 && Boolean(result.stdout.trim());
+}
+function detectLinuxDistro() {
+    try {
+        const raw = readFileSync("/etc/os-release", "utf-8");
+        const record = Object.fromEntries(raw
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .filter((line) => !line.startsWith("#") && line.includes("="))
+            .map((line) => {
+            const index = line.indexOf("=");
+            const key = line.slice(0, index);
+            const value = line.slice(index + 1).replace(/^"/, "").replace(/"$/, "");
+            return [key, value];
+        }));
+        const ids = [
+            String(record.ID ?? "").toLowerCase(),
+            ...String(record.ID_LIKE ?? "")
+                .toLowerCase()
+                .split(/\s+/)
+                .filter(Boolean),
+        ];
+        if (ids.some((value) => ["debian", "ubuntu"].includes(value))) {
+            return "debian";
+        }
+        if (ids.some((value) => ["rhel", "fedora", "centos", "rocky", "almalinux"].includes(value))) {
+            return "rhel";
+        }
+        if (ids.some((value) => ["arch", "manjaro"].includes(value))) {
+            return "arch";
+        }
+        if (ids.includes("alpine")) {
+            return "alpine";
+        }
+    }
+    catch {
+        // fall through
+    }
+    return "unknown";
+}
+function getManualFontCommands(distro) {
+    switch (distro) {
+        case "debian":
+            return ["sudo apt-get update", "sudo apt-get install -y fontconfig fonts-noto-cjk", "fc-cache -fv"];
+        case "rhel":
+            return [
+                "sudo dnf install -y fontconfig google-noto-sans-cjk-ttc-fonts",
+                "fc-cache -fv",
+            ];
+        case "arch":
+            return ["sudo pacman -Sy --noconfirm fontconfig noto-fonts-cjk", "fc-cache -fv"];
+        case "alpine":
+            return ["sudo apk add fontconfig font-noto-cjk", "fc-cache -fv"];
+        default:
+            return [
+                "请安装 fontconfig 和任意可用的中文字体包，例如 Noto Sans CJK",
+                "安装后执行: fc-cache -fv",
+            ];
+    }
+}
+function buildPrivilegedCommand(argv, nonInteractive) {
+    if (isRootUser()) {
+        return argv;
+    }
+    if (!isCommandAvailable("sudo")) {
+        return null;
+    }
+    return nonInteractive ? ["sudo", "-n", ...argv] : ["sudo", ...argv];
+}
+function runSetupCommand(argv, description) {
+    console.log(description);
+    const result = spawnSync(argv[0], argv.slice(1), { stdio: "inherit" });
+    if (result.error) {
+        console.warn(`Warning: failed to run ${description}: ${result.error.message}`);
+        return false;
+    }
+    if (result.status !== 0) {
+        console.warn(`Warning: ${description} exited with status ${result.status}`);
+        return false;
+    }
+    return true;
+}
+async function setupLinuxChineseFonts(nonInteractive) {
+    if (process.platform !== "linux") {
+        return;
+    }
+    if (!isCommandAvailable("fc-list")) {
+        console.warn("Warning: fontconfig is not installed; PNG alerts may not render Chinese text correctly.");
+    }
+    else if (hasChineseFonts()) {
+        console.log("Chinese fonts detected for PNG alert cards.");
+        return;
+    }
+    const distro = detectLinuxDistro();
+    console.log("Chinese fonts not detected. TickFlow Assist will try to install Noto CJK fonts for PNG alert cards.");
+    const attempts = [];
+    switch (distro) {
+        case "debian":
+            attempts.push(["apt-get", "update"]);
+            attempts.push(["apt-get", "install", "-y", "fontconfig", "fonts-noto-cjk"]);
+            break;
+        case "rhel":
+            attempts.push(["dnf", "install", "-y", "fontconfig", "google-noto-sans-cjk-ttc-fonts"]);
+            attempts.push(["dnf", "install", "-y", "fontconfig", "google-noto-cjk-fonts"]);
+            attempts.push(["yum", "install", "-y", "fontconfig", "google-noto-sans-cjk-ttc-fonts"]);
+            attempts.push(["yum", "install", "-y", "fontconfig", "google-noto-cjk-fonts"]);
+            break;
+        case "arch":
+            attempts.push(["pacman", "-Sy", "--noconfirm", "fontconfig", "noto-fonts-cjk"]);
+            break;
+        case "alpine":
+            attempts.push(["apk", "add", "fontconfig", "font-noto-cjk"]);
+            break;
+        default:
+            break;
+    }
+    let attemptedInstall = false;
+    for (const baseArgv of attempts) {
+        if (!isCommandAvailable(baseArgv[0])) {
+            continue;
+        }
+        const argv = buildPrivilegedCommand(baseArgv, nonInteractive);
+        if (!argv) {
+            break;
+        }
+        attemptedInstall = true;
+        if (!runSetupCommand(argv, `Running ${argv.join(" ")}`)) {
+            continue;
+        }
+        if (isCommandAvailable("fc-cache")) {
+            runSetupCommand(["fc-cache", "-fv"], "Refreshing font cache with fc-cache -fv");
+        }
+        if (isCommandAvailable("fc-list") && hasChineseFonts()) {
+            console.log("Chinese fonts installed successfully.");
+            return;
+        }
+    }
+    console.warn("Warning: automatic Chinese font setup did not complete.");
+    if (!attemptedInstall && nonInteractive) {
+        console.warn("Non-interactive mode skipped any sudo password prompt.");
+    }
+    console.warn("Manual install examples:");
+    for (const command of getManualFontCommands(distro)) {
+        console.warn(`  ${command}`);
+    }
+}
 async function configureOpenClaw(options) {
     const configPath = resolveOpenClawConfigPath(options.configPath);
     const stateDir = resolveStateDir(configPath);
@@ -636,6 +798,9 @@ async function configureOpenClaw(options) {
     if (options.pythonSetup) {
         await setupPythonDeps(config.pythonWorkdir, options.nonInteractive);
     }
+    if (options.fontSetup) {
+        await setupLinuxChineseFonts(options.nonInteractive);
+    }
     applyPluginConfig(root, config, target);
     const backupPath = await writeConfig(configPath, root);
     console.log("");

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.12",
+  "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.12",
-  "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"
   }
 }