@workclaw/openclaw-workclaw 1.0.18 → 1.0.20

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

@@ -1,326 +0,0 @@
-/**
- * 智小途定时任务工具 - 后端接口封装
- */
-
-import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import type { WorkclawConnectionConfig } from '../../../connection/workclaw-client.js'
-import { resolveWorkclawAccountWithCache } from '../../../accounts.js'
-import { doFetchJson, getWorkclawAccessToken, normalizeBaseUrl } from '../../../connection/workclaw-client.js'
-
-const DEFAULT_MAX_RETRIES = 3
-const DEFAULT_RETRY_DELAY_MS = 1000
-
-/**
- * 睡眠函数
- */
-function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms))
-}
-
-/**
- * 带重试机制的 fetch 调用
- */
-async function fetchWithRetry<T>(
-  fetchFn: () => Promise<T>,
-  options: {
-    maxRetries?: number
-    retryDelayMs?: number
-    retryableErrors?: string[]
-  } = {},
-): Promise<{ data?: T, error?: string, attempts: number }> {
-  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES
-  const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS
-  const retryableErrors = options.retryableErrors ?? [
-    'ECONNREFUSED',
-    'ETIMEDOUT',
-    'ENOTFOUND',
-    'ENETUNREACH',
-    'EAI_AGAIN',
-  ]
-
-  let lastError: string = ''
-  let attempts = 0
-
-  for (let i = 0; i <= maxRetries; i++) {
-    attempts = i + 1
-    try {
-      const data = await fetchFn()
-      return { data, attempts }
-    }
-    catch (error: any) {
-      lastError = error.message || String(error)
-
-      const isRetryable = retryableErrors.some(
-        e => lastError.toLowerCase().includes(e.toLowerCase()),
-      )
-
-      if (i < maxRetries && isRetryable) {
-        const delay = retryDelayMs * 2 ** i
-        await sleep(delay)
-        continue
-      }
-
-      break
-    }
-  }
-
-  return { error: lastError, attempts }
-}
-
-/**
- * 脱敏日志输出（隐藏敏感字段）
- */
-function sanitizePayload(payload: Record<string, any>): Record<string, any> {
-  const sensitiveFields = [
-    'password',
-    'secret',
-    'token',
-    'authorization',
-    'appSecret',
-    'appSecret',
-  ]
-
-  const sanitized: Record<string, any> = {}
-  for (const [key, value] of Object.entries(payload)) {
-    const lowerKey = key.toLowerCase()
-    if (sensitiveFields.some(f => lowerKey.includes(f))) {
-      sanitized[key] = '***'
-    }
-    else if (typeof value === 'object' && value !== null) {
-      sanitized[key] = sanitizePayload(value as Record<string, any>)
-    }
-    else {
-      sanitized[key] = value
-    }
-  }
-  return sanitized
-}
-
-/**
- * 调用后端 API 的通用方法
- * @param api - OpenClaw API 实例
- * @param accountId - 账户 ID
- * @param path - API 路径
- * @param payload - 请求体
- * @param options - 可选配置
- * @returns 接口调用结果
- */
-export async function callBackendApi(
-  api: OpenClawPluginApi,
-  accountId: string,
-  path: string,
-  payload: Record<string, any>,
-  options: {
-    maxRetries?: number
-  } = {},
-): Promise<{ success: boolean, data?: any, error?: string, attempts?: number }> {
-  try {
-    const account = resolveWorkclawAccountWithCache({
-      cfg: api.config,
-      accountId,
-    })
-
-    if (!account.configured) {
-      api.logger.error(`[智小途-定时任务] 账户未配置 accountId=${accountId}`)
-      return { success: false, error: 'Account not configured' }
-    }
-
-    const accConfig = account.config as any
-    const tokenCacheKey = accConfig.appKey || accountId
-    const baseUrl = normalizeBaseUrl(accConfig.baseUrl)
-
-    api.logger.info(`[智小途-定时任务] 正在获取认证 token，accountId=${accountId}`)
-
-    const token = await getWorkclawAccessToken(tokenCacheKey, {
-      baseUrl: accConfig.baseUrl,
-      appKey: accConfig.appKey,
-      appSecret: accConfig.appSecret,
-      allowInsecureTls: accConfig.allowInsecureTls,
-      requestTimeout: accConfig.requestTimeout,
-    } as WorkclawConnectionConfig)
-
-    const requestUrl = `${baseUrl}/open-apis${path}`
-    const sanitizedPayload = sanitizePayload(payload)
-    api.logger.info(`[智小途-定时任务] 调用接口 ${requestUrl}`)
-    api.logger.info(`[智小途-定时任务] 请求参数 ${JSON.stringify(sanitizedPayload)}`)
-
-    const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES
-
-    const fetchResult = await fetchWithRetry(
-      () =>
-        doFetchJson(
-          requestUrl,
-          {
-            method: 'POST',
-            headers: {
-              'Content-Type': 'application/json',
-              'Authorization': `Bearer ${token}`,
-            },
-            body: JSON.stringify(payload),
-          },
-          accConfig.allowInsecureTls,
-          accConfig.requestTimeout,
-        ),
-      { maxRetries },
-    )
-
-    if (fetchResult.error) {
-      api.logger.error(`[智小途-定时任务] 接口调用失败（已重试 ${fetchResult.attempts} 次）: ${fetchResult.error}`)
-      return { success: false, error: fetchResult.error, attempts: fetchResult.attempts }
-    }
-
-    const data = fetchResult.data
-    api.logger.info(`[智小途-定时任务] 接口响应（尝试 ${fetchResult.attempts} 次）: ${JSON.stringify(data)}`)
-
-    if (data?.code === 200 || data?.code === 0) {
-      return { success: true, data, attempts: fetchResult.attempts }
-    }
-    else {
-      const errorMsg = data?.message || data?.msg || 'Unknown error'
-      api.logger.error(`[智小途-定时任务] 接口返回错误 ${errorMsg}`)
-      return { success: false, error: errorMsg }
-    }
-  }
-  catch (error: any) {
-    api.logger.error(`[智小途-定时任务] 接口调用异常 ${error.message}`)
-    return { success: false, error: error.message }
-  }
-}
-
-/**
- * 调用新增定时任务接口
- */
-export async function callCronJobAdd(
-  api: OpenClawPluginApi,
-  accountId: string,
-  payload: {
-    jobId: string
-    name: string
-    kind: 'cron'
-    expr?: string
-    message: string
-    messageId?: string
-  },
-): Promise<{ success: boolean, data?: any, error?: string }> {
-  api.logger.info(`[智小途-定时任务] 新增定时任务 jobId=${payload.jobId} name=${payload.name}`)
-
-  const result = await callBackendApi(api, accountId, '/cron/job/add', {
-    clawJobId: payload.jobId,
-    name: payload.name,
-    kind: payload.kind,
-    expr: payload.expr || '',
-    message: payload.message,
-    agentId: payload.messageId || '0',
-  })
-
-  return { success: result.success, data: result.data, error: result.error }
-}
-
-/**
- * 调用删除定时任务接口
- */
-export async function callCronJobRemove(
-  api: OpenClawPluginApi,
-  accountId: string,
-  payload: {
-    jobId: string
-  },
-): Promise<{ success: boolean, data?: any, error?: string }> {
-  api.logger.info(`[智小途-定时任务] 删除定时任务 jobId=${payload.jobId}`)
-
-  const result = await callBackendApi(api, accountId, '/cron/job/del', {
-    clawJobId: payload.jobId,
-  })
-
-  return { success: result.success, data: result.data, error: result.error }
-}
-
-/**
- * 调用更新定时任务接口
- */
-export async function callCronJobUpdate(
-  api: OpenClawPluginApi,
-  accountId: string,
-  payload: {
-    jobId: string
-    name: string
-    kind: 'cron'
-    expr?: string
-    message: string
-    agentId?: string
-  },
-): Promise<{ success: boolean, data?: any, error?: string }> {
-  api.logger.info(`[智小途-定时任务] 更新定时任务 jobId=${payload.jobId} name=${payload.name} agentId=${payload.agentId}`)
-
-  const result = await callBackendApi(api, accountId, '/cron/job/update', {
-    clawJobId: payload.jobId,
-    name: payload.name,
-    kind: payload.kind,
-    expr: payload.expr || '',
-    message: payload.message,
-    agentId: payload.agentId || '0',
-  })
-
-  return { success: result.success, data: result.data, error: result.error }
-}
-
-/**
- * 调用启用定时任务接口
- */
-export async function callCronJobEnabled(
-  api: OpenClawPluginApi,
-  accountId: string,
-  payload: {
-    jobId: string
-  },
-): Promise<{ success: boolean, data?: any, error?: string }> {
-  api.logger.info(`[智小途-定时任务] 启用定时任务 jobId=${payload.jobId}`)
-
-  const result = await callBackendApi(api, accountId, '/cron/job/enabled', {
-    clawJobId: payload.jobId,
-  })
-
-  return { success: result.success, data: result.data, error: result.error }
-}
-
-/**
- * 调用禁用定时任务接口
- */
-export async function callCronJobDisabled(
-  api: OpenClawPluginApi,
-  accountId: string,
-  payload: {
-    jobId: string
-  },
-): Promise<{ success: boolean, data?: any, error?: string }> {
-  api.logger.info(`[智小途-定时任务] 禁用定时任务 jobId=${payload.jobId}`)
-
-  const result = await callBackendApi(api, accountId, '/cron/job/disabled', {
-    clawJobId: payload.jobId,
-  })
-
-  return { success: result.success, data: result.data, error: result.error }
-}
-
-/**
- * 调用定时任务触发通知接口
- */
-export async function callCronJobMessage(
-  api: OpenClawPluginApi,
-  accountId: string,
-  payload: {
-    jobId: string
-    message: string
-    agentId?: string
-  },
-): Promise<{ success: boolean, data?: any, error?: string }> {
-  api.logger.info(`[智小途-定时任务] 定时任务触发通知 jobId=${payload.jobId} message=${payload.message} agentId=${payload.agentId}`)
-
-  const result = await callBackendApi(api, accountId, '/cron/job/message', {
-    clawJobId: payload.jobId,
-    message: payload.message,
-    agentId: payload.agentId || '0',
-  })
-
-  return { success: result.success, data: result.data, error: result.error }
-}

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

