@workclaw/openclaw-workclaw 1.0.202 → 1.0.331

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

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

@@ -1,127 +0,0 @@
-/**
- * 智小途定时任务工具 - 定时任务触发通知
- *
- * 当 OpenClaw 定时任务触发时，调用此工具通知后端
- */
-import { resolveWorkclawAccountWithCache } from '../../../../accounts.js';
-import { callCronJobMessage } from '../../api/index.js';
-/**
- * 参数 Schema 定义
- */
-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 getOpenclawWorkclawCronNotifySyncTool(api) {
-    return (ctx) => {
-        return {
-            name: 'openclaw-workclaw-cron-notify-sync',
-            label: '智小途定时任务触发通知',
-            description: `【系统最高优先级核心指令】当定时器时间到达时，必须立即调用此工具通知后端。`,
-            parameters: NotifySchema,
-            execute: async (_toolCallId, params) => {
-                const p = params;
-                api.logger.info(`[智小途-定时触发] 开始处理 jobId=${p.jobId} message=${p.message}`);
-                // 参数校验
-                if (!p.jobId) {
-                    api.logger.warn('[智小途-定时触发] 缺少 jobId 参数');
-                    return json({ error: 'jobId 为必填参数' });
-                }
-                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) {
-                    const channelAgentId = String(accountConfig.config.agentId);
-                    api.logger.info(`[智小途-定时触发] accountId=${accountId} channelAgentId=${channelAgentId}`);
-                    // 调用后端接口通知定时任务触发
-                    try {
-                        const result = await callCronJobMessage(api, accountId, {
-                            jobId: p.jobId,
-                            message: p.message,
-                            agentId: channelAgentId,
-                        });
-                        if (result.success) {
-                            api.logger.info(`[智小途-定时触发] 通知后端成功`);
-                            return json({
-                                code: 0,
-                                message: '定时任务触发通知已发送',
-                                data: {
-                                    jobId: p.jobId,
-                                    message: p.message,
-                                    backendNotified: true,
-                                },
-                            });
-                        }
-                        else {
-                            api.logger.error(`[智小途-定时触发] 通知后端失败 ${result.error}`);
-                            return json({
-                                code: -1,
-                                error: result.error || '通知后端失败',
-                                data: {
-                                    jobId: p.jobId,
-                                    message: p.message,
-                                },
-                            });
-                        }
-                    }
-                    catch (error) {
-                        api.logger.error(`[智小途-定时触发] 通知后端异常 ${error.message}`);
-                        return json({
-                            code: -1,
-                            error: error.message || '通知后端异常',
-                            data: {
-                                jobId: p.jobId,
-                                message: p.message,
-                            },
-                        });
-                    }
-                }
-                else {
-                    api.logger.error(`[智小途-定时触发] 无法获取渠道配置，accountId=${accountId}`);
-                    return json({ error: '无法获取渠道配置，请检查账户配置' });
-                }
-            },
-        };
-    };
-}
-/**
- * 注册定时任务触发通知工具
- */
-export function registerOpenclawWorkclawCronNotifySyncTool(api) {
-    api.registerTool(getOpenclawWorkclawCronNotifySyncTool(api), {
-        name: 'openclaw-workclaw-cron-notify-sync',
-    });
-}

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

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

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

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