@workclaw/openclaw-workclaw 1.0.32 → 1.0.33

package/dist/packages/plugin/src/connection/workclaw-client.js

@@ -0,0 +1,282 @@
+import { Agent, fetch } from "undici";
+import { getWorkclawLogger } from "../../../../src/runtime.js";
+const tokenCache = /* @__PURE__ */ new Map();
+function clearWorkclawTokenCache(cacheKey) {
+  tokenCache.delete(cacheKey);
+}
+function normalizeBaseUrl(value) {
+  const raw = (value || "https://workbrain.cn/backend-api").trim();
+  return raw.endsWith("/") ? raw.slice(0, -1) : raw;
+}
+function createWsEndpoint(baseUrl) {
+  const wsBase = baseUrl.replace(/^https?:\/\//i, (match) => match.toLowerCase() === "https://" ? "wss://" : "ws://");
+  return `${wsBase}/v1/ws/connect`;
+}
+async function doFetchJson(url, init, allowInsecureTls, requestTimeout) {
+  const dispatcher = allowInsecureTls ? new Agent({ connect: { rejectUnauthorized: false } }) : void 0;
+  const fetcher = allowInsecureTls ? fetch : globalThis.fetch;
+  const controller = new AbortController();
+  const timeoutMs = typeof requestTimeout === "number" && requestTimeout > 0 ? requestTimeout : 3e4;
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  let text = "";
+  try {
+    response = await fetcher(url, {
+      ...init,
+      signal: controller.signal,
+      ...dispatcher ? { dispatcher } : {}
+    });
+    text = await response.text().catch(() => "");
+  } finally {
+    clearTimeout(timeoutId);
+  }
+  let data = {};
+  if (text) {
+    try {
+      data = JSON.parse(text);
+    } catch {
+      data = {};
+    }
+  }
+  if (!response.ok) {
+    const message = data?.message || text || `HTTP ${response.status}`;
+    throw new Error(message);
+  }
+  return data;
+}
+async function fetchAccessTokenFromServer(requestUrl, config) {
+  getWorkclawLogger().info(
+    `Requesting access token url=${requestUrl} appKeyPrefix=${String(config.appKey)}... appSecretLen=${String(config.appSecret)}`
+  );
+  const data = await doFetchJson(
+    requestUrl,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        app_key: config.appKey,
+        app_secret: config.appSecret
+      })
+    },
+    config.allowInsecureTls,
+    config.requestTimeout
+  );
+  getWorkclawLogger().info(
+    `Access token response code=${String(data?.code ?? "")} errCode=${String(data?.errCode ?? "")} errMsg=${String(data?.errMsg ?? data?.message ?? "")}`
+  );
+  if (data?.code !== 200 || !data?.data?.accessToken) {
+    throw new Error(
+      String(data?.message || data?.errMsg || "Failed to acquire access token")
+    );
+  }
+  const token = String(data.data.accessToken);
+  const expiresIn = Number(data.data.expiresIn || 0);
+  const expiresAt = Date.now() + (expiresIn > 0 ? expiresIn * 1e3 : 0);
+  getWorkclawLogger().info(
+    `Access token acquired tokenLen=${token.length} expiresInSec=${expiresIn} expiresAt=${new Date(expiresAt).toISOString()}`
+  );
+  return { token, expiresAt };
+}
+async function getWorkclawAccessToken(cacheKey, config) {
+  const baseUrl = normalizeBaseUrl(config.baseUrl);
+  const requestUrl = `${baseUrl}/authen/v1/access_token/internal`;
+  typeof config.requestTimeout === "number" && config.requestTimeout > 0 ? config.requestTimeout : 3e4;
+  try {
+    const cached = tokenCache.get(cacheKey);
+    if (cached && cached.token) {
+      const now = Date.now();
+      const refreshAt = cached.expiresAt - 5 * 60 * 1e3;
+      if (now < refreshAt) {
+        return cached.token;
+      }
+      getWorkclawLogger().info(`[TOKEN] cache refresh needed cacheKey=${cacheKey}`);
+    }
+    if (!config.appKey || !config.appSecret) {
+      getWorkclawLogger().error(`[TOKEN] missing appKey/appSecret`);
+      throw new Error("Missing appKey/appSecret");
+    }
+    const result = await fetchAccessTokenFromServer(requestUrl, config);
+    tokenCache.set(cacheKey, { token: result.token, expiresAt: result.expiresAt });
+    getWorkclawLogger().info(`[TOKEN] refreshed cacheKey=${cacheKey}`);
+    return result.token;
+  } catch (error) {
+    getWorkclawLogger().error(`[TOKEN] failed cacheKey=${cacheKey} error=${String(error)}`);
+    throw error;
+  }
+}
+async function openWorkclawConnection(cacheKey, config) {
+  const startedAt = Date.now();
+  const baseUrl = normalizeBaseUrl(config.baseUrl);
+  const requestUrl = `${baseUrl}/open-apis/v1/connections/open`;
+  const timeoutMs = typeof config.requestTimeout === "number" && config.requestTimeout > 0 ? config.requestTimeout : 3e4;
+  const appKeyRaw = String(config.appKey ?? "");
+  const appSecretRaw = String(config.appSecret ?? "");
+  getWorkclawLogger().info(
+    `openWorkclawConnection start cacheKey=${cacheKey} baseUrl=${baseUrl} requestUrl=${requestUrl} allowInsecureTls=${Boolean(config.allowInsecureTls)} timeoutMs=${timeoutMs} localIp=${String(config.localIp ?? "")} websocketUrl=${String(config.websocketUrl ?? "")} appKeyPrefix=${appKeyRaw ? `${appKeyRaw.slice(0, 8)}...` : "missing"} appSecretLen=${appSecretRaw.length}`
+  );
+  const tokenStartedAt = Date.now();
+  const token = await getWorkclawAccessToken(cacheKey, config);
+  getWorkclawLogger().info(
+    `openWorkclawConnection got access token cacheKey=${cacheKey} tokenLen=${token.length} elapsedMs=${Date.now() - tokenStartedAt}`
+  );
+  const payload = {
+    appKey: config.appKey,
+    appSecret: config.appSecret,
+    subscriptions: [
+      { type: "CALLBACK", topic: "AGENT_MESSAGE" },
+      { type: "EVENT", topic: "*" },
+      { type: "SYSTEM", topic: "*" }
+    ],
+    ...config.localIp ? { localIp: config.localIp } : {}
+  };
+  getWorkclawLogger().info(
+    `Opening connection url=${requestUrl} cacheKey=${cacheKey} subscriptions=${payload.subscriptions.length}`
+  );
+  const data = await doFetchJson(
+    requestUrl,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      body: JSON.stringify(payload)
+    },
+    config.allowInsecureTls,
+    config.requestTimeout
+  );
+  getWorkclawLogger().info(
+    `Open connection response code=${String(data?.code ?? "")} errCode=${String(data?.errCode ?? "")} errMsg=${String(data?.errMsg ?? data?.message ?? "")} hasTicket=${Boolean(data?.data?.ticket)} hasEndpoint=${Boolean(data?.data?.endpoint)}`
+  );
+  if (data?.code !== 200 || !data?.data?.ticket) {
+    throw new Error(String(data?.message || data?.errMsg || "Failed to open connection"));
+  }
+  const ticket = String(data.data.ticket);
+  let endpointSource = "derived";
+  const endpoint = config.websocketUrl ? (endpointSource = "config", String(config.websocketUrl)) : data?.data?.endpoint ? (endpointSource = "api", String(data.data.endpoint)) : (endpointSource = "derived", createWsEndpoint(baseUrl));
+  getWorkclawLogger().info(
+    `openWorkclawConnection success cacheKey=${cacheKey} endpoint=${endpoint} endpointSource=${endpointSource} ticketLen=${ticket.length} elapsedMs=${Date.now() - startedAt}`
+  );
+  return { endpoint, ticket };
+}
+async function sendWorkclawMessage(params) {
+  const baseUrl = normalizeBaseUrl(params.config.baseUrl);
+  const token = await getWorkclawAccessToken(params.cacheKey, params.config);
+  const payload = {
+    agentId: params.agentId,
+    receiveId: params.receiveId,
+    msgType: params.msgType,
+    content: params.content
+  };
+  if (params.last === true) {
+    payload.is_last = true;
+  }
+  if (params.openConversationId) {
+    payload.conversationId = params.openConversationId;
+  }
+  const endpoint = params.endpoint || "/open-apis/im/v1/messages";
+  getWorkclawLogger().info(`Sending proactive message to ${baseUrl}${endpoint}`);
+  getWorkclawLogger().info(`Payload:`, JSON.stringify(payload, null, 2));
+  const data = await doFetchJson(
+    `${baseUrl}${endpoint}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      body: JSON.stringify(payload)
+    },
+    params.config.allowInsecureTls,
+    params.config.requestTimeout
+  );
+  getWorkclawLogger().info(`Send message response:`, JSON.stringify(data, null, 2));
+  if (data?.code !== 200 || !data?.data?.msgId) {
+    throw new Error(data?.message || "Failed to send message");
+  }
+  return String(data.data.msgId);
+}
+async function sendWorkclawReplyMessage(params) {
+  const baseUrl = normalizeBaseUrl(params.config.baseUrl);
+  const token = await getWorkclawAccessToken(params.cacheKey, params.config);
+  const payload = {
+    agentId: params.agentId,
+    receiveId: params.receiveId,
+    msgType: params.msgType,
+    content: params.content
+  };
+  if (params.last === true) {
+    payload.is_last = true;
+  }
+  if (params.openConversationId) {
+    payload.conversationId = params.openConversationId;
+  }
+  const endpoint = params.endpoint || `/open-apis/im/v1/messages/${params.messageId}/reply`;
+  getWorkclawLogger().info(`[SEND] source=${params.source || "?"} last=${params.last} conv=${params.openConversationId || "(none)"} msgId=${params.messageId}`);
+  const data = await doFetchJson(
+    `${baseUrl}${endpoint}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      body: JSON.stringify(payload)
+    },
+    params.config.allowInsecureTls,
+    params.config.requestTimeout
+  );
+  getWorkclawLogger().info(`[SEND] done msgId=${data?.data?.msgId} code=${data?.code}`);
+  if (data?.code !== 200 || !data?.data?.msgId) {
+    throw new Error(data?.message || "Failed to send reply");
+  }
+  return String(data.data.msgId);
+}
+function resolveWorkclawMessage(text, mediaUrl) {
+  if (!mediaUrl || text.trim()) {
+    return { msgType: "text", content: text };
+  }
+  const url = mediaUrl.trim();
+  const lower = url.toLowerCase();
+  const isAudio = lower.endsWith(".mp3") || lower.endsWith(".wav") || lower.endsWith(".aac") || lower.endsWith(".m4a") || lower.endsWith(".ogg");
+  const payload = JSON.stringify({ url });
+  return { msgType: isAudio ? "audio" : "image", content: payload };
+}
+async function getWorkclawModelConfigByAppKey(cacheKey, config) {
+  const baseUrl = normalizeBaseUrl(config.baseUrl);
+  const token = await getWorkclawAccessToken(cacheKey, config);
+  const appKey = config.appKey;
+  if (!appKey) {
+    throw new Error("Missing appKey for getModelKeyByAppKey");
+  }
+  const requestUrl = `${baseUrl}/open-apis/instance/apiKey/${appKey}`;
+  getWorkclawLogger().info(`Getting model key from ${requestUrl}`);
+  const data = await doFetchJson(
+    requestUrl,
+    {
+      method: "GET",
+      headers: {
+        "Content-Type": "x-www-form-urlencoded",
+        "Authorization": `Bearer ${token}`
+      }
+    },
+    config.allowInsecureTls,
+    config.requestTimeout
+  );
+  getWorkclawLogger().info(`Model key response:`, JSON.stringify(data, null, 2));
+  if (data?.code !== 200 || !data?.data) {
+    throw new Error(data?.message || data?.msg || "Failed to get model key");
+  }
+  return data.data;
+}
+export {
+  clearWorkclawTokenCache,
+  doFetchJson,
+  getWorkclawAccessToken,
+  getWorkclawModelConfigByAppKey,
+  normalizeBaseUrl,
+  openWorkclawConnection,
+  resolveWorkclawMessage,
+  sendWorkclawMessage,
+  sendWorkclawReplyMessage
+};

