@workclaw/openclaw-workclaw 1.0.18 → 1.0.19

package/dist/src/media/upload.js

@@ -0,0 +1,125 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+import { Agent, fetch as undiciFetch } from "undici";
+export function isLocalMediaSource(value) {
+    const trimmed = value.trim();
+    return (trimmed.startsWith("/") ||
+        trimmed.startsWith("./") ||
+        trimmed.startsWith("../") ||
+        trimmed.startsWith("~") ||
+        trimmed.startsWith("file://"));
+}
+export function resolveLocalPath(input) {
+    if (input.startsWith("file://")) {
+        return fileURLToPath(input);
+    }
+    if (input.startsWith("~")) {
+        return path.join(os.homedir(), input.slice(1));
+    }
+    return path.resolve(input);
+}
+function readResponseUrlPath(data, pathValue) {
+    if (!pathValue)
+        return undefined;
+    const parts = pathValue.split(".").filter(Boolean);
+    let current = data;
+    for (const part of parts) {
+        if (!current || typeof current !== "object")
+            return undefined;
+        current = current[part];
+    }
+    return typeof current === "string" ? current : undefined;
+}
+function extractUploadedUrl(responseText, responseData, pathValue) {
+    const fromPath = readResponseUrlPath(responseData, pathValue);
+    if (fromPath)
+        return fromPath;
+    const direct = responseData.url ??
+        responseData.mediaUrl;
+    if (typeof direct === "string" && direct.trim())
+        return direct;
+    const dataObj = responseData.data;
+    if (dataObj && typeof dataObj === "object") {
+        const dataUrl = dataObj.url;
+        const dataMedia = dataObj.mediaUrl;
+        if (typeof dataUrl === "string" && dataUrl.trim())
+            return dataUrl;
+        if (typeof dataMedia === "string" && dataMedia.trim())
+            return dataMedia;
+    }
+    const resultObj = responseData.result;
+    if (resultObj && typeof resultObj === "object") {
+        const resultUrl = resultObj.url;
+        const resultMedia = resultObj.mediaUrl;
+        if (typeof resultUrl === "string" && resultUrl.trim())
+            return resultUrl;
+        if (typeof resultMedia === "string" && resultMedia.trim())
+            return resultMedia;
+    }
+    if (responseText.trim() && /^https?:\/\//i.test(responseText.trim())) {
+        return responseText.trim();
+    }
+    return undefined;
+}
+export async function uploadLocalMedia(params) {
+    const stats = await stat(params.filePath);
+    if (!stats.isFile()) {
+        throw new Error(`mediaUrl is not a file: ${params.filePath}`);
+    }
+    const content = await readFile(params.filePath);
+    const form = new FormData();
+    const fieldName = params.uploadFieldName?.trim() || "file";
+    const fileName = path.basename(params.filePath);
+    form.set(fieldName, new Blob([content], { type: "application/octet-stream" }), fileName);
+    if (params.uploadFormFields) {
+        for (const [key, value] of Object.entries(params.uploadFormFields)) {
+            form.set(key, String(value));
+        }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), params.requestTimeout);
+    let dispatcher = undefined;
+    let doFetch = globalThis.fetch.bind(globalThis);
+    if (params.allowInsecureTls) {
+        try {
+            dispatcher = new Agent({ connect: { rejectUnauthorized: false } });
+            doFetch = undiciFetch;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`allowInsecureTls requires undici. ${message}`);
+        }
+    }
+    try {
+        const response = await doFetch(params.uploadUrl, {
+            method: "POST",
+            headers: params.uploadHeaders ?? {},
+            body: form,
+            signal: controller.signal,
+            ...(dispatcher ? { dispatcher } : {}),
+        });
+        const responseText = await response.text().catch(() => "");
+        if (!response.ok) {
+            throw new Error(`Upload failed: ${response.status} ${responseText}`);
+        }
+        let data = {};
+        if (responseText) {
+            try {
+                data = JSON.parse(responseText);
+            }
+            catch {
+                data = {};
+            }
+        }
+        const uploadedUrl = extractUploadedUrl(responseText, data, params.uploadResponseUrlPath);
+        if (!uploadedUrl) {
+            throw new Error("Upload response missing file URL");
+        }
+        return uploadedUrl;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}

