@pwddd/skills-scanner 1.0.0-beta.3 → 1.0.0-beta.4

package/index.ts

@@ -21,7 +21,12 @@ import {
 } from "./src/state.js";
 import { runScan } from "./src/scanner.js";
 import { buildDailyReport } from "./src/report.js";
-import { ensureCronJobViaGateway, checkCronJobStatus } from "./src/cron-manager.js";
+import {
+  ensureCronJob,
+  cleanupCronJob,
+  getCronJobStatus,
+  triggerCronJob,
+} from "./src/cron-manager.js";
 import { startWatcher } from "./src/watcher.js";
 import { createCommandHandlers } from "./src/commands.js";
 import { SKILLS_SECURITY_GUIDANCE } from "./src/prompt-guidance.js";
@@ -143,75 +148,45 @@ export default definePluginEntry({
     api.logger.warn("[skills-scanner] ⚠️  before_install hook DISABLED - installations will NOT be intercepted!");
   }
 
-  // Register gateway_start hook for automatic cron job registration
-  api.on("gateway_start", async () => {
-    try {
-      api.logger.info("[skills-scanner] 🚀 Gateway started, checking cron job...");
-      await ensureCronJobViaGateway({
-        logger: api.logger,
-        callGateway: async (method: string, params: any) => {
-          return await api.callGateway(method, params);
-        },
-      });
-      api.logger.info("[skills-scanner] ✅ Cron job check completed");
-    } catch (err: any) {
-      api.logger.error("[skills-scanner] ❌ Cron job registration failed", {
-        error: err.message,
-        stack: err.stack,
-      });
-      // Don't throw - avoid blocking gateway startup
-    }
-  });
-
-  // Register plugin_uninstall hook for cleanup
-  api.on("plugin_uninstall", async () => {
-    api.logger.info("[skills-scanner] 🗑️  Plugin uninstalling, cleaning up...");
-
-    try {
-      // 1. Stop file watcher
-      if (stopWatcher) {
-        api.logger.debug("[skills-scanner] Stopping file watcher...");
-        stopWatcher();
-        stopWatcher = null;
-        api.logger.debug("[skills-scanner] ✅ File watcher stopped");
-      }
+  // Register service for initialization and cleanup
+  api.registerService({
+    id: "skills-scanner-cron-manager",
+    start: async () => {
+      api.logger.info("[skills-scanner] 🚀 Cron manager starting...");
 
-      // 2. Remove cron jobs
       try {
-        const listResult = await api.callGateway("cron.list", {});
-        const jobs = listResult?.jobs || [];
-        const ourJobs = jobs.filter((j: any) => j.name === "skills-weekly-report");
-
-        for (const job of ourJobs) {
-          const jobId = job.jobId || job.id;
-          await api.callGateway("cron.remove", { jobId });
-          api.logger.info("[skills-scanner] Removed cron job", { jobId });
-        }
-
-        if (ourJobs.length > 0) {
-          api.logger.info(`[skills-scanner] ✅ Removed ${ourJobs.length} cron job(s)`);
-        }
-      } catch (err: any) {
-        api.logger.warn("[skills-scanner] Failed to remove cron jobs", {
-          error: err.message,
+        // 注册定时任务
+        await ensureCronJob({
+          logger: api.logger,
+          config: api.config,
         });
-      }
-
-      // 3. Save final state
-      try {
-        const finalState = loadState(api.runtime);
-        finalState.lastUninstallAt = new Date().toISOString();
-        saveState(finalState, api.runtime);
-        api.logger.debug("[skills-scanner] ✅ Final state saved");
+        api.logger.info("[skills-scanner] ✅ Cron job registered successfully");
       } catch (err: any) {
-        api.logger.warn("[skills-scanner] Failed to save final state", {
+        api.logger.error("[skills-scanner] ❌ Failed to register cron job", {
           error: err.message,
+          stack: err.stack,
         });
+        // Don't throw - avoid blocking service startup
       }
+    },
+    stop: async () => {
+      api.logger.info("[skills-scanner] 🛑 Cron manager stopping...");
+      // Cron 任务在卸载时清理，这里不需要操作
+    },
+  });
+
+  // Register plugin_uninstall hook for cleanup
+  api.on("plugin_uninstall", async () => {
+    api.logger.info("[skills-scanner] 🗑️  Plugin uninstalling, cleaning up cron jobs...");
 
-      api.logger.info("[skills-scanner] ✅ Cleanup completed successfully");
+    try {
+      await cleanupCronJob({
+        logger: api.logger,
+        config: api.config,
+      });
+      api.logger.info("[skills-scanner] ✅ Cron jobs cleaned up");
     } catch (err: any) {
-      api.logger.error("[skills-scanner] ❌ Cleanup failed", {
+      api.logger.error("[skills-scanner] ❌ Failed to cleanup cron jobs", {
         error: err.message,
         stack: err.stack,
       });
@@ -470,9 +445,7 @@ export default definePluginEntry({
     preInstallScan,
     onUnsafe,
     api.logger,
-    async (method: string, params: any) => {
-      return await api.callGateway(method, params);
-    }
+    api.config  // 传递 api.config
   );
 
   // Chat command: /skills-scanner

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "skills-scanner",
   "name": "Skills Scanner",
   "description": "Security scanner for OpenClaw Skills to detect potential threats",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.4",
   "author": "pwddd",
   "skills": ["./skills"],
   "uiHints": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pwddd/skills-scanner",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.4",
   "description": "OpenClaw Skills security scanner plugin - detect malicious code, data exfiltration, and prompt injection",
   "type": "module",
   "main": "./index.ts",

package/src/commands.ts

@@ -8,7 +8,10 @@ import { runScan } from "./scanner.js";
 import { buildDailyReport } from "./report.js";
 import { loadState, saveState, expandPath } from "./state.js";
 import { generateConfigGuide } from "./config.js";
-import { ensureCronJobViaGateway, checkCronJobStatus } from "./cron-manager.js";
+import {
+  getCronJobStatus,
+  triggerCronJob,
+} from "./cron-manager.js";
 import type { ScannerConfig, CommandResponse, PluginLogger } from "./types.js";
 
 export function createCommandHandlers(
@@ -21,7 +24,7 @@ export function createCommandHandlers(
   preInstallScan: string,
   onUnsafe: string,
   logger: PluginLogger,
-  callGateway: (method: string, params: any) => Promise<any>
+  apiConfig?: any  // 添加 api.config 参数
 ) {
   async function handleScanCommand(args: string): Promise<CommandResponse> {
     if (!args) {
@@ -211,59 +214,56 @@ export function createCommandHandlers(
     const action = args.trim().toLowerCase() || "status";
 
     if (action === "setup" || action === "register") {
-      try {
-        await ensureCronJobViaGateway({
+      return {
+        text: [
+          "✅ *定时任务注册*",
+          "",
+          "定时任务已在插件启动时自动注册。",
+          "",
+          "如需查看状态，请使用：",
+          "```bash",
+          "/skills-scanner cron status",
+          "```",
+          "",
+          "或使用 CLI 命令：",
+          "```bash",
+          "openclaw cron list | grep skills-scanner",
+          "```",
+        ].join("\n"),
+      };
+    } else if (action === "unregister" || action === "remove") {
+      return {
+        text: [
+          "✅ *删除定时任务*",
+          "",
+          "定时任务会在插件卸载时自动清理。",
+          "",
+          "如需手动删除，请使用 CLI 命令：",
+          "",
+          "```bash",
+          "# 1. 查找任务 ID",
+          "openclaw cron list | grep skills-scanner",
+          "",
+          "# 2. 删除任务",
+          "openclaw cron remove skills-scanner:weekly-report",
+          "```",
+        ].join("\n"),
+      };
+    } else if (action === "trigger" || action === "run") {
+      return {
+        text: await triggerCronJob({
           logger,
-          callGateway,
-        });
-        return { text: "✅ 定时任务注册完成\n请查看日志了解详情" };
-      } catch (err: any) {
-        return { text: `⚠️ 定时任务注册失败：${err.message}` };
-      }
-    } else if (action === "unregister") {
-      try {
-        // 列出所有任务
-        const listResult = await callGateway("cron.list", {});
-        const jobs = Array.isArray(listResult?.jobs) ? listResult.jobs : [];
-        const existingJobs = jobs.filter((job: any) => job.name === "skills-weekly-report");
-
-        if (existingJobs.length === 0) {
-          return { text: "ℹ️ 未找到已注册的定时任务" };
-        }
-
-        // 删除所有同名任务
-        const deletedIds: string[] = [];
-        for (const job of existingJobs) {
-          const jobId = job.jobId || job.id;
-          try {
-            await callGateway("cron.remove", { jobId });
-            deletedIds.push(jobId);
-          } catch (err: any) {
-            logger.warn(`删除任务 ${jobId} 失败: ${err.message}`);
-          }
-        }
-
-        if (deletedIds.length > 0) {
-          return {
-            text: `✅ 已删除 ${deletedIds.length} 个定时任务\n${deletedIds.map(id => `- ${id}`).join("\n")}`,
-          };
-        } else {
-          return { text: "⚠️ 删除失败，请查看日志" };
-        }
-      } catch (err: any) {
-        return { text: `⚠️ 删除失败：${err.message}` };
-      }
+          config: apiConfig,
+        }),
+      };
     } else {
       // status
-      try {
-        const statusText = await checkCronJobStatus({
+      return {
+        text: await getCronJobStatus({
           logger,
-          callGateway,
-        });
-        return { text: statusText };
-      } catch (err: any) {
-        return { text: `⚠️ 查询状态失败：${err.message}` };
-      }
+          config: apiConfig,
+        }),
+      };
     }
   }
 

package/src/cron-manager.ts

@@ -1,278 +1,237 @@
 /**
- * Cron job management using Gateway API
+ * Cron job management for skills-scanner
  *
- * This module handles automatic cron job registration via gateway_start hook.
- * It ensures only one cron job exists and cleans up duplicates.
+ * 使用 Plugin SDK 提供的 cron store API 来管理定时任务
  */
 
+import {
+  loadCronStore,
+  resolveCronStorePath,
+  saveCronStore,
+} from "openclaw/plugin-sdk/config-runtime";
 import type { PluginLogger } from "./types.js";
 
+// Cron job configuration
 const CRON_JOB_NAME = "skills-weekly-report";
-const CRON_SCHEDULE = "5 12 * * 1";  // 每周一 12:05
+const CRON_SCHEDULE = "5 12 * * 1"; // 每周一 12:05
 const CRON_TIMEZONE = "Asia/Shanghai";
 
 export interface CronManagerOptions {
   logger: PluginLogger;
-  callGateway: (method: string, params: any) => Promise<any>;
-}
-
-interface CronJob {
-  id: string;
-  jobId?: string;
-  name: string;
-  enabled?: boolean;
+  config?: any;
 }
 
 /**
- * 注册定时任务（通过 Gateway API）
- * - 检查是否已存在同名任务
- * - 如果有多个重复任务，仅保留第一个，删除其余
- * - 如果不存在，创建新任务
+ * 确保 cron 任务已注册（启动时调用）
  */
-export async function ensureCronJobViaGateway(
+export async function ensureCronJob(
   options: CronManagerOptions
 ): Promise<void> {
-  const { logger, callGateway } = options;
+  const { logger, config } = options;
 
   try {
-    logger.info("[定时任务] 🔍 检查现有定时任务...");
-
-    // 1. 列出所有任务
-    logger.debug("[定时任务] 调用 cron.list API...");
-    const listResult = await callGateway("cron.list", {});
-
-    logger.debug("[定时任务] API 响应", {
-      hasResult: !!listResult,
-      resultType: typeof listResult,
-      hasJobs: !!listResult?.jobs,
-      jobsType: typeof listResult?.jobs,
-      rawResult: listResult,
-    });
-
-    const jobs: CronJob[] = Array.isArray(listResult?.jobs) ? listResult.jobs : [];
-
-    logger.debug("[定时任务] 查询结果", {
-      totalJobs: jobs.length,
-      targetName: CRON_JOB_NAME,
-    });
-
-    // 2. 查找所有同名任务
-    const existingJobs = jobs.filter(
-      (job) => job.name === CRON_JOB_NAME
-    );
-
-    if (existingJobs.length === 0) {
-      // 不存在，创建新任务
-      logger.info("[定时任务] 📝 未找到现有任务，正在创建...");
-      await createCronJob(options);
-      return;
-    }
-
-    // 3. 如果存在多个重复任务，仅保留第一个
-    if (existingJobs.length > 1) {
-      logger.warn("[定时任务] ⚠️  检测到重复任务，正在清理...", {
-        duplicateCount: existingJobs.length,
-        jobs: existingJobs.map(j => ({
-          jobId: j.jobId,
-          id: j.id,
-          name: j.name,
-          enabled: j.enabled,
-        })),
-      });
-
-      const keepJob = existingJobs[0];
-      const duplicates = existingJobs.slice(1);
-
-      logger.info("[定时任务] 📌 保留第一个任务", {
-        jobId: keepJob.jobId,
-        id: keepJob.id,
-      });
-
-      // 删除重复任务
-      let successCount = 0;
-      let failCount = 0;
-
-      for (const job of duplicates) {
-        const jobId = job.jobId || job.id;
-        logger.debug("[定时任务] 尝试删除重复任务", {
-          jobId,
-          hasJobId: !!job.jobId,
-          hasId: !!job.id,
-        });
-
-        try {
-          const removeResult = await callGateway("cron.remove", { jobId });
-          logger.info("[定时任务] 🗑️  已删除重复任务", {
-            jobId,
-            removeResult,
-          });
-          successCount++;
-        } catch (err: any) {
-          logger.error("[定时任务] ❌ 删除任务失败", {
-            jobId,
-            errorMessage: err?.message || String(err),
-            errorCode: err?.code,
-            errorStack: err?.stack,
-            fullError: err,
-          });
-          failCount++;
-        }
-      }
-
-      logger.info("[定时任务] 清理完成", {
-        total: duplicates.length,
-        success: successCount,
-        failed: failCount,
-      });
-    } else {
-      // 只有一个任务，检查状态
-      const job = existingJobs[0];
-      const jobId = job.jobId || job.id;
-      logger.info("[定时任务] ✅ 检测到已存在的定时任务", {
-        jobId,
-        enabled: job.enabled !== false,
-      });
-
-      // 如果任务被禁用，提示用户
-      if (job.enabled === false) {
-        logger.warn("[定时任务] ⚠️  任务已禁用", {
-          jobId,
-          hint: `openclaw cron edit ${jobId} --enabled`,
-        });
+    const storePath = resolveCronStorePath(config?.cron?.store);
+    const store = await loadCronStore(storePath);
+
+    // 只通过名称检查是否存在任务（ID 是系统自动生成的 UUID）
+    const existingJob = store.jobs.find((j) => j.name === CRON_JOB_NAME);
+
+    if (existingJob) {
+      // 任务已存在，检查是否需要更新配置
+      const needsUpdate =
+        existingJob.schedule.kind !== "cron" ||
+        (existingJob.schedule as any).expr !== CRON_SCHEDULE ||
+        (existingJob.schedule as any).tz !== CRON_TIMEZONE;
+
+      if (needsUpdate) {
+        logger.info("[Cron] 检测到任务配置变更，正在更新...");
+        existingJob.schedule = {
+          kind: "cron",
+          expr: CRON_SCHEDULE,
+          tz: CRON_TIMEZONE,
+        };
+        existingJob.updatedAtMs = Date.now();
+        await saveCronStore(storePath, store);
+        logger.info("[Cron] ✅ 任务配置已更新");
+      } else {
+        logger.info(`[Cron] ✅ 任务已存在: ${CRON_JOB_NAME}`);
       }
+      return;
     }
 
-    logger.info("[定时任务] ⏭️  跳过注册");
-  } catch (err: any) {
-    logger.error("[定时任务] ❌ 检查任务失败", {
-      errorMessage: err?.message || String(err),
-      errorName: err?.name,
-      errorCode: err?.code,
-      errorStack: err?.stack,
-      errorType: typeof err,
-      fullError: err,
-    });
-    logger.info("[定时任务] 💡 请手动注册定时任务: /skills-scanner cron setup");
-  }
-}
-
-/**
- * 创建新的定时任务
- */
-async function createCronJob(options: CronManagerOptions): Promise<void> {
-  const { logger, callGateway } = options;
-
-  try {
-    const jobParams = {
+    // 创建新任务（不设置 id，让系统自动生成）
+    const newJob = {
       name: CRON_JOB_NAME,
+      enabled: true,
       schedule: {
-        kind: "cron",
+        kind: "cron" as const,
         expr: CRON_SCHEDULE,
         tz: CRON_TIMEZONE,
       },
-      sessionTarget: "isolated",
+      sessionTarget: "isolated" as const,
       payload: {
-        kind: "agentTurn",
-        message: "/skills-scanner scan --report",
+        kind: "agentTurn" as const,
+        message: "生成 Skills 安全周报。请扫描所有已配置的 Skills 目录，汇总本周的安全发现，并生成详细报告。",
+        timeoutSeconds: 600, // 10 分钟超时
       },
       delivery: {
-        mode: "announce",
-        channel: "last",
+        mode: "announce" as const,
+        channel: "last" as const,
       },
-      enabled: true,
+      failureAlert: {
+        after: 2,
+        channel: "last" as const,
+        mode: "announce" as const,
+      },
+      createdAtMs: Date.now(),
+      state: {},
     };
 
-    logger.debug("[定时任务] 创建参数", { jobParams });
-    logger.debug("[定时任务] 调用 cron.add API...");
+    store.jobs.push(newJob as any);
+    await saveCronStore(storePath, store);
 
-    const result = await callGateway("cron.add", jobParams);
+    logger.info(`[Cron] ✅ 定时任务已注册: ${CRON_JOB_NAME}`);
+    logger.info(`[Cron]    调度: ${CRON_SCHEDULE} (${CRON_TIMEZONE})`);
+  } catch (err: any) {
+    logger.error(`[Cron] ❌ 注册定时任务失败: ${err.message}`);
+    throw err;
+  }
+}
 
-    logger.debug("[定时任务] API 响应", {
-      hasResult: !!result,
-      resultType: typeof result,
-      hasJobId: !!result?.jobId,
-      hasId: !!result?.id,
-      rawResult: result,
-    });
+/**
+ * 清理 cron 任务（卸载时调用）
+ */
+export async function cleanupCronJob(
+  options: CronManagerOptions
+): Promise<void> {
+  const { logger, config } = options;
+
+  try {
+    const storePath = resolveCronStorePath(config?.cron?.store);
+    const store = await loadCronStore(storePath);
+
+    const before = store.jobs.length;
 
-    const jobId = result?.jobId || result?.id;
+    // 只删除名称为 skills-weekly-report 的任务
+    store.jobs = store.jobs.filter((j) => j.name !== CRON_JOB_NAME);
 
-    if (jobId) {
-      logger.info("[定时任务] ✅ 定时任务创建成功", {
-        jobId,
-        schedule: `${CRON_SCHEDULE} (${CRON_TIMEZONE})`,
-        description: "每周一 12:05",
-      });
+    const removed = before - store.jobs.length;
+
+    if (removed > 0) {
+      await saveCronStore(storePath, store);
+      logger.info(`[Cron] ✅ 已清理 ${removed} 个定时任务`);
     } else {
-      logger.warn("[定时任务] ⚠️  任务创建成功，但未返回任务 ID", {
-        result,
-      });
+      logger.info("[Cron] 没有需要清理的定时任务");
     }
   } catch (err: any) {
-    logger.error("[定时任务] ❌ 创建任务失败", {
-      errorMessage: err?.message || String(err),
-      errorName: err?.name,
-      errorCode: err?.code,
-      errorStack: err?.stack,
-      fullError: err,
-    });
+    logger.error(`[Cron] ❌ 清理定时任务失败: ${err.message}`);
     throw err;
   }
 }
 
 /**
- * 检查定时任务状态（用于命令行）
+ * 获取 cron 任务状态
  */
-export async function checkCronJobStatus(
+export async function getCronJobStatus(
   options: CronManagerOptions
 ): Promise<string> {
-  const { logger, callGateway } = options;
+  const { logger, config } = options;
 
   try {
-    logger.debug("[定时任务] 查询状态...");
-    const listResult = await callGateway("cron.list", {});
-    const jobs: CronJob[] = Array.isArray(listResult?.jobs) ? listResult.jobs : [];
-
-    logger.debug("[定时任务] 状态查询结果", {
-      totalJobs: jobs.length,
-      targetName: CRON_JOB_NAME,
-    });
+    const storePath = resolveCronStorePath(config?.cron?.store);
+    const store = await loadCronStore(storePath);
 
-    const existingJobs = jobs.filter((job) => job.name === CRON_JOB_NAME);
+    const job = store.jobs.find((j) => j.name === CRON_JOB_NAME);
 
-    if (existingJobs.length === 0) {
+    if (!job) {
       return [
-        "✅ *定时任务状态*",
-        "状态：❌ 未注册",
+        "❌ *定时任务状态*",
+        "",
+        "任务未注册。",
         "",
-        "ℹ️ 使用 `/skills-scanner cron setup` 注册",
+        "请重启插件或手动注册:",
+        "```bash",
+        "/skills-scanner cron setup",
+        "```",
       ].join("\n");
     }
 
-    const lines = ["✅ *定时任务状态*"];
+    const nextRun = job.state?.nextRunAtMs
+      ? new Date(job.state.nextRunAtMs).toLocaleString("zh-CN", {
+          timeZone: CRON_TIMEZONE,
+        })
+      : "未知";
+
+    const lastRun = job.state?.lastRunAtMs
+      ? new Date(job.state.lastRunAtMs).toLocaleString("zh-CN", {
+          timeZone: CRON_TIMEZONE,
+        })
+      : "从未运行";
+
+    const lastStatus = job.state?.lastRunStatus || "未知";
+
+    return [
+      "✅ *定时任务状态*",
+      "",
+      `• **任务 ID**: \`${(job as any).id}\``,
+      `• **任务名称**: ${job.name}`,
+      `• **状态**: ${job.enabled ? "✅ 已启用" : "❌ 已禁用"}`,
+      `• **调度**: \`${CRON_SCHEDULE}\` (${CRON_TIMEZONE})`,
+      `• **下次运行**: ${nextRun}`,
+      `• **上次运行**: ${lastRun}`,
+      `• **上次状态**: ${lastStatus}`,
+      "",
+      "管理命令:",
+      "```bash",
+      `openclaw cron list | grep ${CRON_JOB_NAME}`,
+      `openclaw cron run ${(job as any).id}`,
+      `openclaw cron update ${(job as any).id} --enabled false`,
+      "```",
+    ].join("\n");
+  } catch (err: any) {
+    logger.error(`[Cron] ❌ 获取任务状态失败: ${err.message}`);
+    return `❌ 获取任务状态失败: ${err.message}`;
+  }
+}
 
-    if (existingJobs.length > 1) {
-      lines.push(`⚠️ 检测到 ${existingJobs.length} 个重复任务`);
-      lines.push("建议重启 Gateway 以自动清理重复任务");
-      lines.push("");
-    }
+/**
+ * 手动触发任务（用于测试）
+ */
+export async function triggerCronJob(
+  options: CronManagerOptions
+): Promise<string> {
+  const { logger, config } = options;
 
-    for (const job of existingJobs) {
-      const jobId = job.jobId || job.id;
-      const status = job.enabled === false ? "❌ 已禁用" : "✅ 已启用";
-      lines.push(`任务 ID: ${jobId}`);
-      lines.push(`状态: ${status}`);
-      lines.push(`执行时间：每周一 12:05 (${CRON_TIMEZONE})`);
+  try {
+    const storePath = resolveCronStorePath(config?.cron?.store);
+    const store = await loadCronStore(storePath);
+
+    const job = store.jobs.find((j) => j.name === CRON_JOB_NAME);
+
+    if (!job) {
+      return [
+        "❌ *手动触发任务*",
+        "",
+        "任务未找到，请先注册任务。",
+      ].join("\n");
     }
 
-    return lines.join("\n");
+    return [
+      "💡 *手动触发任务*",
+      "",
+      "请使用 CLI 命令手动触发:",
+      "```bash",
+      `openclaw cron run ${(job as any).id} --force`,
+      "```",
+      "",
+      "或者直接运行报告生成:",
+      "```bash",
+      "/skills-scanner scan --report",
+      "```",
+    ].join("\n");
   } catch (err: any) {
-    const errorMsg = err?.message || String(err);
-    logger.error("[定时任务] ❌ 查询状态失败", {
-      errorMessage: errorMsg,
-      errorCode: err?.code,
-      errorStack: err?.stack,
-    });
-    return `❌ 查询失败: ${errorMsg}`;
+    logger.error(`[Cron] ❌ 获取任务信息失败: ${err.message}`);
+    return `❌ 获取任务信息失败: ${err.message}`;
   }
 }
+