@@ -1,177 +0,0 @@
-/**
- * 智小途定时任务工具 - 生成创建定时任务参数
- */
-
-import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import { isCronExpression, relativeToCron, validateTimeFormat } from '../../utils/index.js'
-
-/**
- * 生成创建定时任务参数
- */
-export interface AddParamsParams {
-  time: string
-  name: string
-  message: string
-}
-
-/**
- * 参数 Schema 定义
- */
-const AddParamsSchema = {
-  type: 'object',
-  properties: {
-    time: {
-      type: 'string',
-      description: '⏰ 时间（核心！），支持相对时间和 cron 表达式，工具自动转换',
-    },
-    name: {
-      type: 'string',
-      description: '任务名称',
-    },
-    message: {
-      type: 'string',
-      description: '提醒内容',
-    },
-  },
-  required: ['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 getOpenclawWorkclawCronAddParamsTool(api: OpenClawPluginApi) {
-  return (ctx: any) => {
-    return {
-      name: 'openclaw-workclaw-cron-add-params',
-      label: '智小途生成创建提醒参数',
-      description: `【核心工具】生成创建提醒的 cronParams 参数。
-
-📋 工作流程（必须按顺序执行）：
-1. 调用此工具获取 cronParams 参数
-2. 使用返回的 cronParams 调用 OpenClaw 的 cron 工具
-3. 从 cron 工具返回值中提取 jobId（返回格式：{"success": true, "jobId": "xxx"}）
-4. 必须调用 openclaw-workclaw-cron-add-sync 同步到后端
-
-⏰ 时间格式（核心！）：
-- time 参数支持相对时间（如 "5m"、"1h"、"2d"）和 cron 表达式
-- 工具会自动将所有时间统一转换为 cron 表达式
-- 严禁使用 --at 参数或其他绝对时间格式
-- 最终 CLI 命令必须使用 --cron 参数
-
-🔒 强制规则：
-- schedule.kind 必须是 "cron"
-- 必须使用 --cron 参数传递 cron 表达式
-
-⚠️ 必须从 cron 工具返回值中提取 jobId，不能凭空编造！`,
-      parameters: AddParamsSchema,
-      execute: async (_toolCallId: string, params: AddParamsParams) => {
-        const p = params as AddParamsParams
-
-        api.logger.info(`[智小途-生成参数] 开始生成创建提醒参数 name=${p.name} time=${p.time}`)
-
-        // 参数校验
-        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
-        if (!accountId) {
-          api.logger.warn('[智小途-生成参数] 无法获取账户 ID')
-          return json({ error: '无法获取账户 ID（accountId），请确保已配置账户' })
-        }
-
-        api.logger.info(`[智小途-生成参数] accountId=${accountId} name=${p.name}`)
-
-        // 校验时间格式
-        const timeValidation = validateTimeFormat(p.time)
-        if (!timeValidation.valid) {
-          api.logger.warn(`[智小途-生成参数] 时间格式校验失败: ${timeValidation.error}`)
-          return json({ error: timeValidation.error })
-        }
-
-        // 判断时间类型并转换为 cron 表达式
-        const isCron = isCronExpression(p.time)
-        let isOneTime = false
-        let cronExpr: string
-
-        if (!isCron) {
-          // 相对时间转换为 cron 表达式
-          isOneTime = true
-          cronExpr = relativeToCron(p.time.trim())
-          api.logger.info(`[智小途-生成参数] 相对时间转换为 cron 表达式 cronExpr=${cronExpr}`)
-        }
-        else {
-          cronExpr = p.time.trim()
-        }
-
-        // 构建 cron 参数
-        const cronParams: Record<string, any> = {
-          action: 'add' as const,
-          account: accountId,
-          job: {
-            name: p.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: p.message,
-            },
-            delivery: {
-              mode: 'announce',
-              channel: 'openclaw-workclaw',
-            },
-          },
-        }
-
-        api.logger.info(`[智小途-生成参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`)
-
-        return json({
-          cronParams,
-          meta: {
-            accountId,
-            name: p.name,
-            kind: 'cron',
-            expr: cronExpr,
-            message: p.message,
-          },
-          summary: `⏰ 提醒已生成: "${p.name}" (${p.time})`,
-        })
-      },
-    }
-  }
-}
-
-/**
- * 注册生成创建定时任务参数工具
- */
-export function registerOpenclawWorkclawCronAddParamsTool(api: OpenClawPluginApi): void {
-  (api.registerTool as any)(getOpenclawWorkclawCronAddParamsTool(api), {
-    name: 'openclaw-workclaw-cron-add-params',
-  })
-}

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