package/dist/src/outbound/index.d.ts

@@ -0,0 +1,36 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { WorkclawSendResult } from "../types.js";
+export type SendWorkclawMessageParams = {
+    cfg: OpenClawConfig;
+    to: string;
+    text: string;
+    mediaUrl?: string;
+    replyToMessageId?: string;
+    accountId?: string;
+    openConversationId?: string;
+    agentId?: string | number;
+    /**
+     * 消息类型：
+     * - "reply": 回复消息（用户触发）
+     * - "push": 主动推送（定时任务触发）
+     */
+    messageType?: 'reply' | 'push';
+    msgType?: string;
+    last?: boolean;
+};
+export declare function sendMessageWorkclaw(params: SendWorkclawMessageParams): Promise<WorkclawSendResult>;
+export declare function getMessageWorkclaw(_params: {
+    cfg: OpenClawConfig;
+    messageId: string;
+    accountId?: string;
+}): Promise<null>;
+/**
+ * 发送主动推送消息（定时任务使用）
+ * 使用 pushEndpoint 配置的端口
+ */
+export declare function sendPushMessageWorkclaw(params: Omit<SendWorkclawMessageParams, "messageType">): Promise<WorkclawSendResult>;
+/**
+ * 发送回复消息（用户触发）
+ * 使用 replyEndpoint 配置的端口
+ */
+export declare function sendReplyMessageWorkclaw(params: Omit<SendWorkclawMessageParams, "messageType">): Promise<WorkclawSendResult>;

package/dist/src/outbound/index.js

