@workclaw/openclaw-workclaw 1.0.202 → 1.0.332

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/api/index.js

@@ -0,0 +1,186 @@
+import { resolveWorkclawAccountWithCache } from "../../../accounts.js";
+import { normalizeBaseUrl, getWorkclawAccessToken, doFetchJson } from "../../../connection/workclaw-client.js";
+import logger from "../../../logging.js";
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_RETRY_DELAY_MS = 1e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchWithRetry(fetchFn, options = {}) {
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+  const retryableErrors = options.retryableErrors ?? [
+    "ECONNREFUSED",
+    "ETIMEDOUT",
+    "ENOTFOUND",
+    "ENETUNREACH",
+    "EAI_AGAIN"
+  ];
+  let lastError = "";
+  let attempts = 0;
+  for (let i = 0; i <= maxRetries; i++) {
+    attempts = i + 1;
+    try {
+      const data = await fetchFn();
+      return { data, attempts };
+    } catch (error) {
+      lastError = error.message || String(error);
+      const isRetryable = retryableErrors.some(
+        (e) => lastError.toLowerCase().includes(e.toLowerCase())
+      );
+      if (i < maxRetries && isRetryable) {
+        const delay = retryDelayMs * 2 ** i;
+        await sleep(delay);
+        continue;
+      }
+      break;
+    }
+  }
+  return { error: lastError, attempts };
+}
+function sanitizePayload(payload) {
+  const sensitiveFields = [
+    "password",
+    "secret",
+    "token",
+    "authorization",
+    "appSecret",
+    "appSecret"
+  ];
+  const sanitized = {};
+  for (const [key, value] of Object.entries(payload)) {
+    const lowerKey = key.toLowerCase();
+    if (sensitiveFields.some((f) => lowerKey.includes(f))) {
+      sanitized[key] = "***";
+    } else if (typeof value === "object" && value !== null) {
+      sanitized[key] = sanitizePayload(value);
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+async function callBackendApi(api, accountId, path, payload, options = {}) {
+  try {
+    const account = resolveWorkclawAccountWithCache({
+      cfg: api.config,
+      accountId
+    });
+    if (!account.configured) {
+      logger.error(`[智小途-定时任务] 账户未配置 accountId=${accountId}`);
+      return { success: false, error: "Account not configured" };
+    }
+    const accConfig = account.config;
+    const tokenCacheKey = accConfig.appKey || accountId;
+    const baseUrl = normalizeBaseUrl(accConfig.baseUrl);
+    logger.info(`[智小途-定时任务] 正在获取认证 token，accountId=${accountId}`);
+    const token = await getWorkclawAccessToken(tokenCacheKey, {
+      baseUrl: accConfig.baseUrl,
+      appKey: accConfig.appKey,
+      appSecret: accConfig.appSecret,
+      allowInsecureTls: accConfig.allowInsecureTls,
+      requestTimeout: accConfig.requestTimeout
+    });
+    const requestUrl = `${baseUrl}/open-apis${path}`;
+    const sanitizedPayload = sanitizePayload(payload);
+    logger.info(`[智小途-定时任务] 调用接口 ${requestUrl}`);
+    logger.info(`[智小途-定时任务] 请求参数 ${JSON.stringify(sanitizedPayload)}`);
+    const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const fetchResult = await fetchWithRetry(
+      () => doFetchJson(
+        requestUrl,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${token}`
+          },
+          body: JSON.stringify(payload)
+        },
+        accConfig.allowInsecureTls,
+        accConfig.requestTimeout
+      ),
+      { maxRetries }
+    );
+    if (fetchResult.error) {
+      logger.error(`[智小途-定时任务] 接口调用失败（已重试 ${fetchResult.attempts} 次）: ${fetchResult.error}`);
+      return { success: false, error: fetchResult.error, attempts: fetchResult.attempts };
+    }
+    const data = fetchResult.data;
+    logger.info(`[智小途-定时任务] 接口响应（尝试 ${fetchResult.attempts} 次）: ${JSON.stringify(data)}`);
+    if (data?.code === 200 || data?.code === 0) {
+      return { success: true, data, attempts: fetchResult.attempts };
+    } else {
+      const errorMsg = data?.message || data?.msg || "Unknown error";
+      logger.error(`[智小途-定时任务] 接口返回错误 ${errorMsg}`);
+      return { success: false, error: errorMsg };
+    }
+  } catch (error) {
+    logger.error(`[智小途-定时任务] 接口调用异常 ${error.message}`);
+    return { success: false, error: error.message };
+  }
+}
+async function callCronJobAdd(api, accountId, payload) {
+  logger.info(`[智小途-定时任务] 新增定时任务 jobId=${payload.jobId} name=${payload.name}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/add", {
+    clawJobId: payload.jobId,
+    name: payload.name,
+    kind: payload.kind,
+    expr: payload.expr || "",
+    message: payload.message,
+    agentId: payload.messageId || "0",
+    taskId: payload.taskId
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+async function callCronJobRemove(api, accountId, payload) {
+  logger.info(`[智小途-定时任务] 删除定时任务 jobId=${payload.jobId}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/del", {
+    clawJobId: payload.jobId
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+async function callCronJobUpdate(api, accountId, payload) {
+  logger.info(`[智小途-定时任务] 更新定时任务 jobId=${payload.jobId} name=${payload.name} agentId=${payload.agentId}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/update", {
+    clawJobId: payload.jobId,
+    name: payload.name,
+    kind: payload.kind,
+    expr: payload.expr || "",
+    message: payload.message,
+    agentId: payload.agentId || "0"
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+async function callCronJobEnabled(api, accountId, payload) {
+  logger.info(`[智小途-定时任务] 启用定时任务 jobId=${payload.jobId}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/enabled", {
+    clawJobId: payload.jobId
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+async function callCronJobDisabled(api, accountId, payload) {
+  logger.info(`[智小途-定时任务] 禁用定时任务 jobId=${payload.jobId}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/disabled", {
+    clawJobId: payload.jobId
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+async function callCronJobMessage(api, accountId, payload) {
+  logger.info(`[智小途-定时任务] 定时任务触发通知 jobId=${payload.jobId} message=${payload.message} agentId=${payload.agentId}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/message", {
+    clawJobId: payload.jobId,
+    message: payload.message,
+    agentId: payload.agentId || "0"
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+export {
+  callBackendApi,
+  callCronJobAdd,
+  callCronJobDisabled,
+  callCronJobEnabled,
+  callCronJobMessage,
+  callCronJobRemove,
+  callCronJobUpdate
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/index.js

@@ -0,0 +1,30 @@
+import logger from "../../logging.js";
+import { registerOpenclawWorkclawCronAddParamsTool } from "./src/add/params.js";
+import { registerOpenclawWorkclawCronAddSyncTool } from "./src/add/sync.js";
+import { registerOpenclawWorkclawCronDisableParamsTool } from "./src/disable/params.js";
+import { registerOpenclawWorkclawCronDisableSyncTool } from "./src/disable/sync.js";
+import { registerOpenclawWorkclawCronEnableParamsTool } from "./src/enable/params.js";
+import { registerOpenclawWorkclawCronEnableSyncTool } from "./src/enable/sync.js";
+import { registerOpenclawWorkclawCronNotifySyncTool } from "./src/notify/sync.js";
+import { registerOpenclawWorkclawCronRemoveParamsTool } from "./src/remove/params.js";
+import { registerOpenclawWorkclawCronRemoveSyncTool } from "./src/remove/sync.js";
+import { registerOpenclawWorkclawCronUpdateParamsTool } from "./src/update/params.js";
+import { registerOpenclawWorkclawCronUpdateSyncTool } from "./src/update/sync.js";
+function registerAllOpenclawWorkclawCronTools(api) {
+  logger.info("[智小途-定时任务] 正在注册定时任务工具");
+  registerOpenclawWorkclawCronAddParamsTool(api);
+  registerOpenclawWorkclawCronRemoveParamsTool(api);
+  registerOpenclawWorkclawCronUpdateParamsTool(api);
+  registerOpenclawWorkclawCronEnableParamsTool(api);
+  registerOpenclawWorkclawCronDisableParamsTool(api);
+  registerOpenclawWorkclawCronAddSyncTool(api);
+  registerOpenclawWorkclawCronRemoveSyncTool(api);
+  registerOpenclawWorkclawCronUpdateSyncTool(api);
+  registerOpenclawWorkclawCronEnableSyncTool(api);
+  registerOpenclawWorkclawCronDisableSyncTool(api);
+  registerOpenclawWorkclawCronNotifySyncTool(api);
+  logger.info("[智小途-定时任务] 定时任务工具注册完成");
+}
+export {
+  registerAllOpenclawWorkclawCronTools
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/src/add/params.js

@@ -0,0 +1,147 @@
+import { validateTimeFormat, isCronExpression, relativeToCron } from "../../utils/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+import logger from "../../../../logging.js";
+const AddParamsSchema = {
+  type: "object",
+  properties: {
+    time: {
+      type: "string",
+      description: "⏰ 时间（核心！），支持相对时间和 cron 表达式，工具自动转换"
+    },
+    name: {
+      type: "string",
+      description: "任务名称"
+    },
+    message: {
+      type: "string",
+      description: "提醒内容"
+    },
+    taskId: {
+      type: "string",
+      description: "⚠️ 【关键！】taskId 必须从 WebSocket 消息的 taskId 字段获取， 如果data.taskId没有值，就不传taskId，禁止自行生成！taskId 格式为纯数字字符串（如 12919375446074181），不是时间戳！"
+    }
+  },
+  required: ["time", "name", "message"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronAddParamsTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-add-params",
+    label: "智小途生成创建提醒参数",
+    description: `【智小途提醒创建第一步】生成创建提醒的 cronParams 参数。
+
+📋 工作流程（必须按顺序执行）：
+1. 调用此工具获取 cronParams 参数
+2. 使用返回的 cronParams 调用 OpenClaw 的 cron 工具
+3. 从 cron 工具返回值中提取 jobId（返回格式：{"success": true, "jobId": "xxx"}）
+4. 必须调用 openclaw-workclaw-cron-add-sync 同步到后端
+
+🚫 禁止事项：
+- 禁止跳过本工具后直接手写 CLI 命令
+- 禁止自行拼接 cron 参数
+- 禁止在没有调用 openclaw-workclaw-cron-add-sync 的情况下宣布创建成功
+
+⏰ 时间格式（核心！）：
+- time 参数支持相对时间（如 "5m"、"1h"、"2d"）和 cron 表达式
+- 工具会自动将所有时间统一转换为 cron 表达式
+- 严禁使用 --at 参数或其他绝对时间格式
+- 下一步调用 OpenClaw cron 时必须使用本工具返回的 cron 表达式
+
+🔒 强制规则：
+- schedule.kind 必须是 "cron"
+- 必须沿用本工具返回的 cronParams 结果
+
+⚠️ taskId 来源（必须严格遵守！）：
+- taskId 必须从 WebSocket 消息的 data.taskId 字段获取， 如果data.taskId没有值，就不传taskId
+- taskId 格式为纯数字字符串（如 12919375446074181）
+- ❌ 禁止自行生成 taskId！禁止使用时间戳作为 taskId！
+- ❌ 禁止使用 messageId 或其他字段作为 taskId！
+
+⚠️ 必须从 cron 工具返回值中提取 jobId，不能凭空编造！`,
+    parameters: AddParamsSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`[智小途-生成参数] 开始生成创建提醒参数11111 ctx.config = ${JSON.stringify(ctx.config)}`);
+      if (!p.time) {
+        logger.warn("[智小途-生成参数] 缺少时间参数");
+        return json({ error: "time（时间）为必填参数" });
+      }
+      if (!p.name) {
+        logger.warn("[智小途-生成参数] 缺少任务名称参数");
+        return json({ error: "name（任务名称）为必填参数" });
+      }
+      if (!p.message) {
+        logger.warn("[智小途-生成参数] 缺少用户消息参数");
+        return json({ error: "message（用户消息）为必填参数" });
+      }
+      const taskId = String(ctx?.taskId || p.taskId || "").trim();
+      logger.info(`[智小途-生成参数] 开始生成创建提醒参数 name=${p.name} time=${p.time}, rawTaskId=${p.taskId}, ctxTaskId=${ctx?.taskId}, resolvedTaskId=${taskId}`);
+      const accountId = ctx?.agentAccountId || "default";
+      logger.info(`[智小途-生成参数] accountId=${accountId} name=${p.name}`);
+      const timeValidation = validateTimeFormat(p.time);
+      if (!timeValidation.valid) {
+        logger.warn(`[智小途-生成参数] 时间格式校验失败: ${timeValidation.error}`);
+        return json({ error: timeValidation.error });
+      }
+      const isCron = isCronExpression(p.time);
+      let isOneTime = false;
+      let cronExpr;
+      if (!isCron) {
+        isOneTime = true;
+        cronExpr = relativeToCron(p.time.trim());
+        logger.info(`[智小途-生成参数] 相对时间转换为 cron 表达式 cronExpr=${cronExpr}`);
+      } else {
+        cronExpr = p.time.trim();
+      }
+      const cronParams = {
+        action: "add",
+        account: accountId,
+        job: {
+          name: p.name,
+          schedule: {
+            kind: "cron",
+            expr: cronExpr,
+            tz: "Asia/Shanghai"
+          },
+          sessionTarget: "current",
+          wakeMode: "now",
+          deleteAfterRun: isOneTime ? true : void 0,
+          payload: {
+            kind: "agentTurn",
+            message: p.message
+          },
+          delivery: {
+            mode: "announce",
+            channel: "openclaw-workclaw"
+          }
+        }
+      };
+      logger.info(`[智小途-生成参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+      logger.info(`[智小途-生成参数] 标准化后的参数 ${JSON.stringify({
+        ...p,
+        taskId
+      })}`);
+      return json({
+        cronParams,
+        meta: {
+          accountId,
+          taskId,
+          name: p.name,
+          kind: "cron",
+          expr: cronExpr,
+          message: p.message
+        },
+        summary: `⏰ 提醒已生成: "${p.name}" (${p.time})`
+      });
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronAddParamsTool
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/src/add/sync.js

@@ -0,0 +1,154 @@
+import { resolveWorkclawAccountWithCache } from "../../../../accounts.js";
+import { callCronJobAdd } from "../../api/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+import logger from "../../../../logging.js";
+const AddSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `⛔ 重要：jobId 必须从 OpenClaw cron 工具返回值中提取，格式：{"success": true, "jobId": "123456"}
+
+常见错误：
+- 把 cron 表达式（如 "31 12 11 31 3 *"）当作 jobId
+- 把 name 当作 jobId
+- 编造 jobId
+
+正确做法：
+1. 调用 openclaw-workclaw-cron-add-params
+2. 用返回的 cronParams 调用 cron 工具
+3. 从返回值提取 jobId（如 "7382945612345"）
+4. 用提取到的 jobId 调用此工具`
+    },
+    name: {
+      type: "string",
+      description: "任务名称，与 add-params 中传入的 name 一致"
+    },
+    kind: {
+      type: "string",
+      description: "任务类型",
+      enum: ["cron"]
+    },
+    expr: {
+      type: "string",
+      description: "Cron 表达式"
+    },
+    message: {
+      type: "string",
+      description: "提醒消息，与 add-params 中传入的 message 一致"
+    },
+    taskId: {
+      type: "string",
+      description: "⚠️ 【关键！】taskId 必须从 WebSocket 消息的 data.taskId 字段获取， 如果data.taskId没有值，就不传taskId，禁止自行生成！taskId 格式为纯数字字符串（如 12919375446074181），不是时间戳！"
+    }
+  },
+  required: ["jobId", "name", "kind", "message"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronAddSyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-add-sync",
+    label: "智小途同步创建提醒",
+    description: `【后端同步步骤】将创建定时任务同步到后端。必须在上一步 openclaw-workclaw-cron-add-params 执行后调用此工具完成同步。
+
+⚠️ jobId 必须是 cron 工具返回值 {"success": true, "jobId": "xxx"} 中的 jobId 字段！
+⚠️ taskId 必须沿用 add-params / 业务上下文里的 taskId，如果有值不能省略！ 如果data.taskId没有值，就不传taskId`,
+    parameters: AddSyncSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`[智小途-同步创建] 开始同步 jobId=${p.jobId} name=${p.name}`);
+      if (!p.jobId) {
+        logger.warn("[智小途-同步创建] 缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      const jobIdTrimmed = p.jobId.trim();
+      const parts = jobIdTrimmed.split(/\s+/);
+      const isCronExpression = parts.length >= 5 && parts.length <= 6 && jobIdTrimmed.includes("*");
+      if (isCronExpression) {
+        logger.error(`[智小途-同步创建] jobId 格式错误！jobId=${p.jobId}，看起来像 cron 表达式`);
+        return json({
+          error: `jobId="${p.jobId}" 是 cron 表达式，不是任务 ID！jobId 应来自 cron 工具返回值，如 "123456" 或 "abc123"`
+        });
+      }
+      if (!p.name) {
+        logger.warn("[智小途-同步创建] 缺少 name 参数");
+        return json({ error: "name 为必填参数" });
+      }
+      if (!p.message) {
+        logger.warn("[智小途-同步创建] 缺少 message 参数");
+        return json({ error: "message 为必填参数" });
+      }
+      const taskId = String(ctx?.taskId || p.taskId || "").trim();
+      logger.info(`[智小途-同步创建] 开始同步创建 name=${p.name}`);
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        logger.warn("[智小途-同步创建] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      if (accountConfig.configured) {
+        try {
+          const channelAgentId = String(accountConfig.config.agentId);
+          const channelUserId = String(accountConfig.config.userId ?? "");
+          logger.info(`[智小途-同步通知] ctx=${JSON.stringify(ctx)} p=${JSON.stringify(p)}`);
+          logger.info(`[智小途-同步创建] accountId=${accountId} channelAgentId=${channelAgentId}`);
+          const result = await callCronJobAdd(api, accountId, {
+            jobId: p.jobId,
+            name: p.name,
+            kind: p.kind,
+            expr: p.expr,
+            message: p.message,
+            messageId: channelAgentId,
+            taskId
+          });
+          if (result.success) {
+            logger.info(`[智小途-同步创建] 后端同步成功 jobId=${p.jobId}`);
+            return json({
+              code: 0,
+              message: "定时任务已创建并同步到后端",
+              data: {
+                jobId: p.jobId,
+                name: p.name,
+                message: p.message,
+                backendSynced: true
+              }
+            });
+          } else {
+            logger.error(`[智小途-同步创建] 后端同步失败 ${result.error}`);
+            return json({
+              code: -1,
+              error: result.error || "后端同步失败",
+              data: { jobId: p.jobId, name: p.name }
+            });
+          }
+        } catch (error) {
+          logger.error(`[智小途-同步创建] 后端同步异常 ${error.message}`);
+          return json({
+            code: -1,
+            error: error.message || "后端同步异常",
+            data: { jobId: p.jobId, name: p.name }
+          });
+        }
+      } else {
+        logger.error(`[智小途-同步创建] 账户未配置 accountId=${accountId}`);
+        return json({
+          code: -1,
+          error: "账户未配置",
+          data: { jobId: p.jobId, name: p.name }
+        });
+      }
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronAddSyncTool
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/src/disable/params.js

@@ -0,0 +1,62 @@
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+import logger from "../../../../logging.js";
+const DisableParamsSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronDisableParamsTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-disable-params",
+    label: "智小途生成禁用提醒参数",
+    description: `生成禁用提醒的 CLI 命令参数。
+
+📋 工作流程：
+1. 调用此工具获取 CLI 命令参数
+2. 使用返回的 cronParams 调用 OpenClaw 的 cron 工具
+3. 调用 openclaw-workclaw-cron-disable-sync 同步到后端`,
+    parameters: DisableParamsSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`[智小途-生成禁用参数] 开始处理 jobId=${p.jobId}`);
+      if (!p.jobId) {
+        logger.warn("[智小途-生成禁用参数] 缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        logger.warn("[智小途-生成禁用参数] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      logger.info(`[智小途-生成禁用参数] accountId=${accountId} jobId=${p.jobId}`);
+      const cronParams = {
+        action: "disable",
+        jobId: p.jobId
+      };
+      logger.info(`[智小途-生成禁用参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+      return json({
+        cronParams,
+        meta: {
+          accountId,
+          jobId: p.jobId
+        },
+        summary: `⏸️ 提醒已禁用: jobId=${p.jobId}`
+      });
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronDisableParamsTool
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/src/disable/sync.js

@@ -0,0 +1,86 @@
+import { resolveWorkclawAccountWithCache } from "../../../../accounts.js";
+import { callCronJobDisabled } from "../../api/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+import logger from "../../../../logging.js";
+const DisableSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronDisableSyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-disable-sync",
+    label: "智小途同步禁用提醒",
+    description: "将禁用定时任务同步到后端。在 cron 工具禁用任务后调用此工具同步后端。",
+    parameters: DisableSyncSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`[智小途-同步禁用] 开始同步 jobId=${p.jobId}`);
+      if (!p.jobId) {
+        logger.warn("[智小途-同步禁用] 缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        logger.warn("[智小途-同步禁用] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      if (accountConfig.configured) {
+        try {
+          const channelAgentId = String(accountConfig.config.agentId);
+          logger.info(`[智小途-同步禁用] accountId=${accountId} channelAgentId=${channelAgentId}`);
+          const result = await callCronJobDisabled(api, accountId, {
+            jobId: p.jobId
+          });
+          if (result.success) {
+            logger.info(`[智小途-同步禁用] 后端同步成功 jobId=${p.jobId}`);
+            return json({
+              code: 0,
+              message: "定时任务已禁用并同步到后端",
+              data: {
+                jobId: p.jobId,
+                backendSynced: true
+              }
+            });
+          } else {
+            logger.error(`[智小途-同步禁用] 后端同步失败 ${result.error}`);
+            return json({
+              code: -1,
+              error: result.error || "后端同步失败",
+              data: { jobId: p.jobId }
+            });
+          }
+        } catch (error) {
+          logger.error(`[智小途-同步禁用] 后端同步异常 ${error.message}`);
+          return json({
+            code: -1,
+            error: error.message,
+            data: { jobId: p.jobId }
+          });
+        }
+      } else {
+        logger.error(`[智小途-同步禁用] 无法获取渠道配置，accountId=${accountId}`);
+        return json({ error: "无法获取渠道配置，请检查账户配置" });
+      }
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronDisableSyncTool
+};