@workclaw/openclaw-workclaw 1.0.17 → 1.0.18

package/src/gateway/agent-handlers.ts

@@ -2,130 +2,121 @@
  * Agent Handlers - handle AGENT_CREATED, AGENT_UPDATED, AGENT_DELETED events
  */
 
-import { execSync } from 'node:child_process'
-import { existsSync } from 'node:fs'
-import { copyFile, mkdir, writeFile } from 'node:fs/promises'
-import { homedir } from 'node:os'
-import { join } from 'node:path'
-import process from 'node:process'
-import { allocateWorkerAccountId, refreshAccountCache, resolveAccountByUserIdAndAgentId } from '../accounts.js'
-import { writeConfigFile } from './config-writer.js'
+import { resolveAccountByUserIdAndAgentId, allocateWorkerAccountId, refreshAccountCache, resolveWorkclawAccount } from "../accounts.js";
+import { writeConfigFile } from "./config-writer.js";
+import { startWorkclawGateway, stopWorkclawGateway } from "./workclaw-gateway.js";
+import { homedir } from "os";
+import { join } from "path";
+import { writeFile, copyFile, mkdir } from "fs/promises";
+import { execSync } from "child_process";
+import { existsSync } from "fs";
 
 /** 修复目录所有权（仅非 Windows 环境） */
 function fixOwner(dir: string): void {
-  if (process.platform === 'win32') {
-    return
-  }
-
-  try {
-    execSync(`chown -R node:node "${dir}"`, { stdio: 'ignore' })
-  }
-  catch {}
+    if (process.platform === 'win32') return;
+    try { execSync(`chown -R node:node "${dir}"`, { stdio: 'ignore' }); } catch {}
 }
 
