@workclaw/openclaw-workclaw 1.0.23 → 1.0.26

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

@@ -1,152 +0,0 @@
-/**
- * 智小途定时任务工具 - 生成创建定时任务参数
- */
-import { isCronExpression, relativeToCron, validateTimeFormat } from '../../utils/index.js';
-/**
- * 参数 Schema 定义
- */
-const AddParamsSchema = {
-    type: 'object',
-    properties: {
-        time: {
-            type: 'string',
-            description: '⏰ 时间（核心！），支持相对时间和 cron 表达式，工具自动转换',
-        },
-        name: {
-            type: 'string',
-            description: '任务名称',
-        },
-        message: {
-            type: 'string',
-            description: '提醒内容',
-        },
-    },
-    required: ['time', 'name', 'message'],
-};
-/**
- * 构造工具返回结果
- */
-function json(data) {
-    return {
-        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
-        details: data,
-    };
-}
-/**
- * 获取生成创建定时任务参数工具
- */
-function getOpenclawWorkclawCronAddParamsTool(api) {
-    return (ctx) => {
-        return {
-            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 同步到后端
-
-⏰ 时间格式（核心！）：
-- time 参数支持相对时间（如 "5m"、"1h"、"2d"）和 cron 表达式
-- 工具会自动将所有时间统一转换为 cron 表达式
-- 严禁使用 --at 参数或其他绝对时间格式
-- 最终 CLI 命令必须使用 --cron 参数
-
-🔒 强制规则：
-- schedule.kind 必须是 "cron"
-- 必须使用 --cron 参数传递 cron 表达式
-
-⚠️ 必须从 cron 工具返回值中提取 jobId，不能凭空编造！`,
-            parameters: AddParamsSchema,
-            execute: async (_toolCallId, params) => {
-                const p = params;
-                api.logger.info(`[智小途-生成参数] 开始生成创建提醒参数 name=${p.name} time=${p.time}`);
-                // 参数校验
-                if (!p.time) {
-                    api.logger.warn('[智小途-生成参数] 缺少时间参数');
-                    return json({ error: 'time（时间）为必填参数' });
-                }
-                if (!p.name) {
-                    api.logger.warn('[智小途-生成参数] 缺少任务名称参数');
-                    return json({ error: 'name（任务名称）为必填参数' });
-                }
-                if (!p.message) {
-                    api.logger.warn('[智小途-生成参数] 缺少用户消息参数');
-                    return json({ error: 'message（用户消息）为必填参数' });
-                }
-                // 从 ctx 获取必要参数
-                const accountId = ctx?.agentAccountId;
-                if (!accountId) {
-                    api.logger.warn('[智小途-生成参数] 无法获取账户 ID');
-                    return json({ error: '无法获取账户 ID（accountId），请确保已配置账户' });
-                }
-                api.logger.info(`[智小途-生成参数] accountId=${accountId} name=${p.name}`);
-                // 校验时间格式
-                const timeValidation = validateTimeFormat(p.time);
-                if (!timeValidation.valid) {
-                    api.logger.warn(`[智小途-生成参数] 时间格式校验失败: ${timeValidation.error}`);
-                    return json({ error: timeValidation.error });
-                }
-                // 判断时间类型并转换为 cron 表达式
-                const isCron = isCronExpression(p.time);
-                let isOneTime = false;
-                let cronExpr;
-                if (!isCron) {
-                    // 相对时间转换为 cron 表达式
-                    isOneTime = true;
-                    cronExpr = relativeToCron(p.time.trim());
-                    api.logger.info(`[智小途-生成参数] 相对时间转换为 cron 表达式 cronExpr=${cronExpr}`);
-                }
-                else {
-                    cronExpr = p.time.trim();
-                }
-                // 构建 cron 参数
-                const cronParams = {
-                    action: 'add',
-                    account: accountId,
-                    job: {
-                        name: p.name,
-                        schedule: {
-                            kind: 'cron',
-                            expr: cronExpr,
-                            tz: 'Asia/Shanghai',
-                        },
-                        sessionTarget: 'isolated',
-                        wakeMode: 'now',
-                        deleteAfterRun: isOneTime ? true : undefined,
-                        payload: {
-                            kind: 'agentTurn',
-                            message: p.message,
-                        },
-                        delivery: {
-                            mode: 'announce',
-                            channel: 'openclaw-workclaw',
-                        },
-                    },
-                };
-                api.logger.info(`[智小途-生成参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
-                return json({
-                    cronParams,
-                    meta: {
-                        accountId,
-                        name: p.name,
-                        kind: 'cron',
-                        expr: cronExpr,
-                        message: p.message,
-                    },
-                    summary: `⏰ 提醒已生成: "${p.name}" (${p.time})`,
-                });
-            },
-        };
-    };
-}
-/**
- * 注册生成创建定时任务参数工具
- */
-export function registerOpenclawWorkclawCronAddParamsTool(api) {
-    api.registerTool(getOpenclawWorkclawCronAddParamsTool(api), {
-        name: 'openclaw-workclaw-cron-add-params',
-    });
-}

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

