@sunnoy/wecom 2.2.1 → 2.4.0

package/wecom/welcome-messages-file.js

@@ -0,0 +1,155 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { logger } from "../logger.js";
+
+const DEFAULT_STATE_DIRNAME = ".openclaw";
+const LEGACY_STATE_DIRNAMES = [".clawdbot", ".moldbot", ".moltbot"];
+
+/** @type {Map<string, { mtimeMs: number; size: number; list: string[] }>} */
+const welcomeMessagesFileCache = new Map();
+
+function resolveUserPath(value) {
+  const trimmed = String(value ?? "").trim();
+  if (!trimmed) {
+    return "";
+  }
+  if (trimmed.startsWith("~")) {
+    const homeDir = process.env.OPENCLAW_HOME?.trim() || process.env.HOME || os.homedir();
+    return path.resolve(homeDir, trimmed.slice(1).replace(/^\/+/, ""));
+  }
+  return path.resolve(trimmed);
+}
+
+function resolveOpenclawStateDir() {
+  const override = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim();
+  if (override) {
+    return resolveUserPath(override);
+  }
+
+  const homeDir = process.env.OPENCLAW_HOME?.trim() || process.env.HOME || os.homedir();
+  const preferred = path.join(homeDir, DEFAULT_STATE_DIRNAME);
+  if (existsSync(preferred)) {
+    return preferred;
+  }
+
+  for (const legacyName of LEGACY_STATE_DIRNAMES) {
+    const candidate = path.join(homeDir, legacyName);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return preferred;
+}
+
+export function resolveWelcomeMessagesFilePath(config) {
+  const raw = String(config?.welcomeMessagesFile ?? "").trim();
+  if (!raw) {
+    return "";
+  }
+  if (raw.startsWith("~")) {
+    return resolveUserPath(raw);
+  }
+  if (path.isAbsolute(raw)) {
+    return path.normalize(raw);
+  }
+  return path.join(resolveOpenclawStateDir(), raw);
+}
+
+function normalizeWelcomeEntry(item) {
+  if (typeof item === "string") {
+    const t = item.trim();
+    return t || null;
+  }
+  if (Array.isArray(item)) {
+    if (!item.every((line) => line === null || ["string", "number", "boolean"].includes(typeof line))) {
+      return null;
+    }
+    const joined = item.map((line) => String(line ?? "")).join("\n");
+    const t = joined.trim();
+    return t || null;
+  }
+  return null;
+}
+
+function parseWelcomeMessagesJson(text) {
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    return null;
+  }
+
+  let list = data;
+  if (!Array.isArray(data) && data && typeof data === "object" && Array.isArray(data.messages)) {
+    list = data.messages;
+  }
+  if (!Array.isArray(list)) {
+    return null;
+  }
+
+  const messages = [];
+  for (const item of list) {
+    const normalized = normalizeWelcomeEntry(item);
+    if (normalized) {
+      messages.push(normalized);
+    }
+  }
+  return messages.length > 0 ? messages : null;
+}
+
+/**
+ * Load welcome message candidates from welcomeMessagesFile.
+ * Accepts: JSON array of strings; array of string arrays (lines joined with \\n); or { "messages": same }.
+ * Uses mtime cache so file edits apply without restarting OpenClaw or reloading channel config.
+ * @param {Record<string, unknown> | undefined} config
+ * @returns {string[] | null}
+ */
+export function loadWelcomeMessagesFromFile(config) {
+  const filePath = resolveWelcomeMessagesFilePath(config);
+  if (!filePath) {
+    return null;
+  }
+
+  let st;
+  try {
+    st = statSync(filePath);
+  } catch {
+    return null;
+  }
+  if (!st.isFile()) {
+    return null;
+  }
+
+  const mtimeMs = st.mtimeMs;
+  const size = st.size;
+  const cached = welcomeMessagesFileCache.get(filePath);
+  if (cached && cached.mtimeMs === mtimeMs && cached.size === size) {
+    return cached.list;
+  }
+
+  let text;
+  try {
+    text = readFileSync(filePath, "utf8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.warn(`[wecom] welcomeMessagesFile read failed (${filePath}): ${message}`);
+    return null;
+  }
+
+  const list = parseWelcomeMessagesJson(text);
+  if (!list) {
+    logger.warn(
+      `[wecom] welcomeMessagesFile invalid JSON (expect a non-empty array or { "messages": [...] }): ${filePath}`,
+    );
+    return null;
+  }
+
+  welcomeMessagesFileCache.set(filePath, { mtimeMs, size, list });
+  return list;
+}
+
+export function clearWelcomeMessagesFileCacheForTesting() {
+  welcomeMessagesFileCache.clear();
+}

package/wecom/workspace-template.js

@@ -220,7 +220,7 @@ export function seedAgentWorkspace(agentId, config, overrideTemplateDir) {
   }
 }
 
