tickflow-assist 0.2.15 → 0.2.17

package/README.md

@@ -2,7 +2,7 @@
 
 基于 [OpenClaw](https://openclaw.ai) 的 A 股监控与分析插件。它使用 [TickFlow](https://tickflow.org/auth/register?ref=BUJ54JEDGE) 获取行情与财务数据，结合 LLM 生成技术面、基本面、资讯面的综合判断，并把结果持久化到本地 LanceDB。
 
-最近更新：`v0.2.15` 重新发布 npm 包以刷新包页 README 展示；功能与运行逻辑相对 `v0.2.14` 无新增变更。
+最近更新：`v0.2.17` 补充 Linux / macOS 的字体安装命令，`configure-openclaw` 会自动把被旧版本钉死的 ClawHub install spec 归一化为 `clawhub:tickflow-assist`，并将空自选时的 `ta_startmonitor` 失败改为可见提示。
 
 当前主线按 OpenClaw `v2026.3.31+` 对齐。
 
@@ -13,21 +13,46 @@
 ```bash
 openclaw plugins install tickflow-assist
 npx -y tickflow-assist configure-openclaw
+cd ~/.openclaw/extensions/tickflow-assist/python && uv sync
+openclaw plugins enable tickflow-assist
+openclaw config validate
+openclaw gateway restart
 ```
 
 安装阶段允许先落插件，再通过第二条命令写入 `tickflowApiKey`、`llmApiKey` 等正式配置。
-在 Linux 上，`configure-openclaw` 还会 best-effort 安装 PNG 告警卡所需的中文字体；如需跳过，可追加 `--no-font-setup`。
+`configure-openclaw` 会写入 `~/.openclaw/openclaw.json` 中的 `plugins.entries["tickflow-assist"].config`，并打印后续建议执行的命令；它不再自动执行 `openclaw`、`uv` 或系统包安装命令。
+如果检测到 `plugins.installs["tickflow-assist"]` 来自 `clawhub`，向导还会把被旧版本钉死的 `spec` 归一化为 `clawhub:tickflow-assist`，避免后续升级继续锁在旧版本。
 
-第二条命令会写入 `~/.openclaw/openclaw.json` 中的 `plugins.entries["tickflow-assist"].config`，并默认执行：
+如果你希望先审阅配置，再只打印最少的后续步骤，可使用：
 
-- `openclaw plugins enable tickflow-assist`
-- `openclaw config validate`
-- `openclaw gateway restart`
+```bash
+npx -y tickflow-assist configure-openclaw --no-enable --no-restart
+```
 
-如果你希望先审阅配置再手动启用或重启，可使用：
+如果你在 Linux 或 macOS 上需要 PNG 告警卡正常显示中文，请额外手动安装 `fontconfig` 与 Noto CJK 一类中文字体，例如：
 
 ```bash
-npx -y tickflow-assist configure-openclaw --no-enable --no-restart
+# Debian / Ubuntu
+sudo apt-get update
+sudo apt-get install -y fontconfig fonts-noto-cjk
+fc-cache -fv
+
+# RHEL / Fedora / Rocky / AlmaLinux
+sudo dnf install -y fontconfig google-noto-sans-cjk-ttc-fonts
+fc-cache -fv
+
+# Arch / Manjaro
+sudo pacman -Sy --noconfirm fontconfig noto-fonts-cjk
+fc-cache -fv
+
+# Alpine
+sudo apk add fontconfig font-noto-cjk
+fc-cache -fv
+
+# macOS (Homebrew)
+brew install fontconfig
+brew install --cask font-noto-sans-cjk
+fc-cache -fv
 ```
 
 社区安装后的升级方式：

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

@@ -1,4 +1,3 @@
-import type { PluginConfig } from "../config/schema.js";
 import { UpdateService } from "../services/update-service.js";
 import { AlertService } from "../services/alert-service.js";
 import { PostCloseReviewService } from "../services/post-close-review-service.js";
@@ -16,10 +15,6 @@ export declare class DailyUpdateWorker {
     constructor(updateService: UpdateService, 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>;
-    ensureLoopRunning(config: PluginConfig, configSource: "openclaw_plugin" | "local_config"): Promise<{
-        started: boolean;
-        pid: number | null;
-    }>;
     stopLoop(): Promise<{
         stopped: boolean;
         pid: number | null;
@@ -48,3 +43,4 @@ export declare class DailyUpdateWorker {
     private maybeSendDailyUpdateNotification;
     private maybeSendReviewNotification;
 }
+export declare function isPidAlive(pid: number): boolean;

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

@@ -2,7 +2,6 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { chinaToday, formatChinaDateTime } from "../utils/china-time.js";
 import { sleepWithAbort } from "../utils/abortable-sleep.js";
-import { isPidAlive, spawnDailyUpdateLoop } from "../runtime/daily-update-process.js";
 const DAILY_UPDATE_READY_TIME = "15:25";
 const POST_CLOSE_REVIEW_READY_TIME = "20:00";
 const DEFAULT_STATE = {
@@ -67,19 +66,6 @@ export class DailyUpdateWorker {
             await sleepWithAbort(getNextAlignedDelayMs(this.intervalMs), signal);
         }
     }
-    async ensureLoopRunning(config, configSource) {
-        const state = await this.readState();
-        if (state.workerPid != null && isPidAlive(state.workerPid)) {
-            await this.markSchedulerRunning(state.workerPid, state.runtimeConfigSource ?? configSource);
-            return { started: false, pid: state.workerPid };
-        }
-        const workerPid = spawnDailyUpdateLoop(config, configSource);
-        if (workerPid == null) {
-            throw new Error("无法启动 TickFlow 日更定时进程");
-        }
-        await this.markSchedulerRunning(workerPid, configSource);
-        return { started: true, pid: workerPid };
-    }
     async stopLoop() {
         const state = await this.readState();
         const workerPid = state.workerPid;
@@ -422,6 +408,15 @@ export class DailyUpdateWorker {
         }
     }
 }
+export function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function createReviewExecutionOutput(reviewResult) {
     return {
         resultType: "success",

package/dist/bootstrap.js

@@ -64,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 { createCommandRunner } from "./runtime/command-runner.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";
@@ -74,6 +75,7 @@ export function createAppContext(config, options = {}) {
         openclawConfig: options.openclawConfig,
         pluginRuntime: options.pluginRuntime,
     };
+    const runCommandWithTimeout = createCommandRunner(runtime.pluginRuntime);
     const tickflowClient = new TickFlowClient(config.tickflowApiUrl, config.tickflowApiKey);
     const database = new Database(config.databasePath);
     const watchlistRepository = new WatchlistRepository(database);
@@ -110,7 +112,7 @@ export function createAppContext(config, options = {}) {
             : undefined,
     });
     const alertMediaService = new AlertMediaService(config.databasePath, undefined, undefined, resolveAlertMediaTempRootDir());
-    const indicatorService = new IndicatorService(config.pythonBin, config.pythonArgs, config.pythonWorkdir);
+    const indicatorService = new IndicatorService(config.pythonBin, config.pythonArgs, config.pythonWorkdir, runCommandWithTimeout);
     const watchlistService = new WatchlistService(watchlistRepository, instrumentService, watchlistProfileService);
     const keyLevelsBacktestService = new KeyLevelsBacktestService(keyLevelsHistoryRepository, klinesRepository, intradayKlinesRepository, watchlistService);
     const reviewMemoryService = new ReviewMemoryService(keyLevelsBacktestService);

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

@@ -1,5 +1,4 @@
 #!/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";
@@ -36,11 +35,11 @@ Options:
   --agent <id>                Apply tools.allow to a specific agent
   --global                    Apply tools.allow to top-level tools config
   --non-interactive           Use existing config / flags only, no prompts
-  --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
+  --no-enable                 Do not print 'openclaw plugins enable' in next steps
+  --no-restart                Do not print 'openclaw gateway restart' in next steps
+  --no-python-setup           Do not print Python dependency setup guidance
+  --no-font-setup             Do not print Chinese font setup guidance
+  --openclaw-bin <path>       OpenClaw CLI binary name used in printed next steps
   --tickflow-api-key <key>
   --tickflow-api-key-level <Free|Start|Pro|Expert>
   --mx-search-api-key <key>
@@ -502,6 +501,34 @@ function assertRequired(config) {
         throw new Error("llmApiKey is required");
     }
 }
+function normalizeCommunityInstallSpec(root) {
+    const plugins = root.plugins;
+    if (typeof plugins !== "object" || plugins === null || Array.isArray(plugins)) {
+        return false;
+    }
+    const installs = plugins.installs;
+    if (typeof installs !== "object" || installs === null || Array.isArray(installs)) {
+        return false;
+    }
+    const installEntry = installs[PLUGIN_ID];
+    if (typeof installEntry !== "object" || installEntry === null || Array.isArray(installEntry)) {
+        return false;
+    }
+    const source = stringValue(installEntry.source).toLowerCase();
+    if (source !== "clawhub") {
+        return false;
+    }
+    const canonicalSpec = `clawhub:${PLUGIN_ID}`;
+    const currentSpec = stringValue(installEntry.spec);
+    if (currentSpec === canonicalSpec) {
+        return false;
+    }
+    if (!currentSpec || currentSpec.startsWith(`${canonicalSpec}@`)) {
+        installEntry.spec = canonicalSpec;
+        return true;
+    }
+    return false;
+}
 async function ensurePathNotice(targetPath, label) {
     try {
         await access(targetPath);
@@ -586,60 +613,6 @@ async function writeConfig(configPath, root) {
     await writeFile(configPath, `${JSON.stringify(root, null, 2)}\n`, "utf-8");
     return backupPath;
 }
-function runOpenClaw(bin, args, description) {
-    const result = spawnSync(bin, args, { stdio: "inherit" });
-    if (result.error) {
-        console.warn(`Warning: failed to run ${description}: ${result.error.message}`);
-        return;
-    }
-    if (result.status !== 0) {
-        console.warn(`Warning: ${description} exited with status ${result.status}`);
-    }
-}
-async function setupPythonDeps(pythonWorkdir, nonInteractive) {
-    let uvBin = "uv";
-    try {
-        const which = spawnSync("which", ["uv"], { encoding: "utf-8" });
-        if (which.status !== 0) {
-            console.warn("\n  ⚠️ 找不到 uv (Python 包管理工具)，已跳过 Python 依赖安装。");
-            console.warn("  请先手动安装 uv，再在以下目录执行 `uv sync`：");
-            console.warn(`  ${pythonWorkdir}`);
-            return;
-        }
-        else {
-            uvBin = which.stdout.trim() || "uv";
-        }
-    }
-    catch {
-        // fall through with default "uv"
-    }
-    console.log(`Setting up Python dependencies in ${pythonWorkdir} ...`);
-    const result = spawnSync(uvBin, ["sync"], { cwd: pythonWorkdir, stdio: "inherit" });
-    if (result.error) {
-        console.warn(`Warning: failed to run uv sync: ${result.error.message}`);
-        console.warn("Please run 'uv sync' manually in:");
-        console.warn(`  ${pythonWorkdir}`);
-        return;
-    }
-    if (result.status !== 0) {
-        console.warn(`Warning: uv sync exited with status ${result.status}`);
-        console.warn("Please check the output above and run 'uv sync' manually if needed in:");
-        console.warn(`  ${pythonWorkdir}`);
-        return;
-    }
-    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");
@@ -699,90 +672,45 @@ function getManualFontCommands(distro) {
             ];
     }
 }
-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;
+function getManualMacosFontCommands() {
+    return [
+        "brew install fontconfig",
+        "brew install --cask font-noto-sans-cjk",
+        "fc-cache -fv",
+    ];
 }
-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;
-        }
+function printNextSteps(options, config) {
+    console.log("");
+    console.log("接下来的命令需要你手动执行。");
+    let step = 1;
+    if (options.pythonSetup) {
+        console.log(`${step}. 安装 Python 依赖`);
+        console.log(`   cd ${config.pythonWorkdir}`);
+        console.log("   uv sync");
+        step += 1;
+    }
+    if (options.fontSetup && (process.platform === "linux" || process.platform === "darwin")) {
+        const commands = process.platform === "darwin"
+            ? getManualMacosFontCommands()
+            : getManualFontCommands(detectLinuxDistro());
+        const platformLabel = process.platform === "darwin" ? "macOS" : "Linux 发行版";
+        console.log(`${step}. 如需 PNG 告警卡正常显示中文，请按你的 ${platformLabel} 安装字体`);
+        for (const command of commands) {
+            console.log(`   ${command}`);
+        }
+        step += 1;
     }
-    console.warn("Warning: automatic Chinese font setup did not complete.");
-    if (!attemptedInstall && nonInteractive) {
-        console.warn("Non-interactive mode skipped any sudo password prompt.");
+    if (options.enable) {
+        console.log(`${step}. 启用插件`);
+        console.log(`   ${options.openclawBin} plugins enable ${PLUGIN_ID}`);
+        step += 1;
     }
-    console.warn("Manual install examples:");
-    for (const command of getManualFontCommands(distro)) {
-        console.warn(`  ${command}`);
+    console.log(`${step}. 校验 OpenClaw 配置`);
+    console.log(`   ${options.openclawBin} config validate`);
+    step += 1;
+    if (options.restart) {
+        console.log(`${step}. 重启 Gateway`);
+        console.log(`   ${options.openclawBin} gateway restart`);
     }
 }
 async function configureOpenClaw(options) {
@@ -795,13 +723,8 @@ async function configureOpenClaw(options) {
     const config = await promptForConfig(options, existing, pluginDir, configPath);
     await ensurePathNotice(config.calendarFile, "calendarFile");
     await ensurePathNotice(config.pythonWorkdir, "pythonWorkdir");
-    if (options.pythonSetup) {
-        await setupPythonDeps(config.pythonWorkdir, options.nonInteractive);
-    }
-    if (options.fontSetup) {
-        await setupLinuxChineseFonts(options.nonInteractive);
-    }
     applyPluginConfig(root, config, target);
+    const normalizedInstallSpec = normalizeCommunityInstallSpec(root);
     const backupPath = await writeConfig(configPath, root);
     console.log("");
     console.log(`Updated OpenClaw config: ${configPath}`);
@@ -810,13 +733,10 @@ async function configureOpenClaw(options) {
     }
     console.log(`Plugin dir: ${pluginDir}`);
     console.log(`Allowlist target: ${target.type === "global" ? "global tools" : `agent:${target.id}`}`);
-    if (options.enable) {
-        runOpenClaw(options.openclawBin, ["plugins", "enable", PLUGIN_ID], "openclaw plugins enable");
-    }
-    runOpenClaw(options.openclawBin, ["config", "validate"], "openclaw config validate");
-    if (options.restart) {
-        runOpenClaw(options.openclawBin, ["gateway", "restart"], "openclaw gateway restart");
+    if (normalizedInstallSpec) {
+        console.log(`Community install spec normalized: clawhub:${PLUGIN_ID}`);
     }
+    printNextSteps(options, config);
 }
 async function main() {
     try {

package/dist/plugin-commands.js

@@ -36,6 +36,19 @@ function parseRequiredSymbol(args, usage) {
 async function runToolText(tool, rawInput) {
     return tool.run({ rawInput });
 }
+function formatCommandError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.trim() || "未知错误";
+    return `⚠️ ${normalized}`;
+}
+async function runCommandText(task) {
+    try {
+        return { text: await task() };
+    }
+    catch (error) {
+        return { text: formatCommandError(error) };
+    }
+}
 async function renderWatchlistDebug(app) {
     const snapshot = await buildWatchlistDebugSnapshot(app);
     const lines = [
@@ -79,148 +92,114 @@ export function registerPluginCommands(api, tools, app) {
             description: "添加自选股，不经过 AI 对话。用法: /ta_addstock <symbol> [costPrice] [count]",
             acceptsArgs: true,
             requireAuth: true,
-            handler: async ({ args }) => ({
-                text: await runToolText(addStock, parseAddStockArgs(args)),
-            }),
+            handler: async ({ args }) => runCommandText(() => runToolText(addStock, parseAddStockArgs(args))),
         },
         {
             name: "ta_rmstock",
             description: "删除自选股，不经过 AI 对话。用法: /ta_rmstock <symbol>",
             acceptsArgs: true,
             requireAuth: true,
-            handler: async ({ args }) => ({
-                text: await runToolText(removeStock, {
-                    symbol: parseRequiredSymbol(args, "/ta_rmstock <symbol>"),
-                }),
-            }),
+            handler: async ({ args }) => runCommandText(() => runToolText(removeStock, {
+                symbol: parseRequiredSymbol(args, "/ta_rmstock <symbol>"),
+            })),
         },
         {
             name: "ta_analyze",
             description: "分析单只股票，不经过 AI 对话。用法: /ta_analyze <symbol>",
             acceptsArgs: true,
             requireAuth: true,
-            handler: async ({ args }) => ({
-                text: await runToolText(analyze, {
-                    symbol: parseRequiredSymbol(args, "/ta_analyze <symbol>"),
-                }),
-            }),
+            handler: async ({ args }) => runCommandText(() => runToolText(analyze, {
+                symbol: parseRequiredSymbol(args, "/ta_analyze <symbol>"),
+            })),
         },
         {
             name: "ta_backtest",
             description: "回测活动价位，不经过 AI 对话。用法: /ta_backtest [symbol] [recentLimit]",
             acceptsArgs: true,
             requireAuth: true,
-            handler: async ({ args }) => ({
-                text: await runToolText(backtestKeyLevels, args?.trim() || undefined),
-            }),
+            handler: async ({ args }) => runCommandText(() => runToolText(backtestKeyLevels, args?.trim() || undefined)),
         },
         {
             name: "ta_viewanalysis",
             description: "查看单只股票最近一次保存的分析结果，不经过 AI 对话。用法: /ta_viewanalysis <symbol>",
             acceptsArgs: true,
             requireAuth: true,
-            handler: async ({ args }) => ({
-                text: await runToolText(viewAnalysis, {
-                    symbol: parseRequiredSymbol(args, "/ta_viewanalysis <symbol>"),
-                }),
-            }),
+            handler: async ({ args }) => runCommandText(() => runToolText(viewAnalysis, {
+                symbol: parseRequiredSymbol(args, "/ta_viewanalysis <symbol>"),
+            })),
         },
         {
             name: "ta_watchlist",
             description: "查看当前自选列表，不经过 AI 对话。",
             requireAuth: true,
-            handler: async () => ({
-                text: await runToolText(listWatchlist),
-            }),
+            handler: async () => runCommandText(() => runToolText(listWatchlist)),
         },
         {
             name: "ta_refreshnames",
             description: "刷新自选股名称，不经过 AI 对话。",
             requireAuth: true,
-            handler: async () => ({
-                text: await runToolText(refreshWatchlistNames),
-            }),
+            handler: async () => runCommandText(() => runToolText(refreshWatchlistNames)),
         },
         {
             name: "ta_refreshprofiles",
             description: "刷新自选股行业分类与概念板块，不经过 AI 对话。用法: /ta_refreshprofiles [symbol]",
             acceptsArgs: true,
             requireAuth: true,
-            handler: async ({ args }) => ({
-                text: await runToolText(refreshWatchlistProfiles, args?.trim() || undefined),
-            }),
+            handler: async ({ args }) => runCommandText(() => runToolText(refreshWatchlistProfiles, args?.trim() || undefined)),
         },
         {
             name: "ta_startmonitor",
             description: "启动实时监控，不经过 AI 对话。",
             requireAuth: true,
-            handler: async () => ({
-                text: await runToolText(startMonitor),
-            }),
+            handler: async () => runCommandText(() => runToolText(startMonitor)),
         },
         {
             name: "ta_stopmonitor",
             description: "停止实时监控，不经过 AI 对话。",
             requireAuth: true,
-            handler: async () => ({
-                text: await runToolText(stopMonitor),
-            }),
+            handler: async () => runCommandText(() => runToolText(stopMonitor)),
         },
         {
             name: "ta_monitorstatus",
             description: "查看实时监控状态，不经过 AI 对话。",
             requireAuth: true,
-            handler: async () => ({
-                text: await runToolText(monitorStatus),
-            }),
+            handler: async () => runCommandText(() => runToolText(monitorStatus)),
         },
         {
             name: "ta_startdailyupdate",
             description: "启动定时日更任务，不经过 AI 对话。",
             requireAuth: true,
-            handler: async () => ({
-                text: await runToolText(startDailyUpdate),
-            }),
+            handler: async () => runCommandText(() => runToolText(startDailyUpdate)),
         },
         {
             name: "ta_stopdailyupdate",
             description: "停止定时日更任务，不经过 AI 对话。",
             requireAuth: true,
-            handler: async () => ({
-                text: await runToolText(stopDailyUpdate),
-            }),
+            handler: async () => runCommandText(() => runToolText(stopDailyUpdate)),
         },
         {
             name: "ta_updateall",
             description: "立即执行一次完整日更，不经过 AI 对话。",
             requireAuth: true,
-            handler: async () => ({
-                text: await runToolText(updateAll),
-            }),
+            handler: async () => runCommandText(() => runToolText(updateAll)),
         },
         {
             name: "ta_dailyupdatestatus",
             description: "查看定时日更状态，不经过 AI 对话。",
             requireAuth: true,
-            handler: async () => ({
-                text: await runToolText(dailyUpdateStatus),
-            }),
+            handler: async () => runCommandText(() => runToolText(dailyUpdateStatus)),
         },
         {
             name: "ta_testalert",
             description: "发送一条文本 + PNG 测试告警，不经过 AI 对话。",
             requireAuth: true,
-            handler: async () => ({
-                text: await runToolText(testAlert),
-            }),
+            handler: async () => runCommandText(() => runToolText(testAlert)),
         },
         {
             name: "ta_debug",
             description: "查看 TickFlow 插件运行时调试信息。",
             requireAuth: true,
-            handler: async () => ({
-                text: await renderWatchlistDebug(app),
-            }),
+            handler: async () => runCommandText(() => renderWatchlistDebug(app)),
         },
     ];
     for (const command of commands) {

package/dist/runtime/command-runner.d.ts

@@ -0,0 +1,21 @@
+import type { OpenClawPluginRuntime } from "./plugin-api.js";
+export interface CommandRunResult {
+    pid?: number;
+    stdout: string;
+    stderr: string;
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    killed: boolean;
+    termination: "exit" | "timeout" | "no-output-timeout" | "signal";
+    noOutputTimedOut?: boolean;
+}
+export interface CommandRunOptions {
+    timeoutMs: number;
+    cwd?: string;
+    input?: string;
+    env?: NodeJS.ProcessEnv;
+    windowsVerbatimArguments?: boolean;
+    noOutputTimeoutMs?: number;
+}
+export type RunCommandWithTimeout = (argv: string[], options: number | CommandRunOptions) => Promise<CommandRunResult>;
+export declare function createCommandRunner(runtime?: OpenClawPluginRuntime): RunCommandWithTimeout;

package/dist/runtime/command-runner.js

@@ -0,0 +1,22 @@
+let localRunnerPromise = null;
+async function loadLocalRunner() {
+    localRunnerPromise ??= import("openclaw/plugin-sdk/process-runtime")
+        .then((module) => module.runCommandWithTimeout)
+        .catch((error) => {
+        localRunnerPromise = null;
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error("OpenClaw command runner is unavailable outside plugin runtime. " +
+            "For source-mode local commands, run `npm install` with devDependencies " +
+            `or execute the feature through OpenClaw. Details: ${detail}`);
+    });
+    return localRunnerPromise;
+}
+export function createCommandRunner(runtime) {
+    if (runtime) {
+        return runtime.system.runCommandWithTimeout;
+    }
+    return async (argv, options) => {
+        const runner = await loadLocalRunner();
+        return runner(argv, options);
+    };
+}

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

@@ -26,6 +26,7 @@ export interface AlertSendResult {
 export declare class AlertService {
     private readonly options;
     private lastError;
+    private readonly runCommandWithTimeout;
     constructor(options: AlertServiceOptions);
     send(input: string | AlertSendInput): Promise<boolean>;
     sendWithResult(input: string | AlertSendInput): Promise<AlertSendResult>;
@@ -59,8 +60,7 @@ export declare class AlertService {
     private combineErrors;
     private trySendPayload;
     private trySendViaRuntime;
-    private trySendViaRuntimeCommand;
-    private trySendViaSpawn;
+    private trySendViaCommand;
     private buildCliArgs;
 }
 export {};

package/dist/services/alert-service.js

@@ -1,10 +1,12 @@
-import { spawn } from "node:child_process";
+import { createCommandRunner } from "../runtime/command-runner.js";
 import { calculateProfitPct, formatCostPrice } from "../utils/cost-price.js";
 export class AlertService {
     options;
     lastError = null;
+    runCommandWithTimeout;
     constructor(options) {
         this.options = options;
+        this.runCommandWithTimeout = createCommandRunner(options.runtime?.runtime);
     }
     async send(input) {
         const result = await this.sendWithResult(input);
@@ -135,9 +137,7 @@ export class AlertService {
         if (runtimeError === null) {
             return null;
         }
-        return this.options.runtime
-            ? await this.trySendViaRuntimeCommand(payload)
-            : await this.trySendViaSpawn(payload);
+        return await this.trySendViaCommand(payload);
     }
     async trySendViaRuntime(payload) {
         const runtimeContext = this.options.runtime;
@@ -178,13 +178,9 @@ export class AlertService {
             return `runtime delivery failed: ${formatErrorMessage(error)}`;
         }
     }
-    async trySendViaRuntimeCommand(payload) {
-        const runtimeContext = this.options.runtime;
-        if (!runtimeContext) {
-            return "runtime command unavailable";
-        }
+    async trySendViaCommand(payload) {
         try {
-            const result = await runtimeContext.runtime.system.runCommandWithTimeout(this.buildCliArgs(payload), { timeoutMs: 15_000 });
+            const result = await this.runCommandWithTimeout(this.buildCliArgs(payload), { timeoutMs: 15_000 });
             if (result.code === 0) {
                 return null;
             }
@@ -193,40 +189,9 @@ export class AlertService {
                 || `command exited with ${result.code ?? "unknown"}`);
         }
         catch (error) {
-            return `runtime command failed: ${formatErrorMessage(error)}`;
+            return `command delivery failed: ${formatErrorMessage(error)}`;
         }
     }
-    async trySendViaSpawn(payload) {
-        const argv = this.buildCliArgs(payload);
-        const [command, ...args] = argv;
-        return new Promise((resolve) => {
-            const child = spawn(command, args, {
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-            let stdout = "";
-            let stderr = "";
-            let settled = false;
-            const finish = (value) => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                resolve(value);
-            };
-            child.stdout.on("data", (chunk) => {
-                stdout += chunk.toString();
-            });
-            child.stderr.on("data", (chunk) => {
-                stderr += chunk.toString();
-            });
-            child.on("error", (error) => {
-                finish(`spawn failed: ${error.message}`);
-            });
-            child.on("close", (code) => {
-                finish(code === 0 ? null : (stderr || stdout || `exit code ${code}`).trim());
-            });
-        });
-    }
     buildCliArgs(payload) {
         const args = [
             this.options.openclawCliBin,

package/dist/services/indicator-service.d.ts

@@ -1,9 +1,11 @@
+import type { RunCommandWithTimeout } from "../runtime/command-runner.js";
 import type { IndicatorInputRow, IndicatorRow } from "../types/indicator.js";
 export declare class IndicatorService {
     private readonly pythonBin;
     private readonly pythonArgs;
     private readonly pythonWorkdir;
-    constructor(pythonBin: string, pythonArgs: string[], pythonWorkdir: string);
+    private readonly runCommandWithTimeout;
+    constructor(pythonBin: string, pythonArgs: string[], pythonWorkdir: string, runCommandWithTimeout: RunCommandWithTimeout);
     calculate(rows: IndicatorInputRow[]): Promise<IndicatorRow[]>;
     private runPythonJson;
 }

package/dist/services/indicator-service.js

@@ -1,13 +1,14 @@
-import { spawn } from "node:child_process";
 import path from "node:path";
 export class IndicatorService {
     pythonBin;
     pythonArgs;
     pythonWorkdir;
-    constructor(pythonBin, pythonArgs, pythonWorkdir) {
+    runCommandWithTimeout;
+    constructor(pythonBin, pythonArgs, pythonWorkdir, runCommandWithTimeout) {
         this.pythonBin = pythonBin;
         this.pythonArgs = pythonArgs;
         this.pythonWorkdir = pythonWorkdir;
+        this.runCommandWithTimeout = runCommandWithTimeout;
     }
     async calculate(rows) {
         if (rows.length === 0) {
@@ -38,30 +39,18 @@ export class IndicatorService {
     }
     runPythonJson(payload) {
         const scriptPath = path.join(this.pythonWorkdir, "indicator_runner.py");
-        const child = spawn(this.pythonBin, [...this.pythonArgs, scriptPath], {
+        const argv = [this.pythonBin, ...this.pythonArgs, scriptPath];
+        return this.runCommandWithTimeout(argv, {
             cwd: path.dirname(scriptPath),
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        return new Promise((resolve, reject) => {
-            let stdout = "";
-            let stderr = "";
-            child.stdout.on("data", (chunk) => {
-                stdout += chunk.toString();
-            });
-            child.stderr.on("data", (chunk) => {
-                stderr += chunk.toString();
-            });
-            child.on("error", reject);
-            child.on("close", (code) => {
-                if (code === 0) {
-                    resolve(stdout);
-                    return;
-                }
-                reject(new Error(`indicator_runner failed with code ${code}: ${stderr || stdout}` +
-                    `\npython command: ${this.pythonBin} ${[...this.pythonArgs, scriptPath].join(" ")}`));
-            });
-            child.stdin.write(JSON.stringify(payload));
-            child.stdin.end();
+            input: JSON.stringify(payload),
+            timeoutMs: 30_000,
+            noOutputTimeoutMs: 30_000,
+        }).then((result) => {
+            if (result.code === 0) {
+                return result.stdout;
+            }
+            throw new Error(`indicator_runner failed with code ${result.code}: ${result.stderr || result.stdout}` +
+                `\npython command: ${argv.join(" ")}`);
         });
     }
 }

package/dist/tools/start-daily-update.tool.d.ts

@@ -1,6 +1,6 @@
 import type { PluginConfig } from "../config/schema.js";
 import { DailyUpdateWorker } from "../background/daily-update.worker.js";
-export declare function startDailyUpdateTool(dailyUpdateWorker: DailyUpdateWorker, config: PluginConfig, configSource: "openclaw_plugin" | "local_config", runtime: {
+export declare function startDailyUpdateTool(dailyUpdateWorker: DailyUpdateWorker, _config: PluginConfig, configSource: "openclaw_plugin" | "local_config", runtime: {
     pluginManagedServices: boolean;
 }): {
     name: string;

package/dist/tools/start-daily-update.tool.js

@@ -1,23 +1,36 @@
-export function startDailyUpdateTool(dailyUpdateWorker, config, configSource, runtime) {
+import { isPidAlive } from "../background/daily-update.worker.js";
+export function startDailyUpdateTool(dailyUpdateWorker, _config, configSource, runtime) {
     return {
         name: "start_daily_update",
         description: "Start the TickFlow daily-update scheduler.",
         optional: true,
         async run() {
-            const result = runtime.pluginManagedServices
-                ? await dailyUpdateWorker.enableManagedLoop(configSource)
-                : await dailyUpdateWorker.ensureLoopRunning(config, configSource);
-            if (!result.started) {
+            if (runtime.pluginManagedServices) {
+                const result = await dailyUpdateWorker.enableManagedLoop(configSource);
+                if (!result.started) {
+                    return await dailyUpdateWorker.getStatusReport();
+                }
+                const lines = [
+                    "✅ TickFlow 定时日更已启动",
+                    `PID: ${result.pid ?? "托管服务"}`,
+                    "运行方式: plugin_service",
+                    `配置来源: ${configSource}`,
+                    "说明: 后台按 15 分钟对齐轮询，交易日 15:25 后最多执行一次日更，20:00 后最多执行一次复盘",
+                ];
+                return lines.join("\n");
+            }
+            const state = await dailyUpdateWorker.getState();
+            if (state.running && state.workerPid != null && isPidAlive(state.workerPid)) {
                 return await dailyUpdateWorker.getStatusReport();
             }
-            const lines = [
+            await dailyUpdateWorker.markSchedulerRunning(null, configSource);
+            return [
                 "✅ TickFlow 定时日更已启动",
-                `PID: ${result.pid ?? "托管服务"}`,
-                `运行方式: ${runtime.pluginManagedServices ? "plugin_service" : "project_scheduler"}`,
+                "PID: 手动循环",
+                "运行方式: manual_loop",
                 `配置来源: ${configSource}`,
-                "说明: 后台按 15 分钟对齐轮询，交易日 15:25 后最多执行一次日更，20:00 后最多执行一次复盘",
-            ];
-            return lines.join("\n");
+                "下一步: 在另一个终端执行 `npm run daily-update-loop` 启动本地日更循环。",
+            ].join("\n");
         },
     };
 }

package/dist/tools/start-monitor.tool.js

@@ -1,5 +1,3 @@
-import { spawn } from "node:child_process";
-import path from "node:path";
 export function startMonitorTool(monitorService, runtime) {
     return {
         name: "start_monitor",
@@ -7,9 +5,15 @@ export function startMonitorTool(monitorService, runtime) {
         optional: true,
         async run() {
             if (runtime.pluginManagedServices) {
-                const result = await monitorService.enableManagedLoop();
+                let result;
+                try {
+                    result = await monitorService.enableManagedLoop();
+                }
+                catch (error) {
+                    return formatManagedStartError(error);
+                }
                 if (!result.started) {
-                    return await monitorService.getStatusReport();
+                    return await buildManagedAlreadyRunningSummary(monitorService);
                 }
                 return [
                     "✅ TickFlow 实时监控已启动",
@@ -22,24 +26,44 @@ export function startMonitorTool(monitorService, runtime) {
             if (currentState.running
                 && currentState.workerPid != null
                 && isPidAlive(currentState.workerPid)) {
-                return await monitorService.getStatusReport();
+                return [
+                    "✅ TickFlow 实时监控已在运行",
+                    "运行方式: manual_loop",
+                    `PID: ${currentState.workerPid}`,
+                    "说明: 本地监控循环已存在，无需重复启动。",
+                ].join("\n");
             }
             const summary = await monitorService.start();
-            const workerPid = spawnMonitorLoop();
-            await monitorService.setWorkerPid(workerPid);
-            return summary;
+            return [
+                summary,
+                "运行方式: manual_loop",
+                "下一步: 在另一个终端执行 `npm run monitor-loop` 启动本地监控循环。",
+            ].join("\n");
         },
     };
 }
-function spawnMonitorLoop() {
-    const scriptPath = path.resolve("dist/dev/run-monitor-loop.js");
-    const child = spawn(process.execPath, [scriptPath], {
-        cwd: process.cwd(),
-        detached: true,
-        stdio: "ignore",
-    });
-    child.unref();
-    return child.pid ?? null;
+async function buildManagedAlreadyRunningSummary(monitorService) {
+    const state = await monitorService.getState();
+    return [
+        "✅ TickFlow 实时监控已在运行",
+        "运行方式: plugin_service",
+        `最近心跳: ${state.lastHeartbeatAt ?? "暂无"}`,
+        "说明: 后台服务按配置间隔轮询，交易时段自动执行监控。",
+    ].join("\n");
+}
+function formatManagedStartError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("关注列表为空")) {
+        return [
+            "⚠️ 无法启动实时监控",
+            "原因: 关注列表为空，请先添加至少一只自选股。",
+            "示例: /ta_addstock 000001 10.50",
+        ].join("\n");
+    }
+    return [
+        "⚠️ 启动实时监控失败",
+        `原因: ${message}`,
+    ].join("\n");
 }
 function isPidAlive(pid) {
     try {

package/openclaw.plugin.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickflow-assist",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "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",

package/dist/runtime/daily-update-process.d.ts

@@ -1,3 +0,0 @@
-import type { PluginConfig } from "../config/schema.js";
-export declare function spawnDailyUpdateLoop(config: PluginConfig, configSource: "openclaw_plugin" | "local_config"): number | null;
-export declare function isPidAlive(pid: number): boolean;

package/dist/runtime/daily-update-process.js

@@ -1,24 +0,0 @@
-import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { buildProcessConfigEnv } from "./process-config.js";
-const PROJECT_ROOT = fileURLToPath(new URL("../../", import.meta.url));
-const DAILY_UPDATE_LOOP_SCRIPT = fileURLToPath(new URL("../dev/run-daily-update-loop.js", import.meta.url));
-export function spawnDailyUpdateLoop(config, configSource) {
-    const child = spawn(process.execPath, [DAILY_UPDATE_LOOP_SCRIPT], {
-        cwd: PROJECT_ROOT,
-        detached: true,
-        stdio: "ignore",
-        env: buildProcessConfigEnv(config, configSource),
-    });
-    child.unref();
-    return child.pid ?? null;
-}
-export function isPidAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}