-interface AgentLogger {
-  info?: (msg: string) => void
-  warn?: (msg: string) => void
-  error?: (msg: string) => void
-}
+type AgentLogger = {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+    error?: (msg: string) => void;
+};
 
 async function createSubAgentForAccount(
-  agentId: string | number,
-  userId: string | number,
-  cfg: any,
-  log?: AgentLogger,
+    agentId: string | number,
+    userId: string | number,
+    cfg: any,
+    log?: AgentLogger,
 ): Promise<any> {
-  try {
-    const channels = cfg?.channels ?? {}
-    const openclawWorkclaw = channels['openclaw-workclaw'] ?? {}
-    const accounts = openclawWorkclaw.accounts ?? {}
-    const accountCount = Object.keys(accounts).length
-    const subAgentId = `openclaw-workclaw-${agentId}`
-
-    const existingAgents = cfg?.agents?.list ?? []
-    const existingBindings = cfg?.bindings ?? []
-
-    const agentExists = existingAgents.some((a: any) => a.id === subAgentId)
-
-    if (!agentExists) {
-      const newAgentsList = [...existingAgents]
-      const subAgent = {
-        id: subAgentId,
-        default: false,
-        name: `智小途 - Agent ${agentId}`,
-        workspace: `~/.openclaw/workspace-workclaw/${agentId}`,
-        agentDir: `~/.openclaw/agents/workspace-workclaw-${agentId}/agent`,
-        tools: { allow: ['*'] },
-      }
-      newAgentsList.push(subAgent)
-
-      if (accountCount === 0) {
-        const defaultAgent = {
-          id: 'default',
-          default: true,
-          name: 'Default Agent',
-          workspace: 'default',
-          tools: { allow: ['*'] },
+    try {
+        const channels = cfg?.channels ?? {};
+        const openclawWorkclaw = channels['openclaw-workclaw'] ?? {};
+        const accounts = openclawWorkclaw.accounts ?? {};
+        const accountCount = Object.keys(accounts).length;
+        const subAgentId = `openclaw-workclaw-${agentId}`;
+
+        const existingAgents = cfg?.agents?.list ?? [];
+        const existingBindings = cfg?.bindings ?? [];
+
+        const agentExists = existingAgents.some((a: any) => a.id === subAgentId);
+
+        if (!agentExists) {
+            const newAgentsList = [...existingAgents];
+            const subAgent = {
+                id: subAgentId,
+                default: false,
+                name: `智小途 - Agent ${agentId}`,
+                workspace: `~/.openclaw/workspace-workclaw/${agentId}`,
+                agentDir: `~/.openclaw/agents/workspace-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: any) => b?.agentId === subAgentId);
+            let 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: openclaw-workclaw-${agentId} (account #${accountCount + 1})`);
+
+            return {
+                agents: newAgents,
+                bindings: newBindings,
+            };
         }
-        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: any) => 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: openclaw-workclaw-${agentId} (account #${accountCount + 1})`)
-
-      return {
-        agents: newAgents,
-        bindings: newBindings,
-      }
+    } catch (err) {
+        log?.error?.(`SubAgent: Failed to create sub-agent: ${String(err)}`);
+        return {};
     }
-  }
-  catch (err) {
-    log?.error?.(`SubAgent: Failed to create sub-agent: ${String(err)}`)
-    return {}
-  }
 }
 
 /**
@@ -133,142 +124,129 @@ async function createSubAgentForAccount(
  * 复制 AGENTS.md、TOOLS.md、USER.md，并生成 IDENTITY.md、SOUL.md
  */
 async function initializeAgentWorkspace(
-  agentId: string | number,
-  accountData: {
-    nickName?: string
-    phone?: string
-    introduction?: string
-    name?: string
-    tip?: string
-    characterSettings?: string
-    personFeatures?: string
-    workFeatures?: string
-    learningFeatures?: string
-    socializeFeatures?: string
-    job?: string
-    city?: string
-  },
-  log?: AgentLogger,
+    agentId: string | number,
+    accountData: {
+        nickName?: string;
+        phone?: string;
+        introduction?: string;
+        name?: string;
+        tip?: string;
+        characterSettings?: string;
+        personFeatures?: string;
+        workFeatures?: string;
+        learningFeatures?: string;
+        socializeFeatures?: string;
+        job?: string;
+        city?: string;
+    },
+    log?: AgentLogger,
 ): Promise<void> {
-  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')
-
-    // 确保 .openclaw 目录存在
-    if (!existsSync(openclawDir)) {
-      try {
-        await mkdir(openclawDir, { recursive: true, mode: 0o755 })
-        log?.info?.(`Workspace: Created directory ${openclawDir}`)
-      }
-      catch (err: any) {
-        if (err.code === 'EACCES' || err.code === 'EPERM') {
-          log?.warn?.(`Workspace: Permission denied creating ${openclawDir}, attempting with 777`)
-          await mkdir(openclawDir, { recursive: true, mode: 0o777 })
+    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");
+
+        // 确保 .openclaw 目录存在
+        if (!existsSync(openclawDir)) {
+            try {
+                await mkdir(openclawDir, { recursive: true, mode: 0o755 });
+                log?.info?.(`Workspace: Created directory ${openclawDir}`);
+            } catch (err: any) {
+                if (err.code === 'EACCES' || err.code === 'EPERM') {
+                    log?.warn?.(`Workspace: Permission denied creating ${openclawDir}, attempting with 777`);
+                    await mkdir(openclawDir, { recursive: true, mode: 0o777 });
+                } else throw err;
+            }
         }
-        else {
-          throw err
+        // 修复权限（目录可能已存在但权限不对）
+        fixOwner(openclawDir);
+
+        // 确保 workspace 目录存在
+        if (!existsSync(workspaceDir)) {
+            try {
+                await mkdir(workspaceDir, { recursive: true, mode: 0o755 });
+                log?.info?.(`Workspace: Created directory ${workspaceDir}`);
+            } catch (err: any) {
+                if (err.code === 'EACCES' || err.code === 'EPERM') {
+                    log?.warn?.(`Workspace: Permission denied creating ${workspaceDir}, attempting with 777`);
+                    await mkdir(workspaceDir, { recursive: true, mode: 0o777 });
+                } else throw err;
+            }
         }
-      }
-    }
-    // 修复权限（目录可能已存在但权限不对）
-    fixOwner(openclawDir)
-
-    // 确保 workspace 目录存在
-    if (!existsSync(workspaceDir)) {
-      try {
-        await mkdir(workspaceDir, { recursive: true, mode: 0o755 })
-        log?.info?.(`Workspace: Created directory ${workspaceDir}`)
-      }
-      catch (err: any) {
-        if (err.code === 'EACCES' || err.code === 'EPERM') {
-          log?.warn?.(`Workspace: Permission denied creating ${workspaceDir}, attempting with 777`)
-          await mkdir(workspaceDir, { recursive: true, mode: 0o777 })
+        // 修复权限（目录可能已存在但权限不对）
+        fixOwner(workspaceDir);
+
+        // 确保 main workspace 目录存在（用于复制模板文件）
+        if (!existsSync(mainWorkspaceDir)) {
+            try {
+                await mkdir(mainWorkspaceDir, { recursive: true, mode: 0o755 });
+                log?.info?.(`Workspace: Created directory ${mainWorkspaceDir}`);
+            } catch (err: any) {
+                if (err.code === 'EACCES' || err.code === 'EPERM') {
+                    log?.warn?.(`Workspace: Permission denied creating ${mainWorkspaceDir}, attempting with 777`);
+                    await mkdir(mainWorkspaceDir, { recursive: true, mode: 0o777 });
+                } else throw err;
+            }
         }
-        else {
-          throw err
-        }
-      }
-    }
-    // 修复权限（目录可能已存在但权限不对）
-    fixOwner(workspaceDir)
-
-    // 确保 main workspace 目录存在（用于复制模板文件）
-    if (!existsSync(mainWorkspaceDir)) {
-      try {
-        await mkdir(mainWorkspaceDir, { recursive: true, mode: 0o755 })
-        log?.info?.(`Workspace: Created directory ${mainWorkspaceDir}`)
-      }
-      catch (err: any) {
-        if (err.code === 'EACCES' || err.code === 'EPERM') {
-          log?.warn?.(`Workspace: Permission denied creating ${mainWorkspaceDir}, attempting with 777`)
-          await mkdir(mainWorkspaceDir, { recursive: true, mode: 0o777 })
+        // 修复权限（目录可能已存在但权限不对）
+        fixOwner(mainWorkspaceDir);
+
+        // 1. 复制 AGENTS.md、TOOLS.md、USER.md（从 main workspace）
+        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}`);
+                }
+            }
         }
-        else {
-          throw err
-        }
-      }
-    }
-    // 修复权限（目录可能已存在但权限不对）
-    fixOwner(mainWorkspaceDir)
-
-    // 1. 复制 AGENTS.md、TOOLS.md、USER.md（从 main workspace）
-    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}`)
-        }
-      }
-    }
 
-    // 2. 生成 IDENTITY.md（使用后端推送的智能体信息）
-    const identityContent = buildIdentityContent(accountData)
-    const identityPath = join(workspaceDir, 'IDENTITY.md')
-    await writeFile(identityPath, identityContent, 'utf-8')
-    log?.info?.(`Workspace: Created IDENTITY.md in ${workspaceDir}`)
-
-    // 3. 生成 SOUL.md（使用后端推送的智能体信息）
-    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)}`)
-    // 不抛出错误，不影响主流程
-  }
+        // 2. 生成 IDENTITY.md（使用后端推送的智能体信息）
+        const identityContent = buildIdentityContent(accountData);
+        const identityPath = join(workspaceDir, "IDENTITY.md");
+        await writeFile(identityPath, identityContent, "utf-8");
+        log?.info?.(`Workspace: Created IDENTITY.md in ${workspaceDir}`);
+
+        // 3. 生成 SOUL.md（使用后端推送的智能体信息）
+        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)}`);
+        // 不抛出错误，不影响主流程
+    }
 }
 
 /**
  * 构建 IDENTITY.md 内容
  */
 function buildIdentityContent(accountData: {
-  nickName?: string
-  name?: string
-  tip?: string
-  characterSettings?: string
-  job?: string
-  city?: string
+    nickName?: string;
+    name?: string;
+    tip?: string;
+    characterSettings?: string;
+    job?: string;
+    city?: string;
 }): string {
-  const agentName = accountData.nickName || accountData.name || '智小途'
-  const tip = accountData.tip || ''
-  const characterSettings = accountData.characterSettings || ''
+    const agentName = accountData.nickName || accountData.name || "智小途";
+    const tip = accountData.tip || "";
+    const characterSettings = accountData.characterSettings || "";
 
-  return `# IDENTITY.md - Who Am I?
+    return `# IDENTITY.md - Who Am I?
 
 _Fill this in during your first conversation. Make it yours._
 
 - **Name:** ${agentName}
 - **Creature:** AI智能助手
-- **Vibe:** ${characterSettings || '专业、友善、智能'}
+- **Vibe:** ${characterSettings || "专业、友善、智能"}
 - **Emoji:** 🤖
 - **Avatar:** avatars/${agentName}.png
 
@@ -280,45 +258,41 @@ Notes:
 
 - Save this file at the workspace root as \`IDENTITY.md\`.
 - For avatars, use a workspace-relative path like \`avatars/openclaw.png\`.
-${tip ? `\n---\n${tip}` : ''}`
+${tip ? `\n---\n${tip}` : ""}`;
 }
 
 /**
  * 构建 SOUL.md 内容
  */
 function buildSoulContent(accountData: {
-  nickName?: string
-  name?: string
-  introduction?: string
-  personFeatures?: string
-  workFeatures?: string
-  learningFeatures?: string
-  socializeFeatures?: string
-  job?: string
-  city?: string
+    nickName?: string;
+    name?: string;
+    introduction?: string;
+    personFeatures?: string;
+    workFeatures?: string;
+    learningFeatures?: string;
+    socializeFeatures?: string;
+    job?: string;
+    city?: string;
 }): string {
-  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: string[] = []
-  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 ? `\n${features.map(f => `- ${f}`).join('\n')}` : ''
-
-  return `# SOUL.md - Who You Are
+    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: string[] = [];
+    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 ? `\n${features.map(f => `- ${f}`).join("\n")}` : "";
+
+    return `# SOUL.md - Who You Are
 
 _You're not a chatbot. You're becoming someone._
 
@@ -355,203 +329,195 @@ If you change this file, tell the user — it's your soul, and they should know.
 
 ## About ${agentName}
 ${featuresText}
-${introduction ? `\n**开场白：** ${introduction}` : ''}
-${job ? `\n**职业：** ${job}` : ''}
-${city ? `\n**城市：** ${city}` : ''}
+${introduction ? `\n**开场白：** ${introduction}` : ""}
+${job ? `\n**职业：** ${job}` : ""}
+${city ? `\n**城市：** ${city}` : ""}
 
 ---
 
-_This file is yours to evolve. As you learn who you are, update it._`
+_This file is yours to evolve. As you learn who you are, update it._`;
 }
 
 export async function handleAgentCreated(
-  accountData: any,
-  cfg: any,
-  log?: AgentLogger,
+    accountData: any,
+    cfg: any,
+    log?: AgentLogger,
 ): Promise<void> {
-  try {
-    const agentId = accountData.agentId
-    const userId = accountData.userId
+    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}`)
+        if (!agentId) {
+            log?.error?.(`AgentCreated: Missing agentId`);
+            return;
+        }
 