@@ -0,0 +1,123 @@
+import { resolveWorkclawAccountWithCache } from "../accounts.js";
+import { resolveAccountByUserIdAndAgentId } from "../accounts.js";
+import { isLocalMediaSource, resolveLocalPath, uploadLocalMedia } from "../media/upload.js";
+import { sendWorkclawOutboundMessage, } from "./workclaw-sender.js";
+import { getWorkclawLogger, setLastOutboundAt } from "../runtime.js";
+import { loadOpenConversationId } from "../gateway/config-writer.js";
+import { stat } from "node:fs/promises";
+/**
+ * 根据 target (userId) 和可选的 agentId 查找匹配的账户
+ * 如果同时提供 userId 和 agentId，走 O(1) 查找
+ * 否则遍历所有账户，查找 userId 等于 target 的账户
+ */
+function findAccountIdByTarget(cfg, target, agentId) {
+    // O(1) 查找：userId + agentId 唯一确定一个账户
+    if (agentId !== undefined && agentId !== null) {
+        return resolveAccountByUserIdAndAgentId(cfg, target, String(agentId)) ?? undefined;
+    }
+    // 遍历：只有 userId 时，无法唯一确定账户（一个 userId 对应多个 agentId）
+    // 需要通过 bindings 或其他方式 resolve，这里暂不支持
+    return undefined;
+}
+async function resolveMediaUrl(mediaUrl, config) {
+    if (!mediaUrl)
+        return undefined;
+    if (!isLocalMediaSource(mediaUrl))
+        return mediaUrl;
+    const uploadUrl = config.uploadUrl;
+    if (!uploadUrl) {
+        throw new Error('uploadUrl not configured for local mediaUrl');
+    }
+    const filePath = resolveLocalPath(mediaUrl);
+    if (typeof config.mediaMaxMb === "number" && config.mediaMaxMb > 0) {
+        const stats = await stat(filePath);
+        const maxBytes = config.mediaMaxMb * 1024 * 1024;
+        if (stats.size > maxBytes) {
+            throw new Error(`mediaUrl exceeds limit (${config.mediaMaxMb} MB)`);
+        }
+    }
+    return uploadLocalMedia({
+        uploadUrl,
+        filePath,
+        uploadFieldName: config.uploadFieldName,
+        uploadHeaders: config.uploadHeaders,
+        uploadFormFields: config.uploadFormFields,
+        uploadResponseUrlPath: config.uploadResponseUrlPath,
+        requestTimeout: config.requestTimeout ?? 30000,
+        allowInsecureTls: config.allowInsecureTls,
+    });
+}
+export async function sendMessageWorkclaw(params) {
+    const { cfg, to, text, mediaUrl, replyToMessageId, accountId, openConversationId, agentId, messageType, msgType, last } = params;
+    // 如果没有指定 messageType，根据是否有 replyToMessageId 来判断
+    // - 有 replyToMessageId: 回复消息
+    // - 没有 replyToMessageId: 主动推送
+    const resolvedMessageType = messageType ?? (replyToMessageId ? 'reply' : 'push');
+    // 如果没有指定 accountId，尝试根据 target (to) 和 agentId 查找匹配的账户
+    let resolvedAccountId = accountId;
+    if (!resolvedAccountId) {
+        const foundAccountId = findAccountIdByTarget(cfg, to, agentId);
+        if (foundAccountId) {
+            resolvedAccountId = foundAccountId;
+        }
+    }
+    const account = resolveWorkclawAccountWithCache({ cfg, accountId: resolvedAccountId });
+    if (!account.configured) {
+        throw new Error(`Workclaw account "${account.accountId}" not configured`);
+    }
+    const resolvedMediaUrl = await resolveMediaUrl(mediaUrl, account.config);
+    const cfgChannel = cfg.channels?.['openclaw-workclaw'] ?? {};
+    const cfgAccounts = cfgChannel.accounts ?? {};
+    const cfgAccount = cfgAccounts[resolvedAccountId] ?? {};
+    const cfgOpenConversationId = cfgAccount?.openConversationId ?? cfgChannel?.openConversationId;
+    // 最后尝试从 state 文件恢复（进程重启后 cfg 没有持久化的 openConversationId）
+    const stateOpenConversationId = loadOpenConversationId(resolvedAccountId, to);
+    const effectiveOpenConversationId = openConversationId ?? cfgOpenConversationId ?? stateOpenConversationId;
+    getWorkclawLogger().info(`sendMessageWorkclaw - resolvedAccountId: ${resolvedAccountId}, openConversationId param: ${openConversationId}, cfgOpenConversationId: ${cfgOpenConversationId}, effectiveOpenConversationId: ${effectiveOpenConversationId}, messageType: ${resolvedMessageType}, replyToMessageId: ${replyToMessageId}`);
+    // 使用 appKey 作为缓存键，让所有账户共享同一个 token
+    const tokenCacheKey = account.config.appKey || account.accountId;
+    const result = await sendWorkclawOutboundMessage({
+        cacheKey: tokenCacheKey,
+        to,
+        text,
+        msgType,
+        mediaUrl: resolvedMediaUrl,
+        replyToMessageId,
+        openConversationId: effectiveOpenConversationId,
+        agentId,
+        config: account.config,
+        messageType: resolvedMessageType,
+        last,
+    });
+    // 更新上次出站时间
+    if (resolvedAccountId) {
+        setLastOutboundAt(resolvedAccountId, Date.now());
+    }
+    return {
+        messageId: result.messageId,
+        chatId: to,
+    };
+}
+export async function getMessageWorkclaw(_params) {
+    return null;
+}
+/**
+ * 发送主动推送消息（定时任务使用）
+ * 使用 pushEndpoint 配置的端口
+ */
+export async function sendPushMessageWorkclaw(params) {
+    return sendMessageWorkclaw({
+        ...params,
+        messageType: 'push',
+    });
+}
+/**
+ * 发送回复消息（用户触发）
+ * 使用 replyEndpoint 配置的端口
+ */
+export async function sendReplyMessageWorkclaw(params) {
+    return sendMessageWorkclaw({
+        ...params,
+        messageType: 'reply',
+    });
+}

