tickflow-assist 0.3.4 → 0.3.6

package/dist/services/alert-service.js

@@ -1,4 +1,9 @@
+import { randomBytes } from "node:crypto";
+import { copyFile, mkdir, unlink } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 import { createCommandRunner } from "../runtime/command-runner.js";
+import { basenameOrUndefined, buildAlertMessageHash, buildAlertSendId, truncateDiagnosticText, } from "../utils/alert-diagnostic-log.js";
 import { calculateProfitPct, formatCostPrice } from "../utils/cost-price.js";
 export class AlertService {
     options;
@@ -16,55 +21,84 @@ export class AlertService {
     async sendWithResult(input) {
         this.lastError = null;
         const payload = normalizeSendInput(input);
+        const sendId = buildAlertSendId(payload.message);
+        const messageHash = buildAlertMessageHash(payload.message);
+        const diagnosticContext = {
+            sendId,
+            step: "primary",
+            messageHash,
+        };
         const mediaAttempted = Boolean(payload.mediaPath);
-        const primaryError = await this.trySendPayload(payload);
-        if (primaryError === null) {
-            return {
+        await this.logDiagnostic("send_started", {
+            sendId,
+            step: diagnosticContext.step,
+            channel: this.channel,
+            messageHash,
+            messageLength: payload.message.length,
+            hasMedia: mediaAttempted,
+            mediaFile: basenameOrUndefined(payload.mediaPath),
+            filename: payload.filename,
+            accountConfigured: Boolean(this.options.account.trim()),
+            targetConfigured: Boolean(this.options.target.trim()),
+            runtimeAvailable: Boolean(this.options.runtime),
+            messagePreview: truncateDiagnosticText(payload.message.split("\n")[0] ?? ""),
+        });
+        const primaryFailure = await this.trySendPayload(payload, diagnosticContext);
+        if (primaryFailure === null) {
+            const result = {
                 ok: true,
                 mediaAttempted,
                 mediaDelivered: mediaAttempted,
                 error: null,
             };
+            await this.logCompletion(sendId, messageHash, payload, result);
+            return result;
         }
         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,
-                    };
-                }
+            if (primaryFailure.ambiguous) {
+                const result = {
+                    ok: false,
+                    mediaAttempted: true,
+                    mediaDelivered: false,
+                    error: primaryFailure.error,
+                    deliveryUncertain: true,
+                };
+                await this.logCompletion(sendId, messageHash, payload, result);
+                return result;
             }
             const textFallback = normalizeSendInput(payload.message);
-            const textFallbackError = await this.trySendPayload(textFallback);
-            if (textFallbackError === null) {
-                return {
+            const textFallbackFailure = await this.trySendPayload(textFallback, {
+                sendId,
+                step: "text_fallback",
+                messageHash,
+            });
+            if (textFallbackFailure === null) {
+                const result = {
                     ok: true,
                     mediaAttempted: true,
                     mediaDelivered: false,
-                    error: primaryError,
+                    error: primaryFailure.error,
                 };
+                await this.logCompletion(sendId, messageHash, payload, result);
+                return result;
             }
-            return {
+            const result = {
                 ok: false,
                 mediaAttempted: true,
                 mediaDelivered: false,
-                error: this.combineErrors(primaryError, textFallbackError),
+                error: this.combineErrors(primaryFailure.error, textFallbackFailure.error),
             };
+            await this.logCompletion(sendId, messageHash, payload, result);
+            return result;
         }
-        return {
+        const result = {
             ok: false,
             mediaAttempted: false,
             mediaDelivered: false,
-            error: primaryError,
+            error: primaryFailure.error,
         };
+        await this.logCompletion(sendId, messageHash, payload, result);
+        return result;
     }
     getLastError() {
         return this.lastError;
@@ -132,17 +166,35 @@ export class AlertService {
         }
         return `${runtimeError}; ${fallbackError}`;
     }
-    async trySendPayload(payload) {
-        const runtimeError = await this.trySendViaRuntime(payload);
-        if (runtimeError === null) {
+    async trySendPayload(payload, context) {
+        // OpenClaw documents `api.runtime.channel` as channel-plugin-specific helper
+        // surface. For a regular tool/service plugin like tickflow-assist, Telegram
+        // and QQ Bot delivery are more reliable via the shared
+        // `openclaw message send` CLI path.
+        if (this.channel === "telegram" || this.channel === "qqbot") {
+            return await this.trySendViaCommand(payload, context);
+        }
+        const runtimeFailure = await this.trySendViaRuntime(payload, context);
+        if (runtimeFailure === null) {
             return null;
         }
-        return await this.trySendViaCommand(payload);
+        // Only image/media sends are risky to replay after an ambiguous transport error.
+        // Text-only notifications (for example session boundary notifications) should
+        // still fall back to the CLI path so transient runtime failures do not drop them.
+        if (runtimeFailure.ambiguous && payload.mediaPath) {
+            return runtimeFailure;
+        }
+        return await this.trySendViaCommand(payload, context);
     }
-    async trySendViaRuntime(payload) {
+    async trySendViaRuntime(payload, context) {
         const runtimeContext = this.options.runtime;
         if (!runtimeContext || !this.options.target.trim()) {
-            return "runtime delivery unavailable";
+            const failure = {
+                error: "runtime delivery unavailable",
+                ambiguous: false,
+            };
+            await this.logTransportFailure("runtime_unavailable", context, payload, failure);
+            return failure;
         }
         const baseOptions = {
             accountId: this.options.account || undefined,
@@ -152,33 +204,51 @@ export class AlertService {
         };
         try {
             switch (this.channel) {
-                case "telegram":
-                    await this.invokeRuntimeChannelSend(runtimeContext.runtime.channel, "telegram", "sendMessageTelegram", this.options.target, payload.message, baseOptions);
-                    return null;
                 case "discord":
                     await this.invokeRuntimeChannelSend(runtimeContext.runtime.channel, "discord", "sendMessageDiscord", this.options.target, payload.message, {
                         ...baseOptions,
                         filename: payload.filename,
                     });
-                    return null;
+                    break;
                 case "slack":
                     await this.invokeRuntimeChannelSend(runtimeContext.runtime.channel, "slack", "sendMessageSlack", this.options.target, payload.message, {
                         ...baseOptions,
                         uploadFileName: payload.filename,
                         uploadTitle: payload.filename,
                     });
-                    return null;
+                    break;
                 case "signal":
                     await this.invokeRuntimeChannelSend(runtimeContext.runtime.channel, "signal", "sendMessageSignal", this.options.target, payload.message, baseOptions);
-                    return null;
+                    break;
                 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}`;
+                    const failure = {
+                        error: `runtime delivery not supported for channel: ${this.channel}`,
+                        ambiguous: false,
+                    };
+                    await this.logTransportFailure("runtime_unsupported", context, payload, failure);
+                    return failure;
             }
+            await this.logDiagnostic("transport_success", {
+                sendId: context.sendId,
+                step: context.step,
+                transport: "runtime",
+                channel: this.channel,
+                messageHash: context.messageHash,
+                hasMedia: Boolean(payload.mediaPath),
+                mediaFile: basenameOrUndefined(payload.mediaPath),
+            });
+            return null;
         }
         catch (error) {
-            return `runtime delivery failed: ${formatErrorMessage(error)}`;
+            const detail = formatErrorMessage(error);
+            const failure = {
+                error: `runtime delivery failed: ${detail}`,
+                ambiguous: !isRuntimeCapabilityUnavailableError(detail),
+            };
+            await this.logTransportFailure("runtime_failed", context, payload, failure);
+            return failure;
         }
     }
     async invokeRuntimeChannelSend(runtimeChannel, channelName, methodName, target, message, options) {
@@ -189,19 +259,94 @@ export class AlertService {
         }
         await method.call(channelApi, target, message, options);
     }
-    async trySendViaCommand(payload) {
+    async trySendViaCommand(payload, context) {
+        const prepared = await this.prepareCommandPayload(payload);
+        const commandOptions = this.getCommandRunOptions(prepared.payload);
         try {
-            const result = await this.runCommandWithTimeout(this.buildCliArgs(payload), { timeoutMs: 15_000 });
+            const result = await this.runCommandWithTimeout(this.buildCliArgs(prepared.payload), commandOptions);
             if (result.code === 0) {
+                const commandOutcome = inspectCommandDeliveryResult(result.stdout);
+                if (commandOutcome?.error) {
+                    const failure = {
+                        error: commandOutcome.error,
+                        ambiguous: false,
+                    };
+                    await this.logTransportFailure("command_reported_error", context, payload, failure, {
+                        timeoutMs: commandOptions.timeoutMs,
+                        termination: result.termination,
+                        messageId: commandOutcome.messageId,
+                        stdout: truncateDiagnosticText(result.stdout.trim()),
+                    });
+                    return failure;
+                }
+                await this.logDiagnostic("transport_success", {
+                    sendId: context.sendId,
+                    step: context.step,
+                    transport: "command",
+                    channel: this.channel,
+                    messageHash: context.messageHash,
+                    hasMedia: Boolean(payload.mediaPath),
+                    mediaFile: basenameOrUndefined(payload.mediaPath),
+                    timeoutMs: commandOptions.timeoutMs,
+                    termination: result.termination,
+                    messageId: commandOutcome?.messageId,
+                });
                 return null;
             }
-            return (result.stderr.trim()
-                || result.stdout.trim()
-                || `command exited with ${result.code ?? "unknown"}`);
+            const failure = {
+                error: result.stderr.trim()
+                    || result.stdout.trim()
+                    || `command exited with ${result.code ?? "unknown"}`,
+                ambiguous: true,
+            };
+            await this.logTransportFailure("command_failed", context, payload, failure, {
+                code: result.code,
+                timeoutMs: commandOptions.timeoutMs,
+                termination: result.termination,
+                stderr: truncateDiagnosticText(result.stderr.trim()),
+                stdout: truncateDiagnosticText(result.stdout.trim()),
+            });
+            return failure;
         }
         catch (error) {
-            return `command delivery failed: ${formatErrorMessage(error)}`;
+            const failure = {
+                error: `command delivery failed: ${formatErrorMessage(error)}`,
+                ambiguous: false,
+            };
+            await this.logTransportFailure("command_error", context, payload, failure);
+            return failure;
+        }
+        finally {
+            await prepared.cleanup();
+        }
+    }
+    async prepareCommandPayload(payload) {
+        if (!shouldStageQQBotMedia(this.channel, payload.mediaPath)) {
+            return {
+                payload,
+                cleanup: async () => { },
+            };
+        }
+        const stagedMediaPath = await stageQQBotMediaFile(payload.mediaPath);
+        return {
+            payload: {
+                ...payload,
+                mediaPath: stagedMediaPath,
+            },
+            cleanup: async () => {
+                await unlink(stagedMediaPath).catch((error) => {
+                    if (error.code !== "ENOENT") {
+                        throw error;
+                    }
+                });
+            },
+        };
+    }
+    getCommandRunOptions(payload) {
+        if (payload.mediaPath) {
+            return { timeoutMs: 45_000 };
         }
+        return { timeoutMs: 15_000 };
     }
     buildCliArgs(payload) {
         const args = [
@@ -223,8 +368,40 @@ export class AlertService {
         if (this.options.account) {
             args.push("--account", this.options.account);
         }
+        args.push("--json");
         return args;
     }
+    async logCompletion(sendId, messageHash, payload, result) {
+        await this.logDiagnostic("send_completed", {
+            sendId,
+            channel: this.channel,
+            messageHash,
+            hasMedia: Boolean(payload.mediaPath),
+            mediaFile: basenameOrUndefined(payload.mediaPath),
+            ok: result.ok,
+            mediaAttempted: result.mediaAttempted,
+            mediaDelivered: result.mediaDelivered,
+            deliveryUncertain: result.deliveryUncertain === true,
+            error: result.error ? truncateDiagnosticText(result.error) : null,
+        });
+    }
+    async logTransportFailure(event, context, payload, failure, extra = {}) {
+        await this.logDiagnostic(event, {
+            sendId: context.sendId,
+            step: context.step,
+            transport: event.startsWith("command") ? "command" : "runtime",
+            channel: this.channel,
+            messageHash: context.messageHash,
+            hasMedia: Boolean(payload.mediaPath),
+            mediaFile: basenameOrUndefined(payload.mediaPath),
+            ambiguous: failure.ambiguous,
+            error: truncateDiagnosticText(failure.error),
+            ...extra,
+        });
+    }
+    async logDiagnostic(event, details) {
+        await this.options.diagnosticLogger?.append("alert_service", event, details);
+    }
 }
 function formatErrorMessage(error) {
     if (error instanceof Error) {
@@ -240,11 +417,62 @@ function formatErrorMessage(error) {
         return String(error);
     }
 }
+function isRuntimeCapabilityUnavailableError(detail) {
+    return /runtime channel .* unavailable/i.test(detail);
+}
 function normalizeSendInput(input) {
     return typeof input === "string"
         ? { message: input }
         : input;
 }
+function inspectCommandDeliveryResult(stdout) {
+    const payload = extractCommandJsonPayload(stdout);
+    if (!payload) {
+        return null;
+    }
+    const directResult = isRecord(payload.result) ? payload.result : null;
+    const directResultMeta = isRecord(directResult?.meta) ? directResult.meta : null;
+    const error = getNonEmptyString(directResult?.error)
+        ?? getNonEmptyString(directResultMeta?.error)
+        ?? getNonEmptyString(payload.error);
+    const messageId = getNonEmptyString(directResult?.messageId)
+        ?? getNonEmptyString(directResultMeta?.messageId)
+        ?? getNonEmptyString(payload.messageId);
+    if (!error && !messageId) {
+        return null;
+    }
+    return {
+        ...(error ? { error } : {}),
+        ...(messageId ? { messageId } : {}),
+    };
+}
+function extractCommandJsonPayload(stdout) {
+    const root = extractTrailingJsonObject(stdout);
+    if (!root) {
+        return null;
+    }
+    return isRecord(root.payload) ? root.payload : root;
+}
+function extractTrailingJsonObject(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+        return null;
+    }
+    for (let start = trimmed.lastIndexOf("{"); start >= 0; start = trimmed.lastIndexOf("{", start - 1)) {
+        const candidate = trimmed.slice(start);
+        try {
+            const parsed = JSON.parse(candidate);
+            const record = isRecord(parsed) ? parsed : null;
+            if (record) {
+                return record;
+            }
+        }
+        catch {
+            // Keep scanning backward until the trailing JSON object is found.
+        }
+    }
+    return null;
+}
 function getRuntimeChannelApi(runtimeChannel, channelName) {
     if (!isRecord(runtimeChannel)) {
         return null;
@@ -255,6 +483,60 @@ function getRuntimeChannelApi(runtimeChannel, channelName) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function getNonEmptyString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function shouldStageQQBotMedia(channel, mediaPath) {
+    return channel === "qqbot"
+        && typeof mediaPath === "string"
+        && mediaPath.length > 0
+        && !isRemoteMediaPath(mediaPath)
+        && !isUnderQQBotManagedMediaRoot(mediaPath);
+}
+function isRemoteMediaPath(mediaPath) {
+    return /^(?:https?:|data:)/i.test(mediaPath.trim());
+}
+function isUnderQQBotManagedMediaRoot(mediaPath) {
+    const candidate = path.resolve(mediaPath);
+    const mediaRoot = path.resolve(getQQBotManagedMediaRoot());
+    const relative = path.relative(mediaRoot, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+async function stageQQBotMediaFile(mediaPath) {
+    const destinationDir = path.join(getQQBotManagedMediaRoot(), "tickflow-assist");
+    await mkdir(destinationDir, { recursive: true });
+    const sourceExt = path.extname(mediaPath);
+    const sourceBase = path.basename(mediaPath, sourceExt);
+    const safeBase = sanitizeFileNamePart(sourceBase) || "alert-media";
+    const safeExt = sanitizeFileExtension(sourceExt);
+    const stagedName = `${safeBase}-${Date.now()}-${randomBytes(3).toString("hex")}${safeExt}`;
+    const stagedPath = path.join(destinationDir, stagedName);
+    await copyFile(mediaPath, stagedPath);
+    return stagedPath;
+}
+function getQQBotManagedMediaRoot() {
+    return path.join(resolveHomeDir(), ".openclaw", "media", "qqbot");
+}
+function resolveHomeDir() {
+    const fromOs = os.homedir();
+    if (fromOs) {
+        return fromOs;
+    }
+    return process.env.HOME || process.env.USERPROFILE || ".";
+}
+function sanitizeFileNamePart(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+function sanitizeFileExtension(value) {
+    if (!value) {
+        return "";
+    }
+    return /^\.[a-zA-Z0-9]+$/.test(value) ? value.toLowerCase() : "";
+}
 function getAlertStyle(ruleCode, fallbackTitle) {
     switch (ruleCode) {
         case "stop_loss_hit":

package/dist/services/analysis-service.js

@@ -1,3 +1,4 @@
+import { formatConfigEnvFallback } from "../config/env.js";
 export class AnalysisService {
     llmBaseUrl;
     llmApiKey;
@@ -14,13 +15,13 @@ export class AnalysisService {
     }
     getConfigurationError() {
         if (!this.llmBaseUrl.trim()) {
-            return "LLM 未配置接口地址，请设置 llmBaseUrl";
+            return `LLM 未配置接口地址，请设置 llmBaseUrl 或环境变量 ${formatConfigEnvFallback("llmBaseUrl")}`;
         }
         if (!this.llmApiKey.trim()) {
-            return "LLM 未配置 API Key，请设置 llmApiKey";
+            return `LLM 未配置 API Key，请设置 llmApiKey 或环境变量 ${formatConfigEnvFallback("llmApiKey")}`;
         }
         if (!this.llmModel.trim()) {
-            return "LLM 未配置模型，请设置 llmModel";
+            return `LLM 未配置模型，请设置 llmModel 或环境变量 ${formatConfigEnvFallback("llmModel")}`;
         }
         return null;
     }

package/dist/services/jin10-mcp-service.js

@@ -1,3 +1,4 @@
+import { formatConfigEnvFallback } from "../config/env.js";
 export class Jin10McpService {
     serverUrl;
     apiToken;
@@ -14,10 +15,10 @@ export class Jin10McpService {
     }
     getConfigurationError() {
         if (!this.serverUrl.trim()) {
-            return "Jin10 MCP 未配置接口地址，请设置 jin10McpUrl";
+            return `Jin10 MCP 未配置接口地址，请设置 jin10McpUrl 或环境变量 ${formatConfigEnvFallback("jin10McpUrl")}`;
         }
         if (!this.apiToken.trim()) {
-            return "Jin10 MCP 未配置 API Token，请设置 jin10ApiToken";
+            return `Jin10 MCP 未配置 API Token，请设置 jin10ApiToken 或环境变量 ${formatConfigEnvFallback("jin10ApiToken")}`;
         }
         return null;
     }

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

@@ -1,4 +1,5 @@
 import type { MonitorState } from "../types/monitor.js";
+import { AlertDiagnosticLogger } from "../utils/alert-diagnostic-log.js";
 import { QuoteService } from "./quote-service.js";
 import { TradingCalendarService } from "./trading-calendar-service.js";
 import { WatchlistService } from "./watchlist-service.js";
@@ -23,7 +24,8 @@ export declare class MonitorService {
     private readonly klineService;
     private readonly alertService;
     private readonly alertMediaService;
-    constructor(baseDir: string, requestInterval: number, alertChannel: string, watchlistService: WatchlistService, quoteService: QuoteService, tradingCalendarService: TradingCalendarService, keyLevelsRepository: KeyLevelsRepository, alertLogRepository: AlertLogRepository, klinesRepository: KlinesRepository, intradayKlinesRepository: IntradayKlinesRepository, klineService: KlineService, alertService: AlertService, alertMediaService: AlertMediaService);
+    private readonly diagnosticLogger?;
+    constructor(baseDir: string, requestInterval: number, alertChannel: string, watchlistService: WatchlistService, quoteService: QuoteService, tradingCalendarService: TradingCalendarService, keyLevelsRepository: KeyLevelsRepository, alertLogRepository: AlertLogRepository, klinesRepository: KlinesRepository, intradayKlinesRepository: IntradayKlinesRepository, klineService: KlineService, alertService: AlertService, alertMediaService: AlertMediaService, diagnosticLogger?: AlertDiagnosticLogger | undefined);
     start(): Promise<string>;
     stop(): Promise<string>;
     enableManagedLoop(): Promise<{
@@ -59,4 +61,5 @@ export declare class MonitorService {
     private cleanupAlertMedia;
     private getRunLockFilePath;
     private getAlertClaimFilePath;
+    private logDiagnostic;
 }

package/dist/services/monitor-service.js

@@ -1,5 +1,6 @@
 import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { basenameOrUndefined, buildAlertMessageHash, truncateDiagnosticText, } from "../utils/alert-diagnostic-log.js";
 import { formatChinaDateTime } from "../utils/china-time.js";
 import { calculateProfitPct, formatCostPrice } from "../utils/cost-price.js";
 const DEFAULT_STATE = {
@@ -36,7 +37,8 @@ export class MonitorService {
     klineService;
     alertService;
     alertMediaService;
-    constructor(baseDir, requestInterval, alertChannel, watchlistService, quoteService, tradingCalendarService, keyLevelsRepository, alertLogRepository, klinesRepository, intradayKlinesRepository, klineService, alertService, alertMediaService) {
+    diagnosticLogger;
+    constructor(baseDir, requestInterval, alertChannel, watchlistService, quoteService, tradingCalendarService, keyLevelsRepository, alertLogRepository, klinesRepository, intradayKlinesRepository, klineService, alertService, alertMediaService, diagnosticLogger) {
         this.baseDir = baseDir;
         this.requestInterval = requestInterval;
         this.alertChannel = alertChannel;
@@ -50,6 +52,7 @@ export class MonitorService {
         this.klineService = klineService;
         this.alertService = alertService;
         this.alertMediaService = alertMediaService;
+        this.diagnosticLogger = diagnosticLogger;
     }
     async start() {
         const watchlist = await this.watchlistService.list();
@@ -464,21 +467,54 @@ export class MonitorService {
     }
     async trySendAlert(symbol, ruleName, input) {
         const sessionKey = getSessionKey();
+        const message = typeof input === "string" ? input : input.message;
+        const messageHash = buildAlertMessageHash(message);
+        const hasMedia = typeof input !== "string" && Boolean(input.mediaPath);
+        await this.logDiagnostic("try_send_alert_enter", {
+            symbol,
+            ruleName,
+            sessionKey,
+            messageHash,
+            hasMedia,
+            mediaFile: typeof input === "string" ? undefined : basenameOrUndefined(input.mediaPath),
+        });
         const claim = await this.tryAcquireAlertClaim(symbol, ruleName, sessionKey);
         if (!claim) {
+            await this.logDiagnostic("try_send_alert_claim_busy", {
+                symbol,
+                ruleName,
+                sessionKey,
+                messageHash,
+            });
             await this.cleanupAlertMedia(input);
             return false;
         }
         try {
             if (await this.alertLogRepository.isSentThisSession(symbol, ruleName, sessionKey)) {
+                await this.logDiagnostic("try_send_alert_already_sent", {
+                    symbol,
+                    ruleName,
+                    sessionKey,
+                    messageHash,
+                });
                 await this.cleanupAlertMedia(input);
                 return false;
             }
             const result = await this.sendAlertAndCleanupMedia(input);
-            if (!result.ok) {
+            await this.logDiagnostic("try_send_alert_result", {
+                symbol,
+                ruleName,
+                sessionKey,
+                messageHash,
+                ok: result.ok,
+                mediaAttempted: result.mediaAttempted,
+                mediaDelivered: result.mediaDelivered,
+                deliveryUncertain: result.deliveryUncertain === true,
+                error: result.error ? truncateDiagnosticText(result.error) : null,
+            });
+            if (!result.ok && !result.deliveryUncertain) {
                 return false;
             }
-            const message = typeof input === "string" ? input : input.message;
             await this.alertLogRepository.append({
                 symbol,
                 alert_date: sessionKey,
@@ -486,6 +522,12 @@ export class MonitorService {
                 message,
                 triggered_at: formatChinaDateTime(),
             });
+            await this.logDiagnostic("try_send_alert_logged", {
+                symbol,
+                ruleName,
+                sessionKey,
+                messageHash,
+            });
             return true;
         }
         finally {
@@ -616,6 +658,9 @@ export class MonitorService {
     getAlertClaimFilePath(symbol, ruleName, sessionKey) {
         return path.join(this.baseDir, "alert-claims", `${sanitizeAlertClaimPart(sessionKey)}_${sanitizeAlertClaimPart(symbol)}_${sanitizeAlertClaimPart(ruleName)}.lock`);
     }
+    async logDiagnostic(event, details) {
+        await this.diagnosticLogger?.append("monitor_service", event, details);
+    }
 }
 function formatRunningState(state, requestInterval) {
     const heartbeat = getHeartbeatStatus(state, requestInterval);

package/dist/services/mx-search-service.js

@@ -1,3 +1,4 @@
+import { formatConfigEnvFallback } from "../config/env.js";
 export class MxSearchServiceError extends Error {
     constructor(message) {
         super(message);
@@ -16,10 +17,10 @@ export class MxApiService {
     }
     getConfigurationError() {
         if (!this.apiBaseUrl.trim()) {
-            return "mx_search 未配置接口地址，请设置 mxSearchApiUrl 或环境变量 MX_SEARCH_API_URL";
+            return `mx_search 未配置接口地址，请设置 mxSearchApiUrl 或环境变量 ${formatConfigEnvFallback("mxSearchApiUrl")}`;
         }
         if (!this.apiKey.trim()) {
-            return "mx_search 未配置 API Key，请设置插件配置 mxSearchApiKey 或环境变量 MX_APIKEY";
+            return `mx_search 未配置 API Key，请设置插件配置 mxSearchApiKey 或环境变量 ${formatConfigEnvFallback("mxSearchApiKey")}`;
         }
         return null;
     }