@workclaw/openclaw-workclaw 1.0.202 → 1.0.332

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.js

@@ -1,135 +0,0 @@
-/**
- * 智小途定时任务工具 - 同步修改定时任务到后端
- */
-import { resolveWorkclawAccountWithCache } from '../../../../accounts.js';
-import { callCronJobUpdate } from '../../api/index.js';
-/**
- * 参数 Schema 定义
- */
-const UpdateSyncSchema = {
-    type: 'object',
-    properties: {
-        jobId: {
-            type: 'string',
-            description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`,
-        },
-        name: {
-            type: 'string',
-            description: '任务名称',
-        },
-        kind: {
-            type: 'string',
-            description: '任务类型（仅支持 cron）',
-            enum: ['cron'],
-        },
-        expr: {
-            type: 'string',
-            description: 'Cron 表达式（kind=cron 时必填）',
-        },
-        message: {
-            type: 'string',
-            description: '提醒消息',
-        },
-    },
-    required: ['jobId', 'name', 'kind', 'message'],
-};
-/**
- * 构造工具返回结果
- */
-function json(data) {
-    return {
-        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
-        details: data,
-    };
-}
-/**
- * 获取同步修改定时任务到后端工具
- */
-function getOpenclawWorkclawCronUpdateSyncTool(api) {
-    return (ctx) => {
-        return {
-            name: 'openclaw-workclaw-cron-update-sync',
-            label: '智小途同步修改提醒',
-            description: '将修改定时任务同步到后端。在 cron 工具修改任务后调用此工具同步后端。',
-            parameters: UpdateSyncSchema,
-            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 为必填参数' });
-                }
-                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;
-                const channelUserId = ctx?.From;
-                // 校验必要参数
-                if (!accountId) {
-                    api.logger.warn('[智小途-同步修改] 无法获取账户 ID');
-                    return json({ error: '无法获取账户 ID（accountId），请确保已配置账户' });
-                }
-                const accountConfig = resolveWorkclawAccountWithCache({
-                    cfg: ctx.config,
-                    accountId,
-                });
-                const channelAgentId = accountConfig.configured ? String(accountConfig.config.agentId) : '0';
-                api.logger.info(`[智小途-同步修改] accountId=${accountId} channelUserId=${channelUserId} channelAgentId=${channelAgentId}`);
-                try {
-                    const result = await callCronJobUpdate(api, accountId, {
-                        jobId: p.jobId,
-                        name: p.name,
-                        kind: p.kind,
-                        expr: p.expr,
-                        message: p.message,
-                        agentId: 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 },
-                    });
-                }
-            },
-        };
-    };
-}
-/**
- * 注册同步修改定时任务到后端工具
- */
-export function registerOpenclawWorkclawCronUpdateSyncTool(api) {
-    api.registerTool(getOpenclawWorkclawCronUpdateSyncTool(api), {
-        name: 'openclaw-workclaw-cron-update-sync',
-    });
-}

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

@@ -1,4 +0,0 @@
-/**
- * 智小途定时任务工具 - 类型定义
- */
-export {};

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

@@ -1,122 +0,0 @@
-/**
- * 智小途定时任务工具 - 工具函数
- */
-/**
- * 解析相对时间字符串
- * 支持格式：5m, 1h, 1h30m, 2d, 30s, 1d2h30m 等
- * @param timeStr - 时间字符串
- * @returns 毫秒数，解析失败返回 null
- */
-export function parseRelativeTime(timeStr) {
-    const s = timeStr.trim().toLowerCase();
-    if (/^\d+$/.test(s)) {
-        return Number.parseInt(s, 10) * 60_000;
-    }
-    let totalMs = 0;
-    let matched = false;
-    const regex = /(\d+(?:\.\d+)?)\s*([dhms])/g;
-    let match;
-    // eslint-disable-next-line no-cond-assign
-    while ((match = regex.exec(s)) !== null) {
-        matched = true;
-        const value = Number.parseFloat(match[1]);
-        const unit = match[2];
-        switch (unit) {
-            case 'd':
-                totalMs += value * 86_400_000;
-                break;
-            case 'h':
-                totalMs += value * 3_600_000;
-                break;
-            case 'm':
-                totalMs += value * 60_000;
-                break;
-            case 's':
-                totalMs += value * 1_000;
-                break;
-        }
-    }
-    return matched ? Math.round(totalMs) : null;
-}
-/**
- * 判断是否为 cron 表达式
- * @param timeStr - 时间字符串
- * @returns 是否为 cron 表达式
- */
-export function isCronExpression(timeStr) {
-    const parts = timeStr.trim().split(/\s+/);
-    return parts.length >= 3 && parts.length <= 6;
-}
-/**
- * 校验 cron 表达式格式
- * @param timeStr - 时间字符串
- * @returns 校验结果和错误信息
- */
-export function validateCronExpression(timeStr) {
-    const parts = timeStr.trim().split(/\s+/);
-    if (parts.length < 3 || parts.length > 6) {
-        return { valid: false, error: `无效的 cron 表达式：字段数量不正确（期望 3-6 个字段，实际 ${parts.length} 个）` };
-    }
-    const patterns = [
-        /^(\*|[0-5]?\d(-[0-5]?\d)?(\/[0-5]?\d)?|L(-[0-5]?\d)?|W?)$/,
-        /^(\*|[0-5]?\d(-[0-5]?\d)?(\/[0-5]?\d)?|L(-[0-5]?\d)?|W?)$/,
-        /^(\*|[01]?\d|2[0-3](-[01]?\d|2[0-3])?(\/\d|[01]?\d|2[0-3])?|L(-[01]?\d|2[0-3])?|W)?$/,
-        /^(\*|1[0-2]|0?[1-9](-[1-9]|0?[1-9])?(\/[1-9]|0?[1-9])?|L(-1[0-2]|0?[1-9])?|W)?$/,
-        /^([*LW]|[0-6](-[0-6])?(\/[0-6])?|L-[0-6])?$/,
-        /^(\*|L|(\*\/)?\d{1,2})?$/,
-    ];
-    const fieldNames = ['秒', '分钟', '小时', '日期', '月份', '星期'];
-    for (let i = 0; i < parts.length && i < patterns.length; i++) {
-        const part = parts[i].trim();
-        const offset = parts.length - patterns.length;
-        if (i < offset)
-            continue;
-        if (!patterns[i].test(part)) {
-            return { valid: false, error: `无效的 cron 表达式：${fieldNames[i]}字段 "${part}" 格式不正确` };
-        }
-    }
-    return { valid: true };
-}
-/**
- * 校验时间格式（相对时间或 cron 表达式）
- * @param timeStr - 时间字符串
- * @returns 校验结果和错误信息
- */
-export function validateTimeFormat(timeStr) {
-    if (!timeStr || typeof timeStr !== 'string' || timeStr.trim() === '') {
-        return { valid: false, error: '时间参数不能为空' };
-    }
-    const trimmed = timeStr.trim();
-    if (trimmed.startsWith('+') || /^\d+$/.test(trimmed) || /^\d+[dhms]/.test(trimmed)) {
-        const relativeMs = parseRelativeTime(trimmed);
-        if (relativeMs === null) {
-            return { valid: false, error: `无法解析相对时间 "${trimmed}"，支持的格式：5m、1h、1h30m、2d、30s 等` };
-        }
-        if (relativeMs < 30_000) {
-            return { valid: false, error: '提醒时间不能少于 30 秒' };
-        }
-        return { valid: true };
-    }
-    if (isCronExpression(trimmed)) {
-        return validateCronExpression(trimmed);
-    }
-    return { valid: false, error: `无法解析时间 "${trimmed}"，请使用相对时间（如 5m、1h）或 cron 表达式（如 0 8 * * *）` };
-}
-/**
- * 将相对时间转换为标准 cron 表达式
- * @param timeStr - 相对时间字符串，如 "5m", "1h", "2h30m"
- * @returns 标准 cron 表达式（秒 分 时 日 月 星期），格式为 "SS MM HH DD MM *"
- */
-export function relativeToCron(timeStr) {
-    const delayMs = parseRelativeTime(timeStr);
-    if (delayMs === null) {
-        return timeStr;
-    }
-    const futureTime = new Date(Date.now() + delayMs);
-    const seconds = futureTime.getSeconds();
-    const minutes = futureTime.getMinutes();
-    const hours = futureTime.getHours();
-    const dayOfMonth = futureTime.getDate();
-    const month = futureTime.getMonth() + 1;
-    return `${seconds} ${minutes} ${hours} ${dayOfMonth} ${month} *`;
-}

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

@@ -1,15 +0,0 @@
-/**
- * 智小途系统信息工具 - 统一出口
- *
- * 提供统一的工具注册入口，一次性注册所有系统信息相关工具
- */
-import { registerOpenclawWorkclawSystemConfigTool } from './src/get/index.js';
-import { registerOpenclawWorkclawSystemTokenTool } from './src/token/index.js';
-/**
- * 统一注册所有系统信息工具
- * @param api - OpenClaw API 实例
- */
-export function registerAllOpenclawWorkclawSystemTools(api) {
-    registerOpenclawWorkclawSystemConfigTool(api);
-    registerOpenclawWorkclawSystemTokenTool(api);
-}

package/dist/src/tools/openclaw-workclaw-system/src/get/index.js

@@ -1,64 +0,0 @@
-/**
- * 智小途系统信息工具 - 获取系统配置信息
- */
-import { resolveWorkclawAccountWithCache } from '../../../../accounts.js';
-/**
- * 构造工具返回结果
- */
-function json(data) {
-    return {
-        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
-        details: data,
-    };
-}
-/**
- * 获取系统配置信息工具
- */
-function getOpenclawWorkclawSystemConfigTool(api) {
-    return (ctx) => {
-        return {
-            name: 'openclaw-workclaw-system-config',
-            label: '智小途获取系统信息',
-            description: '获取当前渠道的系统配置信息，包括 appKey、appSecret、agentId、userId 等',
-            execute: async () => {
-                api.logger.info('[智小途-系统信息] 开始获取系统配置信息');
-                const accountId = ctx?.agentAccountId;
-                if (!accountId) {
-                    api.logger.warn('[智小途-系统信息] 无法获取账户 ID');
-                    return json({ error: '无法获取账户 ID（accountId），请确保已配置账户' });
-                }
-                api.logger.info(`[智小途-系统信息] accountId=${accountId}`);
-                const accountConfig = resolveWorkclawAccountWithCache({
-                    cfg: ctx.config,
-                    accountId,
-                });
-                if (!accountConfig.configured) {
-                    api.logger.error('[智小途-系统信息] 账户未配置');
-                    return json({ error: '账户未配置，请检查账户配置' });
-                }
-                const accConfig = accountConfig.config;
-                const result = {
-                    accountId,
-                    appKey: accConfig.appKey,
-                    appSecret: accConfig.appSecret,
-                    agentId: accConfig.agentId,
-                    userId: accConfig.userId,
-                };
-                api.logger.info(`[智小途-系统信息] 获取成功${JSON.stringify(result)}`);
-                return json({
-                    code: 0,
-                    message: '系统信息获取成功',
-                    data: result,
-                });
-            },
-        };
-    };
-}
-/**
- * 注册获取系统配置信息工具
- */
-export function registerOpenclawWorkclawSystemConfigTool(api) {
-    api.registerTool(getOpenclawWorkclawSystemConfigTool(api), {
-        name: 'openclaw-workclaw-system-config',
-    });
-}

package/dist/src/tools/openclaw-workclaw-system/src/token/index.js

@@ -1,78 +0,0 @@
-/**
- * 智小途系统信息工具 - 获取用户 AccessToken
- */
-import { resolveWorkclawAccountWithCache } from '../../../../accounts.js';
-import { getWorkclawAccessToken } from '../../../../connection/workclaw-client.js';
-/**
- * 构造工具返回结果
- */
-function json(data) {
-    return {
-        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
-        details: data,
-    };
-}
-/**
- * 获取用户 AccessToken 工具
- */
-function getOpenclawWorkclawSystemTokenTool(api) {
-    return (ctx) => {
-        return {
-            name: 'openclaw-workclaw-system-token',
-            label: '智小途获取 AccessToken',
-            description: '获取用户的 AccessToken',
-            execute: async () => {
-                api.logger.info('[智小途-系统信息] 开始获取 AccessToken');
-                const accountId = ctx?.agentAccountId;
-                if (!accountId) {
-                    api.logger.warn('[智小途-系统信息] 无法获取账户 ID');
-                    return json({ error: '无法获取账户 ID（accountId），请确保已配置账户' });
-                }
-                api.logger.info(`[智小途-系统信息] accountId=${accountId}`);
-                const accountConfig = resolveWorkclawAccountWithCache({
-                    cfg: ctx.config,
-                    accountId,
-                });
-                if (!accountConfig.configured) {
-                    api.logger.error('[智小途-系统信息] 账户未配置');
-                    return json({ error: '账户未配置，请检查账户配置' });
-                }
-                const accConfig = accountConfig.config;
-                try {
-                    const tokenCacheKey = accConfig.appKey || accountId;
-                    api.logger.info(`[智小途-系统信息] 正在获取 AccessToken，accountId=${accountId}`);
-                    const accessToken = await getWorkclawAccessToken(tokenCacheKey, {
-                        baseUrl: accConfig.baseUrl,
-                        appKey: accConfig.appKey,
-                        appSecret: accConfig.appSecret,
-                        allowInsecureTls: accConfig.allowInsecureTls,
-                        requestTimeout: accConfig.requestTimeout,
-                    });
-                    api.logger.info('[智小途-系统信息] AccessToken 获取成功');
-                    return json({
-                        code: 0,
-                        message: 'AccessToken 获取成功',
-                        data: {
-                            accessToken,
-                        },
-                    });
-                }
-                catch (error) {
-                    api.logger.error(`[智小途-系统信息] AccessToken 获取失败 ${error.message}`);
-                    return json({
-                        code: -1,
-                        error: error.message || 'AccessToken 获取失败',
-                    });
-                }
-            },
-        };
-    };
-}
-/**
- * 注册获取用户 AccessToken 工具
- */
-export function registerOpenclawWorkclawSystemTokenTool(api) {
-    api.registerTool(getOpenclawWorkclawSystemTokenTool(api), {
-        name: 'openclaw-workclaw-system-token',
-    });
-}

package/dist/src/types.js

@@ -1 +0,0 @@
-export {};

package/dist/src/utils/content.js

@@ -1,38 +0,0 @@
-/**
- * Content extraction utilities - copied from SDK's internal implementations
- * node_modules/openclaw/dist/plugin-sdk/thread-bindings-SYAnWHuW.js (collectTextContentBlocks)
- * node_modules/openclaw/dist/auth-profiles-DRjqKE3G.js (extractToolResultText)
- */
-/**
- * Extract text blocks from chat content array.
- * Handles content format: [{ type: "text", text: "..." }]
- */
-export function collectTextContentBlocks(content) {
-    if (!Array.isArray(content))
-        return [];
-    const parts = [];
-    for (const block of content) {
-        if (!block || typeof block !== "object")
-            continue;
-        const rec = block;
-        if (rec.type === "text" && typeof rec.text === "string")
-            parts.push(rec.text);
-    }
-    return parts;
-}
-/**
- * Extract plain text from a tool result object.
- * Handles result.content as array of text blocks or direct text fields.
- */
-export function extractToolResultText(result) {
-    if (!result || typeof result !== "object")
-        return;
-    const record = result;
-    const texts = collectTextContentBlocks(record.content).map((item) => {
-        const trimmed = item.trim();
-        return trimmed ? trimmed : void 0;
-    }).filter((value) => Boolean(value));
-    if (texts.length === 0)
-        return;
-    return texts.join("\n");
-}