package/dist/src/outbound/workclaw-sender.d.ts

@@ -0,0 +1,36 @@
+import type { WorkclawFullAccountConfig } from "../types.js";
+export interface WorkClawSenderParams {
+    cacheKey: string;
+    to: string;
+    text: string;
+    mediaUrl?: string;
+    replyToMessageId?: string;
+    openConversationId?: string;
+    agentId?: string | number;
+    config: WorkclawFullAccountConfig;
+    /**
+     * 消息类型：
+     * - "reply": 回复消息（用户触发）
+     * - "push": 主动推送（定时任务触发）
+     */
+    messageType?: "reply" | "push";
+    msgType?: string;
+    last?: boolean;
+}
+export declare function sendWorkclawOutboundMessage(params: WorkClawSenderParams): Promise<{
+    messageId: string;
+}>;
+/**
+ * 发送主动推送消息（定时任务使用）
+ * POST /im/v1/messages
+ */
+export declare function sendWorkClawPushMessage(params: Omit<WorkClawSenderParams, "messageType">): Promise<{
+    messageId: string;
+}>;
+/**
+ * 发送回复消息（用户触发）
+ * POST /im/v1/messages/{messageId}/reply
+ */
+export declare function sendWorkclawReplyMessage(params: Omit<WorkClawSenderParams, "messageType">): Promise<{
+    messageId: string;
+}>;

package/{src/outbound/workclaw-sender.ts → dist/src/outbound/workclaw-sender.js}

