@workclaw/openclaw-workclaw 1.0.202 → 1.0.332

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

@@ -1,209 +0,0 @@
-/**
- * 智小途定时任务工具 - 后端接口封装
- */
-import { resolveWorkclawAccountWithCache } from '../../../accounts.js';
-import { doFetchJson, getWorkclawAccessToken, normalizeBaseUrl } from '../../../connection/workclaw-client.js';
-const DEFAULT_MAX_RETRIES = 3;
-const DEFAULT_RETRY_DELAY_MS = 1000;
-/**
- * 睡眠函数
- */
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-/**
- * 带重试机制的 fetch 调用
- */
-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;
-}
-/**
- * 调用后端 API 的通用方法
- * @param api - OpenClaw API 实例
- * @param accountId - 账户 ID
- * @param path - API 路径
- * @param payload - 请求体
- * @param options - 可选配置
- * @returns 接口调用结果
- */
-export async function callBackendApi(api, accountId, path, payload, options = {}) {
-    try {
-        const account = resolveWorkclawAccountWithCache({
-            cfg: api.config,
-            accountId,
-        });
-        if (!account.configured) {
-            api.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);
-        api.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);
-        api.logger.info(`[智小途-定时任务] 调用接口 ${requestUrl}`);
-        api.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) {
-            api.logger.error(`[智小途-定时任务] 接口调用失败（已重试 ${fetchResult.attempts} 次）: ${fetchResult.error}`);
-            return { success: false, error: fetchResult.error, attempts: fetchResult.attempts };
-        }
-        const data = fetchResult.data;
-        api.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';
-            api.logger.error(`[智小途-定时任务] 接口返回错误 ${errorMsg}`);
-            return { success: false, error: errorMsg };
-        }
-    }
-    catch (error) {
-        api.logger.error(`[智小途-定时任务] 接口调用异常 ${error.message}`);
-        return { success: false, error: error.message };
-    }
-}
-/**
- * 调用新增定时任务接口
- */
-export async function callCronJobAdd(api, accountId, payload) {
-    api.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',
-    });
-    return { success: result.success, data: result.data, error: result.error };
-}
-/**
- * 调用删除定时任务接口
- */
-export async function callCronJobRemove(api, accountId, payload) {
-    api.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 };
-}
-/**
- * 调用更新定时任务接口
- */
-export async function callCronJobUpdate(api, accountId, payload) {
-    api.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 };
-}
-/**
- * 调用启用定时任务接口
- */
-export async function callCronJobEnabled(api, accountId, payload) {
-    api.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 };
-}
-/**
- * 调用禁用定时任务接口
- */
-export async function callCronJobDisabled(api, accountId, payload) {
-    api.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 };
-}
-/**
- * 调用定时任务触发通知接口
- */
-export async function callCronJobMessage(api, accountId, payload) {
-    api.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 };
-}

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

@@ -1,33 +0,0 @@
-/**
- * 智小途定时任务工具 - 统一出口
- *
- * 提供统一的工具注册入口，一次性注册所有定时任务相关工具
- */
-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';
-/**
- * 统一注册所有定时任务工具
- * @param api - OpenClaw API 实例
- */
-export function registerAllOpenclawWorkclawCronTools(api) {
-    registerOpenclawWorkclawCronAddParamsTool(api);
-    registerOpenclawWorkclawCronRemoveParamsTool(api);
-    registerOpenclawWorkclawCronUpdateParamsTool(api);
-    registerOpenclawWorkclawCronEnableParamsTool(api);
-    registerOpenclawWorkclawCronDisableParamsTool(api);
-    registerOpenclawWorkclawCronAddSyncTool(api);
-    registerOpenclawWorkclawCronRemoveSyncTool(api);
-    registerOpenclawWorkclawCronUpdateSyncTool(api);
-    registerOpenclawWorkclawCronEnableSyncTool(api);
-    registerOpenclawWorkclawCronDisableSyncTool(api);
-    registerOpenclawWorkclawCronNotifySyncTool(api);
-}

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',
-    });
-}