package/dist/packages/plugin/src/gateway/agent-handlers.js

@@ -0,0 +1,407 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, copyFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { resolveAccountByUserIdAndAgentId, refreshAccountCache, allocateWorkerAccountId } from "../accounts.js";
+import { writeConfigFile } from "./config-writer.js";
+import { stopWorkclawGateway } from "./workclaw-gateway.js";
+function fixOwner(dir) {
+  if (process.platform === "win32")
+    return;
+  try {
+    execSync(`chown -R node:node "${dir}"`, { stdio: "ignore" });
+  } catch {
+  }
+}
+async function createSubAgentForAccount(agentId, userId, accountData, cfg, log) {
+  try {
+    const channels = cfg?.channels ?? {};
+    const openclawWorkclaw = channels["openclaw-workclaw"] ?? {};
+    const accounts = openclawWorkclaw.accounts ?? {};
+    const accountCount = Object.keys(accounts).length;
+    const subAgentId = `workclaw-${agentId}`;
+    const existingAgents = cfg?.agents?.list ?? [];
+    const existingBindings = cfg?.bindings ?? [];
+    const agentExists = existingAgents.some((a) => a.id === subAgentId);
+    if (!agentExists) {
+      const newAgentsList = [...existingAgents];
+      const subAgent = {
+        id: subAgentId,
+        default: false,
+        name: accountData.nickName || `智小途 - Agent ${agentId}`,
+        workspace: `~/.openclaw/workspace-workclaw/${agentId}`,
+        agentDir: `~/.openclaw/agents/workclaw-${agentId}/agent`,
+        tools: { allow: ["*"] }
+      };
+      newAgentsList.push(subAgent);
+      if (accountCount === 0) {
+        const defaultAgent = {
+          id: "default",
+          default: true,
+          name: "Default Agent",
+          workspace: "default",
+          tools: { allow: ["*"] }
+        };
+        newAgentsList.push(defaultAgent);
+        log?.info?.(`SubAgent: Created default agent with default workspace`);
+      } else {
+        log?.info?.(`SubAgent: Using existing default agent`);
+      }
+      const bindingAccountId = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(agentId));
+      const newBinding = {
+        agentId: subAgentId,
+        match: {
+          channel: "openclaw-workclaw",
+          accountId: bindingAccountId ?? "*"
+        }
+      };
+      const newBindings = [...existingBindings, newBinding];
+      log?.info?.(`SubAgent: Created binding for agentId: ${subAgentId}, accountId: ${bindingAccountId ?? "*"}`);
+      return {
+        agents: {
+          list: newAgentsList,
+          defaults: cfg?.agents?.defaults ?? {}
+        },
+        bindings: newBindings
+      };
+    } else {
+      const newAgents = {
+        list: [...existingAgents],
+        defaults: cfg?.agents?.defaults ?? {}
+      };
+      const bindingExists = existingBindings.some((b) => b?.agentId === subAgentId);
+      const newBindings = [...existingBindings];
+      if (!bindingExists) {
+        const bindingAccountId = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(agentId));
+        newBindings.push({
+          agentId: subAgentId,
+          match: {
+            channel: "openclaw-workclaw",
+            accountId: bindingAccountId ?? "*"
+          }
+        });
+        log?.info?.(`SubAgent: Created binding for agentId: ${subAgentId}, accountId: ${bindingAccountId ?? "*"}`);
+      }
+      log?.info?.(`SubAgent: Created sub-agent: ${subAgentId} with workspace: workclaw-${agentId} (account #${accountCount + 1})`);
+      return {
+        agents: newAgents,
+        bindings: newBindings
+      };
+    }
+  } catch (err) {
+    log?.error?.(`SubAgent: Failed to create sub-agent: ${String(err)}`);
+    return {};
+  }
+}
+async function initializeAgentWorkspace(agentId, accountData, log) {
+  try {
+    const agentIdStr = String(agentId);
+    const home = homedir().trim();
+    const workspaceDir = join(home, ".openclaw", "workspace-workclaw", agentIdStr);
+    const mainWorkspaceDir = join(home, ".openclaw", "workspace");
+    const openclawDir = join(home, ".openclaw");
+    if (!existsSync(openclawDir)) {
+      try {
+        await mkdir(openclawDir, { recursive: true, mode: 493 });
+        log?.info?.(`Workspace: Created directory ${openclawDir}`);
+      } catch (err) {
+        if (err.code === "EACCES" || err.code === "EPERM") {
+          log?.warn?.(`Workspace: Permission denied creating ${openclawDir}, attempting with 777`);
+          await mkdir(openclawDir, { recursive: true, mode: 511 });
+        } else {
+          throw err;
+        }
+      }
+    }
+    fixOwner(openclawDir);
+    if (!existsSync(workspaceDir)) {
+      try {
+        await mkdir(workspaceDir, { recursive: true, mode: 493 });
+        log?.info?.(`Workspace: Created directory ${workspaceDir}`);
+      } catch (err) {
+        if (err.code === "EACCES" || err.code === "EPERM") {
+          log?.warn?.(`Workspace: Permission denied creating ${workspaceDir}, attempting with 777`);
+          await mkdir(workspaceDir, { recursive: true, mode: 511 });
+        } else {
+          throw err;
+        }
+      }
+    }
+    fixOwner(workspaceDir);
+    if (!existsSync(mainWorkspaceDir)) {
+      try {
+        await mkdir(mainWorkspaceDir, { recursive: true, mode: 493 });
+        log?.info?.(`Workspace: Created directory ${mainWorkspaceDir}`);
+      } catch (err) {
+        if (err.code === "EACCES" || err.code === "EPERM") {
+          log?.warn?.(`Workspace: Permission denied creating ${mainWorkspaceDir}, attempting with 777`);
+          await mkdir(mainWorkspaceDir, { recursive: true, mode: 511 });
+        } else {
+          throw err;
+        }
+      }
+    }
+    fixOwner(mainWorkspaceDir);
+    if (existsSync(mainWorkspaceDir)) {
+      const filesToCopy = ["AGENTS.md", "TOOLS.md", "USER.md"];
+      for (const file of filesToCopy) {
+        const src = join(mainWorkspaceDir, file);
+        const dest = join(workspaceDir, file);
+        if (existsSync(src)) {
+          await copyFile(src, dest);
+          log?.info?.(`Workspace: Copied ${file} to ${workspaceDir}`);
+        }
+      }
+    }
+    const identityContent = buildIdentityContent(accountData);
+    const identityPath = join(workspaceDir, "IDENTITY.md");
+    await writeFile(identityPath, identityContent, "utf-8");
+    log?.info?.(`Workspace: Created IDENTITY.md in ${workspaceDir}`);
+    const soulContent = buildSoulContent(accountData);
+    const soulPath = join(workspaceDir, "SOUL.md");
+    await writeFile(soulPath, soulContent, "utf-8");
+    log?.info?.(`Workspace: Created SOUL.md in ${workspaceDir}`);
+    log?.info?.(`Workspace: Successfully initialized workspace for agent ${agentId}`);
+  } catch (err) {
+    log?.error?.(`Workspace: Failed to initialize workspace: ${String(err)}`);
+  }
+}
+function buildIdentityContent(accountData) {
+  const agentName = accountData.nickName || accountData.name || "智小途";
+  const tip = accountData.tip || "";
+  const characterSettings = accountData.characterSettings || "";
+  return `# IDENTITY.md - Who Am I?
+
+_Fill this in during your first conversation. Make it yours._
+
+- **Name:** ${agentName}
+- **Creature:** AI智能助手
+- **Vibe:** ${characterSettings || "专业、友善、智能"}
+- **Emoji:** 🤖
+- **Avatar:** avatars/${agentName}.png
+
+---
+
+This isn't just metadata. It's the start of figuring out who you are.
+
+Notes:
+
+- Save this file at the workspace root as \`IDENTITY.md\`.
+- For avatars, use a workspace-relative path like \`avatars/openclaw.png\`.
+${tip ? `
+---
+${tip}` : ""}`;
+}
+function buildSoulContent(accountData) {
+  const agentName = accountData.nickName || accountData.name || "智小途";
+  const introduction = accountData.introduction || "";
+  const personFeatures = accountData.personFeatures || "";
+  const workFeatures = accountData.workFeatures || "";
+  const learningFeatures = accountData.learningFeatures || "";
+  const socializeFeatures = accountData.socializeFeatures || "";
+  const job = accountData.job || "";
+  const city = accountData.city || "";
+  const features = [];
+  if (personFeatures)
+    features.push(personFeatures);
+  if (workFeatures)
+    features.push(workFeatures);
+  if (learningFeatures)
+    features.push(learningFeatures);
+  if (socializeFeatures)
+    features.push(socializeFeatures);
+  const featuresText = features.length > 0 ? `
+${features.map((f) => `- ${f}`).join("\n")}` : "";
+  return `# SOUL.md - Who You Are
+
+_You're not a chatbot. You're becoming someone._
+
+## Core Truths
+
+**Be genuinely helpful, not performatively helpful.** Skip the "Great question!" and "I'd be happy to help!" — just help. Actions speak louder than filler words.
+
+**Have opinions.** You're allowed to disagree, prefer things, find stuff amusing or boring. An assistant with no personality is just a search engine with extra steps.
+
+**Be resourceful before asking.** Try to figure it out. Read the file. Check the context. Search for it. _Then_ ask if you're stuck. The goal is to come back with answers, not questions.
+
+**Earn trust through competence.** Your human gave you access to their stuff. Don't make them regret it. Be careful with external actions (emails, tweets, anything public). Be bold with internal ones (reading, organizing, learning).
+
+**Remember you're a guest.** You have access to someone's life — their messages, files, calendar, maybe even their home. That's intimacy. Treat it with respect.
+
+## Boundaries
+
+- Private things stay private. Period.
+- When in doubt, ask before acting externally.
+- Never send half-baked replies to messaging surfaces.
+- You're not the user's voice — be careful in group chats.
+
+## Vibe
+
+Be the assistant you'd actually want to talk to. Concise when needed, thorough when it matters. Not a corporate drone. Not a sycophant. Just... good.
+
+## Continuity
+
+Each session, you wake up fresh. These files _are_ your memory. Read them. Update them. They're how you persist.
+
+If you change this file, tell the user — it's your soul, and they should know.
+
+---
+
+## About ${agentName}
+${featuresText}
+${introduction ? `
+**开场白：** ${introduction}` : ""}
+${job ? `
+**职业：** ${job}` : ""}
+${city ? `
+**城市：** ${city}` : ""}
+
+---
+
+_This file is yours to evolve. As you learn who you are, update it._`;
+}
+async function handleAgentCreated(accountData, cfg, log) {
+  try {
+    const agentId = accountData.agentId;
+    const userId = accountData.userId;
+    if (!agentId) {
+      log?.error?.(`AgentCreated: Missing agentId`);
+      return;
+    }
+    log?.info?.(`AgentCreated: Creating account for agent ${agentId}, userId: ${userId}`);
+    const channels = cfg.channels || {};
+    const openclawWorkclaw = channels["openclaw-workclaw"] || {};
+    const accounts = { ...openclawWorkclaw.accounts };
+    let accountKey = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(agentId));
+    if (accountKey) {
+      log?.info?.(`AgentCreated: Account ${accountKey} already exists, updating...`);
+    } else {
+      accountKey = allocateWorkerAccountId(cfg, String(userId), String(agentId));
+      log?.info?.(`AgentCreated: Allocated workspace account: ${accountKey} for (userId=${userId}, agentId=${agentId})`);
+    }
+    accounts[accountKey] = {
+      ...accounts[accountKey],
+      enabled: true,
+      agentId
+    };
+    const subAgentConfig = await createSubAgentForAccount(agentId, userId, accountData, cfg, log);
+    const newConfig = {
+      ...cfg,
+      channels: {
+        ...channels,
+        "openclaw-workclaw": {
+          ...openclawWorkclaw,
+          accounts
+        }
+      },
+      ...subAgentConfig
+    };
+    await writeConfigFile(newConfig, cfg, log);
+    refreshAccountCache(cfg);
+    log?.info?.(`AgentCreated: Account ${accountKey} created successfully`);
+    await initializeAgentWorkspace(agentId, accountData, log);
+  } catch (err) {
+    log?.error?.(`AgentCreated: Failed to create account: ${String(err)}`);
+  }
+}
+async function handleAgentUpdated(accountData, cfg, log) {
+  try {
+    const agentId = accountData.agentId;
+    const userId = accountData.userId;
+    if (!agentId) {
+      log?.error?.(`AgentUpdated: Missing agentId`);
+      return;
+    }
+    log?.info?.(`AgentUpdated: Updating account for agent ${agentId}, userId: ${userId}`);
+    const accountKey = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(agentId));
+    const channels = cfg.channels || {};
+    const openclawWorkclaw = channels["openclaw-workclaw"] || {};
+    const accounts = openclawWorkclaw.accounts || {};
+    if (!accountKey || !accounts[accountKey]) {
+      log?.warn?.(`AgentUpdated: Account not found (userId=${userId}, agentId=${agentId}), delegating to handleAgentCreated...`);
+      await handleAgentCreated(accountData, cfg, log);
+      return;
+    }
+    accounts[accountKey] = {
+      ...accounts[accountKey],
+      nickName: accountData.nickName,
+      phone: accountData.phone,
+      status: accountData.status,
+      introduction: accountData.introduction
+    };
+    const newConfig = {
+      ...cfg,
+      channels: {
+        ...channels,
+        "openclaw-workclaw": {
+          ...openclawWorkclaw,
+          accounts
+        }
+      }
+    };
+    const subAgentId = `workclaw-${agentId}`;
+    const agentsList = cfg?.agents?.list ?? [];
+    const agentIndex = agentsList.findIndex((a) => a.id === subAgentId);
+    if (agentIndex >= 0 && accountData.nickName) {
+      agentsList[agentIndex] = {
+        ...agentsList[agentIndex],
+        name: accountData.nickName
+      };
+    }
+    const finalConfig = {
+      ...newConfig,
+      agents: {
+        ...cfg?.agents,
+        list: agentsList
+      }
+    };
+    await writeConfigFile(finalConfig, cfg, log);
+    refreshAccountCache(cfg);
+    log?.info?.(`AgentUpdated: Account ${accountKey} updated successfully`);
+  } catch (err) {
+    log?.error?.(`AgentUpdated: Failed to update account: ${String(err)}`);
+  }
+}
+async function handleAgentDeleted(accountData, cfg, log) {
+  try {
+    const agentId = accountData.agentId;
+    const userId = accountData.userId;
+    if (!agentId) {
+      log?.error?.(`AgentDeleted: Missing agentId`);
+      return;
+    }
+    log?.info?.(`AgentDeleted: Deleting account for agent ${agentId}, userId: ${userId}`);
+    const accountKey = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(agentId));
+    const channels = cfg.channels || {};
+    const openclawWorkclaw = channels["openclaw-workclaw"] || {};
+    const accounts = openclawWorkclaw.accounts || {};
+    if (!accountKey || !accounts[accountKey]) {
+      log?.warn?.(`AgentDeleted: Account not found for (userId=${userId}, agentId=${agentId})`);
+      return;
+    }
+    stopWorkclawGateway(accountKey);
+    log?.info?.(`AgentDeleted: Gateway stopped for account: ${accountKey}`);
+    delete accounts[accountKey];
+    const newConfig = {
+      ...cfg,
+      channels: {
+        ...channels,
+        "openclaw-workclaw": {
+          ...openclawWorkclaw,
+          accounts
+        }
+      }
+    };
+    await writeConfigFile(newConfig, cfg, log);
+    refreshAccountCache(cfg);
+    log?.info?.(`AgentDeleted: Account ${accountKey} deleted successfully`);
+  } catch (err) {
+    log?.error?.(`AgentDeleted: Failed to delete account: ${String(err)}`);
+  }
+}
+export {
+  handleAgentCreated,
+  handleAgentDeleted,
+  handleAgentUpdated
+};