@workclaw/openclaw-workclaw 1.0.20 → 1.0.25

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.d.ts

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

@@ -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.d.ts

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

@@ -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.d.ts

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

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

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

@@ -1,17 +0,0 @@
-/**
- * 智小途定时任务工具 - 生成修改定时任务参数
- */
-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;

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

@@ -1,164 +0,0 @@
-/**
- * 智小途定时任务工具 - 生成修改定时任务参数
- */
-import { isCronExpression, relativeToCron, validateTimeFormat, } from '../../utils/index.js';
-/**
- * 参数 Schema 定义
- */
-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 getOpenclawWorkclawCronUpdateParamsTool(api) {
-    return (ctx) => {
-        return {
-            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;
-                api.logger.info(`[智小途-生成修改参数] 开始处理 jobId=${p.jobId} name=${p.name} time=${p.time}`);
-                // 参数校验
-                if (!p.jobId) {
-                    api.logger.warn('[智小途-生成修改参数] 缺少 jobId 参数');
-                    return json({ error: 'jobId 为必填参数' });
-                }
-                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;
-                const name = p.name;
-                const message = p.message;
-                const time = p.time;
-                // 校验必要参数
-                if (!accountId) {
-                    api.logger.warn('[智小途-生成修改参数] 无法获取账户 ID');
-                    return json({ error: '无法获取账户 ID（accountId），请确保已配置账户' });
-                }
-                api.logger.info(`[智小途-生成修改参数] accountId=${accountId} jobId=${p.jobId}`);
-                // 校验时间格式
-                const timeValidation = validateTimeFormat(time);
-                if (!timeValidation.valid) {
-                    api.logger.warn(`[智小途-生成修改参数] 时间格式校验失败: ${timeValidation.error}`);
-                    return json({ error: timeValidation.error });
-                }
-                // 判断时间类型
-                const isCron = isCronExpression(time);
-                let isOneTime = false;
-                let cronExpr;
-                // 如果是相对时间（5m、1h 等），转换为绝对时间的 cron 表达式
-                if (!isCron) {
-                    isOneTime = true;
-                    cronExpr = relativeToCron(time.trim());
-                    api.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 : undefined,
-                        payload: {
-                            kind: 'agentTurn',
-                            message,
-                        },
-                        delivery: {
-                            mode: 'announce',
-                            channel: 'openclaw-workclaw',
-                        },
-                    },
-                };
-                api.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 function registerOpenclawWorkclawCronUpdateParamsTool(api) {
-    api.registerTool(getOpenclawWorkclawCronUpdateParamsTool(api), {
-        name: 'openclaw-workclaw-cron-update-params',
-    });
-}

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

@@ -1,18 +0,0 @@
-/**
- * 智小途定时任务工具 - 同步修改定时任务到后端
- */
-import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
-/**
- * 同步修改定时任务参数
- */
-export interface UpdateSyncParams {
-    jobId: string;
-    name: string;
-    kind: 'cron';
-    expr?: string;
-    message: string;
-}
-/**
- * 注册同步修改定时任务到后端工具
- */
-export declare function registerOpenclawWorkclawCronUpdateSyncTool(api: OpenClawPluginApi): void;