@workclaw/openclaw-workclaw 1.0.19 → 1.0.23

package/src/gateway/config-writer.ts

@@ -0,0 +1,378 @@
+/**
+ * Config Writer - handles writing account config to openclaw.json
+ *
+ * NOTE: Only agent creation/initialization writes to openclaw.json via writeConfigFile.
+ * Runtime dynamic data (openConversationId) is stored in a separate state file
+ * to avoid triggering openclaw's config watcher, which would re-parse env vars
+ * and potentially overwrite already-resolved values like ${MODEL_API_KEY}.
+ */
+
+import { execSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { getWorkclawRuntime } from '../runtime.js'
+
+/** 修复目录所有权（仅非 Windows 环境） */
+function fixOwner(dir: string): void {
+  if (process.platform === 'win32')
+    return
+  try { execSync(`chown -R node:node "${dir}"`, { stdio: 'ignore' }) }
+  catch {}
+}
+
+interface ConfigLogger {
+  info?: (msg: string) => void
+  error?: (msg: string) => void
+}
+
+const STATE_DIR = join('workclaw', 'data')
+
+// 写入节流时间（避免频繁写入）
+const SAVE_THROTTLE_MS = 1000
+
+// 每个账户的上次写入时间，key 格式: accountId:userId
+const lastSaveTimeMap = new Map<string, number>()
+
+/**
+ * Find the actual openclaw.json config path.
+ */
+function findConfigPath(): string {
+  // Prefer homedir config over cwd, since cwd might be the project directory
+  // which could have a stale or unrelated openclaw.json
+  const configPaths = [
+    join(homedir(), '.openclaw', 'openclaw.json'),
+    join(homedir(), '.openclaw', 'config.json'),
+    join(process.cwd(), 'openclaw.json'),
+    join(process.cwd(), 'config.json'),
+  ]
+
+  const found = configPaths.find(p => existsSync(p))
+  return found ?? join(homedir(), '.openclaw', 'openclaw.json')
+}
+
+/**
+ * Get the state directory for workclaw runtime data.
+ * Uses ~/.openclaw as the canonical base, consistent with openclaw's recommended layout.
+ */
+function findStateDir(): string {
+  const stateDir = join(homedir(), '.openclaw')
+  return join(stateDir, STATE_DIR)
+}
+
+function getStateFilePath(): string {
+  return join(findStateDir(), 'conversations.json')
+}
+
+/**
+ * Write a new config to the openclaw.json file.
+ */
+export async function writeConfigFile(
+  newConfig: any,
+  cfg: any,
+  log?: ConfigLogger,
+): Promise<void> {
+  try {
+    const runtime = getWorkclawRuntime()
+    const configApi = runtime.config as {
+      writeConfigFile: (cfg: unknown) => Promise<void>
+    }
+    await configApi.writeConfigFile(newConfig)
+    log?.info?.(`[WriteConfig] Config written via runtime.config.writeConfigFile`)
+    Object.assign(cfg, newConfig)
+  }
+  catch (err) {
+    log?.error?.(`[WriteConfig] Failed to write config: ${String(err)}`)
+    throw err
+  }
+}
+
+/**
+ * Load openConversationId from the separate state file.
+ *
+ * Key format: accountId:userId
+ *
+ * Called at runtime to restore openConversationId after process restart,
+ * since cfg is reloaded from openclaw.json which does not contain this value.
+ */
+export function loadOpenConversationId(accountId: string, userId: string): string | null {
+  const statePath = getStateFilePath()
+  const key = `${accountId}:${userId}`
+  try {
+    if (!existsSync(statePath))
+      return null
+    const content = readFileSync(statePath, 'utf-8')
+    const state = JSON.parse(content) as Record<string, Record<string, string>>
+    return state[key]?.openConversationId ?? null
+  }
+  catch {
+    return null
+  }
+}
+
+/**
+ * Save openConversationId to a separate state file (with write throttling).
+ *
+ * Key format: accountId:userId
+ * Throttling: if called multiple times within 1 second, only the last value is saved.
+ * This avoids excessive disk writes from high-frequency messages.
+ *
+ * Stored in ~/.openclaw/workclaw-state/conversations.json (separate from openclaw.json)
+ * to avoid triggering openclaw's config watcher which would re-parse env vars.
+ */
+export async function saveOpenConversationId(
+  accountId: string,
+  userId: string,
+  openConversationId: string,
+  cfg: any,
+  log?: ConfigLogger,
+): Promise<void> {
+  const key = `${accountId}:${userId}`
+
+  // Also update cfg memory immediately
+  const workclawCfg = cfg?.channels?.['openclaw-workclaw']
+  if (workclawCfg?.accounts?.[accountId]) {
+    workclawCfg.accounts[accountId].openConversationId = openConversationId
+  }
+
+  // Throttle: skip if written recently
+  const lastSaveTime = lastSaveTimeMap.get(key) ?? 0
+  const now = Date.now()
+  if (now - lastSaveTime < SAVE_THROTTLE_MS) {
+    return
+  }
+
+  // Write immediately — never lose a pending value on crash
+  await doSaveOpenConversationId(key, openConversationId, log)
+  lastSaveTimeMap.set(key, now)
+}
+
+async function doSaveOpenConversationId(
+  key: string,
+  openConversationId: string,
+  log?: ConfigLogger,
+): Promise<void> {
+  try {
+    const statePath = getStateFilePath()
+    let state: Record<string, Record<string, string>> = {}
+
+    if (existsSync(statePath)) {
+      try {
+        const content = await readFile(statePath, 'utf-8')
+        state = JSON.parse(content)
+      }
+      catch (parseErr) {
+        log?.error?.(`SaveConversation: Failed to parse state file: ${String(parseErr)}`)
+      }
+    }
+
+    if (!state[key])
+      state[key] = {}
+    // Skip write only when the value is the same (and not empty/null)
+    const existing = state[key].openConversationId
+    if (existing === openConversationId && existing != null && existing !== '') {
+      return
+    }
+    state[key].openConversationId = openConversationId
+
+    // Ensure state dir exists
+    const stateDir = findStateDir()
+    if (!existsSync(stateDir)) {
+      try {
+        await mkdir(stateDir, { recursive: true, mode: 0o755 })
+      }
+      catch (mkdirErr: any) {
+        if (mkdirErr.code === 'EACCES' || mkdirErr.code === 'EPERM') {
+          // Docker/non-root: retry with loose permissions
+          await mkdir(stateDir, { recursive: true, mode: 0o777 })
+        }
+        else {
+          throw mkdirErr
+        }
+      }
+      // 修复权限（目录可能已存在但权限不对）
+      fixOwner(stateDir)
+    }
+
+    // Atomic write: write to tmp file then rename
+    const tmpPath = `${statePath}.tmp`
+    await writeFile(tmpPath, JSON.stringify(state, null, 2), 'utf-8')
+    await rename(tmpPath, statePath)
+    log?.info?.(`SaveConversation: Saved openConversationId for key ${key}`)
+  }
+  catch (err) {
+    log?.error?.(`SaveConversation: Failed to write state file: ${String(err)}`)
+  }
+}
+
+/**
+ * Initialize workclaw agent config in one shot (hardware device init).
+ *
+ * Sets apiKey, agentId, userId and persists to openclaw.json in a single write.
+ *
+ * NOTE: If apiKey already contains a SecretRef (type: "env"|"file"|"exec"),
+ * it is preserved and NOT overwritten, since OpenClaw handles SecretRef resolution.
+ */
+export async function initWorkclawAgent(
+  params: {
+    apiKey?: string
+    agentId?: string
+    userId?: string
+    accountId?: string
+  },
+  cfg: any,
+  log?: ConfigLogger,
+): Promise<void> {
+  try {
+    const workclawCfg = cfg?.channels?.['openclaw-workclaw']
+    if (!workclawCfg)
+      return
+
+    if (params.apiKey) {
+      // Check if existing value is a SecretRef object - if so, skip to preserve it
+      const existingApiKey = cfg.models?.providers?.['sophnet-minimax']?.apiKey
+      if (existingApiKey && typeof existingApiKey === 'object' && existingApiKey.type) {
+        log?.info?.(`initWorkclawAgent: apiKey is SecretRef (type=${existingApiKey.type}), skipping overwrite`)
+      }
+      else {
+        if (!cfg.models)
+          cfg.models = {}
+        if (!cfg.models.providers)
+          cfg.models.providers = {}
+        if (!cfg.models.providers['sophnet-minimax'])
+          cfg.models.providers['sophnet-minimax'] = {}
+        cfg.models.providers['sophnet-minimax'].apiKey = params.apiKey
+        log?.info?.(`initWorkclawAgent: apiKey set (plain value)`)
+      }
+    }
+
+    if (params.agentId) {
+      const accountId = params.accountId || 'default'
+      const accounts = workclawCfg.accounts ?? {}
+      workclawCfg.accounts = accounts
+      if (!accounts[accountId])
+        accounts[accountId] = {}
+      accounts[accountId].agentId = params.agentId
+      log?.info?.(`initWorkclawAgent: agentId=${params.agentId} set for ${accountId}`)
+    }
+
+    if (params.userId) {
+      workclawCfg.userId = params.userId
+      log?.info?.(`initWorkclawAgent: userId=${params.userId} set`)
+    }
+
+    // Single write to persist all
+    await writeConfigFile(cfg, cfg, log)
+    log?.info?.(`initWorkclawAgent: all config persisted`)
+  }
+  catch (err) {
+    log?.error?.(`initWorkclawAgent: failed: ${String(err)}`)
+    throw err
+  }
+}
+
+/**
+ * Save userId to cfg memory and persist to openclaw.json.
+ *
+ * Used during hardware device initialization to persist the default userId.
+ */
+export async function saveWorkClawUserId(
+  accountId: string,
+  userId: string | number,
+  cfg: any,
+  log?: ConfigLogger,
+): Promise<void> {
+  try {
+    const workclawCfg = cfg?.channels?.['openclaw-workclaw']
+    if (!workclawCfg)
+      return
+    workclawCfg.userId = userId
+    log?.info?.(`SaveUserId: Saved userId ${userId} for account ${accountId}`)
+
+    // Persist to openclaw.json via framework API
+    await writeConfigFile(cfg, cfg, log)
+  }
+  catch (err) {
+    log?.error?.(`SaveUserId: Failed to update cfg: ${String(err)}`)
+    throw err
+  }
+}
+
+/**
+ * Save agentId to cfg memory and persist to openclaw.json.
+ *
+ * Used during hardware device initialization to persist the default agentId.
+ */
+export async function saveWorkClawAgentId(
+  accountId: string,
+  agentId: string | number,
+  cfg: any,
+  log?: ConfigLogger,
+): Promise<void> {
+  try {
+    const workclawCfg = cfg?.channels?.['openclaw-workclaw']
+    if (!workclawCfg)
+      return
+
+    const accounts = workclawCfg.accounts
+    let savedToAccount: string | null = null
+
+    if (accounts?.[accountId]) {
+      accounts[accountId].agentId = agentId
+      savedToAccount = accountId
+    }
+    else if (accounts?.default) {
+      if (!accounts.default.agentId) {
+        accounts.default.agentId = agentId
+        savedToAccount = 'default'
+        log?.info?.(`SaveAgentId: Saved agentId ${agentId} to default account`)
+      }
+    }
+    else {
+      log?.info?.(`SaveAgentId: Account ${accountId} not found, default account also missing`)
+    }
+
+    if (savedToAccount) {
+      log?.info?.(`SaveAgentId: Saved agentId ${agentId} for account ${savedToAccount}`)
+    }
+
+    // Persist to openclaw.json via framework API
+    await writeConfigFile(cfg, cfg, log)
+  }
+  catch (err) {
+    log?.error?.(`SaveAgentId: Failed to update cfg: ${String(err)}`)
+    throw err
+  }
+}
+
+/**
+ * Save apiKey to cfg memory only.
+ *
+ * Does NOT write to openclaw.json to avoid triggering openclaw's config watcher,
+ * which would re-parse env vars (e.g. ${MODEL_API_KEY}) and potentially
+ * overwrite resolved values in the runtime cfg.
+ */
+export async function saveWorkClawApiKey(
+  apiKey: string,
+  cfg: any,
+  log?: ConfigLogger,
+): Promise<void> {
+  try {
+    if (!cfg.models)
+      cfg.models = {}
+    if (!cfg.models.providers)
+      cfg.models.providers = {}
+    if (!cfg.models.providers['sophnet-minimax'])
+      cfg.models.providers['sophnet-minimax'] = {}
+    cfg.models.providers['sophnet-minimax'].apiKey = apiKey
+    log?.info?.(`SaveApiKey: Saved apiKey to cfg`)
+
+    // Persist to openclaw.json via framework API
+    await writeConfigFile(cfg, cfg, log)
+  }
+  catch (err) {
+    log?.error?.(`SaveApiKey: Failed to update cfg: ${String(err)}`)
+    throw err
+  }
+}

package/src/gateway/cron-tasks-handler.ts

@@ -0,0 +1,230 @@
+import { exec } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const execAsync = promisify(exec)
+
+// --- 类型定义 ---
+export interface ParsedTaskData {
+  clawJobId?: string | null
+  agentIds: string[]
+  dotype: 'add' | 'remove' | 'edit' | 'search'
+  name: string
+  expr: string
+  mainId: string
+  userId: string
+}
+
+interface Logger {
+  info?: (msg: string) => void
+  warn?: (msg: string) => void
+  error?: (msg: string) => void
+}
+
+// --- 核心公共工具函数 ---
+
+/**
+ * 1. 统一命令执行器
+ * @param ignoreError 如果为 true，即便命令执行失败也不会抛出异常（用于 disable/enable 等非关键步骤）
+ */
+async function runCli(command: string, log?: Logger, ignoreError = false): Promise<{ stdout: string, success: boolean }> {
+  log?.info?.(`[CLI] Executing: ${command}`)
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      timeout: 60000,
+      maxBuffer: 10 * 1024 * 1024,
+    })
+    if (stderr)
+      log?.info?.(`[CLI] stderr: ${stderr}`)
+    return { stdout: stdout.trim(), success: true }
+  }
+  catch (error: any) {
+    const errorMsg = error?.stderr || error?.message || 'unknown error'
+    log?.error?.(`[CLI] Command failed: ${command} -> ${errorMsg}`)
+    if (ignoreError)
+      return { stdout: errorMsg, success: false }
+    throw new Error(errorMsg)
+  }
+}
+
+/**
+ * 2. 统一回调发送器
+ * 封装了复杂的后端数据结构，减少各处的重复代码
+ */
+async function sendTaskResult(
+  url: string,
+  token: string,
+  taskData: ParsedTaskData,
+  status: { success: boolean, message: string, dataListOverride?: any[] },
+  log?: Logger,
+) {
+  const { agentIds, dotype, userId, mainId, clawJobId, name, expr } = taskData
+
+  const payload = {
+    appKey: '',
+    userId,
+    agentId: mainId,
+    agentIds,
+    dotype,
+    doStatus: status.success,
+    doErrorMsg: status.success ? '' : status.message,
+    dataList: status.dataListOverride || [{
+      messageId: 0,
+      clawJobId,
+      name,
+      kind: '',
+      expr,
+      message: status.success ? status.message : '',
+      agentId: mainId,
+      nextRunAtMs: 0,
+    }],
+  }
+
+  try {
+    log?.info?.(`[Callback] Sending status to ${url}`)
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },
+      body: JSON.stringify(payload),
+    })
+    if (!response.ok)
+      log?.error?.(`[Callback] Http error: ${response.status}`)
+  }
+  catch (err) {
+    log?.error?.(`[Callback] Network error: ${String(err)}`)
+  }
+}
+
+/**
+ * 3. 参数安全拼接工具
+ */
+const buildCmd = (args: string[]) => args.map(a => (a && a.includes(' ') ? `"${a}"` : a)).join(' ')
+
+// --- 业务处理器 ---
+
+/**
+ * 创建任务
+ */
+async function handleTaskCreate(taskData: ParsedTaskData, token: string, url: string, log?: Logger) {
+  try {
+    const cmd = buildCmd(['openclaw', 'cron', 'add', '--name', taskData.name, '--cron', taskData.expr, '--command', 'echo "Task executed"'])
+    const { stdout } = await runCli(cmd, log)
+    await sendTaskResult(url, token, taskData, { success: true, message: '创建成功' }, log)
+  }
+  catch (e: any) {
+    await sendTaskResult(url, token, taskData, { success: false, message: `创建失败: ${e.message}` }, log)
+    throw e
+  }
+}
+
+/**
+ * 修改任务 (禁用 -> 修改 -> 启用)
+ */
+async function handleTaskUpdate(taskData: ParsedTaskData, token: string, url: string, log?: Logger) {
+  const taskId = taskData.clawJobId
+  if (!taskId)
+    throw new Error('clawJobId为空无法修改')
+
+  try {
+    // 1. 尝试禁用 (忽略失败)
+    await runCli(`openclaw cron disable ${taskId}`, log, true)
+    await new Promise(r => setTimeout(r, 500))
+
+    // 2. 执行更新 (核心逻辑)
+    const args = ['openclaw', 'cron', 'edit', taskId]
+    if (taskData.name)
+      args.push('--name', taskData.name)
+    if (taskData.expr)
+      args.push('--cron', taskData.expr)
+    await runCli(buildCmd(args), log)
+
+    // 3. 尝试启用 (忽略失败)
+    await runCli(`openclaw cron enable ${taskId}`, log, true)
+
+    await sendTaskResult(url, token, taskData, { success: true, message: '更新成功' }, log)
+  }
+  catch (e: any) {
+    await sendTaskResult(url, token, taskData, { success: false, message: `更新失败: ${e.message}` }, log)
+    throw e
+  }
+}
+
+/**
+ * 删除任务
+ */
+async function handleTaskDelete(taskData: ParsedTaskData, token: string, url: string, log?: Logger) {
+  const taskId = taskData.clawJobId
+  if (!taskId)
+    throw new Error('clawJobId为空无法删除')
+
+  try {
+    await runCli(`openclaw cron disable ${taskId}`, log, true)
+    await runCli(`openclaw cron rm ${taskId}`, log)
+    await sendTaskResult(url, token, taskData, { success: true, message: '删除成功' }, log)
+  }
+  catch (e: any) {
+    // 特殊处理：如果本身就不存在，也视为成功
+    const msg = e.message
+    const isAlreadyGone = msg.includes('not found') || msg.includes('gateway timeout')
+    await sendTaskResult(url, token, taskData, {
+      success: isAlreadyGone,
+      message: isAlreadyGone ? '任务已不存在' : `删除失败: ${msg}`,
+    }, log)
+  }
+}
+
+/**
+ * 查询任务 (增加了回调处理)
+ */
+async function handleTaskSearch(taskData: ParsedTaskData, token: string, url: string, log?: Logger) {
+  try {
+    const { stdout } = await runCli('openclaw cron list', log)
+    let tasks = []
+    try { tasks = JSON.parse(stdout) }
+    catch { /* 容错非JSON输出 */ }
+
+    // 处理 search 回调：将查询到的列表放入 dataList
+    const dataList = Array.isArray(tasks)
+      ? tasks.map(t => ({
+          clawJobId: t.id || t.clawJobId,
+          name: t.name,
+          expr: t.cron || t.expr,
+          agentId: t.agentId || taskData.mainId,
+        }))
+      : []
+
+    await sendTaskResult(url, token, taskData, {
+      success: true,
+      message: '查询成功',
+      dataListOverride: dataList,
+    }, log)
+
+    return tasks
+  }
+  catch (e: any) {
+    await sendTaskResult(url, token, taskData, { success: false, message: `查询失败: ${e.message}` }, log)
+    throw e
+  }
+}
+
+// --- 主入口 ---
+export async function handleCronTaskEvent(
+  backendEvent: { dotype: string, data: any },
+  token: string,
+  baseUrl: string,
+  appKey: string,
+  log?: Logger,
+): Promise<void> {
+  const taskData: ParsedTaskData = backendEvent.data
+  const callbackUrl = `${baseUrl}/open-apis/v1/claw/do/cron/result`
+
+  log?.info?.(`[Event] Processing ${taskData.dotype}`)
+
+  switch (taskData.dotype) {
+    case 'add': await handleTaskCreate(taskData, token, callbackUrl, log); break
+    case 'remove': await handleTaskDelete(taskData, token, callbackUrl, log); break
+    case 'edit': await handleTaskUpdate(taskData, token, callbackUrl, log); break
+    case 'search': await handleTaskSearch(taskData, token, callbackUrl, log); break
+    default:
+      log?.warn?.(`Unknown dotype: ${taskData.dotype}`)
+  }
+}