@workclaw/openclaw-workclaw 1.0.18 → 1.0.20

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

@@ -0,0 +1,80 @@
+/**
+ * 智小途定时任务工具 - 生成启用定时任务参数
+ */
+/**
+ * 参数 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.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 智小途定时任务工具 - 同步启用定时任务到后端
+ */
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+/**
+ * 同步启用定时任务参数
+ */
+export interface EnableSyncParams {
+    jobId: string;
+}
+/**
+ * 注册同步启用定时任务到后端工具
+ */
+export declare function registerOpenclawWorkclawCronEnableSyncTool(api: OpenClawPluginApi): void;

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

@@ -0,0 +1,107 @@
+/**
+ * 智小途定时任务工具 - 同步启用定时任务到后端
+ */
+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.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 智小途定时任务工具 - 定时任务触发通知
+ *
+ * 当 OpenClaw 定时任务触发时，调用此工具通知后端
+ */
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+/**
+ * 定时任务触发通知参数
+ */
+export interface NotifyParams {
+    jobId: string;
+    message: string;
+}
+/**
+ * 注册定时任务触发通知工具
+ */
+export declare function registerOpenclawWorkclawCronNotifySyncTool(api: OpenClawPluginApi): void;

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

@@ -0,0 +1,127 @@
+/**
+ * 智小途定时任务工具 - 定时任务触发通知
+ *
+ * 当 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.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 智小途定时任务工具 - 生成删除定时任务参数
+ */
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+/**
+ * 生成删除定时任务参数
+ */
+export interface RemoveParamsParams {
+    jobId: string;
+}
+/**
+ * 注册生成删除定时任务参数工具
+ */
+export declare function registerOpenclawWorkclawCronRemoveParamsTool(api: OpenClawPluginApi): void;

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

@@ -0,0 +1,87 @@
+/**
+ * 智小途定时任务工具 - 生成删除定时任务参数
+ */
+/**
+ * 参数 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.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 智小途定时任务工具 - 同步删除定时任务到后端
+ */
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+/**
+ * 同步删除定时任务参数
+ */
+export interface RemoveSyncParams {
+    jobId: string;
+}
+/**
+ * 注册同步删除定时任务到后端工具
+ */
+export declare function registerOpenclawWorkclawCronRemoveSyncTool(api: OpenClawPluginApi): void;

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

@@ -0,0 +1,107 @@
+/**
+ * 智小途定时任务工具 - 同步删除定时任务到后端
+ */
+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',
+    });
+}

package/dist/src/tools/openclaw-workclaw-cron/src/update/params.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 智小途定时任务工具 - 生成修改定时任务参数
+ */
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+/**
+ * 生成修改定时任务参数
+ */
+export interface UpdateParamsParams {
+    jobId: string;
+    time: string;
+    name: string;
+    message: string;
+}
+/**
+ * 注册生成修改定时任务参数工具
+ */
+export declare function registerOpenclawWorkclawCronUpdateParamsTool(api: OpenClawPluginApi): void;