dlinkclaw-openclaw 2026.8.24-alpha.1

package/dist/src/client/dl-client.d.ts

@@ -0,0 +1,99 @@
+import EventEmitter from 'events';
+import { OpenClawConfig, PluginLogger } from 'openclaw/plugin-sdk';
+import { AccumulatorsStatus, AutoReplyOpts } from './message.js';
+import { BotType, DLArchiveSession, DLKind, DLMessagePayload, DLResolvedAccount, MessageStatus } from './types.js';
+import { CmdMessage, CmdResponse, EventType } from '../services/types.js';
+export type DLContext = {
+    account: DLResolvedAccount;
+    channelId: string;
+    cfg: OpenClawConfig;
+    rbotId?: string;
+};
+export interface DLMessageContext {
+    ctx: DLContext;
+    msg: DLMessagePayload;
+    accStatus: AccumulatorsStatus;
+}
+export type DLReceiveMessageHandler = (topic: string, msg: DLMessagePayload) => void;
+export interface MqttConfig {
+    url: string;
+    port: number;
+    websocketPort: number;
+    serverId: string;
+    qos: 0 | 1 | 2;
+    userName: string;
+    password: string;
+    willTopic: string;
+    serverTopics: Array<string>;
+    clientTopics: Array<string>;
+    openUserTopics: Array<string>;
+    openUserNotifyTopics: Array<string>;
+}
+export declare class DLClient extends EventEmitter {
+    private ctx;
+    private mqttConfig;
+    private mqttClient;
+    private cmdHandler;
+    private readonly http;
+    private readonly logger;
+    private readonly accountLog;
+    private lastInboundAt;
+    constructor(ctx: DLContext, logger: PluginLogger);
+    private fetchConfig;
+    private changeConnectStatus;
+    private connect;
+    private receiveEventHandle;
+    private closeHandler;
+    private publish;
+    getLastInboundAt(): number | null;
+    isConnected(): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    exeCmd(cmdMessage: CmdMessage): Promise<CmdResponse | undefined>;
+    publishEventToDLClient(payload: any, event: EventType, sqos?: '0' | '1' | '2', to?: string): Promise<void>;
+    publishCmdResultToDLClient(topic: string, playload: CmdResponse, sqos?: '0' | '1' | '2'): Promise<void>;
+    publishEventToServer(playload: any, event: EventType, sqos?: '0' | '1' | '2'): Promise<void>;
+    publishCmdResultToServer(playload: CmdResponse, sqos?: '0' | '1' | '2'): Promise<void>;
+    publishToServer(params: {
+        streamId: string;
+        content: string;
+        finish: boolean;
+        kind: DLKind;
+        mediaFiles?: Array<string>;
+        session?: DLArchiveSession;
+    }, autoParams?: AutoReplyOpts): Promise<{
+        autoRelay: boolean;
+        reqId: string | undefined;
+    } | {
+        autoRelay: boolean;
+        reqId?: undefined;
+    }>;
+    /**
+     * 减轻服务端负担，将处理状态直接推送到客户端(处理结果走服务端)
+     * @param params
+     */
+    publishProcessingState(params: {
+        streamId: string;
+        content: string;
+        status: MessageStatus;
+        runId?: string;
+        kind: DLKind;
+    }): Promise<void>;
+    downloadFileRaw(url: string, botType: BotType): Promise<{
+        buffer: Buffer;
+        filename?: string;
+    }>;
+    /**
+     * 对码成功回调通知
+     */
+    approved(ok: boolean): Promise<void>;
+    autoReply(params: {
+        to: string;
+        text?: string;
+        mediaFiles?: Array<string>;
+    }): Promise<{
+        channel: string;
+        messageId: string;
+        chatId: string;
+    }>;
+}

package/dist/src/client/dl-client.js

