@workclaw/openclaw-workclaw 1.0.17 → 1.0.19

package/dist/src/gateway/message-dispatcher.js

@@ -0,0 +1,512 @@
+/**
+ * Message Dispatcher - handles all WorkClaw WebSocket message types
+ */
+import { parseWorkClawMessage } from "./message-context.js";
+import { buildInboundContext } from "./message-context.js";
+import { handleAgentCreated, handleAgentUpdated, handleAgentDeleted } from "./agent-handlers.js";
+import { saveOpenConversationId, initWorkclawAgent } from "./config-writer.js";
+import { getWorkclawWsConnection, setLastInboundAt } from "../runtime.js";
+import { getWorkclawRuntime } from "../runtime.js";
+import { sendMessageWorkclaw } from "../outbound/index.js";
+import { resolveAccountByUserIdAndAgentId, resolveWorkclawAccountWithCache } from "../accounts.js";
+import { getWorkclawAccessToken, getWorkclawModelConfigByAppKey } from "../connection/workclaw-client.js";
+import { setToolContext } from "../runtime.js";
+import { handleSkillsEvent } from "./skills-handler.js";
+import { handleToolsListEvent as doHandleToolsListEvent } from "./tools-list-handler.js";
+import { handleSkillsListEvent as doHandleSkillsListEvent } from "./skills-list-handler.js";
+import { request } from "undici";
+/** Log an error safely */
+function logError(log, context, err) {
+    const errAny = err;
+    const stack = typeof errAny?.stack === "string" ? `\nStack: ${errAny.stack}` : "";
+    log?.error?.(`Dispatcher ${context}: ${String(err)}${stack}`);
+}
+// ---------------------------------------------------------------------------
+// Individual message handlers
+// ---------------------------------------------------------------------------
+async function handlePing(ctx, result) {
+    const { accountId, log } = ctx;
+    const ws = getWorkclawWsConnection(accountId);
+    if (!ws)
+        return;
+    try {
+        const pongResponse = {
+            code: 200,
+            message: "pong",
+            metadata: { contentType: "application/json" },
+            data: JSON.stringify(result.pongData),
+        };
+        ws.send(JSON.stringify(pongResponse));
+        log?.debug?.(`pong`);
+    }
+    catch (err) {
+        logError(log, "Failed to send pong", err);
+    }
+}
+async function handleDisconnect(ctx) {
+    const { accountId, log, scheduleReconnect } = ctx;
+    const ws = getWorkclawWsConnection(accountId);
+    if (ws) {
+        try {
+            ws.close();
+            log?.info?.(`Closed WebSocket due to disconnect command`);
+        }
+        catch (err) {
+            logError(log, "Failed to close WebSocket", err);
+        }
+    }
+    else {
+        log?.info?.(`WebSocket already cleared, triggering reconnect...`);
+        scheduleReconnect();
+    }
+}
+async function handleAgentEvent(ctx, result) {
+    const { cfg, log, baseConfig, accountId } = ctx;
+    const eventData = result.eventData;
+    if (!eventData) {
+        log?.warn?.(`Received ${result.type} event but no data`);
+        return;
+    }
+    const agentId = String(eventData.id || "");
+    const userId = String(eventData.futureId || "");
+    if (!agentId) {
+        log?.warn?.(`Received ${result.type} event but missing agent id`);
+        return;
+    }
+    log?.info?.(`Processing ${result.type} event for agent ${agentId}, userId: ${userId}`);
+    const accountData = {
+        agentId,
+        userId,
+        nickName: eventData.nickName,
+        phone: eventData.phone,
+        status: eventData.status,
+        introduction: eventData.introduction,
+        name: eventData.name,
+        tip: eventData.tip,
+        characterSettings: eventData.characterSettings,
+        personFeatures: eventData.personFeatures,
+        workFeatures: eventData.workFeatures,
+        learningFeatures: eventData.learningFeatures,
+        socializeFeatures: eventData.socializeFeatures,
+        job: eventData.job,
+        city: eventData.city,
+    };
+    switch (result.type) {
+        case "agent_created":
+            await handleAgentCreated(accountData, cfg, log);
+            handleAgentCreatedMessage(baseConfig, agentId, accountId, log);
+            break;
+        case "agent_updated":
+            await handleAgentUpdated(accountData, cfg, log);
+            break;
+        case "agent_deleted":
+            await handleAgentDeleted(accountData, cfg, log);
+            break;
+    }
+}
+async function handleSkillsProcessingEvent(ctx, result) {
+    const { accountId, baseConfig, log } = ctx;
+    if (!result.eventData)
+        return;
+    try {
+        const connConfig = {
+            baseUrl: baseConfig.baseUrl || "",
+            websocketUrl: baseConfig.websocketUrl,
+            appKey: baseConfig.appKey,
+            appSecret: baseConfig.appSecret,
+            localIp: baseConfig.localIp,
+            allowInsecureTls: baseConfig.allowInsecureTls,
+            requestTimeout: baseConfig.requestTimeout,
+        };
+        const tokenCacheKey = baseConfig.appKey || accountId;
+        const token = await getWorkclawAccessToken(tokenCacheKey, connConfig);
+        await handleSkillsEvent(result.eventData, token, connConfig.baseUrl, connConfig.appKey || accountId, log);
+    }
+    catch (err) {
+        logError(log, "handleSkillsEvent failed", err);
+    }
+}
+async function handleToolsListEvent(ctx, result) {
+    const { accountId, baseConfig, log } = ctx;
+    if (!result.eventData)
+        return;
+    try {
+        const connConfig = {
+            baseUrl: baseConfig.baseUrl || "",
+            websocketUrl: baseConfig.websocketUrl,
+            appKey: baseConfig.appKey,
+            appSecret: baseConfig.appSecret,
+            localIp: baseConfig.localIp,
+            allowInsecureTls: baseConfig.allowInsecureTls,
+            requestTimeout: baseConfig.requestTimeout,
+        };
+        const tokenCacheKey = baseConfig.appKey || accountId;
+        const token = await getWorkclawAccessToken(tokenCacheKey, connConfig);
+        await doHandleToolsListEvent(result.eventData, connConfig.baseUrl, token, log);
+    }
+    catch (err) {
+        logError(log, "handleToolsListEvent failed", err);
+    }
+}
+async function handleSkillsListEvent(ctx, result) {
+    const { accountId, baseConfig, log } = ctx;
+    if (!result.eventData)
+        return;
+    try {
+        const connConfig = {
+            baseUrl: baseConfig.baseUrl || "",
+            websocketUrl: baseConfig.websocketUrl,
+            appKey: baseConfig.appKey,
+            appSecret: baseConfig.appSecret,
+            localIp: baseConfig.localIp,
+            allowInsecureTls: baseConfig.allowInsecureTls,
+            requestTimeout: baseConfig.requestTimeout,
+        };
+        const tokenCacheKey = baseConfig.appKey || accountId;
+        const token = await getWorkclawAccessToken(tokenCacheKey, connConfig);
+        await doHandleSkillsListEvent(result.eventData, connConfig.baseUrl, token, log);
+    }
+    catch (err) {
+        logError(log, "handleSkillsListEvent failed", err);
+    }
+}
+async function handleInitAgentEvent(ctx, result) {
+    const { accountId, cfg, baseConfig, log } = ctx;
+    const initStartedAt = Date.now();
+    const eventData = result.eventData;
+    if (!eventData) {
+        log?.warn?.(`init_agent received but no data`);
+        return;
+    }
+    log?.info?.(`init_agent accountId=${accountId} eventDataType=${typeof eventData} preview=${JSON.stringify(eventData).slice(0, 200)}`);
+    const connConfig = {
+        baseUrl: baseConfig.baseUrl || "",
+        websocketUrl: baseConfig.websocketUrl,
+        appKey: baseConfig.appKey,
+        appSecret: baseConfig.appSecret,
+        localIp: baseConfig.localIp,
+        allowInsecureTls: baseConfig.allowInsecureTls,
+        requestTimeout: baseConfig.requestTimeout,
+    };
+    // Fetch apiKey and init agent config in one write
+    try {
+        const tokenCacheKey = baseConfig.appKey || accountId;
+        const { baseUrl: modelBaseUrl, apiKey } = await getWorkclawModelConfigByAppKey(tokenCacheKey, connConfig);
+        const maskedKey = apiKey ? `${String(apiKey).slice(0, 6)}...(${String(apiKey).length})` : "missing";
+        log?.info?.(`init_agent model fetched baseUrl=${modelBaseUrl} apiKey=${maskedKey}`);
+        const agentId = String(eventData?.id || eventData?.agentId || "");
+        const userId = String(eventData?.futureId || eventData?.userId || "");
+        await initWorkclawAgent({ apiKey, agentId, userId, accountId: "default" }, cfg, log);
+        log?.info?.(`init_agent config saved elapsedMs=${Date.now() - initStartedAt}`);
+    }
+    catch (err) {
+        logError(log, "init_agent failed", err);
+    }
+    log?.info?.(`init_agent handled elapsedMs=${Date.now() - initStartedAt}`);
+}
+async function handleAgentMessage(ctx, data, result) {
+    const { accountId, account, cfg, accountConfig, log } = ctx;
+    const { message } = result;
+    if (!message)
+        return;
+    // 这里的msgAgentId是云平台的agentId
+    const { text, userId, openConversationId, messageId: parsedMessageId, agentId: msgAgentId } = message;
+    // Resolve account from message
+    let messageAccountId = accountId;
+    let messageAccount = account;
+    if (userId && msgAgentId) {
+        const resolvedAccountId = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(msgAgentId));
+        if (resolvedAccountId) {
+            const resolved = resolveWorkclawAccountWithCache({ cfg, accountId: resolvedAccountId });
+            messageAccountId = resolvedAccountId;
+            messageAccount = resolved;
+            log?.info?.(`Resolved account ${resolvedAccountId} from message (userId=${userId}, agentId=${msgAgentId})`);
+        }
+        else if (String(msgAgentId) !== String(accountConfig.agentId)) {
+            log?.warn?.(`Account not found for userId=${userId}, agentId=${msgAgentId}, ignoring`);
+            return;
+        }
+    }
+    const resolvedAccountConfig = messageAccount.config;
+    const msgAgentIdResolved = msgAgentId ?? accountConfig.agentId;
+    // Save openConversationId if new
+    if (openConversationId && openConversationId !== resolvedAccountConfig.openConversationId) {
+        try {
+            await saveOpenConversationId(messageAccountId, userId, openConversationId, cfg, log);
+            log?.info?.(`Saved openConversationId ${openConversationId} to account ${messageAccountId}`);
+        }
+        catch (err) {
+            logError(log, "saveOpenConversationId failed", err);
+        }
+    }
+    const resolvedOpenConversationId = openConversationId || resolvedAccountConfig.openConversationId || "";
+    const to = userId;
+    const bodyText = text || data;
+    if (!bodyText) {
+        log?.warn?.(`Empty body, ignoring`);
+        return;
+    }
+    // Route via bindings
+    const bindings = cfg?.bindings ?? [];
+    let targetAgentId = "default";
+    const matchedBinding = bindings.find((binding) => {
+        const match = binding?.match;
+        if (!match || match.channel !== "openclaw-workclaw")
+            return false;
+        return match.accountId === messageAccountId || match.accountId === "*";
+    });
+    if (matchedBinding) {
+        targetAgentId = matchedBinding.agentId;
+        log?.info?.(`Routing to agent ${targetAgentId} via binding (account: ${messageAccountId})`);
+    }
+    if (!targetAgentId) {
+        log?.warn?.(`Missing target, ignoring`);
+        return;
+    }
+    // 构建用于解析 sessionKey 的消息对象
+    // to = agentId (智能体/机器人), from = userId (用户)
+    const attachments = message.attachments;
+    const inboundMessage = {
+        text: bodyText,
+        to: to,
+        from: userId,
+        chatType: "dm",
+        messageId: parsedMessageId,
+        rawPayload: data,
+        timestamp: Date.now(),
+        attachments: attachments,
+    };
+    log?.info?.(`handleAgentMessage: text=${bodyText?.substring(0, 50)}, attachments=${attachments?.length || 0}`);
+    const pluginRuntime = getWorkclawRuntime();
+    // 使用扩展后的 buildInboundContext，它会处理完整的 session 流程
+    const finalized = await buildInboundContext(inboundMessage, messageAccountId, messageAccount.config, targetAgentId, pluginRuntime, true, log);
+    // 维护当前工具名称状态
+    let currentToolName = null;
+    // 追踪 final 是否已投递（框架在流式输出时会 drop final，需要手动补发 last: true）
+    let finalDelivered = false;
+    // 发送工具消息的辅助函数
+    const sendToolMessage = async (text, isStart = false) => {
+        try {
+            await sendMessageWorkclaw({
+                cfg,
+                to: to,
+                text,
+                accountId: messageAccountId,
+                openConversationId: resolvedOpenConversationId,
+                agentId: msgAgentIdResolved,
+                replyToMessageId: parsedMessageId,
+                last: false,
+            });
+        }
+        catch (err) {
+            logError(log, isStart ? "Tool start message send failed" : "Tool result message send failed", err);
+        }
+    };
+    await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx: finalized,
+        cfg,
+        replyOptions: {
+            onAgentRunStart(runId) {
+                // 保存 runId 和 ctx 的关联，供 hook 使用
+                setToolContext(runId, {
+                    target: targetAgentId,
+                    replyToMessageId: parsedMessageId,
+                    openConversationId: resolvedOpenConversationId,
+                    accountId: messageAccountId,
+                    agentId: String(msgAgentIdResolved),
+                    sessionKey: finalized.SessionKey || "",
+                });
+                log?.info?.(`[AGENT] onAgentRunStart: runId=${runId} target=${targetAgentId}`);
+            },
+            /*onToolStart(payload) {
+                log?.info?.(`[AGENT] onToolStart: ${JSON.stringify(payload)}`);
+                if (payload.phase === "start") {
+                    currentToolName = payload.name ?? null;
+                    const hint = getToolStartHint(currentToolName);
+                    log?.info?.(`[TOOL] Starting tool: ${currentToolName}, sending hint: ${hint}`);
+                    sendToolMessage(hint, true).catch((err) => {
+                        logError(log, "Tool start hint send failed", err);
+                    });
+                }
+            }*/
+        },
+        dispatcherOptions: {
+            deliver: async (payload, info) => {
+                // 记录每次 deliver 调用，帮助调试 info.kind 问题
+                log?.info?.(`[DELIVER] deliver called: info.kind=${info?.kind}, payload.text=${String(payload?.text ?? "").substring(0, 100)}`);
+                const resolvedReplyToId = payload?.replyToId || parsedMessageId;
+                let textOut = String(payload.text ?? payload.body ?? "");
+                const target = to || String(payload.to ?? "");
+                if (!target) {
+                    log?.warn?.(`Skipping reply: no target`);
+                    return;
+                }
+                if (!textOut.trim()) {
+                    log?.warn?.(`Empty reply text, skipping`);
+                    return;
+                }
+                if (info?.kind === "tool")
+                    return;
+                // 处理工具类型的 deliver
+                /*if (info?.kind === "tool") {
+                    // log?.info?.(`[DELIVER] tool reply: ${JSON.stringify(payload)}`);
+                    const toolText = payload.text ?? "";
+                    if (toolText.trim()) {
+                        // 使用 formattedToolOutput 格式发送
+                        try {
+                            await sendMessageWorkclaw({
+                                cfg,
+                                to: targetAgentId,
+                                text: JSON.stringify({
+                                    name: currentToolName || "Unknown",
+                                    content: toolText,
+                                    state: "result",
+                                }),
+                                msgType: "26",
+                                accountId: messageAccountId,
+                                openConversationId: resolvedOpenConversationId,
+                                agentId: msgAgentIdResolved,
+                                replyToMessageId: parsedMessageId,
+                            });
+                        } catch (err) {
+                            logError(log, "Tool result send failed", err);
+                        }
+                    }
+                    return;
+                }*/
+                // final 时清空工具状态
+                if (info?.kind === "final") {
+                    currentToolName = null;
+                    finalDelivered = true;
+                    log?.info?.(`[DELIVER] final received, cleared currentToolName`);
+                }
+                // 明确设置 last：final 时为 true，否则为 false（显式转换，避免 undefined）
+                const isFinal = info?.kind === "final";
+                const isLast = isFinal ? true : false;
+                log?.info?.(`[DELIVER] is last: ${isLast} (info.kind=${info?.kind})`);
+                try {
+                    const result = await sendMessageWorkclaw({
+                        cfg, to: target, text: textOut,
+                        accountId: messageAccountId, openConversationId: resolvedOpenConversationId,
+                        agentId: msgAgentIdResolved, replyToMessageId: resolvedReplyToId,
+                        last: isLast,
+                    });
+                    log?.info?.(`Reply sent messageId=${result.messageId}`);
+                }
+                catch (err) {
+                    logError(log, "Reply send failed", err);
+                    throw err;
+                }
+            },
+        },
+    });
+    // 框架在流式输出时会 drop final payload，检测到时应手动补发 last: true
+    if (!finalDelivered) {
+        log?.warn?.(`[DELIVER] final was dropped by framework, sending last: true`);
+        try {
+            // 发送一个空格作为占位内容，确保 last: true 能被服务端接受
+            await sendMessageWorkclaw({
+                cfg, to: to || String(userId || ""),
+                text: "",
+                accountId: messageAccountId, openConversationId: resolvedOpenConversationId,
+                agentId: msgAgentIdResolved, replyToMessageId: parsedMessageId,
+                last: true,
+            });
+        }
+        catch (err) {
+            // 服务端可能拒绝空内容的 last 信号，忽略即可
+            const errStr = String(err);
+            if (errStr.includes("content can't be empty")) {
+                log?.info?.(`[DELIVER] last signal skipped (empty content not supported)`);
+            }
+            else {
+                logError(log, "Final/last signal send failed", err);
+            }
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Main dispatcher
+// ---------------------------------------------------------------------------
+export async function dispatchWorkclawMessage(data, ctx) {
+    const { log } = ctx;
+    const rawHasAuthToken = data.includes("authToken") ||
+        data.toLowerCase().includes("authorization") ||
+        data.toLowerCase().includes("bearer ");
+    const rawPreview = data.length > 300 ? `${data.slice(0, 300)}...` : data;
+    /*log?.info?.(
+        `Raw message bytes=${data.length} hasAuthToken=${rawHasAuthToken} preview=${rawPreview}`,
+    );*/
+    const result = parseWorkClawMessage(data, log);
+    if (!result) {
+        log?.warn?.(`Failed to parse message`);
+        return;
+    }
+    log?.info?.(`Message type=${result.type}`);
+    // 更新上次消息时间（始终用 accountId，因为每个账号的入站时间需要独立追踪）
+    const { accountId } = ctx;
+    if (accountId) {
+        setLastInboundAt(accountId, Date.now());
+    }
+    switch (result.type) {
+        case "ping":
+            await handlePing(ctx, result);
+            return;
+        case "disconnect":
+            await handleDisconnect(ctx);
+            return;
+        case "agent_created":
+        case "agent_updated":
+        case "agent_deleted":
+            await handleAgentEvent(ctx, result);
+            return;
+        case "skills_event":
+            await handleSkillsProcessingEvent(ctx, result);
+            return;
+        case "tools_list":
+            await handleToolsListEvent(ctx, result);
+            return;
+        case "skills_list":
+            await handleSkillsListEvent(ctx, result);
+            return;
+        case "init_agent":
+            await handleInitAgentEvent(ctx, result);
+            return;
+        case "ignored":
+            log?.info?.(`Ignoring message type=${result.type}`);
+            return;
+        case "agent_message":
+            await handleAgentMessage(ctx, data, result);
+            return;
+        default:
+            log?.info?.(`Unknown message type: ${result.type}, ignoring`);
+    }
+}
+// 创建成功回调
+async function handleAgentCreatedMessage(baseConfig, agentId, accountId, log) {
+    // 通知
+    try {
+        const callbackUrl = `${baseConfig.baseUrl}/open-apis/instance/agent-created/status`;
+        const tokenCacheKey = baseConfig.appKey || accountId;
+        const callbackData = {
+            "agentId": agentId,
+            "success": true
+        };
+        log?.info?.(`[AgentCreated] Calling callback API: ${callbackUrl}`);
+        const token = await getWorkclawAccessToken(tokenCacheKey, baseConfig);
+        const response = await request(callbackUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${token}`,
+            },
+            body: JSON.stringify(callbackData),
+        });
+        const responseBody = await response.body.text();
+        log?.info?.(`[AgentCreated] Callback API response: status=${response.statusCode}, body=${responseBody}`);
+    }
+    catch (callbackErr) {
+        // 接口调用失败不影响主流程，只记录错误
+        log?.error?.(`[AgentCreated] Callback API failed: ${String(callbackErr)}`);
+    }
+}

package/dist/src/gateway/reconnect.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Reconnect Scheduler - manages WebSocket reconnection with exponential backoff
+ */
+import { WebSocket } from "undici";
+import type { WorkClawBaseConfig } from "../types.js";
+export interface ReconnectSchedulerOptions {
+    /** Key for WebSocket storage (appKey) */
+    key: string;
+    config: WorkClawBaseConfig;
+    log?: {
+        info?: (msg: string) => void;
+        warn?: (msg: string) => void;
+        error?: (msg: string) => void;
+        debug?: (msg: string) => void;
+    };
+    onMessage: (data: string) => void;
+    onReconnectSuccess?: () => void;
+    /** Called when connection closes (after initial connect), to trigger reconnect */
+    onClose?: () => void;
+    /** Called after WebSocket is registered (before onopen), useful for lock release */
+    onConnectingStarted?: (ws: WebSocket) => void;
+}
+export declare function createReconnectScheduler(options: ReconnectSchedulerOptions): {
+    connect: () => Promise<void>;
+    scheduleReconnect: () => void;
+    stopReconnect: () => void;
+};