-export function upsertAgentIdOnlyEntry(cfg, agentId) {
+export function upsertAgentIdOnlyEntry(cfg, agentId, baseAgentId) {
   const normalizedId = String(agentId || "")
     .trim()
     .toLowerCase();
@@ -252,8 +252,44 @@ export function upsertAgentIdOnlyEntry(cfg, agentId) {
   }
 
   if (!existingIds.has(normalizedId)) {
-    nextList.push({ id: normalizedId, heartbeat: {} });
+    const entry = { id: normalizedId, heartbeat: {} };
+
+    // Inherit inheritable properties from the base agent so the dynamic
+    // agent retains model, subagents (spawn permissions), and tool config.
+    if (baseAgentId) {
+      const baseEntry = currentList.find(
+        (e) => e && typeof e.id === "string" && e.id === baseAgentId,
+      );
+      if (baseEntry) {
+        for (const key of ["model", "subagents", "tools"]) {
+          if (baseEntry[key] != null) {
+            entry[key] = JSON.parse(JSON.stringify(baseEntry[key]));
+          }
+        }
+      }
+    }
+
+    nextList.push(entry);
     changed = true;
+  } else if (baseAgentId) {
+    // Backfill missing inheritable properties on existing entries that were
+    // persisted before the inheritance logic was added.
+    const existingEntry = nextList.find(
+      (e) => e && typeof e.id === "string" && e.id.trim().toLowerCase() === normalizedId,
+    );
+    if (existingEntry) {
+      const baseEntry = currentList.find(
+        (e) => e && typeof e.id === "string" && e.id === baseAgentId,
+      );
+      if (baseEntry) {
+        for (const key of ["model", "subagents", "tools"]) {
+          if (existingEntry[key] == null && baseEntry[key] != null) {
+            existingEntry[key] = JSON.parse(JSON.stringify(baseEntry[key]));
+            changed = true;
+          }
+        }
+      }
+    }
   }
 
   if (changed) {
@@ -263,7 +299,7 @@ export function upsertAgentIdOnlyEntry(cfg, agentId) {
   return changed;
 }
 
-export async function ensureDynamicAgentListed(agentId, templateDir) {
+export async function ensureDynamicAgentListed(agentId, templateDir, baseAgentId) {
   const normalizedId = String(agentId || "")
     .trim()
     .toLowerCase();
@@ -285,24 +321,31 @@ export async function ensureDynamicAgentListed(agentId, templateDir) {
       }
 
       // Upsert into in-memory config so the running gateway sees it immediately.
-      const changed = upsertAgentIdOnlyEntry(openclawConfig, normalizedId);
+      const changed = upsertAgentIdOnlyEntry(openclawConfig, normalizedId, baseAgentId);
       if (changed) {
         logger.info("WeCom: dynamic agent added to in-memory agents.list", { agentId: normalizedId });
 
         // Persist to disk so `openclaw agents list` (separate process) can see
         // the dynamic agent and it survives gateway restarts.
-        // Write the mutated in-memory config directly (same pattern as logoutAccount).
-        // NOTE: loadConfig() returns runtimeConfigSnapshot in gateway mode — the same
-        // object we already mutated above — so a read-modify-write pattern silently
-        // skips the write (diskChanged=false). Writing directly avoids this.
-        try {
-          await configRuntime.writeConfigFile(openclawConfig);
-          logger.info("WeCom: dynamic agent persisted to config file", { agentId: normalizedId });
-        } catch (writeErr) {
-          logger.warn("WeCom: failed to persist dynamic agent to config file", {
+        // Safety check: refuse to write if critical config sections are missing,
+        // which would indicate the in-memory snapshot is incomplete and writing
+        // it would destroy the user's configuration (#136).
+        const hasChannels = openclawConfig.channels && typeof openclawConfig.channels === "object";
+        if (!hasChannels) {
+          logger.warn("WeCom: skipping config write — in-memory config is missing 'channels' section", {
             agentId: normalizedId,
-            error: writeErr?.message || String(writeErr),
+            keys: Object.keys(openclawConfig),
           });
+        } else {
+          try {
+            await configRuntime.writeConfigFile(openclawConfig);
+            logger.info("WeCom: dynamic agent persisted to config file", { agentId: normalizedId });
+          } catch (writeErr) {
+            logger.warn("WeCom: failed to persist dynamic agent to config file", {
+              agentId: normalizedId,
+              error: writeErr?.message || String(writeErr),
+            });
+          }
         }
       }
       

package/wecom/ws-monitor.js

@@ -39,7 +39,6 @@ import {
 import { setConfigProxyUrl } from "./http.js";
 import { checkDmPolicy } from "./dm-policy.js";
 import { checkGroupPolicy } from "./group-policy.js";
-import { fetchAndSaveMcpConfig } from "./mcp-config.js";
 import {
   clearAccountDisplaced,
   forecastActiveSendQuota,
@@ -63,6 +62,8 @@ import {
   startMessageStateCleanup,
 } from "./ws-state.js";
 import { ensureDynamicAgentListed } from "./workspace-template.js";
+import { listAccountIds, resolveAccount } from "./accounts.js";
+import { loadWelcomeMessagesFromFile } from "./welcome-messages-file.js";
 
 const DEFAULT_AGENT_ID = "main";
 const DEFAULT_STATE_DIRNAME = ".openclaw";
@@ -138,6 +139,11 @@ function buildWaitingModelContent(seconds) {
   return `<think>${lines.join("\n")}`;
 }
 
+function buildWaitingModelReasoningText(seconds) {
+  const normalizedSeconds = Math.max(1, Number.parseInt(String(seconds ?? 1), 10) || 1);
+  return `等待模型响应 ${normalizedSeconds}s`;
+}
+
 function buildWsStreamContent({ reasoningText = "", visibleText = "", finish = false }) {
   const normalizedReasoning = String(reasoningText ?? "").trim();
   const normalizedVisible = String(visibleText ?? "").trim();
@@ -360,10 +366,23 @@ function resolveAgentWorkspaceDir(config, agentId) {
 }
 
 function resolveConfiguredReplyMediaLocalRoots(config) {
-  const roots = Array.isArray(config?.channels?.[CHANNEL_ID]?.mediaLocalRoots)
+  const topLevel = Array.isArray(config?.channels?.[CHANNEL_ID]?.mediaLocalRoots)
     ? config.channels[CHANNEL_ID].mediaLocalRoots
     : [];
-  return roots.map((entry) => resolveUserPath(entry)).filter(Boolean);
+
+  // Also collect mediaLocalRoots from each account entry (multi-account mode).
+  // In single-account mode the account config IS the top-level config, so
+  // listAccountIds returns ["default"] and the roots are already in topLevel.
+  const accountRoots = [];
+  for (const accountId of listAccountIds(config)) {
+    const accountConfig = resolveAccount(config, accountId)?.config;
+    if (Array.isArray(accountConfig?.mediaLocalRoots)) {
+      accountRoots.push(...accountConfig.mediaLocalRoots);
+    }
+  }
+
+  const merged = [...new Set([...topLevel, ...accountRoots])];
+  return merged.map((entry) => resolveUserPath(entry)).filter(Boolean);
 }
 
 function resolveReplyMediaLocalRoots(config, agentId) {
@@ -398,6 +417,7 @@ function buildReplyMediaGuidance(config, agentId) {
   const workspaceDir = resolveAgentWorkspaceDir(config, agentId || resolveDefaultAgentId(config));
   const browserMediaDir = path.join(resolveStateDir(), "media", "browser");
   const configuredRoots = resolveConfiguredReplyMediaLocalRoots(config);
+  const qwenImageToolsConfig = config?.plugins?.entries?.wecom?.config?.qwenImageTools;
   const guidance = [
     WECOM_REPLY_MEDIA_GUIDANCE_HEADER,
     `Local reply files are allowed only under the current workspace: ${workspaceDir}`,
@@ -418,6 +438,22 @@ function buildReplyMediaGuidance(config, agentId) {
     guidance.push(`Additional configured host roots are also allowed: ${configuredRoots.join(", ")}`);
   }
 
+  if (qwenImageToolsConfig?.enabled === true) {
+    guidance.push(
+      "[WeCom image_studio rule]",
+      "When the user asks to generate an image, use image_studio with action=\"generate\".",
+      "When the user asks to edit an existing image, use image_studio with action=\"edit\" and pass images.",
+      "Use aspect=\"landscape\" for architecture diagrams, flowcharts, and banners unless the user asks otherwise.",
+      "Prefer model_preference=\"qwen\" for text-heavy diagrams or label-rich images, and model_preference=\"wan\" for photorealistic scenes.",
+      "For workspace-local images, always use /workspace/... paths when calling image_studio.",
+      "Prefer n=1 unless the user explicitly asks for multiple images.",
+      "If image_studio returns MEDIA: URLs, treat the image task as completed successfully.",
+      "If image_studio returns MEDIA: URLs, do NOT repeat those URLs in the visible reply.",
+      "Do NOT embed markdown images, raw image URLs, or OSS links in the text reply after image_studio succeeds.",
+      "Instead, tell the user the image will be sent separately, for example: 图片会单独发送，请查收。",
+    );
+  }
+
   guidance.push("Never reference any other host path.");
   return guidance.join("\n");
 }
@@ -563,6 +599,11 @@ async function sendMediaBatch({ wsClient, frame, state, account, runtime, config
 
     if (result.ok) {
       state.hasMedia = true;
+      if (result.finalType === "image") {
+        state.hasImageMedia = true;
+      } else {
+        state.hasFileMedia = true;
+      }
       if (result.downgraded) {
         logger.info(`[WS] Media downgraded: ${result.downgradeNote}`);
       }
@@ -601,7 +642,19 @@ async function finishThinkingStream({ wsClient, frame, state, accountId }) {
       finish: true,
     });
   } else if (state.hasMedia) {
-    finishText = "文件已发送，请查收。";
+    const mediaVisibleText = state.hasImageMedia && !state.hasFileMedia
+      ? "图片已生成，请查收。"
+      : "文件已发送，请查收。";
+    const fallbackReasoningText = state.waitingModelSeconds > 0
+      ? buildWaitingModelReasoningText(state.waitingModelSeconds)
+      : state.hasImageMedia && !state.hasFileMedia
+        ? "正在生成图片"
+        : "正在整理并发送文件";
+    finishText = buildWsStreamContent({
+      reasoningText: fallbackReasoningText,
+      visibleText: mediaVisibleText,
+      finish: true,
+    });
   } else if (state.hasMediaFailed && state.mediaErrorSummary) {
     finishText = state.mediaErrorSummary;
   } else {
@@ -624,6 +677,12 @@ function resolveWelcomeMessage(account) {
     return configured;
   }
 
+  const fromFile = loadWelcomeMessagesFromFile(account?.config);
+  if (fromFile?.length) {
+    const pick = Math.floor(Math.random() * fromFile.length);
+    return fromFile[pick];
+  }
+
   const index = Math.floor(Math.random() * DEFAULT_WELCOME_MESSAGES.length);
   return DEFAULT_WELCOME_MESSAGES[index] || DEFAULT_WELCOME_MESSAGE;
 }
@@ -1160,9 +1219,12 @@ async function processWsMessage({ frame, account, config, runtime, wsClient, req
     replyMediaUrls: [],
     pendingMediaUrls: [],
     hasMedia: false,
+    hasImageMedia: false,
+    hasFileMedia: false,
     hasMediaFailed: false,
     mediaErrorSummary: "",
     deliverCalled: false,
+    waitingModelSeconds: 0,
   };
   setMessageState(messageId, state);
 
@@ -1194,6 +1256,7 @@ async function processWsMessage({ frame, account, config, runtime, wsClient, req
 
   const sendWaitingModelUpdate = async (seconds) => {
     const waitingText = buildWaitingModelContent(seconds);
+    state.waitingModelSeconds = seconds;
     lastStreamSentAt = Date.now();
     lastNonEmptyStreamText = waitingText;
     try {
@@ -1523,6 +1586,7 @@ async function processWsMessage({ frame, account, config, runtime, wsClient, req
   if (account.sendThinkingMessage !== false) {
     waitingModelActive = true;
     waitingModelSeconds = 1;
+    state.waitingModelSeconds = waitingModelSeconds;
     await sendThinkingReply({
       wsClient,
       frame,
@@ -1547,10 +1611,6 @@ async function processWsMessage({ frame, account, config, runtime, wsClient, req
       ? generateAgentId(peerKind, peerId, account.accountId)
       : null;
 
-  if (dynamicAgentId) {
-    await ensureDynamicAgentListed(dynamicAgentId, account.config.workspaceTemplate);
-  }
-
   const route = core.routing.resolveAgentRoute({
     cfg: config,
     channel: CHANNEL_ID,
@@ -1565,8 +1625,15 @@ async function processWsMessage({ frame, account, config, runtime, wsClient, req
     );
 
   if (dynamicAgentId && !hasExplicitBinding) {
+    const routeAgentId = route.agentId;
+    // Use the account's configured agentId as the base for property inheritance
+    // (model, subagents, tools). route.agentId may resolve to "main" when
+    // there is no explicit binding, but the account's agentId points to the
+    // actual parent agent whose properties the dynamic agent should inherit.
+    const baseAgentId = account.config.agentId || routeAgentId;
+    await ensureDynamicAgentListed(dynamicAgentId, account.config.workspaceTemplate, baseAgentId);
+    route.sessionKey = route.sessionKey.replace(`agent:${routeAgentId}:`, `agent:${dynamicAgentId}:`);
     route.agentId = dynamicAgentId;
-    route.sessionKey = `agent:${dynamicAgentId}:${peerKind}:${peerId}`;
   }
 
   const { ctxPayload, storePath } = buildInboundContext({
@@ -1893,8 +1960,6 @@ export async function startWsMonitor({ account, config, runtime, abortSignal, ws
       clearAccountDisplaced(account.accountId);
       setWsClient(account.accountId, wsClient);
 
-      void fetchAndSaveMcpConfig(wsClient, account.accountId, runtime);
-
       // Drain pending replies that failed due to prior WS disconnection.
       if (account?.agentCredentials && hasPendingReplies(account.accountId)) {
         void flushPendingRepliesViaAgentApi(account).catch((flushError) => {

package/wecom/mcp-config.js

@@ -1,146 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { generateReqId } from "@wecom/aibot-node-sdk";
-import { logger } from "../logger.js";
-
-const MCP_GET_CONFIG_CMD = "aibot_get_mcp_config";
-const MCP_CONFIG_FETCH_TIMEOUT_MS = 15_000;
-const MCP_CONFIG_KEY = "doc";
-const DEFAULT_MCP_TRANSPORT = "streamable-http";
-
-let mcpConfigWriteQueue = Promise.resolve();
-
-function withTimeout(promise, timeoutMs, message) {
-  if (!timeoutMs || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-    return promise;
-  }
-
-  let timer = null;
-  const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(new Error(message ?? `Timed out after ${timeoutMs}ms`)), timeoutMs);
-  });
-
-  promise.catch(() => {});
-
-  return Promise.race([promise, timeout]).finally(() => {
-    if (timer) {
-      clearTimeout(timer);
-    }
-  });
-}
-
-function getWecomConfigPath() {
-  return path.join(os.homedir(), ".openclaw", "wecomConfig", "config.json");
-}
-
-function resolveMcpTransport(body = {}) {
-  const candidate = String(
-    body.transport_type ??
-      body.transportType ??
-      body.config_type ??
-      body.configType ??
-      body.type ??
-      "",
-  )
-    .trim()
-    .toLowerCase();
-
-  return candidate || DEFAULT_MCP_TRANSPORT;
-}
-
-async function readJsonFile(filePath, fallback = {}) {
-  try {
-    const raw = await readFile(filePath, "utf8");
-    return JSON.parse(raw);
-  } catch (error) {
-    if (error?.code === "ENOENT") {
-      return fallback;
-    }
-    throw error;
-  }
-}
-
-async function writeJsonFileAtomically(filePath, value) {
-  const dir = path.dirname(filePath);
-  await mkdir(dir, { recursive: true });
-  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-  await rename(tempPath, filePath);
-}
-
-export async function fetchMcpConfig(wsClient) {
-  if (!wsClient || typeof wsClient.reply !== "function") {
-    throw new Error("WS client does not support MCP config requests");
-  }
-
-  const reqId = generateReqId("mcp_config");
-  const response = await withTimeout(
-    wsClient.reply({ headers: { req_id: reqId } }, { biz_type: MCP_CONFIG_KEY }, MCP_GET_CONFIG_CMD),
-    MCP_CONFIG_FETCH_TIMEOUT_MS,
-    `MCP config fetch timed out after ${MCP_CONFIG_FETCH_TIMEOUT_MS}ms`,
-  );
-
-  if (response?.errcode && response.errcode !== 0) {
-    throw new Error(`MCP config request failed: errcode=${response.errcode}, errmsg=${response.errmsg ?? "unknown"}`);
-  }
-
-  const body = response?.body;
-  if (!body?.url) {
-    throw new Error("MCP config response missing required 'url' field");
-  }
-
-  return {
-    key: MCP_CONFIG_KEY,
-    type: resolveMcpTransport(body),
-    url: body.url,
-    isAuthed: body.is_authed,
-  };
-}
-
-export async function saveMcpConfig(config, runtime) {
-  const configPath = getWecomConfigPath();
-
-  const saveTask = mcpConfigWriteQueue.then(async () => {
-    const current = await readJsonFile(configPath, {});
-    if (!current.mcpConfig || typeof current.mcpConfig !== "object") {
-      current.mcpConfig = {};
-    }
-
-    current.mcpConfig[config.key || MCP_CONFIG_KEY] = {
-      type: config.type,
-      url: config.url,
-    };
-
-    await writeJsonFileAtomically(configPath, current);
-    runtime?.log?.(`[WeCom] MCP config saved to ${configPath}`);
-  });
-
-  mcpConfigWriteQueue = saveTask.catch(() => {});
-  return saveTask;
-}
-
-export async function fetchAndSaveMcpConfig(wsClient, accountId, runtime) {
-  try {
-    runtime?.log?.(`[${accountId}] Fetching MCP config...`);
-    const config = await fetchMcpConfig(wsClient);
-    runtime?.log?.(
-      `[${accountId}] MCP config fetched: url=${config.url}, type=${config.type}, is_authed=${config.isAuthed ?? "N/A"}`,
-    );
-    await saveMcpConfig(config, runtime);
-  } catch (error) {
-    if (typeof wsClient?.reply !== "function") {
-      logger.debug?.(`[${accountId}] Skipping MCP config fetch because WS client has no reply() support`);
-      return;
-    }
-    runtime?.error?.(`[${accountId}] Failed to fetch/save MCP config: ${String(error)}`);
-  }
-}
-
-export const mcpConfigTesting = {
-  getWecomConfigPath,
-  resolveMcpTransport,
-  resetWriteQueue() {
-    mcpConfigWriteQueue = Promise.resolve();
-  },
-};