-    const channels = cfg.channels || {}
-    const openclawWorkclaw = channels['openclaw-workclaw'] || {}
-    const accounts = { ...openclawWorkclaw.accounts }
+        log?.info?.(`AgentCreated: Creating account for agent ${agentId}, userId: ${userId}`);
 
-    let accountKey = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(agentId))
+        const channels = cfg.channels || {};
+        const openclawWorkclaw = channels['openclaw-workclaw'] || {};
+        const accounts = { ...openclawWorkclaw.accounts };
 
-    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})`)
-    }
+        let accountKey = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(agentId));
 
-    accounts[accountKey] = {
-      ...accounts[accountKey],
-      enabled: true,
-      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})`);
+        }
 
-    const subAgentConfig = await createSubAgentForAccount(agentId, userId, cfg, log)
-
-    const newConfig = {
-      ...cfg,
-      channels: {
-        ...channels,
-        'openclaw-workclaw': {
-          ...openclawWorkclaw,
-          accounts,
-        },
-      },
-      ...subAgentConfig,
+        accounts[accountKey] = {
+            ...accounts[accountKey],
+            enabled: true,
+            agentId: agentId,
+        };
+
+        const subAgentConfig = await createSubAgentForAccount(agentId, userId, 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`);
+
+        // 初始化 workspace 目录（复制/生成 AGENTS.md、TOOLS.md、USER.md、IDENTITY.md、SOUL.md）
+        await initializeAgentWorkspace(agentId, accountData, log);
+
+        setTimeout(async () => {
+            try {
+                const account = resolveWorkclawAccount({ cfg: newConfig, accountId: accountKey });
+                if (account.configured) {
+                    await startWorkclawGateway({
+                        accountId: accountKey,
+                        account,
+                        cfg: newConfig,
+                        log,
+                    });
+                    log?.info?.(`AgentCreated: Gateway started for account: ${accountKey}`);
+                }
+            } catch (err) {
+                log?.error?.(`AgentCreated: Failed to start gateway: ${String(err)}`);
+            }
+        }, 500);
+    } catch (err) {
+        log?.error?.(`AgentCreated: Failed to create account: ${String(err)}`);
     }
-
-    await writeConfigFile(newConfig, cfg, log)
-    refreshAccountCache(cfg)
-    log?.info?.(`AgentCreated: Account ${accountKey} created successfully`)
-
-    // 初始化 workspace 目录（复制/生成 AGENTS.md、TOOLS.md、USER.md、IDENTITY.md、SOUL.md）
-    await initializeAgentWorkspace(agentId, accountData, log)
-
-    setTimeout(async () => {
-      try {
-        const { resolveOpenclawWorkclawAccount } = await import('../accounts.js')
-        const { startOpenclawWorkclawGateway } = await import('./workclaw-gateway.js')
-        const account = resolveOpenclawWorkclawAccount({ cfg: newConfig, accountId: accountKey })
-        if (account.configured) {
-          await startOpenclawWorkclawGateway({
-            accountId: accountKey,
-            account,
-            cfg: newConfig,
-            log,
-          })
-          log?.info?.(`AgentCreated: Gateway started for account: ${accountKey}`)
-        }
-      }
-      catch (err) {
-        log?.error?.(`AgentCreated: Failed to start gateway: ${String(err)}`)
-      }
-    }, 500)
-  }
-  catch (err) {
-    log?.error?.(`AgentCreated: Failed to create account: ${String(err)}`)
-  }
 }
 
 export async function handleAgentUpdated(
-  accountData: any,
-  cfg: any,
-  log?: AgentLogger,
+    accountData: any,
+    cfg: any,
+    log?: AgentLogger,
 ): Promise<void> {
-  try {
-    const agentId = accountData.agentId
-    const userId = accountData.userId
+    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}`)
+        if (!agentId) {
+            log?.error?.(`AgentUpdated: Missing agentId`);
+            return;
+        }
 
-    const accountKey = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(agentId))
+        log?.info?.(`AgentUpdated: Updating account for agent ${agentId}, userId: ${userId}`);
 
