@workclaw/openclaw-workclaw 1.0.17 → 1.0.19

package/src/tools/openclaw-workclaw-cron/src/remove/sync.ts

@@ -1,127 +0,0 @@
-/**
- * 智小途定时任务工具 - 同步删除定时任务到后端
- */
-
-import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import { resolveOpenclawWorkclawAccount } from '../../../../accounts.js'
-import { callCronJobRemove } from '../../api/index.js'
-
-/**
- * 同步删除定时任务参数
- */
-export interface RemoveSyncParams {
-  jobId: string
-}
-
-/**
- * 参数 Schema 定义
- */
-const RemoveSyncSchema = {
-  type: 'object',
-  properties: {
-    jobId: {
-      type: 'string',
-      description: 'OpenClaw 任务 ID',
-    },
-  },
-  required: ['jobId'],
-} as const
-
-/**
- * 构造工具返回结果
- */
-function json(data: unknown): any {
-  return {
-    content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }],
-    details: data,
-  }
-}
-
-/**
- * 获取同步删除定时任务到后端工具
- */
-function getOpenclawWorkclawCronRemoveSyncTool(api: OpenClawPluginApi) {
-  return (ctx: any) => {
-    return {
-      name: 'openclaw-workclaw-cron-remove-sync',
-      label: '智小途同步删除提醒',
-      description: '【后端同步步骤】将删除定时任务同步到后端。必须在上一步 openclaw-workclaw-cron-remove-params 执行后调用此工具完成同步。',
-      parameters: RemoveSyncSchema,
-      execute: async (_toolCallId: string, params: RemoveSyncParams) => {
-        const p = params as RemoveSyncParams
-
-        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 = resolveOpenclawWorkclawAccount({
-          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: any) {
-            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: OpenClawPluginApi): void {
-  (api.registerTool as any)(getOpenclawWorkclawCronRemoveSyncTool(api), {
-    name: 'openclaw-workclaw-cron-remove-sync',
-  })
-}

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

@@ -1,197 +0,0 @@
-/**
- * 智小途定时任务工具 - 生成修改定时任务参数
- */
-
-import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import {
-  isCronExpression,
-  relativeToCron,
-  validateTimeFormat,
-} from '../../utils/index.js'
-
-/**
- * 生成修改定时任务参数
- */
-export interface UpdateParamsParams {
-  jobId: string
-  time: string
-  name: string
-  message: string
-}
-
-/**
- * 参数 Schema 定义
- */
-const UpdateParamsSchema = {
-  type: 'object',
-  properties: {
-    jobId: {
-      type: 'string',
-      description: 'OpenClaw 任务 ID',
-    },
-    time: {
-      type: 'string',
-      description:
-                '时间描述。相对时间如 "5m"、"1h"；cron 表达式如 "0 8 * * *"',
-    },
-    name: {
-      type: 'string',
-      description: '任务名称',
-    },
-    message: {
-      type: 'string',
-      description: '提醒内容',
-    },
-  },
-  required: ['jobId', 'time', 'name', 'message'],
-} as const
-
-/**
- * 构造工具返回结果
- */
-function json(data: unknown): any {
-  return {
-    content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }],
-    details: data,
-  }
-}
-
-/**
- * 获取生成修改定时任务参数工具
- */
-function getOpenclawWorkclawCronUpdateParamsTool(api: OpenClawPluginApi) {
-  return (ctx: any) => {
-    return {
-      name: 'openclaw-workclaw-cron-update-params',
-      label: '智小途生成修改提醒参数',
-      description: `【必须执行的核心步骤】生成修改提醒的 cronParams 参数。
-
-📋 工作流程（必须按顺序执行）：
-1. ✅ 调用此工具获取 cronParams 参数
-2. ✅ 使用返回的 cronParams 调用 OpenClaw 的 cron 工具
-3. ✅ 【关键步骤】必须调用 openclaw-workclaw-cron-update-sync 同步到后端
-
-🔒 强制规则（必须遵守）：
-- ✅ 生成的 cronParams 中 schedule.kind 必须是 "cron"
-- ✅ 调用 cron 工具时必须使用 --cron 参数
-- ❌ 严禁将 cron 表达式转换为 --at 绝对时间参数
-- ❌ 严禁将 kind: "cron" 转换为其他类型
-- ✅ 使用 --session isolated + --message（agentTurn），禁止使用 --system-event
-
-⚠️ 重要提醒：
-- time 参数支持相对时间（如 "10m"、"1h"），内部会转换为 cron 表达式
-- 最终执行的 CLI 命令必须是 --cron 参数（绝对禁止使用 --at）
-- 必须从 cron 工具返回值中确认更新成功
-- 如果不执行步骤3，后端的定时任务信息将无法同步更新！
-`,
-      parameters: UpdateParamsSchema,
-      execute: async (_toolCallId: string, params: UpdateParamsParams) => {
-        const p = params as UpdateParamsParams
-
-        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: string
-
-        // 如果是相对时间（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' as const,
-          jobId: p.jobId,
-          job: {
-            name,
-            schedule: {
-              kind: 'cron' as const,
-              expr: cronExpr,
-              tz: 'Asia/Shanghai',
-            },
-            sessionTarget: 'isolated',
-            wakeMode: 'now' as const,
-            deleteAfterRun: isOneTime ? true : undefined,
-            payload: {
-              kind: 'agentTurn' as const,
-              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: OpenClawPluginApi): void {
-  (api.registerTool as any)(getOpenclawWorkclawCronUpdateParamsTool(api), {
-    name: 'openclaw-workclaw-cron-update-params',
-  })
-}

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

@@ -1,161 +0,0 @@
-/**
- * 智小途定时任务工具 - 同步修改定时任务到后端
- */
-
-import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import { resolveOpenclawWorkclawAccount } from '../../../../accounts.js'
-import { callCronJobUpdate } from '../../api/index.js'
-
-/**
- * 同步修改定时任务参数
- */
-export interface UpdateSyncParams {
-  jobId: string
-  name: string
-  kind: 'cron'
-  expr?: string
-  message: string
-}
-
-/**
- * 参数 Schema 定义
- */
-const UpdateSyncSchema = {
-  type: 'object',
-  properties: {
-    jobId: {
-      type: 'string',
-      description: 'OpenClaw 任务 ID',
-    },
-    name: {
-      type: 'string',
-      description: '任务名称',
-    },
-    kind: {
-      type: 'string',
-      description: '任务类型：at 或 cron',
-      enum: ['cron'],
-    },
-    expr: {
-      type: 'string',
-      description: 'Cron 表达式（kind=cron 时必填）',
-    },
-    message: {
-      type: 'string',
-      description: '提醒消息',
-    },
-  },
-  required: ['jobId', 'name', 'kind', 'message'],
-} as const
-
-/**
- * 构造工具返回结果
- */
-function json(data: unknown): any {
-  return {
-    content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }],
-    details: data,
-  }
-}
-
-/**
- * 获取同步修改定时任务到后端工具
- */
-function getOpenclawWorkclawCronUpdateSyncTool(api: OpenClawPluginApi) {
-  return (ctx: any) => {
-    return {
-      name: 'openclaw-workclaw-cron-update-sync',
-      label: '智小途同步修改提醒',
-      description: '将修改定时任务同步到后端。在 cron 工具修改任务后调用此工具同步后端。',
-      parameters: UpdateSyncSchema,
-      execute: async (_toolCallId: string, params: UpdateSyncParams) => {
-        const p = params as UpdateSyncParams
-
-        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 = resolveOpenclawWorkclawAccount({
-          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: any) {
-          api.logger.error(`[智小途-同步修改] 后端同步异常 ${error.message}`)
-          return json({
-            code: -1,
-            error: error.message,
-            data: { jobId: p.jobId, name: p.name },
-          })
-        }
-      },
-    }
-  }
-}
-
-/**
- * 注册同步修改定时任务到后端工具
- */
-export function registerOpenclawWorkclawCronUpdateSyncTool(api: OpenClawPluginApi): void {
-  (api.registerTool as any)(getOpenclawWorkclawCronUpdateSyncTool(api), {
-    name: 'openclaw-workclaw-cron-update-sync',
-  })
-}

package/src/tools/openclaw-workclaw-cron/types/index.ts

@@ -1,55 +0,0 @@
-/**
- * 智小途定时任务工具 - 类型定义
- */
-
-/**
- * 后端接口请求体
- */
-export interface CronJobPayload {
-  agentId: string
-  messageId: string
-  clawJobId: string
-  name: string
-  kind: 'cron'
-  expr?: string
-  message: string
-}
-
-/**
- * OpenClaw cron 工具参数
- */
-export interface OpenClawCronParams {
-  action: 'add' | 'list' | 'remove' | 'update' | 'enable' | 'disable'
-  job?: {
-    agentId: string
-    name: string
-    schedule: {
-      kind: 'cron'
-      expr: string
-      tz: string
-    }
-    sessionTarget: 'isolated'
-    wakeMode: 'now'
-    deleteAfterRun?: boolean
-    payload: {
-      kind: 'agentTurn'
-      message: string
-    }
-    delivery: {
-      mode: 'announce'
-      channel: string
-      to: string
-    }
-  }
-  jobId?: string
-}
-
-/**
- * 工具返回结果
- */
-export interface CronToolResult {
-  success: boolean
-  jobId?: string
-  jobs?: any[]
-  error?: string
-}

package/src/tools/openclaw-workclaw-cron/utils/index.ts

@@ -1,141 +0,0 @@
-/**
- * 智小途定时任务工具 - 工具函数
- */
-
-/**
- * 解析相对时间字符串
- * 支持格式：5m, 1h, 1h30m, 2d, 30s, 1d2h30m 等
- * @param timeStr - 时间字符串
- * @returns 毫秒数，解析失败返回 null
- */
-export function parseRelativeTime(timeStr: string): number | null {
-  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: RegExpExecArray | null
-  // 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: string): boolean {
-  const parts = timeStr.trim().split(/\s+/)
-  return parts.length >= 3 && parts.length <= 6
-}
-
-/**
- * 校验 cron 表达式格式
- * @param timeStr - 时间字符串
- * @returns 校验结果和错误信息
- */
-export function validateCronExpression(timeStr: string): { valid: boolean, error?: string } {
-  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: string): { valid: boolean, error?: string } {
-  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: string): string {
-  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} *`
-}