@workclaw/openclaw-workclaw 1.0.202 → 1.0.332

package/dist/packages/plugin/src/gateway/config-writer.js

@@ -0,0 +1,157 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { readFile, mkdir, writeFile, rename } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import logger from "../logging.js";
+import { getWorkclawRuntime } from "../../../../src/runtime.js";
+import { STATE_DIR, PLUGIN_ID, DEFAULT_PROVIDER } from "../types/system.js";
+function fixOwner(dir) {
+  if (process.platform === "win32")
+    return;
+  try {
+    execSync(`chown -R node:node "${dir}"`, { stdio: "ignore" });
+  } catch {
+  }
+}
+const SAVE_THROTTLE_MS = 1e3;
+const lastSaveTimeMap = /* @__PURE__ */ new Map();
+function findStateDir() {
+  const stateDir = join(homedir(), ".openclaw");
+  return join(stateDir, STATE_DIR);
+}
+function getStateFilePath() {
+  return join(findStateDir(), "conversations.json");
+}
+async function writeConfigFile(newConfig, cfg, log) {
+  try {
+    const runtime = getWorkclawRuntime();
+    const configApi = runtime.config;
+    if (typeof configApi.mutateConfigFile === "function") {
+      await configApi.mutateConfigFile((existing) => {
+        Object.assign(existing, newConfig);
+      });
+      logger.info(`[智小途-配置] 通过 runtime.config.mutateConfigFile 增量写入配置`);
+    } else {
+      await configApi.writeConfigFile(newConfig);
+      logger.info(`[智小途-配置] 通过 runtime.config.writeConfigFile 写入配置（已废弃）`);
+    }
+    Object.assign(cfg, newConfig);
+  } catch (err) {
+    logger.error(`[智小途-配置] 写入配置失败: ${String(err)}`);
+    throw err;
+  }
+}
+function loadOpenConversationId(accountId, userId) {
+  const statePath = getStateFilePath();
+  const key = `${accountId}:${userId}`;
+  try {
+    if (!existsSync(statePath))
+      return null;
+    const content = readFileSync(statePath, "utf-8");
+    const state = JSON.parse(content);
+    return state[key]?.openConversationId ?? null;
+  } catch {
+    return null;
+  }
+}
+async function saveOpenConversationId(accountId, userId, openConversationId, cfg, log) {
+  const key = `${accountId}:${userId}`;
+  const workclawCfg = cfg?.channels?.[PLUGIN_ID];
+  if (workclawCfg?.accounts?.[accountId]) {
+    workclawCfg.accounts[accountId].openConversationId = openConversationId;
+  }
+  const lastSaveTime = lastSaveTimeMap.get(key) ?? 0;
+  const now = Date.now();
+  if (now - lastSaveTime < SAVE_THROTTLE_MS) {
+    return;
+  }
+  await doSaveOpenConversationId(key, openConversationId);
+  lastSaveTimeMap.set(key, now);
+}
+async function doSaveOpenConversationId(key, openConversationId, log) {
+  try {
+    const statePath = getStateFilePath();
+    let state = {};
+    if (existsSync(statePath)) {
+      try {
+        const content = await readFile(statePath, "utf-8");
+        state = JSON.parse(content);
+      } catch (parseErr) {
+        logger.error(`[智小途-会话] 解析状态文件失败: ${String(parseErr)}`);
+      }
+    }
+    if (!state[key])
+      state[key] = {};
+    const existing = state[key].openConversationId;
+    if (existing === openConversationId && existing != null && existing !== "") {
+      return;
+    }
+    state[key].openConversationId = openConversationId;
+    const stateDir = findStateDir();
+    if (!existsSync(stateDir)) {
+      try {
+        await mkdir(stateDir, { recursive: true, mode: 493 });
+      } catch (mkdirErr) {
+        if (mkdirErr.code === "EACCES" || mkdirErr.code === "EPERM") {
+          await mkdir(stateDir, { recursive: true, mode: 511 });
+        } else {
+          throw mkdirErr;
+        }
+      }
+      fixOwner(stateDir);
+    }
+    const tmpPath = `${statePath}.tmp`;
+    await writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+    await rename(tmpPath, statePath);
+    logger.info(`[智小途-会话] 保存会话 ID，key=${key}`);
+  } catch (err) {
+    logger.error(`[智小途-会话] 写入状态文件失败: ${String(err)}`);
+  }
+}
+async function initWorkclawAgent(params, cfg, log) {
+  try {
+    const workclawCfg = cfg?.channels?.[PLUGIN_ID];
+    if (!workclawCfg)
+      return;
+    if (params.apiKey) {
+      const existingApiKey = cfg.models?.providers?.[DEFAULT_PROVIDER]?.apiKey;
+      if (existingApiKey && typeof existingApiKey === "object" && existingApiKey.type) {
+        logger.info(`[智小途-智能体] apiKey 是 SecretRef (type=${existingApiKey.type})，跳过覆盖`);
+      } else {
+        if (!cfg.models)
+          cfg.models = {};
+        if (!cfg.models.providers)
+          cfg.models.providers = {};
+        if (!cfg.models.providers[DEFAULT_PROVIDER])
+          cfg.models.providers[DEFAULT_PROVIDER] = {};
+        cfg.models.providers[DEFAULT_PROVIDER].apiKey = params.apiKey;
+        logger.info(`[智小途-智能体] apiKey 已设置（明文值）`);
+      }
+    }
+    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;
+      logger.info(`[智小途-智能体] agentId=${params.agentId} 已设置 accountId=${accountId}`);
+    }
+    if (params.userId) {
+      workclawCfg.userId = params.userId;
+      logger.info(`[智小途-智能体] userId=${params.userId} 已设置`);
+    }
+    await writeConfigFile(cfg, cfg, log);
+    logger.info(`[智小途-智能体] 所有配置已持久化`);
+  } catch (err) {
+    logger.error(`[智小途-智能体] 初始化失败: ${String(err)}`);
+    throw err;
+  }
+}
+export {
+  initWorkclawAgent,
+  loadOpenConversationId,
+  saveOpenConversationId,
+  writeConfigFile
+};