-    const channels = cfg.channels || {}
-    const openclawWorkclaw = channels['openclaw-workclaw'] || {}
-    const accounts = openclawWorkclaw.accounts || {}
+        const accountKey = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(agentId));
 
-    if (!accountKey || !accounts[accountKey]) {
-      log?.warn?.(`AgentUpdated: Account not found (userId=${userId}, agentId=${agentId}), delegating to handleAgentCreated...`)
-      await handleAgentCreated(accountData, cfg, log)
-      return
-    }
+        const channels = cfg.channels || {};
+        const openclawWorkclaw = channels['openclaw-workclaw'] || {};
+        const accounts = openclawWorkclaw.accounts || {};
 
-    accounts[accountKey] = {
-      ...accounts[accountKey],
-      nickName: accountData.nickName,
-      phone: accountData.phone,
-      status: accountData.status,
-      introduction: accountData.introduction,
-    }
+        if (!accountKey || !accounts[accountKey]) {
+            log?.warn?.(`AgentUpdated: Account not found (userId=${userId}, agentId=${agentId}), delegating to handleAgentCreated...`);
+            await handleAgentCreated(accountData, cfg, log);
+            return;
+        }
 
-    const newConfig = {
-      ...cfg,
-      channels: {
-        ...channels,
-        'openclaw-workclaw': {
-          ...openclawWorkclaw,
-          accounts,
-        },
-      },
+        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,
+                },
+            },
+        };
+
+        await writeConfigFile(newConfig, cfg, log);
+        refreshAccountCache(cfg);
+        log?.info?.(`AgentUpdated: Account ${accountKey} updated successfully`);
+    } catch (err) {
+        log?.error?.(`AgentUpdated: Failed to update account: ${String(err)}`);
     }