@@ -1,158 +1,95 @@
-import type { WorkclawFullAccountConfig } from "../types.js";
-import {
-    sendWorkclawMessage,
-    sendWorkclawReplyMessage as sendWorkclawReplyToMessage,
-    resolveWorkclawMessage,
-    type WorkclawConnectionConfig,
-} from "../connection/workclaw-client.js";
-import { getWorkclawLogger } from "../runtime.js";
-
-export interface WorkClawSenderParams {
-    cacheKey: string;
-    to: string;
-    text: string;
-    mediaUrl?: string;
-    replyToMessageId?: string;
-    openConversationId?: string;
-    agentId?: string | number;
-    config: WorkclawFullAccountConfig;
-    /**
-     * 消息类型：
-     * - "reply": 回复消息（用户触发）
-     * - "push": 主动推送（定时任务触发）
-     */
-    messageType?: "reply" | "push";
-    msgType?: string;
-    last?: boolean;
-}
-
-
-export async function sendWorkclawOutboundMessage(
-    params: WorkClawSenderParams,
-): Promise<{ messageId: string }> {
-    const {
-        cacheKey,
-        to,
-        mediaUrl,
-        replyToMessageId,
-        openConversationId,
-        agentId,
-        config,
-        messageType = "reply",
-        last,
-    } = params;
-
-    let msgType = params.msgType;
-    let content = params.text;
-
-    // 优先级: 传入参数 > 配置
-    const resolvedAgentId = agentId ?? config.agentId;
-
-    if (resolvedAgentId === undefined || resolvedAgentId === null || String(resolvedAgentId).trim() === "") {
-        throw new Error(
-            "agentId is required for sending messages. " +
-            "Please create an account via cloud platform command or configure accounts in openclaw.json"
-        );
-    }
-
-
-    if (!msgType) {
-        ({ msgType, content } = resolveWorkclawMessage(content, mediaUrl));
-    }
-
-
-    // msgType 转换为 "1"（文本）或其他类型码
-    const messageTypeCode = msgType === "text" ? "1" : msgType;
-
-    // 构建 WorkclawConnectionConfig（短名格式，用于 connection 模块）
-    const workclawConfig: WorkclawConnectionConfig = {
-        baseUrl: config.baseUrl ?? "",
-        appKey: config.appKey ?? "",
-        appSecret: config.appSecret ?? "",
-        localIp: config.localIp,
-        allowInsecureTls: config.allowInsecureTls,
-        requestTimeout: config.requestTimeout,
-    };
-
-    // 解析 userId 作为 receiveId（优先使用配置中保存的原始 userId）
-    // 配置中的 userId 是原始值（可能为负数），to 是绝对值（OpenClaw 要求）
-    const receiveId = config.userId ?? to;
-
-    // 从配置中读取 endpoint，支持自定义
-    const replyEndpoint = config.replyEndpoint || "/open-apis/im/v1/messages/{messageId}/reply";
-    const pushEndpoint = config.pushEndpoint || "/open-apis/im/v1/messages";
-
-    if (messageType === "reply") {
-        // 回复消息需要 replyToMessageId
-        if (!replyToMessageId) {
-            throw new Error("replyToMessageId is required for reply message");
-        }
-
-        // 优先使用传入的 openConversationId，其次使用配置中持久化的
-        const resolvedOpenConversationId = openConversationId ?? config.openConversationId;
-        getWorkclawLogger().info(`Sending reply message to messageId: ${replyToMessageId}, openConversationId: ${resolvedOpenConversationId}`);
-
-        const msgId = await sendWorkclawReplyToMessage({
-            cacheKey,
-            config: workclawConfig,
-            agentId: resolvedAgentId,
-            receiveId,
-            msgType: messageTypeCode,
-            content,
-            messageId: replyToMessageId,
-            openConversationId: resolvedOpenConversationId,
-            endpoint: replyEndpoint.replace("{messageId}", String(replyToMessageId)),
-            last,
-        });
-
-        return { messageId: msgId };
-    } else {
-        // 主动推送消息
-        getWorkclawLogger().info(` Sending proactive message`);
-
-        // 优先使用传入的 openConversationId，其次使用配置中持久化的
-        const resolvedOpenConversationId = openConversationId ?? config.openConversationId;
-        getWorkclawLogger().info(` Resolved openConversationId: ${resolvedOpenConversationId}`);
-        getWorkclawLogger().info(` Config openConversationId: ${config.openConversationId}`);
-
-        const msgId = await sendWorkclawMessage({
-            cacheKey,
-            config: workclawConfig,
-            agentId: resolvedAgentId,
-            receiveId,
-            msgType: messageTypeCode,
-            content,
-            openConversationId: resolvedOpenConversationId,
-            endpoint: pushEndpoint,
-            last,
-        });
-
-        return { messageId: msgId };
-    }
-}
-
-/**
- * 发送主动推送消息（定时任务使用）
- * POST /im/v1/messages
- */
-export async function sendWorkClawPushMessage(
-    params: Omit<WorkClawSenderParams, "messageType">,
-): Promise<{ messageId: string }> {
-    return sendWorkclawOutboundMessage({
-        ...params,
-        messageType: "push",
-    });
-}
-
-/**
- * 发送回复消息（用户触发）
- * POST /im/v1/messages/{messageId}/reply
- */
-export async function sendWorkclawReplyMessage(
-    params: Omit<WorkClawSenderParams, "messageType">,
-): Promise<{ messageId: string }> {
-    return sendWorkclawOutboundMessage({
-        ...params,
-        messageType: "reply",
-    });
-}
+import { sendWorkclawMessage, sendWorkclawReplyMessage as sendWorkclawReplyToMessage, resolveWorkclawMessage, } from "../connection/workclaw-client.js";
+import { getWorkclawLogger } from "../runtime.js";
+export async function sendWorkclawOutboundMessage(params) {
+    const { cacheKey, to, mediaUrl, replyToMessageId, openConversationId, agentId, config, messageType = "reply", last, } = params;
+    let msgType = params.msgType;
+    let content = params.text;
+    // 优先级: 传入参数 > 配置
+    const resolvedAgentId = agentId ?? config.agentId;
+    if (resolvedAgentId === undefined || resolvedAgentId === null || String(resolvedAgentId).trim() === "") {
+        throw new Error("agentId is required for sending messages. " +
+            "Please create an account via cloud platform command or configure accounts in openclaw.json");
+    }
+    if (!msgType) {
+        ({ msgType, content } = resolveWorkclawMessage(content, mediaUrl));
+    }
+    // msgType 转换为 "1"（文本）或其他类型码
+    const messageTypeCode = msgType === "text" ? "1" : msgType;
+    // 构建 WorkclawConnectionConfig（短名格式，用于 connection 模块）
+    const workclawConfig = {
+        baseUrl: config.baseUrl ?? "",
+        appKey: config.appKey ?? "",
+        appSecret: config.appSecret ?? "",
+        localIp: config.localIp,
+        allowInsecureTls: config.allowInsecureTls,
+        requestTimeout: config.requestTimeout,
+    };
+    // 解析 userId 作为 receiveId（优先使用配置中保存的原始 userId）
+    // 配置中的 userId 是原始值（可能为负数），to 是绝对值（OpenClaw 要求）
+    const receiveId = config.userId ?? to;
+    // 使用固定的 endpoint
+    const replyEndpoint = "/open-apis/im/v1/messages/{messageId}/reply";
+    const pushEndpoint = "/open-apis/im/v1/messages";
+    if (messageType === "reply") {
+        // 回复消息需要 replyToMessageId
+        if (!replyToMessageId) {
+            throw new Error("replyToMessageId is required for reply message");
+        }
+        // 优先使用传入的 openConversationId，其次使用配置中持久化的
+        const resolvedOpenConversationId = openConversationId ?? config.openConversationId;
+        getWorkclawLogger().info(`Sending reply message to messageId: ${replyToMessageId}, openConversationId: ${resolvedOpenConversationId}`);
+        const msgId = await sendWorkclawReplyToMessage({
+            cacheKey,
+            config: workclawConfig,
+            agentId: resolvedAgentId,
+            receiveId,
+            msgType: messageTypeCode,
+            content,
+            messageId: replyToMessageId,
+            openConversationId: resolvedOpenConversationId,
+            endpoint: replyEndpoint.replace("{messageId}", String(replyToMessageId)),
+            last,
+        });
+        return { messageId: msgId };
+    }
+    else {
+        // 主动推送消息
+        getWorkclawLogger().info(` Sending proactive message`);
+        // 优先使用传入的 openConversationId，其次使用配置中持久化的
+        const resolvedOpenConversationId = openConversationId ?? config.openConversationId;
+        getWorkclawLogger().info(` Resolved openConversationId: ${resolvedOpenConversationId}`);
+        getWorkclawLogger().info(` Config openConversationId: ${config.openConversationId}`);
+        const msgId = await sendWorkclawMessage({
+            cacheKey,
+            config: workclawConfig,
+            agentId: resolvedAgentId,
+            receiveId,
+            msgType: messageTypeCode,
+            content,
+            openConversationId: resolvedOpenConversationId,
+            endpoint: pushEndpoint,
+            last,
+        });
+        return { messageId: msgId };
+    }
+}
+/**
+ * 发送主动推送消息（定时任务使用）
+ * POST /im/v1/messages
+ */
+export async function sendWorkClawPushMessage(params) {
+    return sendWorkclawOutboundMessage({
+        ...params,
+        messageType: "push",
+    });
+}
+/**
+ * 发送回复消息（用户触发）
+ * POST /im/v1/messages/{messageId}/reply
+ */
+export async function sendWorkclawReplyMessage(params) {
+    return sendWorkclawOutboundMessage({
+        ...params,
+        messageType: "reply",
+    });
+}