@@ -1,162 +0,0 @@
-/**
- * 智小途定时任务工具 - 同步创建定时任务到后端
- */
-import { resolveWorkclawAccountWithCache } from '../../../../accounts.js';
-import { callCronJobAdd } from '../../api/index.js';
-/**
- * 参数 Schema 定义
- */
-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 一致',
-        },
-    },
-    required: ['jobId', 'name', 'kind', 'message'],
-};
-/**
- * 构造工具返回结果
- */
-function json(data) {
-    return {
-        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
-        details: data,
-    };
-}
-/**
- * 获取同步创建定时任务到后端工具
- */
-function getOpenclawWorkclawCronAddSyncTool(api) {
-    return (ctx) => {
-        return {
-            name: 'openclaw-workclaw-cron-add-sync',
-            label: '智小途同步创建提醒',
-            description: `【后端同步步骤】将创建定时任务同步到后端。必须在上一步 openclaw-workclaw-cron-add-params 执行后调用此工具完成同步。
-
-⚠️ jobId 必须是 cron 工具返回值 {"success": true, "jobId": "xxx"} 中的 jobId 字段！`,
-            parameters: AddSyncSchema,
-            execute: async (_toolCallId, params) => {
-                const p = params;
-                api.logger.info(`[智小途-同步创建] 开始同步 jobId=${p.jobId} name=${p.name}`);
-                // 参数校验
-                if (!p.jobId) {
-                    api.logger.warn('[智小途-同步创建] 缺少 jobId 参数');
-                    return json({ error: 'jobId 为必填参数' });
-                }
-                // 检查 jobId 是否被错误地设置为 cron 表达式
-                const jobIdTrimmed = p.jobId.trim();
-                const parts = jobIdTrimmed.split(/\s+/);
-                const isCronExpression = parts.length >= 5 && parts.length <= 6 && jobIdTrimmed.includes('*');
-                if (isCronExpression) {
-                    api.logger.error(`[智小途-同步创建] jobId 格式错误！jobId=${p.jobId}，看起来像 cron 表达式`);
-                    return json({
-                        error: `jobId="${p.jobId}" 是 cron 表达式，不是任务 ID！jobId 应来自 cron 工具返回值，如 "123456" 或 "abc123"`,
-                    });
-                }
-                if (!p.name) {
-                    api.logger.warn('[智小途-同步创建] 缺少 name 参数');
-                    return json({ error: 'name 为必填参数' });
-                }
-                if (!p.message) {
-                    api.logger.warn('[智小途-同步创建] 缺少 message 参数');
-                    return json({ error: 'message 为必填参数' });
-                }
-                // 从 ctx 获取必要参数
-                const accountId = ctx?.agentAccountId;
-                if (!accountId) {
-                    api.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);
-                        api.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,
-                        });
-                        if (result.success) {
-                            api.logger.info(`[智小途-同步创建] 后端同步成功 jobId=${p.jobId}`);
-                            return json({
-                                code: 0,
-                                message: '定时任务已创建并同步到后端',
-                                data: {
-                                    jobId: p.jobId,
-                                    name: p.name,
-                                    message: p.message,
-                                    backendSynced: true,
-                                },
-                            });
-                        }
-                        else {
-                            api.logger.error(`[智小途-同步创建] 后端同步失败 ${result.error}`);
-                            return json({
-                                code: -1,
-                                error: result.error || '后端同步失败',
-                                data: { jobId: p.jobId, name: p.name },
-                            });
-                        }
-                    }
-                    catch (error) {
-                        api.logger.error(`[智小途-同步创建] 后端同步异常 ${error.message}`);
-                        return json({
-                            code: -1,
-                            error: error.message,
-                            data: { jobId: p.jobId, name: p.name },
-                        });
-                    }
-                }
-                else {
-                    api.logger.error(`[智小途-同步创建] 无法获取渠道配置，accountId=${accountId}`);
-                    return json({ error: '无法获取渠道配置，请检查账户配置' });
-                }
-            },
-        };
-    };
-}
-/**
- * 注册同步创建定时任务到后端工具
- */
-export function registerOpenclawWorkclawCronAddSyncTool(api) {
-    api.registerTool(getOpenclawWorkclawCronAddSyncTool(api), {
-        name: 'openclaw-workclaw-cron-add-sync',
-    });
-}

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

