@workclaw/openclaw-workclaw 1.0.202 → 1.0.331

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

@@ -0,0 +1,62 @@
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+import logger from "../../../../logging.js";
+const EnableParamsSchema = {
+  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 registerOpenclawWorkclawCronEnableParamsTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-enable-params",
+    label: "智小途生成启用提醒参数",
+    description: `生成启用提醒的 CLI 命令参数。
+
+📋 工作流程：
+1. 调用此工具获取 CLI 命令参数
+2. 使用返回的 cronParams 调用 OpenClaw 的 cron 工具
+3. 调用 openclaw-workclaw-cron-enable-sync 同步到后端`,
+    parameters: EnableParamsSchema,
+    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: "enable",
+        jobId: p.jobId
+      };
+      logger.info(`[智小途-生成启用参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+      return json({
+        cronParams,
+        meta: {
+          accountId,
+          jobId: p.jobId
+        },
+        summary: `✅ 提醒已启用: jobId=${p.jobId}`
+      });
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronEnableParamsTool
+};

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

@@ -0,0 +1,86 @@
+import { resolveWorkclawAccountWithCache } from "../../../../accounts.js";
+import { callCronJobEnabled } from "../../api/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+import logger from "../../../../logging.js";
+const EnableSyncSchema = {
+  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 registerOpenclawWorkclawCronEnableSyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-enable-sync",
+    label: "智小途同步启用提醒",
+    description: "将启用定时任务同步到后端。在 cron 工具启用任务后调用此工具同步后端。",
+    parameters: EnableSyncSchema,
+    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 callCronJobEnabled(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 {
+  registerOpenclawWorkclawCronEnableSyncTool
+};

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

@@ -0,0 +1,103 @@
+import { resolveWorkclawAccountWithCache } from "../../../../accounts.js";
+import { callCronJobMessage } from "../../api/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+import logger from "../../../../logging.js";
+const NotifySchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: "OpenClaw 任务 ID（从上下文获取）"
+    },
+    message: {
+      type: "string",
+      description: "要发送的提醒内容"
+    }
+  },
+  required: ["jobId", "message"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronNotifySyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-notify-sync",
+    label: "智小途定时任务触发通知",
+    description: `【系统最高优先级核心指令】当定时器时间到达时，必须立即调用此工具通知后端。`,
+    parameters: NotifySchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`[智小途-定时触发] 开始处理 jobId=${p.jobId} message=${p.message}`);
+      if (!p.jobId) {
+        logger.warn("[智小途-定时触发] 缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      if (!p.message) {
+        logger.warn("[智小途-定时触发] 缺少 message 参数");
+        return json({ error: "message 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        logger.warn("[智小途-定时触发] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      if (accountConfig.configured) {
+        const channelAgentId = String(accountConfig.config.agentId);
+        logger.info(`[智小途-定时触发] accountId=${accountId} channelAgentId=${channelAgentId}`);
+        try {
+          const result = await callCronJobMessage(api, accountId, {
+            jobId: p.jobId,
+            message: p.message,
+            agentId: channelAgentId
+          });
+          if (result.success) {
+            logger.info(`[智小途-定时触发] 通知后端成功`);
+            return json({
+              code: 0,
+              message: "定时任务触发通知已发送",
+              data: {
+                jobId: p.jobId,
+                message: p.message,
+                backendNotified: true
+              }
+            });
+          } else {
+            logger.error(`[智小途-定时触发] 通知后端失败 ${result.error}`);
+            return json({
+              code: -1,
+              error: result.error || "通知后端失败",
+              data: {
+                jobId: p.jobId,
+                message: p.message
+              }
+            });
+          }
+        } catch (error) {
+          logger.error(`[智小途-定时触发] 通知后端异常 ${error.message}`);
+          return json({
+            code: -1,
+            error: error.message || "通知后端异常",
+            data: {
+              jobId: p.jobId,
+              message: p.message
+            }
+          });
+        }
+      } else {
+        logger.error(`[智小途-定时触发] 无法获取渠道配置，accountId=${accountId}`);
+        return json({ error: "无法获取渠道配置，请检查账户配置" });
+      }
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronNotifySyncTool
+};

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

@@ -0,0 +1,68 @@
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+import logger from "../../../../logging.js";
+const RemoveParamsSchema = {
+  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 registerOpenclawWorkclawCronRemoveParamsTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-remove-params",
+    label: "智小途生成删除提醒参数",
+    description: `生成删除提醒的 CLI 命令。
+**必须**严格按照以下格式执行：
+openclaw cron remove <jobId>
+
+示例：openclaw cron remove 123456
+`,
+    parameters: RemoveParamsSchema,
+    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;
+      const agentId = ctx?.agentId;
+      if (!accountId) {
+        logger.warn("[智小途-生成删除参数] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      if (!agentId) {
+        logger.warn("[智小途-生成删除参数] 无法获取智能体 ID");
+        return json({ error: "无法获取智能体 ID（agentId），请确保已配置智能体" });
+      }
+      logger.info(`[智小途-生成删除参数] accountId=${accountId} agentId=${agentId} jobId=${p.jobId}`);
+      const cronParams = {
+        action: "remove",
+        jobId: p.jobId
+      };
+      logger.info(`[智小途-生成删除参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+      return json({
+        cronParams,
+        meta: {
+          accountId,
+          agentId,
+          jobId: p.jobId
+        },
+        summary: `🗑️ 提醒已删除: jobId=${p.jobId}`
+      });
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronRemoveParamsTool
+};

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

@@ -0,0 +1,86 @@
+import { resolveWorkclawAccountWithCache } from "../../../../accounts.js";
+import { callCronJobRemove } from "../../api/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+import logger from "../../../../logging.js";
+const RemoveSyncSchema = {
+  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 registerOpenclawWorkclawCronRemoveSyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-remove-sync",
+    label: "智小途同步删除提醒",
+    description: "【后端同步步骤】将删除定时任务同步到后端。必须在上一步 openclaw-workclaw-cron-remove-params 执行后调用此工具完成同步。",
+    parameters: RemoveSyncSchema,
+    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 callCronJobRemove(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 {
+  registerOpenclawWorkclawCronRemoveSyncTool
+};

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

@@ -0,0 +1,141 @@
+import { validateTimeFormat, isCronExpression, relativeToCron } from "../../utils/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+import logger from "../../../../logging.js";
+const UpdateParamsSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    },
+    time: {
+      type: "string",
+      description: "⏰ 时间（核心！），支持相对时间和 cron 表达式，工具自动转换"
+    },
+    name: {
+      type: "string",
+      description: "任务名称"
+    },
+    message: {
+      type: "string",
+      description: "提醒内容"
+    }
+  },
+  required: ["jobId", "time", "name", "message"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronUpdateParamsTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-update-params",
+    label: "智小途生成修改提醒参数",
+    description: `【核心工具】生成修改提醒的 cronParams 参数。
+
+📋 工作流程（必须按顺序执行）：
+1. 调用此工具获取 cronParams 参数
+2. 使用返回的 cronParams 调用 OpenClaw 的 cron 工具
+3. 必须调用 openclaw-workclaw-cron-update-sync 同步到后端
+
+⏰ 时间格式（核心！）：
+- time 参数支持相对时间（如 "10m"、"1h"、"2d"）和 cron 表达式
+- 工具会自动将所有时间统一转换为 cron 表达式
+- 严禁使用 --at 参数或其他绝对时间格式
+- 最终 CLI 命令必须使用 --cron 参数
+
+🔒 强制规则：
+- schedule.kind 必须是 "cron"
+- 必须使用 --cron 参数传递 cron 表达式
+
+⚠️ 必须从 cron 工具返回值中确认更新成功`,
+    parameters: UpdateParamsSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`[智小途-生成修改参数] 开始处理 jobId=${p.jobId} name=${p.name} time=${p.time}`);
+      if (!p.jobId) {
+        logger.warn("[智小途-生成修改参数] 缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      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 accountId = ctx?.agentAccountId;
+      const name = p.name;
+      const message = p.message;
+      const time = p.time;
+      if (!accountId) {
+        logger.warn("[智小途-生成修改参数] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      logger.info(`[智小途-生成修改参数] accountId=${accountId} jobId=${p.jobId}`);
+      const timeValidation = validateTimeFormat(time);
+      if (!timeValidation.valid) {
+        logger.warn(`[智小途-生成修改参数] 时间格式校验失败: ${timeValidation.error}`);
+        return json({ error: timeValidation.error });
+      }
+      const isCron = isCronExpression(time);
+      let isOneTime = false;
+      let cronExpr;
+      if (!isCron) {
+        isOneTime = true;
+        cronExpr = relativeToCron(time.trim());
+        logger.info(`[智小途-生成修改参数] 相对时间转换为绝对时间 cron 表达式 cronExpr=${cronExpr}`);
+      } else {
+        cronExpr = time.trim();
+      }
+      const cronParams = {
+        action: "update",
+        account: accountId,
+        jobId: p.jobId,
+        job: {
+          name,
+          schedule: {
+            kind: "cron",
+            expr: cronExpr,
+            tz: "Asia/Shanghai"
+          },
+          sessionTarget: "isolated",
+          wakeMode: "now",
+          deleteAfterRun: isOneTime ? true : void 0,
+          payload: {
+            kind: "agentTurn",
+            message
+          },
+          delivery: {
+            mode: "announce",
+            channel: "openclaw-workclaw"
+          }
+        }
+      };
+      logger.info(`[智小途-生成修改参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+      return json({
+        cronParams,
+        meta: {
+          accountId,
+          jobId: p.jobId,
+          name,
+          kind: "cron",
+          expr: cronExpr,
+          message
+        },
+        summary: `✅ 提醒已修改: "${name}" (${time})`
+      });
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronUpdateParamsTool
+};

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

@@ -0,0 +1,114 @@
+import { resolveWorkclawAccountWithCache } from "../../../../accounts.js";
+import { callCronJobUpdate } from "../../api/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+import logger from "../../../../logging.js";
+const UpdateSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    },
+    name: {
+      type: "string",
+      description: "任务名称"
+    },
+    kind: {
+      type: "string",
+      description: "任务类型（仅支持 cron）",
+      enum: ["cron"]
+    },
+    expr: {
+      type: "string",
+      description: "Cron 表达式（kind=cron 时必填）"
+    },
+    message: {
+      type: "string",
+      description: "提醒消息"
+    }
+  },
+  required: ["jobId", "name", "kind", "message"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronUpdateSyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-update-sync",
+    label: "智小途同步修改提醒",
+    description: "将修改定时任务同步到后端。在 cron 工具修改任务后调用此工具同步后端。",
+    parameters: UpdateSyncSchema,
+    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 为必填参数" });
+      }
+      if (!p.name) {
+        logger.warn("[智小途-同步修改] 缺少 name 参数");
+        return json({ error: "name 为必填参数" });
+      }
+      if (!p.message) {
+        logger.warn("[智小途-同步修改] 缺少 message 参数");
+        return json({ error: "message 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      const channelUserId = ctx?.From;
+      if (!accountId) {
+        logger.warn("[智小途-同步修改] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      const channelAgentId = accountConfig.configured ? String(accountConfig.config.agentId) : "0";
+      logger.info(`[智小途-同步修改] accountId=${accountId} channelUserId=${channelUserId} channelAgentId=${channelAgentId}`);
+      try {
+        const result = await callCronJobUpdate(api, accountId, {
+          jobId: p.jobId,
+          name: p.name,
+          kind: p.kind,
+          expr: p.expr,
+          message: p.message,
+          agentId: channelAgentId
+        });
+        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 }
+        });
+      }
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronUpdateSyncTool
+};