@workclaw/openclaw-workclaw 1.0.17 → 1.0.19

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

@@ -0,0 +1,433 @@
+/**
+ * Agent Handlers - handle AGENT_CREATED, AGENT_UPDATED, AGENT_DELETED events
+ */
+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) {
+    if (process.platform === 'win32')
+        return;
+    try {
+        execSync(`chown -R node:node "${dir}"`, { stdio: 'ignore' });
+    }
+    catch { }
+}
+async function createSubAgentForAccount(agentId, userId, cfg, log) {
+    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) => 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) => 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,
+            };
+        }
+    }
+    catch (err) {
+        log?.error?.(`SubAgent: Failed to create sub-agent: ${String(err)}`);
+        return {};
+    }
+}
+/**
+ * 初始化智能体 workspace 目录
+ * 复制 AGENTS.md、TOOLS.md、USER.md，并生成 IDENTITY.md、SOUL.md
+ */
+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");
+        // 确保 .openclaw 目录存在
+        if (!existsSync(openclawDir)) {
+            try {
+                await mkdir(openclawDir, { recursive: true, mode: 0o755 });
+                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: 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) {
+                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(workspaceDir);
+        // 确保 main workspace 目录存在（用于复制模板文件）
+        if (!existsSync(mainWorkspaceDir)) {
+            try {
+                await mkdir(mainWorkspaceDir, { recursive: true, mode: 0o755 });
+                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: 0o777 });
+                }
+                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)}`);
+        // 不抛出错误，不影响主流程
+    }
+}
+/**
+ * 构建 IDENTITY.md 内容
+ */
+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 ? `\n---\n${tip}` : ""}`;
+}
+/**
+ * 构建 SOUL.md 内容
+ */
+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 ? `\n${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 ? `\n**开场白：** ${introduction}` : ""}
+${job ? `\n**职业：** ${job}` : ""}
+${city ? `\n**城市：** ${city}` : ""}
+
+---
+
+_This file is yours to evolve. As you learn who you are, update it._`;
+}
+export 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: 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)}`);
+    }
+}
+export 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,
+                },
+            },
+        };
+        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, 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)}`);
+    }
+}

package/dist/src/gateway/config-writer.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Config Writer - handles writing account config to openclaw.json
+ *
+ * NOTE: Only agent creation/initialization writes to openclaw.json via writeConfigFile.
+ * Runtime dynamic data (openConversationId) is stored in a separate state file
+ * to avoid triggering openclaw's config watcher, which would re-parse env vars
+ * and potentially overwrite already-resolved values like ${MODEL_API_KEY}.
+ */
+type ConfigLogger = {
+    info?: (msg: string) => void;
+    error?: (msg: string) => void;
+};
+/**
+ * Write a new config to the openclaw.json file.
+ */
+export declare function writeConfigFile(newConfig: any, cfg: any, log?: ConfigLogger): Promise<void>;
+/**
+ * Load openConversationId from the separate state file.
+ *
+ * Key format: accountId:userId
+ *
+ * Called at runtime to restore openConversationId after process restart,
+ * since cfg is reloaded from openclaw.json which does not contain this value.
+ */
+export declare function loadOpenConversationId(accountId: string, userId: string): string | null;
+/**
+ * Save openConversationId to a separate state file (with write throttling).
+ *
+ * Key format: accountId:userId
+ * Throttling: if called multiple times within 1 second, only the last value is saved.
+ * This avoids excessive disk writes from high-frequency messages.
+ *
+ * Stored in ~/.openclaw/workclaw-state/conversations.json (separate from openclaw.json)
+ * to avoid triggering openclaw's config watcher which would re-parse env vars.
+ */
+export declare function saveOpenConversationId(accountId: string, userId: string, openConversationId: string, cfg: any, log?: ConfigLogger): Promise<void>;
+/**
+ * Initialize workclaw agent config in one shot (hardware device init).
+ *
+ * Sets apiKey, agentId, userId and persists to openclaw.json in a single write.
+ *
+ * NOTE: If apiKey already contains a SecretRef (type: "env"|"file"|"exec"),
+ * it is preserved and NOT overwritten, since OpenClaw handles SecretRef resolution.
+ */
+export declare function initWorkclawAgent(params: {
+    apiKey?: string;
+    agentId?: string;
+    userId?: string;
+    accountId?: string;
+}, cfg: any, log?: ConfigLogger): Promise<void>;
+/**
+ * Save userId to cfg memory and persist to openclaw.json.
+ *
+ * Used during hardware device initialization to persist the default userId.
+ */
+export declare function saveWorkClawUserId(accountId: string, userId: string | number, cfg: any, log?: ConfigLogger): Promise<void>;
+/**
+ * Save agentId to cfg memory and persist to openclaw.json.
+ *
+ * Used during hardware device initialization to persist the default agentId.
+ */
+export declare function saveWorkClawAgentId(accountId: string, agentId: string | number, cfg: any, log?: ConfigLogger): Promise<void>;
+/**
+ * Save apiKey to cfg memory only.
+ *
+ * Does NOT write to openclaw.json to avoid triggering openclaw's config watcher,
+ * which would re-parse env vars (e.g. ${MODEL_API_KEY}) and potentially
+ * overwrite resolved values in the runtime cfg.
+ */
+export declare function saveWorkClawApiKey(apiKey: string, cfg: any, log?: ConfigLogger): Promise<void>;
+export {};