dlinkclaw-openclaw 1.0.0

package/dist/src/client/timeout.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 超时控制工具模块
+ *
+ * 为异步操作提供统一的超时保护机制
+ */
+/**
+ * 为 Promise 添加超时保护
+ *
+ * @param promise - 原始 Promise
+ * @param timeoutMs - 超时时间（毫秒）
+ * @param message - 超时错误消息
+ * @returns 带超时保护的 Promise
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message?: string): Promise<T>;
+/**
+ * 超时错误类型
+ */
+export declare class TimeoutError extends Error {
+    constructor(message: string);
+}

package/dist/src/client/timeout.js

@@ -0,0 +1,36 @@
+/**
+ * 超时控制工具模块
+ *
+ * 为异步操作提供统一的超时保护机制
+ */
+/**
+ * 为 Promise 添加超时保护
+ *
+ * @param promise - 原始 Promise
+ * @param timeoutMs - 超时时间（毫秒）
+ * @param message - 超时错误消息
+ * @returns 带超时保护的 Promise
+ */
+export function withTimeout(promise, timeoutMs, message) {
+    if (timeoutMs <= 0 || !Number.isFinite(timeoutMs)) {
+        return promise;
+    }
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(new TimeoutError(message ?? `Operation timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]).finally(() => {
+        clearTimeout(timeoutId);
+    });
+}
+/**
+ * 超时错误类型
+ */
+export class TimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TimeoutError";
+    }
+}

package/dist/src/client/types.d.ts

@@ -0,0 +1,226 @@
+export type DLCallbackHandler = (...avg: any) => void;
+export interface DLGroupConfig {
+    enabled: boolean;
+    allowFrom?: Array<string | number>;
+    topicSessionMode?: 'enabled' | 'disabled';
+}
+export interface DLResolvedAccount {
+    accountId: string;
+    accountName?: string;
+    enabled: boolean;
+    config: DLConfig;
+}
+export interface DLConfig {
+    enabled: boolean;
+    apiKey: string;
+    secret: string;
+    baseUrl: string;
+    accountId?: string;
+    accountName?: string;
+    /** open允许所有用户,allowlist[允许指定的用户],pairing需要管理员对码, disabled完全禁用*/
+    dmPolicy?: "open" | "allowlist" | "pairing" | "disabled";
+    allowFrom?: Array<string | number>;
+    /** 群组访问策略："open" = 允许所有群组（默认），"allowlist" = 仅允许 groupAllowFrom 中的群组，"disabled" = 禁用群组消息 */
+    groupPolicy?: "open" | "allowlist" | "disabled";
+    groupAllowFrom?: string[];
+    configured?: boolean;
+    verificationToken?: string;
+    groups?: Record<string, DLGroupConfig>;
+    mediaMaxMb?: number;
+    historyLimit?: number;
+    dynamicAgentConfig?: DLDynamicAgentConfig;
+    accounts?: Map<string, DLConfig>;
+}
+export type DLGroupMember = {
+    id: string;
+    name: string;
+    /** 2026-08-13 新增：Agent 成员内部名（main/agent01 等），用于 Agent 间 sessions_send 协作路由 */
+    agentId?: string;
+    responsibilities?: string;
+    type: 'agent' | 'user';
+};
+export type DLMsgType = 'text' | 'image' | 'voice' | 'video' | 'file' | 'mixed' | 'cmd';
+/**
+ * 不同渠道的Bot
+ */
+export type BotType = 'ewx' | 'qq' | 'dd' | 'feishu' | 'dLink';
+export type ContactType = 'agent' | 'user' | 'group' | 'workflow' | 'task';
+export interface DLQuoteBase {
+    type: DLMsgType;
+}
+export interface DLQuoteText extends DLQuoteBase {
+    text: string;
+}
+export interface DLQuoteImage extends DLQuoteBase {
+    imageUrl: string;
+    aesKey?: string;
+}
+export interface DLQuoteVoice extends DLQuoteBase {
+    voiceUrl: string;
+    aesKey?: string;
+}
+export interface DLQuoteVideo extends DLQuoteBase {
+    videoUrl: string;
+    aesKey?: string;
+}
+export interface DLQuoteFile extends DLQuoteBase {
+    fileUrl: string;
+    aesKey?: string;
+}
+export interface DLQuoteMixed extends DLQuoteBase {
+    msgList: Array<DLTextBody | DLImageBody>;
+}
+export interface DLBaseBody {
+    msgType: DLMsgType;
+}
+export interface DLMediaBody extends DLBaseBody {
+    aesKey?: string;
+}
+export interface DLTextBody extends DLBaseBody {
+    text: string;
+    quote?: DLQuoteBase;
+}
+export interface DLImageBody extends DLMediaBody {
+    imageUrl: string;
+}
+export interface DLVoiceBody extends DLMediaBody {
+    voiceUrl: string;
+}
+export interface DLVideoBody extends DLMediaBody {
+    videoUrl: string;
+}
+export interface DLFileBody extends DLMediaBody {
+    fileUrl: string;
+}
+export interface DLMixedBody extends DLBaseBody {
+    msgList: Array<DLTextBody | DLImageBody | DLVoiceBody | DLVideoBody | DLFileBody>;
+    quote?: DLQuoteBase;
+}
+export type DLKind = 'block' | 'in_process' | 'tool' | 'plan' | 'patch' | 'command' | 'reasoning' | 'end_reasoning';
+export type MessageStatus = 'read' | 'unRead' | undefined;
+export interface ChatUser {
+    id: string;
+    nickname?: string;
+    avatar?: string;
+    jobPost?: string;
+}
+export interface FromUser {
+    id: string;
+    nickname?: string;
+    chatTopic: string;
+    notifyTopic: string;
+}
+/**
+ * DLinkclaw客户端定义
+ * 直接发消息给客户端时使用
+ */
+export interface DLMessage {
+    msgId: string;
+    streamId?: string;
+    chatId?: string;
+    sender: ChatUser;
+    receiver: ChatUser;
+    contactType: ContactType;
+    contactId: string;
+    botType: BotType;
+    payload: string;
+    createdAt: number | string;
+    timezone?: string;
+    status: MessageStatus;
+    finish: boolean;
+    kind?: DLKind;
+    sessionKey?: string;
+    runId?: string;
+    relayType: 'openClaw';
+}
+export interface ToAgent {
+    sessionKey: string;
+    agentId: string;
+    id: string;
+    nickname?: string;
+    avatarUrl?: string;
+    jobPost?: string;
+}
+export interface FromPerson {
+    corpId: string;
+    empId: string;
+    nickname?: string;
+    avatarUrl?: string;
+    openId: string;
+    thr3UserId?: string;
+    thr3BotId?: string;
+}
+/**
+ * 服务端SpringBoot中定义
+ * AgentMessage
+ */
+export interface DLMessagePayload {
+    msgType?: Exclude<DLMsgType, 'cmd'>;
+    relayType: 'openClaw';
+    toAgent: ToAgent;
+    fromPerson: FromPerson;
+    payload: string;
+    finish: boolean;
+    msgId: string;
+    streamId: string;
+    botType: BotType;
+    contactType: ContactType;
+    contactId: string;
+    notify: boolean;
+    notifyUrl?: string;
+    chatId?: string;
+    group: boolean;
+    groupIntroduction?: string;
+    reqId: string;
+    websocket: boolean;
+    askQuestion?: string;
+    timestamp?: number;
+    timezone?: string;
+    /** 指定会话路由: 客户端可直接指定完整的 sessionKey。
+     * 不传时自动构建默认会话 (agent:main:workrelay:direct:xxx),
+     * 传入时直接使用该 sessionKey 路由消息 */
+    groupMembers?: Array<DLGroupMember>;
+    relayTimeRhreshold?: number;
+    kind?: DLKind;
+    runId?: string;
+    fromUsers?: Array<FromUser>;
+    archiveSession?: DLArchiveSession;
+    relayId: string;
+}
+export interface DLArchiveSession {
+    archived: boolean;
+    sessionKey: string;
+    newSessionKey?: string;
+    runId: string;
+}
+export type DLIMessagePayload = {
+    content: string;
+    userId: string;
+    streamId: string;
+    msgId: string;
+    timestamp: number;
+};
+export type DLToolsConfig = {
+    doc?: boolean;
+    wiki?: boolean;
+    drive?: boolean;
+    perm?: boolean;
+    scopes?: boolean;
+};
+export type DLDynamicAgentConfig = {
+    enabled?: boolean;
+    workspaceTemplate?: string;
+    agentDirTemplate?: string;
+    maxAgents?: number;
+};
+export type DLMediaType = Exclude<DLMsgType, 'text' | 'mixed' | 'cmd'>;
+export type DLMediaInfo = {
+    path: string;
+    contentType?: Exclude<DLMsgType, 'text' | 'mixed' | 'cmd'>;
+    placeholder: string;
+};
+export type DLDownloadResourceResult = {
+    buffer: Buffer;
+    contentType?: string;
+    fileName?: string;
+};

package/dist/src/client/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/monitor.d.ts

@@ -0,0 +1,18 @@
+import { OpenClawConfig as ClawdbotConfig } from "openclaw/plugin-sdk/core";
+import { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
+import { DLResolvedAccount } from "./client/types.js";
+export type DLMonitorOpts = {
+    config: ClawdbotConfig;
+    runtime: RuntimeEnv;
+    abortSignal: AbortSignal;
+    accountId: string;
+    channelId: string;
+};
+export type DLMonitorAccountParams = {
+    cfg: ClawdbotConfig;
+    account: DLResolvedAccount;
+    runtime: RuntimeEnv;
+    abortSignal: AbortSignal;
+    channelId: string;
+};
+export declare function monitorDuolinkProvider(opts: DLMonitorOpts): Promise<void>;

package/dist/src/monitor.js

@@ -0,0 +1,322 @@
+import { listDuolinkConfiguredAccounts, resolveDLAccount } from "./account.js";
+import { getDLLogger, getDLRuntime } from "./runtime.js";
+import { DLClient } from "./client/dl-client.js";
+import { checkDmPolicy, checkGroupPolicy } from "./policy.js";
+import { buildMessageContext, parseMessageContent, routeAndDispatchMessage } from "./client/message.js";
+import { withTimeout } from "./client/timeout.js";
+import { getDLClient, removeDLClient, setDLClient } from "./client/client-manager.js";
+import { downloadAndSaveFiles } from "./client/media-handler.js";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/core";
+import { DEFAULT_GROUP_HISTORY_LIMIT, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
+import { resolveAllowlistMatchSimple } from "openclaw/plugin-sdk/allow-from";
+export async function monitorDuolinkProvider(opts) {
+    const cfg = opts.config;
+    const { accountId, channelId, runtime, abortSignal } = opts;
+    if (accountId === DEFAULT_ACCOUNT_ID) {
+        const account = resolveDLAccount({ cfg, accountId: accountId }, channelId);
+        if (!account.enabled || !account.config.configured) {
+            throw new Error(`${channelId} account "${opts.accountId}" not configured or disabled`);
+        }
+        return monitorSingleAccount({
+            cfg,
+            account,
+            runtime,
+            abortSignal,
+            channelId,
+        });
+    }
+    const accounts = listDuolinkConfiguredAccounts(cfg, channelId);
+    if (accounts.size === 0) {
+        throw new Error(`No enabled ${channelId} accounts[${accountId}] configured`);
+    }
+    //TODO:处理多帐号信息
+}
+/**
+ * Monitor a single Duolian account.
+ */
+async function monitorSingleAccount(params) {
+    const { account, abortSignal, cfg, channelId } = params;
+    const { accountId } = account;
+    const logger = getDLLogger();
+    let client = getDLClient(accountId);
+    if (!client) {
+        client = new DLClient({
+            account,
+            channelId,
+            cfg,
+        }, logger);
+        client.on('message', duolinkMessageHandler);
+        setDLClient(accountId, client);
+        logger.info(`DLClient account[${account.accountId}] is starting...`);
+    }
+    return new Promise(async (resolve, reject) => {
+        const cleanup = () => {
+            removeDLClient(accountId);
+        };
+        if (abortSignal.aborted) {
+            if (client.isConnected()) {
+                client.stop();
+            }
+            cleanup();
+            resolve();
+            return;
+        }
+        const handleAbort = () => {
+            logger.error(`account[${accountId}]: abort signal received, stopping`);
+            if (client.isConnected()) {
+                client.stop();
+            }
+            removeDLClient(accountId);
+        };
+        abortSignal.addEventListener("abort", handleAbort, { once: true });
+        if (!client.isConnected()) {
+            try {
+                await client.start();
+                logger.info(`account[${accountId}] start successfully!`);
+                //resolve(); 
+            }
+            catch (e) {
+                logger.error(`account[${accountId}]:DLClient启动失败:${String(e)}`);
+                cleanup();
+                abortSignal?.removeEventListener("abort", handleAbort);
+                reject(e);
+                return;
+            }
+        }
+    });
+}
+async function duolinkMessageHandler(dlCtx, client) {
+    const { cfg, account, channelId, rbotId } = dlCtx.ctx;
+    const accountLogInfo = `account[${account.accountId}-${rbotId}],[Monitor.ts]`;
+    const { msg, accStatus } = dlCtx;
+    const { config } = account;
+    const relayId = rbotId;
+    const botType = msg.botType;
+    const logger = getDLLogger();
+    //const relayTimeRhreshold = msg.relayTimeRhreshold ?? 5 * 60 * 1000;
+    //TODO:群组历史
+    const chatHistories = new Map();
+    const historyLimit = Math.max(0, config.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT);
+    //Step 1: 解析消息内容
+    const msgContext = parseMessageContent(msg.payload);
+    if (!msgContext) {
+        logger.error(`${accountLogInfo} resolve payload entity error!`);
+        client.publishToServer({
+            streamId: msg.streamId,
+            content: '[tag_error_resolve_payload_entity]',
+            finish: true,
+            kind: 'block'
+        });
+        return;
+    }
+    const { textParts, quoteContent, imageUrls, imageAesKeys, voiceUrls, voiceAesKeys, videoUrls, videoAesKeys, fileUrls, fileAesKeys } = msgContext;
+    let textBody = textParts.join("\n").trim();
+    if (textBody.length === 0 && quoteContent && quoteContent.length > 0) {
+        textBody = quoteContent;
+    }
+    //Step 2: 群组及DM策略
+    const isGroup = msg.group;
+    //const mentionTargets: DLMentionTarget[] = [];
+    if (isGroup) {
+        //这里暂时移除提及,可能需要提取提及
+        //textBody = textBody.replace(/@\S+/g, "").trim();
+        //群组策略
+        const groupPolicy = checkGroupPolicy({
+            chatId: msg.chatId,
+            senderId: rbotId,
+            account,
+            channelId,
+            logger
+        });
+        if (!groupPolicy.allowed) {
+            logger.error(`${accountLogInfo} group policy is not allowed`);
+            client.publishToServer({
+                streamId: msg.streamId,
+                content: '[tag_error_group_prolicy_not_allow]',
+                finish: true,
+                kind: 'block'
+            });
+            return;
+        }
+        if (chatHistories && textBody.length > 0) {
+            const senderId = msg.fromPerson.empId;
+            createChannelHistoryWindow({
+                historyMap: chatHistories
+            }).record({
+                historyKey: msg.chatId,
+                limit: historyLimit,
+                entry: {
+                    sender: senderId,
+                    body: `${senderId}: ${textBody}`,
+                    timestamp: Date.now(),
+                    messageId: senderId, //群组发信人,回复时可提及
+                }
+            });
+        }
+    }
+    const core = getDLRuntime();
+    const dmPolicy = await checkDmPolicy({
+        core,
+        senderId: relayId, //单聊对码使用中继ID效验，只要效验一次，使用该中继的用户均不需要重新对码
+        account,
+        client,
+        channelId,
+        streamId: msg.streamId,
+        logger
+    });
+    if (!dmPolicy.allowed) {
+        client.publishToServer({
+            streamId: msg.streamId,
+            content: '[tag_error_policy_refuse]',
+            kind: 'block',
+            finish: true
+        });
+        return;
+    }
+    //const msgInfo = textBody.length > 50 ? textBody.slice(0, 50) + "..." : textBody
+    //logger.info(`${accountLogInfo} received message from ${senderId} in ${msg.botType}, message >>> ${msgInfo}`);
+    //Step 3: 斜扛“/”命令授权检测
+    let commandAuthorized = undefined;
+    if (textBody.length > 0) {
+        //是否应该授权命令行
+        const shouldComputeCommandAuthorized = core.channel.commands.shouldComputeCommandAuthorized(textBody, cfg);
+        logger.info(`${accountLogInfo} shouldComputeCommandAuthorized >>> ${shouldComputeCommandAuthorized}`);
+        const effectiveDmAllowFrom = [...dmPolicy.allowFrom ?? []];
+        const commandAllowFrom = isGroup ? (config.groupAllowFrom ?? [rbotId]) : effectiveDmAllowFrom;
+        logger.info(`${accountLogInfo} commandAllowFrom=[${commandAllowFrom.join(',')}]`);
+        const senderAllowedForCommands = resolveAllowlistMatchSimple({
+            allowFrom: commandAllowFrom,
+            senderId: relayId, //使用中继器ID所以命令行效验，即使用该中继的人都可以使用/命令
+            allowNameMatching: false,
+        }).allowed;
+        logger.warn(`${accountLogInfo} senderAllowedForCommands >>> ${senderAllowedForCommands}`);
+        // 2026-09-06 适配 openclaw 2026.9.1：CommandsConfig 类型已移除 useAccessGroups 字段，
+        // 运行时配置值仍可能由 openclaw.json 下发，这里保持兼容读取（缺省 true）
+        const useAccessGroups = cfg.commands?.useAccessGroups ?? true;
+        commandAuthorized = shouldComputeCommandAuthorized
+            ? core.channel.commands.resolveCommandAuthorizedFromAuthorizers({
+                useAccessGroups,
+                authorizers: [
+                    { configured: commandAllowFrom.length > 0, allowed: senderAllowedForCommands },
+                ],
+            })
+            : undefined;
+    }
+    logger.warn(`${accountLogInfo} commandAuthorized >>> ${commandAuthorized}`);
+    //Step 4: 下载媒体文
+    const [imageMediaList, voiceMediaList, videoMediaList, fileMediaList] = await Promise.all([
+        downloadAndSaveFiles({
+            client,
+            fileUrls: imageUrls,
+            fileAesKeys: imageAesKeys,
+            account,
+            clawConfig: cfg,
+            core,
+            channelId,
+            streamId: msg.streamId,
+            logger,
+            botType
+        }),
+        downloadAndSaveFiles({
+            client,
+            fileUrls: voiceUrls,
+            fileAesKeys: voiceAesKeys,
+            account,
+            clawConfig: cfg,
+            core,
+            channelId,
+            streamId: msg.streamId,
+            logger,
+            botType,
+            // 2026-08-05 语音消息：强制按音频处理（.weba + audio/webm），避免被识别为 video
+            forceAudio: true
+        }),
+        downloadAndSaveFiles({
+            client,
+            fileUrls: videoUrls,
+            fileAesKeys: videoAesKeys,
+            account,
+            clawConfig: cfg,
+            core,
+            channelId,
+            streamId: msg.streamId,
+            logger,
+            botType
+        }),
+        downloadAndSaveFiles({
+            client,
+            fileUrls: fileUrls,
+            fileAesKeys: fileAesKeys,
+            account,
+            clawConfig: cfg,
+            core,
+            channelId,
+            streamId: msg.streamId,
+            logger,
+            botType
+        }),
+    ]);
+    const mediaList = [...imageMediaList, ...voiceMediaList, ...videoMediaList, ...fileMediaList];
+    if (mediaList.length === 0 && textBody.length === 0) {
+        client.publishToServer({ streamId: msg.streamId, content: '[tag_error_empty_content]', kind: 'block', finish: true });
+        return;
+    }
+    //Step 5: 构建上下文并路由到核心处理流程
+    const ctxPayload = await buildMessageContext({
+        core,
+        channelId,
+        account,
+        clawConfig: cfg,
+        msg,
+        imageList: imageMediaList,
+        voiceList: voiceMediaList,
+        videoList: videoMediaList,
+        fileList: fileMediaList,
+        textBody,
+        quoteContent,
+        commandAuthorized,
+        chatHistories,
+        historyLimit,
+        logger,
+        client,
+        streamId: msg.streamId,
+        relayId
+    });
+    if (!ctxPayload) {
+        logger.warn("上下文为空,未进入方法routeAndDispatchMessage...");
+        return;
+    }
+    try {
+        await withTimeout(routeAndDispatchMessage({
+            ctxPayload,
+            core,
+            cfg,
+            client,
+            logger,
+            commandAuthorized,
+            channelId,
+            accountId: account.accountId,
+            streamId: msg.streamId,
+            accStatus,
+            chatOpts: {
+                toAgent: msg.toAgent,
+                fromUser: msg.fromPerson,
+                botType: msg.botType,
+                contactId: msg.contactId,
+                relayId,
+                chatId: isGroup ? msg.chatId : msg.fromPerson.empId,
+                isGroup,
+                notifyUrl: msg.notifyUrl
+            }
+        }), 0, //1_800_000, //30分钟不设置超时
+        `[tag_error_processing_timed_out](streamId=${msg.streamId})`);
+    }
+    catch (e) {
+        client.publishToServer({
+            streamId: msg.streamId,
+            content: `[tag_error_build_ctx]\n${e}`,
+            kind: 'block',
+            finish: true
+        });
+    }
+}

package/dist/src/outbound.d.ts

@@ -0,0 +1,6 @@
+import { ChannelOutboundAdapter } from "openclaw/plugin-sdk/core";
+import type { createTextPairingAdapter } from "openclaw/plugin-sdk/channel-pairing";
+type ChannelPairingAdapter = ReturnType<typeof createTextPairingAdapter>;
+export declare const dlOutbound: () => ChannelOutboundAdapter;
+export declare const dlPairing: (channelId: string) => ChannelPairingAdapter;
+export {};