-
-    await writeConfigFile(newConfig, cfg, log)
-    refreshAccountCache(cfg)
-    log?.info?.(`AgentUpdated: Account ${accountKey} updated successfully`)
-  }
-  catch (err) {
-    log?.error?.(`AgentUpdated: Failed to update account: ${String(err)}`)
-  }
 }
 
 export async function handleAgentDeleted(
-  accountData: any,
-  cfg: any,
-  log?: AgentLogger,
+    accountData: any,
+    cfg: any,
+    log?: AgentLogger,
 ): Promise<void> {
-  try {
-    const agentId = accountData.agentId
-    const userId = accountData.userId
+    try {
+        const agentId = accountData.agentId;
+        const userId = accountData.userId;
 
-    if (!agentId) {
-      log?.error?.(`AgentDeleted: Missing agentId`)
-      return
-    }
+        if (!agentId) {
+            log?.error?.(`AgentDeleted: Missing agentId`);
+            return;
+        }
 
-    log?.info?.(`AgentDeleted: Deleting account for agent ${agentId}, userId: ${userId}`)
+        log?.info?.(`AgentDeleted: Deleting account for agent ${agentId}, userId: ${userId}`);
 
-    const accountKey = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(agentId))
+        const accountKey = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(agentId));
 
-    const channels = cfg.channels || {}
-    const openclawWorkclaw = channels['openclaw-workclaw'] || {}
-    const accounts = openclawWorkclaw.accounts || {}
+        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
-    }
+        if (!accountKey || !accounts[accountKey]) {
+            log?.warn?.(`AgentDeleted: Account not found for (userId=${userId}, agentId=${agentId})`);
+            return;
+        }
 
-    const { stopOpenclawWorkclawGateway } = await import('./workclaw-gateway.js')
-    const wsStrategy = (accounts[accountKey] as any)?.wsConnectionStrategy || 'per-account'
-    stopOpenclawWorkclawGateway(accountKey, wsStrategy)
-    log?.info?.(`AgentDeleted: Gateway stopped for account: ${accountKey}`)
-
-    delete accounts[accountKey]
-
-    const newConfig = {
-      ...cfg,
-      channels: {
-        ...channels,
-        'openclaw-workclaw': {
-          ...openclawWorkclaw,
-          accounts,
-        },
-      },
+        const wsStrategy = (accounts[accountKey] as any)?.wsConnectionStrategy || "per-account";
+        stopWorkclawGateway(accountKey, wsStrategy);
+        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)}`);
     }
-
-    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)}`)
-  }
 }