@@ -0,0 +1,535 @@
+import EventEmitter from 'events';
+import { buildDLReplyMessage, messagePreviewHandler } from './message.js';
+import mqtt from 'mqtt';
+import { DLHttp } from './dl-http.js';
+import { decryptAesEcbPkcs5 } from './crypto.js';
+import { AUTO_RELAY_API, AUTO_RELAY_UPLOAD } from './const.js';
+import { createCmdHandler } from '../services/index.js';
+import { uuidStr } from '../utils.js';
+export class DLClient extends EventEmitter {
+    ctx;
+    mqttConfig = null;
+    mqttClient = null;
+    cmdHandler = null;
+    http;
+    logger;
+    accountLog;
+    lastInboundAt = null;
+    //private runtime: PluginRuntime | null = null;
+    constructor(ctx, logger) {
+        super();
+        this.ctx = ctx;
+        this.logger = logger;
+        this.accountLog = `account[${ctx.account.accountId}] [DL-Client.ts]`;
+        const { baseUrl, apiKey, secret } = ctx.account.config;
+        this.http = new DLHttp({ baseUrl, apiKey, secret }, logger);
+        const cfg = ctx.cfg;
+        if (cfg.gateway?.auth?.token) {
+            const token = cfg.gateway.auth.token.toString();
+            const gatewayUrl = 'ws://127.0.0.1:18789';
+            this.cmdHandler = createCmdHandler({
+                cfg,
+                channelId: ctx.channelId,
+                gatewayUrl,
+                token,
+                baseUrl: ctx.account.config.baseUrl
+            }, this, this.logger);
+        }
+    }
+    async fetchConfig() {
+        const url = `/guest/mqtt/getConfig/${this.ctx.account.config.apiKey}`;
+        const res = await this.http.get(url);
+        if (res) {
+            const secret = this.ctx.account.config.secret;
+            const mqttConfig = decryptAesEcbPkcs5(res, secret);
+            if (mqttConfig) {
+                this.logger.info(`mqttconfig:${JSON.stringify(mqttConfig)}`);
+                const topics = mqttConfig.serverTopics;
+                const messageTopic = topics.find(item => item.endsWith('/message'));
+                const cmdTopic = topics.find(item => item.endsWith('/cmd'));
+                this.mqttConfig = { ...mqttConfig, serverTopics: [messageTopic, cmdTopic] };
+                return;
+            }
+        }
+        throw new Error(`Failed to get config!`);
+    }
+    async changeConnectStatus(status) {
+        const url = '/guest/relayBot/changeConnectStatus/' + this.ctx.account.config.apiKey;
+        const p = {
+            connect: status === 'start' ? 'true' : 'false'
+        };
+        return await this.http.post(url, p);
+    }
+    async connect() {
+        if (!this.mqttConfig) {
+            await this.fetchConfig();
+        }
+        const config = this.mqttConfig;
+        const connectionUrl = `mqtt://${config.url}:${config.port}`;
+        const rbotId = config.clientTopics[0].split('/')[1];
+        const msgTopic = config.clientTopics.filter((item) => item.endsWith('/message'))[0];
+        const cmdTopic = config.clientTopics.filter((item) => item.endsWith('/cmd'))[0];
+        const account = this.ctx.account;
+        return new Promise((resolve, reject) => {
+            this.mqttClient = mqtt.connect(connectionUrl, {
+                clientId: `openclaw_${account.accountId}_${rbotId}_${Date.now()}`,
+                username: config.userName,
+                password: config.password,
+                qos: config.qos,
+                clean: true,
+                reconnectPeriod: 5000,
+                connectTimeout: 30000
+            });
+            this.mqttClient.on("connect", () => {
+                this.logger.info(`${this.accountLog} Connected to broker`);
+                this.mqttClient?.subscribe([msgTopic, cmdTopic], { qos: config.qos }, (err) => {
+                    if (err) {
+                        this.logger.error(`${this.accountLog} Subscribe error:${err}`);
+                    }
+                    else {
+                        this.logger.info(`${this.accountLog} Subscribed to topic:[${msgTopic}, ${cmdTopic}]`);
+                        this.ctx.rbotId = rbotId;
+                    }
+                    resolve();
+                });
+            });
+            this.mqttClient.on("message", (topic, message) => {
+                try {
+                    this.logger.debug ?? (`${this.accountLog} Topic: ${topic}, Received message:${message}`);
+                    const payload = JSON.parse(message.toString());
+                    this.receiveEventHandle(topic, payload);
+                }
+                catch (err) {
+                    this.logger.error(`${this.accountLog} Failed to parse message:${String(err)}`);
+                }
+            });
+            this.mqttClient.on("error", (err) => {
+                this.logger.error(`${this.accountLog} Connection error:${err}`);
+                reject(err);
+            });
+            this.mqttClient.on("close", () => {
+                this.logger.warn(`${this.accountLog} Connection closed`);
+                if (this.closeHandler != null) {
+                    this.closeHandler();
+                }
+            });
+            this.mqttClient.on("reconnect", () => {
+                this.logger.info(`${this.accountLog} Reconnecting...`);
+            });
+            // try {
+            //     this.runtime = getDLRuntime();
+            //     if (this.runtime) {
+            //         this.runtime.events.onAgentEvent(event => {
+            //             this.logger.warn(`中间文本 >>> ${JSON.stringify(event)}`)
+            //             if (event?.stream === "assistant" && event.data?.phase === "commentary" && event.data?.text) {
+            //                // this.logger.warn(`中间文本 >>> ${event.data?.text}`)
+            //             }
+            //         })
+            //         this.logger.info(`runtime.events.onAgentEvent事件注册成功...`)
+            //     }
+            // } catch (e) {
+            //     this.logger.error(`${this.accountLog} ${new String(e)}`);
+            // }
+        });
+    }
+    async receiveEventHandle(topic, msg) {
+        if (topic.endsWith('/cmd')) {
+            const cmdMessage = msg;
+            let result = {
+                requestId: cmdMessage.requestId,
+                success: false,
+                error: 'CMD 处理器未初始化',
+                timestamp: Date.now()
+            };
+            if (this.cmdHandler?.isReady()) {
+                const res = await this.cmdHandler.handleCmdMessage(cmdMessage);
+                result = {
+                    ...res,
+                    requestId: result.requestId
+                };
+            }
+            if (cmdMessage.from) {
+                await this.publishCmdResultToDLClient(cmdMessage.from, result, "1");
+            }
+            else {
+                await this.publishCmdResultToServer(result, '1');
+            }
+            return;
+        }
+        this.lastInboundAt = Date.now();
+        const accStatus = messagePreviewHandler(msg, this.ctx.account.accountId, this.logger);
+        const t = this.emit('message', {
+            "ctx": this.ctx,
+            "msg": msg,
+            "accStatus": accStatus
+        }, this);
+        if (!t) {
+            this.logger.error('DLClient Event[message] emit fail!');
+        }
+    }
+    closeHandler() {
+        const t = this.emit('close');
+        if (!t) {
+            this.logger.warn(`DLClient account[${this.ctx.account.accountId}] Event[close] emit fail!`);
+        }
+    }
+    publish(topic, payload, sqos) {
+        const qos = (sqos ? parseInt(sqos) : (this.mqttConfig?.qos ?? 0));
+        return new Promise((reslove, reject) => {
+            this.mqttClient.publish(topic, payload, { qos }, (error) => {
+                if (error) {
+                    const errorStr = String(error);
+                    this.logger.error(`${this.accountLog} Publish error:${errorStr}`);
+                    reject(errorStr);
+                }
+                else {
+                    //this.logger.info(`${this.accountLog} Published to ${topic}`);
+                    reslove();
+                }
+            });
+        });
+    }
+    getLastInboundAt() {
+        return this.lastInboundAt;
+    }
+    isConnected() {
+        return this.mqttClient?.connected ?? false;
+    }
+    async start() {
+        if (!this.isConnected()) {
+            await this.connect();
+        }
+        if (this.cmdHandler) {
+            await this.cmdHandler.initialize();
+        }
+        await this.changeConnectStatus('start');
+    }
+    async stop() {
+        if (this.mqttClient) {
+            this.mqttClient.end(false, () => {
+                this.mqttClient = null;
+                this.logger.warn(`DLClient account[${this.ctx.account.accountId}] Disconnected`);
+                if (this.cmdHandler) {
+                    this.cmdHandler.cleanup();
+                }
+                this.cmdHandler = null;
+                this.mqttConfig = null;
+            });
+        }
+        await this.changeConnectStatus('stop');
+    }
+    async exeCmd(cmdMessage) {
+        if (this.cmdHandler?.isReady()) {
+            return await this.cmdHandler.handleCmdMessage(cmdMessage);
+        }
+    }
+    async publishEventToDLClient(payload, event, sqos, to) {
+        const timestamp = Date.now();
+        const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        const api_key = this.ctx.account.config.apiKey;
+        const message = {
+            apiKey: api_key,
+            type: 'event',
+            event: event,
+            payload: payload,
+            agentBrand: 'openClaw',
+            timestamp,
+            timezone
+        };
+        if (to && to.length > 0) {
+            this.logger.info(`推送客户端事件消息, topic= ${to}`);
+            try {
+                await this.publish(to, JSON.stringify(message), sqos);
+                return;
+            }
+            catch (e) {
+                this.logger.error(String(e));
+            }
+            return;
+        }
+        const openUserTopics = this.mqttConfig?.openUserTopics ?? [];
+        //this.logger.info(`推送客户端事件消息, topics= [${openUserTopics}]`,)
+        for (const topic of openUserTopics) {
+            try {
+                await this.publish(topic, JSON.stringify(message), sqos);
+            }
+            catch (e) {
+                this.logger.error(String(e));
+            }
+        }
+    }
+    async publishCmdResultToDLClient(topic, playload, sqos) {
+        const timestamp = Date.now();
+        const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        const api_key = this.ctx.account.config.apiKey;
+        const message = {
+            apiKey: api_key,
+            type: 'cmd',
+            payload: playload,
+            agentBrand: 'openClaw',
+            timestamp,
+            timezone
+        };
+        return await this.publish(topic, JSON.stringify(message), sqos);
+    }
+    async publishEventToServer(playload, event, sqos) {
+        const topic = this.mqttConfig?.serverTopics[1];
+        if (!topic) {
+            return;
+        }
+        const timestamp = Date.now();
+        const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        const api_key = this.ctx.account.config.apiKey;
+        const message = {
+            apiKey: api_key,
+            type: 'event',
+            event: event,
+            payload: playload,
+            agentBrand: 'openClaw',
+            timestamp,
+            timezone
+        };
+        return await this.publish(topic, JSON.stringify(message), sqos);
+    }
+    async publishCmdResultToServer(playload, sqos) {
+        const topic = this.mqttConfig?.serverTopics[1];
+        if (!topic) {
+            return;
+        }
+        const timestamp = Date.now();
+        const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        const api_key = this.ctx.account.config.apiKey;
+        const message = {
+            apiKey: api_key,
+            type: 'cmd',
+            payload: playload,
+            agentBrand: 'openClaw',
+            timestamp,
+            timezone
+        };
+        return await this.publish(topic, JSON.stringify(message), sqos);
+    }
+    async publishToServer(params, autoParams) {
+        const { streamId, content, finish, mediaFiles, session, kind } = params;
+        if (!this.mqttClient || !this.mqttConfig) {
+            throw new Error(`${this.accountLog} client not connected`);
+        }
+        const message = buildDLReplyMessage({
+            streamId,
+            content,
+            finish,
+            kind
+        });
+        if (!message) {
+            if (autoParams) {
+                const { toAgent, contactId, relayId, chatId, notifyUrl, isGroup, botType } = autoParams;
+                this.logger.info(`${this.accountLog} streamId:[${streamId}] has been cleaned up due to overdue. current use autoSend...`);
+                const data = {
+                    "chatId": chatId,
+                    "botType": botType,
+                    "group": isGroup ? "true" : "false",
+                    "content": content ?? "",
+                    "notifyUrl": notifyUrl ?? "",
+                    "toAgent.id": toAgent.id,
+                    "toAgent.sessionKey": toAgent.sessionKey,
+                    "contactId": contactId ?? '',
+                    "relayId": relayId
+                };
+                if (session) {
+                    data["archiveSession.archived"] = session.archived ? 'true' : 'false';
+                    data["archiveSession.sessionKey"] = session.sessionKey;
+                    if (session.newSessionKey) {
+                        data["archiveSession.newSessionKey"] = session.newSessionKey;
+                    }
+                    data["archiveSession.runId"] = session.runId;
+                }
+                let res;
+                if (mediaFiles && mediaFiles.length > 0) {
+                    res = await this.http.upload(AUTO_RELAY_API, mediaFiles, data);
+                }
+                else if (data.content.length > 0) {
+                    res = await this.http.post(AUTO_RELAY_API, data);
+                }
+                return {
+                    autoRelay: true,
+                    reqId: res
+                };
+            }
+            this.logger.error(`${this.accountLog} streamId:[${streamId}] has been cleaned up due to overdue.`);
+            return {
+                autoRelay: true
+            };
+        }
+        const now = Date.now();
+        if (message.relayTimeRhreshold && now > message.relayTimeRhreshold) {
+            //超时回复使用主动回复
+            this.logger.info(`${this.accountLog} Over the reply time, take the initiative to reply!`);
+            message.notify = true;
+        }
+        if (mediaFiles && mediaFiles.length > 0) {
+            this.logger.info(`${this.accountLog} upload media files..`);
+            const data = {
+                "streamId": streamId
+            };
+            const res = await this.http.upload(AUTO_RELAY_UPLOAD, mediaFiles, data);
+            if (res && res.length > 0) {
+                this.logger.info(`${this.accountLog} upload media files success!`);
+            }
+        }
+        if (session) {
+            message.archiveSession = { ...session };
+        }
+        const topic = this.mqttConfig.serverTopics[0];
+        try {
+            await this.publish(topic, JSON.stringify(message));
+            return {
+                autoRelay: false,
+                reqId: message.streamId
+            };
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    /**
+     * 减轻服务端负担，将处理状态直接推送到客户端(处理结果走服务端)
+     * @param params
+     */
+    async publishProcessingState(params) {
+        const { streamId, content, kind, status, runId } = params;
+        if (!this.mqttClient || !this.mqttConfig) {
+            throw new Error(`${this.accountLog} client not connected`);
+        }
+        const message = buildDLReplyMessage({
+            streamId,
+            content,
+            finish: false,
+            kind,
+            runId
+        });
+        if (!message) {
+            this.logger.error(`[publishProcessingState]${this.accountLog} streamId:[${streamId}] has been cleaned up due to overdue.`);
+            return;
+        }
+        const now = Date.now();
+        if (message.relayTimeRhreshold && now > message.relayTimeRhreshold) {
+            this.logger.error(`[publishProcessingState]${this.accountLog} Over the reply time, take the initiative to reply!`);
+            return;
+        }
+        const fromUsers = message.fromUsers ?? [];
+        if (fromUsers.length === 0) {
+            this.logger.warn(`[publishProcessingState]${this.accountLog} from users is empty, can not send message status!`);
+            return;
+        }
+        if (kind === 'plan' && message.contactType === 'group') {
+            //群组时中间态消息就不回传了，显得消息太杂
+            return;
+        }
+        let result_content = message.payload;
+        if (kind !== 'patch' && kind !== 'plan' && kind !== 'block') {
+            if (result_content.length > 200) {
+                result_content = result_content.substring(0, 300);
+            }
+        }
+        const toAgent = message.toAgent;
+        const sessionKey = toAgent.sessionKey;
+        for (const user of fromUsers) {
+            const msg = {
+                msgId: uuidStr(36),
+                streamId,
+                chatId: message.chatId,
+                sender: {
+                    id: toAgent.id,
+                    nickname: toAgent.nickname,
+                    avatar: toAgent.avatarUrl,
+                    jobPost: toAgent.jobPost
+                },
+                receiver: {
+                    id: user.id,
+                    nickname: user.nickname
+                },
+                contactType: message.contactType,
+                contactId: message.contactId,
+                botType: message.botType,
+                payload: result_content,
+                createdAt: Date.now(),
+                timezone: message.timezone,
+                status,
+                finish: message.finish,
+                kind,
+                sessionKey,
+                runId,
+                relayType: 'openClaw'
+            };
+            try {
+                await this.publish(user.chatTopic, JSON.stringify(msg));
+            }
+            catch (e) {
+                this.logger.error(String(e));
+            }
+        }
+    }
+    async downloadFileRaw(url, botType) {
+        return await this.http.downloadFileRaw(url, { botType });
+    }
+    /**
+     * 对码成功回调通知
+     */
+    async approved(ok) {
+        const url = '/guest/relayBot/approved/' + this.ctx.rbotId;
+        const p = {
+            "approved": ok ? "true" : "false"
+        };
+        await this.http.post(url, p);
+    }
+    async autoReply(params) {
+        const { to: rawTo, text, mediaFiles } = params;
+        const { channelId, account } = this.ctx;
+        const config = account.config;
+        if (!config.configured) {
+            throw new Error(`${channelId} account[${account.accountId}] not configured`);
+        }
+        if ((!text || text.length === 0) && (!mediaFiles || mediaFiles.length === 0)) {
+            throw new Error(`${channelId} account[${account.accountId}] content is empty!`);
+        }
+        // 从 to 中解析 sessionKey（格式: dlink:user:xxx-xxx-dLink#agent:main:dlink-00001:direct:xxx）
+        const hashIdx = rawTo.lastIndexOf('#');
+        const to = hashIdx > 0 ? rawTo.substring(0, hashIdx) : rawTo;
+        const sessionKey = hashIdx > 0 ? rawTo.substring(hashIdx + 1) : undefined;
+        const channelPrefix = new RegExp(`^${channelId}:`, "i");
+        const chat_id = to.replace(channelPrefix, "");
+        const isGroup = chat_id.includes("group:");
+        const strArr = isGroup ? chat_id.replace(new RegExp('^group:', 'i'), "").split("-") : chat_id.replace(new RegExp('^user:', 'i'), "").split("-");
+        const chatId = strArr[0];
+        const botId = strArr[1];
+        const botType = strArr[2];
+        const relayId = strArr[3];
+        const data = {
+            "chatId": chatId,
+            "toAgent.id": botId,
+            "botType": botType,
+            "group": isGroup ? "true" : "false",
+            "content": text ?? '',
+            "relayId": relayId
+        };
+        // 携带 sessionKey 到服务端，用于下游 Agent 路由
+        if (sessionKey) {
+            data["toAgent.sessionKey"] = sessionKey;
+        }
+        let res;
+        if (mediaFiles && mediaFiles.length > 0) {
+            res = await this.http.upload(AUTO_RELAY_API, mediaFiles, data);
+        }
+        else {
+            res = await this.http.post(AUTO_RELAY_API, data);
+        }
+        if (res) {
+            return {
+                channel: channelId,
+                messageId: res,
+                chatId: chatId
+            };
+        }
+        throw new Error(`${channelId} account[${account.accountId}] Sending message failed.`);
+    }
+}

package/dist/src/client/dl-http.d.ts

@@ -0,0 +1,27 @@
+import { PluginLogger } from 'openclaw/plugin-sdk';
+import { BotType } from './types.js';
+export type HttpOpts = {
+    baseUrl: string;
+    apiKey: string;
+    secret: string;
+};
+export declare class DLHttp {
+    private readonly opts;
+    private readonly deviceId;
+    private readonly client;
+    private readonly logger;
+    constructor(opts: HttpOpts, logger: PluginLogger, timeout?: number);
+    private randomString;
+    private genSign;
+    private response;
+    get<T>(url: string, data?: Record<string, string>): Promise<T | undefined>;
+    post<T>(url: string, data?: Record<string, string>): Promise<T | undefined>;
+    upload<T>(url: string, files: Array<string>, data?: Record<string, string>): Promise<T | undefined>;
+    downloadFileRaw(url: string, { timeout, botType }: {
+        timeout?: number;
+        botType: BotType;
+    }): Promise<{
+        buffer: Buffer;
+        filename?: string;
+    }>;
+}