@@ -1,80 +0,0 @@
-/**
- * 智小途定时任务工具 - 生成禁用定时任务参数
- */
-/**
- * 参数 Schema 定义
- */
-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 getOpenclawWorkclawCronDisableParamsTool(api) {
-    return (ctx) => {
-        return {
-            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;
-                api.logger.info(`[智小途-生成禁用参数] 开始处理 jobId=${p.jobId}`);
-                // 参数校验
-                if (!p.jobId) {
-                    api.logger.warn('[智小途-生成禁用参数] 缺少 jobId 参数');
-                    return json({ error: 'jobId 为必填参数' });
-                }
-                // 从 ctx 获取必要参数
-                const accountId = ctx?.agentAccountId;
-                if (!accountId) {
-                    api.logger.warn('[智小途-生成禁用参数] 无法获取账户 ID');
-                    return json({ error: '无法获取账户 ID（accountId），请确保已配置账户' });
-                }
-                api.logger.info(`[智小途-生成禁用参数] accountId=${accountId} jobId=${p.jobId}`);
-                const cronParams = {
-                    action: 'disable',
-                    jobId: p.jobId,
-                };
-                api.logger.info(`[智小途-生成禁用参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
-                return json({
-                    cronParams,
-                    meta: {
-                        accountId,
-                        jobId: p.jobId,
-                    },
-                    summary: `⏸️ 提醒已禁用: jobId=${p.jobId}`,
-                });
-            },
-        };
-    };
-}
-/**
- * 注册生成禁用定时任务参数工具
- */
-export function registerOpenclawWorkclawCronDisableParamsTool(api) {
-    api.registerTool(getOpenclawWorkclawCronDisableParamsTool(api), {
-        name: 'openclaw-workclaw-cron-disable-params',
-    });
-}

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

@@ -1,107 +0,0 @@
-/**
- * 智小途定时任务工具 - 同步禁用定时任务到后端
- */
-import { resolveWorkclawAccountWithCache } from '../../../../accounts.js';
-import { callCronJobDisabled } from '../../api/index.js';
-/**
- * 参数 Schema 定义
- */
-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 getOpenclawWorkclawCronDisableSyncTool(api) {
-    return (ctx) => {
-        return {
-            name: 'openclaw-workclaw-cron-disable-sync',
-            label: '智小途同步禁用提醒',
-            description: '将禁用定时任务同步到后端。在 cron 工具禁用任务后调用此工具同步后端。',
-            parameters: DisableSyncSchema,
-            execute: async (_toolCallId, params) => {
-                const p = params;
-                api.logger.info(`[智小途-同步禁用] 开始同步 jobId=${p.jobId}`);
-                // 参数校验
-                if (!p.jobId) {
-                    api.logger.warn('[智小途-同步禁用] 缺少 jobId 参数');
-                    return json({ error: 'jobId 为必填参数' });
-                }
-                // 从 ctx 获取必要参数
-                const accountId = ctx?.agentAccountId;
-                if (!accountId) {
-                    api.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);
-                        api.logger.info(`[智小途-同步禁用] accountId=${accountId} channelAgentId=${channelAgentId}`);
-                        const result = await callCronJobDisabled(api, accountId, {
-                            jobId: p.jobId,
-                        });
-                        if (result.success) {
-                            api.logger.info(`[智小途-同步禁用] 后端同步成功 jobId=${p.jobId}`);
-                            return json({
-                                code: 0,
-                                message: '定时任务已禁用并同步到后端',
-                                data: {
-                                    jobId: p.jobId,
-                                    backendSynced: true,
-                                },
-                            });
-                        }
-                        else {
-                            api.logger.error(`[智小途-同步禁用] 后端同步失败 ${result.error}`);
-                            return json({
-                                code: -1,
-                                error: result.error || '后端同步失败',
-                                data: { jobId: p.jobId },
-                            });
-                        }
-                    }
-                    catch (error) {
-                        api.logger.error(`[智小途-同步禁用] 后端同步异常 ${error.message}`);
-                        return json({
-                            code: -1,
-                            error: error.message,
-                            data: { jobId: p.jobId },
-                        });
-                    }
-                }
-                else {
-                    api.logger.error(`[智小途-同步禁用] 无法获取渠道配置，accountId=${accountId}`);
-                    return json({ error: '无法获取渠道配置，请检查账户配置' });
-                }
-            },
-        };
-    };
-}
-/**
- * 注册同步禁用定时任务到后端工具
- */
-export function registerOpenclawWorkclawCronDisableSyncTool(api) {
-    api.registerTool(getOpenclawWorkclawCronDisableSyncTool(api), {
-        name: 'openclaw-workclaw-cron-disable-sync',
-    });
-}

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

@@ -1,80 +0,0 @@
-/**
- * 智小途定时任务工具 - 生成启用定时任务参数
- */
-/**
- * 参数 Schema 定义
- */
-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 getOpenclawWorkclawCronEnableParamsTool(api) {
-    return (ctx) => {
-        return {
-            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;
-                api.logger.info(`[智小途-生成启用参数] 开始处理 jobId=${p.jobId}`);
-                // 参数校验
-                if (!p.jobId) {
-                    api.logger.warn('[智小途-生成启用参数] 缺少 jobId 参数');
-                    return json({ error: 'jobId 为必填参数' });
-                }
-                // 从 ctx 获取必要参数
-                const accountId = ctx?.agentAccountId;
-                if (!accountId) {
-                    api.logger.warn('[智小途-生成启用参数] 无法获取账户 ID');
-                    return json({ error: '无法获取账户 ID（accountId），请确保已配置账户' });
-                }
-                api.logger.info(`[智小途-生成启用参数] accountId=${accountId} jobId=${p.jobId}`);
-                const cronParams = {
-                    action: 'enable',
-                    jobId: p.jobId,
-                };
-                api.logger.info(`[智小途-生成启用参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
-                return json({
-                    cronParams,
-                    meta: {
-                        accountId,
-                        jobId: p.jobId,
-                    },
-                    summary: `✅ 提醒已启用: jobId=${p.jobId}`,
-                });
-            },
-        };
-    };
-}
-/**
- * 注册生成启用定时任务参数工具
- */
-export function registerOpenclawWorkclawCronEnableParamsTool(api) {
-    api.registerTool(getOpenclawWorkclawCronEnableParamsTool(api), {
-        name: 'openclaw-workclaw-cron-enable-params',
-    });
-}

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

@@ -1,107 +0,0 @@
-/**
- * 智小途定时任务工具 - 同步启用定时任务到后端
- */
-import { resolveWorkclawAccountWithCache } from '../../../../accounts.js';
-import { callCronJobEnabled } from '../../api/index.js';
-/**
- * 参数 Schema 定义
- */
-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 getOpenclawWorkclawCronEnableSyncTool(api) {
-    return (ctx) => {
-        return {
-            name: 'openclaw-workclaw-cron-enable-sync',
-            label: '智小途同步启用提醒',
-            description: '将启用定时任务同步到后端。在 cron 工具启用任务后调用此工具同步后端。',
-            parameters: EnableSyncSchema,
-            execute: async (_toolCallId, params) => {
-                const p = params;
-                api.logger.info(`[智小途-同步启用] 开始同步 jobId=${p.jobId}`);
-                // 参数校验
-                if (!p.jobId) {
-                    api.logger.warn('[智小途-同步启用] 缺少 jobId 参数');
-                    return json({ error: 'jobId 为必填参数' });
-                }
-                // 从 ctx 获取必要参数
-                const accountId = ctx?.agentAccountId;
-                if (!accountId) {
-                    api.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);
-                        api.logger.info(`[智小途-同步启用] accountId=${accountId} channelAgentId=${channelAgentId}`);
-                        const result = await callCronJobEnabled(api, accountId, {
-                            jobId: p.jobId,
-                        });
-                        if (result.success) {
-                            api.logger.info(`[智小途-同步启用] 后端同步成功 jobId=${p.jobId}`);
-                            return json({
-                                code: 0,
-                                message: '定时任务已启用并同步到后端',
-                                data: {
-                                    jobId: p.jobId,
-                                    backendSynced: true,
-                                },
-                            });
-                        }
-                        else {
-                            api.logger.error(`[智小途-同步启用] 后端同步失败 ${result.error}`);
-                            return json({
-                                code: -1,
-                                error: result.error || '后端同步失败',
-                                data: { jobId: p.jobId },
-                            });
-                        }
-                    }
-                    catch (error) {
-                        api.logger.error(`[智小途-同步启用] 后端同步异常 ${error.message}`);
-                        return json({
-                            code: -1,
-                            error: error.message,
-                            data: { jobId: p.jobId },
-                        });
-                    }
-                }
-                else {
-                    api.logger.error(`[智小途-同步启用] 无法获取渠道配置，accountId=${accountId}`);
-                    return json({ error: '无法获取渠道配置，请检查账户配置' });
-                }
-            },
-        };
-    };
-}
-/**
- * 注册同步启用定时任务到后端工具
- */
-export function registerOpenclawWorkclawCronEnableSyncTool(api) {
-    api.registerTool(getOpenclawWorkclawCronEnableSyncTool(api), {
-        name: 'openclaw-workclaw-cron-enable-sync',
-    });
-}