package/dist/packages/plugin/src/gateway/cron-tasks-handler.js

@@ -0,0 +1,184 @@
+import { exec } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import logger from "../logging.js";
+const execAsync = promisify(exec);
+function resolvePreferredCliPathEnv() {
+  const defaultAliasPath = join(homedir(), ".nvm", "alias", "default");
+  if (!existsSync(defaultAliasPath))
+    return process.env;
+  try {
+    const defaultVersion = readFileSync(defaultAliasPath, "utf8").trim();
+    if (!defaultVersion)
+      return process.env;
+    const preferredBin = join(homedir(), ".nvm", "versions", "node", defaultVersion, "bin");
+    if (!existsSync(preferredBin))
+      return process.env;
+    const currentPath = process.env.PATH || "";
+    return {
+      ...process.env,
+      PATH: currentPath ? `${preferredBin}:${currentPath}` : preferredBin
+    };
+  } catch {
+    return process.env;
+  }
+}
+async function runCli(command, log, ignoreError = false) {
+  logger.info(`[命令行] 执行: ${command}`);
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      timeout: 6e4,
+      maxBuffer: 10 * 1024 * 1024,
+      env: resolvePreferredCliPathEnv()
+    });
+    if (stderr)
+      logger.info(`[命令行] 标准错误: ${stderr}`);
+    return { stdout: stdout.trim(), success: true };
+  } catch (error) {
+    const errorMsg = error?.stderr || error?.message || "unknown error";
+    logger.error(`[命令行] 命令失败: ${command} -> ${errorMsg}`);
+    if (ignoreError)
+      return { stdout: errorMsg, success: false };
+    throw new Error(errorMsg);
+  }
+}
+async function sendTaskResult(url, token, taskData, status, log) {
+  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 {
+    logger.info(`[回调] 发送状态到 ${url}`);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "Authorization": `Bearer ${token}` },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok)
+      logger.error(`[智小途-回调] HTTP 错误: ${response.status}`);
+  } catch (err) {
+    logger.error(`[智小途-回调] 网络错误: ${String(err)}`);
+  }
+}
+function buildCmd(args) {
+  return args.map((a) => {
+    const cleaned = a?.replace(/\s+/g, " ").trim() || "";
+    return cleaned && cleaned.includes(" ") ? `"${cleaned}"` : cleaned;
+  }).join(" ");
+}
+async function handleTaskUpdate(taskData, token, url, log) {
+  const taskId = taskData.clawJobId;
+  if (!taskId)
+    throw new Error("clawJobId为空无法修改");
+  try {
+    await runCli(`openclaw cron disable ${taskId}`, log, true);
+    await new Promise((r) => setTimeout(r, 500));
+    const args = ["openclaw", "cron", "edit", taskId];
+    if (taskData.name)
+      args.push("--name", taskData.name.trim());
+    if (taskData.expr)
+      args.push("--cron", taskData.expr.trim());
+    await runCli(buildCmd(args), log);
+    await runCli(`openclaw cron enable ${taskId}`, log, true);
+    await sendTaskResult(url, token, taskData, { success: true, message: "更新成功" }, log);
+  } catch (e) {
+    await sendTaskResult(url, token, taskData, { success: false, message: `更新失败: ${e.message}` });
+    throw e;
+  }
+}
+async function handleTaskDelete(taskData, token, url, log) {
+  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) {
+    const msg = e.message;
+    const isAlreadyGone = msg.includes("not found") || msg.includes("gateway timeout");
+    await sendTaskResult(url, token, taskData, {
+      success: isAlreadyGone,
+      message: isAlreadyGone ? "任务已不存在" : `删除失败: ${msg}`
+    });
+  }
+}
+async function handleTaskSearch(taskData, token, url, log) {
+  try {
+    const { stdout } = await runCli("openclaw cron list", log);
+    let tasks = [];
+    try {
+      tasks = JSON.parse(stdout);
+    } catch {
+    }
+    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) {
+    await sendTaskResult(url, token, taskData, { success: false, message: `查询失败: ${e.message}` });
+    throw e;
+  }
+}
+async function handleTaskTrigger(taskData, token, url, log) {
+  const taskId = taskData.clawJobId;
+  if (!taskId)
+    throw new Error("clawJobId为空无法执行");
+  try {
+    await runCli(`openclaw cron run ${taskId}`, log);
+    await sendTaskResult(url, token, taskData, { success: true, message: "执行成功" }, log);
+  } catch (e) {
+    await sendTaskResult(url, token, taskData, { success: false, message: `执行失败: ${e.message}` });
+    throw e;
+  }
+}
+async function handleCronTaskEvent(backendEvent, token, baseUrl, appKey, log) {
+  const taskData = backendEvent.data;
+  const callbackUrl = `${baseUrl}/open-apis/v1/claw/do/cron/result`;
+  logger.info(`[事件] 处理任务类型 ${taskData.dotype}`);
+  switch (taskData.dotype) {
+    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;
+    case "trigger":
+      await handleTaskTrigger(taskData, token, callbackUrl, log);
+      break;
+    default:
+      logger.warn(`未知任务类型: ${taskData.dotype}`);
+  }
+}
+export {
+  handleCronTaskEvent
+};