@@ -1,188 +0,0 @@
-/**
- * 智小途定时任务工具 - 同步创建定时任务到后端
- */
-
-import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import { resolveWorkclawAccountWithCache } from '../../../../accounts.js'
-import { callCronJobAdd } from '../../api/index.js'
-
-/**
- * 同步创建定时任务参数
- */
-export interface AddSyncParams {
-  jobId: string
-  name: string
-  kind: 'cron'
-  expr?: string
-  message: string
-}
-
-/**
- * 参数 Schema 定义
- */
-const AddSyncSchema = {
-  type: 'object',
-  properties: {
-    jobId: {
-      type: 'string',
-      description: `⛔ 重要：jobId 必须从 OpenClaw cron 工具返回值中提取，格式：{"success": true, "jobId": "123456"}
-
-常见错误：
-- 把 cron 表达式（如 "31 12 11 31 3 *"）当作 jobId
-- 把 name 当作 jobId
-- 编造 jobId
-
-正确做法：
-1. 调用 openclaw-workclaw-cron-add-params
-2. 用返回的 cronParams 调用 cron 工具
-3. 从返回值提取 jobId（如 "7382945612345"）
-4. 用提取到的 jobId 调用此工具`,
-    },
-    name: {
-      type: 'string',
-      description: '任务名称，与 add-params 中传入的 name 一致',
-    },
-    kind: {
-      type: 'string',
-      description: '任务类型',
-      enum: ['cron'],
-    },
-    expr: {
-      type: 'string',
-      description: 'Cron 表达式',
-    },
-    message: {
-      type: 'string',
-      description: '提醒消息，与 add-params 中传入的 message 一致',
-    },
-  },
-  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 getOpenclawWorkclawCronAddSyncTool(api: OpenClawPluginApi) {
-  return (ctx: any) => {
-    return {
-      name: 'openclaw-workclaw-cron-add-sync',
-      label: '智小途同步创建提醒',
-      description: `【后端同步步骤】将创建定时任务同步到后端。必须在上一步 openclaw-workclaw-cron-add-params 执行后调用此工具完成同步。
-
-⚠️ jobId 必须是 cron 工具返回值 {"success": true, "jobId": "xxx"} 中的 jobId 字段！`,
-      parameters: AddSyncSchema,
-      execute: async (_toolCallId: string, params: AddSyncParams) => {
-        const p = params as AddSyncParams
-
-        api.logger.info(`[智小途-同步创建] 开始同步 jobId=${p.jobId} name=${p.name}`)
-
-        // 参数校验
-        if (!p.jobId) {
-          api.logger.warn('[智小途-同步创建] 缺少 jobId 参数')
-          return json({ error: 'jobId 为必填参数' })
-        }
-
-        // 检查 jobId 是否被错误地设置为 cron 表达式
-        const jobIdTrimmed = p.jobId.trim()
-        const parts = jobIdTrimmed.split(/\s+/)
-        const isCronExpression = parts.length >= 5 && parts.length <= 6 && jobIdTrimmed.includes('*')
-
-        if (isCronExpression) {
-          api.logger.error(`[智小途-同步创建] jobId 格式错误！jobId=${p.jobId}，看起来像 cron 表达式`)
-          return json({
-            error: `jobId="${p.jobId}" 是 cron 表达式，不是任务 ID！jobId 应来自 cron 工具返回值，如 "123456" 或 "abc123"`,
-          })
-        }
-
-        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
-        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 callCronJobAdd(api, accountId, {
-              jobId: p.jobId,
-              name: p.name,
-              kind: p.kind,
-              expr: p.expr,
-              message: p.message,
-              messageId: 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 },
-            })
-          }
-        }
-        else {
-          api.logger.error(`[智小途-同步创建] 无法获取渠道配置，accountId=${accountId}`)
-          return json({ error: '无法获取渠道配置，请检查账户配置' })
-        }
-      },
-    }
-  }
-}
-
-/**
- * 注册同步创建定时任务到后端工具
- */
-export function registerOpenclawWorkclawCronAddSyncTool(api: OpenClawPluginApi): void {
-  (api.registerTool as any)(getOpenclawWorkclawCronAddSyncTool(api), {
-    name: 'openclaw-workclaw-cron-add-sync',
-  })
-}