dlinkclaw-openclaw 2026.8.24-alpha.1

package/dist/src/outbound.js

@@ -0,0 +1,83 @@
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/core";
+import { getDLLogger, getDLRuntime } from "./runtime.js";
+import { TEXT_CHUNK_LIMIT } from "./client/const.js";
+import { getDLClient } from "./client/client-manager.js";
+const log_prefix = "[Outbound.ts]";
+const getClient = (accountId) => {
+    const dlClient = getDLClient(accountId);
+    if (!dlClient) {
+        throw new Error(`${log_prefix} DLClient account[${accountId}] is null!`);
+    }
+    return dlClient;
+};
+export const dlOutbound = () => {
+    const logger = getDLLogger();
+    return {
+        deliveryMode: "direct",
+        chunker: (text, limit) => getDLRuntime().channel.text.chunkMarkdownText(text, limit),
+        chunkerMode: "markdown",
+        textChunkLimit: TEXT_CHUNK_LIMIT,
+        async sendMedia(ctx) {
+            const { to, text, accountId, replyToId, threadId, mediaUrl } = ctx;
+            const accId = accountId || DEFAULT_ACCOUNT_ID;
+            logger.info(`${log_prefix} Notify[sendMedia] to[${to}], accountId=${accId}, replyToId=${replyToId}, threadId=${threadId}, text=${text}`);
+            logger.info(`${log_prefix} Media files = [${mediaUrl}]..`);
+            return await getClient(accId).autoReply({
+                to,
+                text,
+                mediaFiles: mediaUrl && mediaUrl.length > 0 ? [mediaUrl] : []
+            });
+        },
+        async sendPayload(ctx) {
+            //主动出站(文本与媒体文件)
+            const { to, accountId, replyToId, threadId, payload } = ctx;
+            const accId = accountId || DEFAULT_ACCOUNT_ID;
+            logger.info(`${log_prefix} Notify[sendPayload] to[${to}], accountId=${accId}, replyToId=${replyToId}, threadId=${threadId}, text=${payload.text}`);
+            const mediaFile = [];
+            if (payload.mediaUrl) {
+                mediaFile.push(payload.mediaUrl);
+            }
+            if (payload.mediaUrls && payload.mediaUrls.length > 0) {
+                payload.mediaUrls.map(item => mediaFile.push(item));
+            }
+            const text = payload.text ?? '';
+            const dlClient = getClient(accId);
+            return await dlClient.autoReply({
+                to,
+                text,
+                mediaFiles: [...mediaFile]
+            });
+        },
+        async sendText(ctx) {
+            //主动出站(文本)
+            const { cfg, to, text, accountId, replyToId, threadId } = ctx;
+            const accId = accountId || DEFAULT_ACCOUNT_ID;
+            logger.info(`${log_prefix} Notify[sendText] to[${to}], accountId=${accId}, replyToId=${replyToId}, threadId=${threadId}, text=${text}`);
+            const dlClient = getClient(accId);
+            return await dlClient.autoReply({
+                to,
+                text
+            });
+        }
+    };
+};
+export const dlPairing = (channelId) => {
+    const logger = getDLLogger();
+    return {
+        idLabel: channelId,
+        normalizeAllowEntry: (entry) => {
+            const trimmed = entry?.trim();
+            logger.info(`${log_prefix} NormalizeAllowEntry: ${trimmed}`);
+            return trimmed.replace(new RegExp(`^(${channelId}|user):`, "i"), "").trim();
+        },
+        notifyApproval: async ({ cfg, accountId }) => {
+            const accId = accountId || DEFAULT_ACCOUNT_ID;
+            logger.info('对码成功回调通知...');
+            const dlClient = getDLClient(accId);
+            if (dlClient) {
+                await dlClient.approved(true);
+            }
+            throw new Error(`${channelId} account[${accId}] DLClient is null!`);
+        }
+    };
+};

package/dist/src/policy.d.ts

@@ -0,0 +1,42 @@
+import { DLConfig, DLResolvedAccount } from "./client/types.js";
+import { DLClient } from "./client/dl-client.js";
+import { OpenClawConfig, PluginLogger, PluginRuntime } from "openclaw/plugin-sdk";
+export type DLGroupPolicyCheckResult = {
+    allowed: boolean;
+};
+export type DmPolicyCheckResult = {
+    allowed: boolean;
+    allowFrom?: Array<string | number>;
+};
+export declare function checkGroupPolicy(params: {
+    chatId: string;
+    senderId: string;
+    account: DLResolvedAccount;
+    channelId: string;
+    logger: PluginLogger;
+}): DLGroupPolicyCheckResult;
+/**
+ * 检查发送者是否在允许列表中（通用）
+ */
+export declare function isSenderAllowed(senderId: string, allowFrom: string[], channelId: string): boolean;
+/**
+ * 检查 DM Policy 访问控制
+ * @returns 检查结果，包含是否允许继续处理
+ */
+export declare function checkDmPolicy(params: {
+    core: PluginRuntime;
+    senderId: string;
+    account: DLResolvedAccount;
+    client: DLClient;
+    channelId: string;
+    streamId: string;
+    logger: PluginLogger;
+}): Promise<DmPolicyCheckResult>;
+/**
+ * 设置 dmPolicy
+ */
+export declare function setDmPolicy(cfg: OpenClawConfig, dmPolicy: "pairing" | "allowlist" | "open" | "disabled", channelId: string): OpenClawConfig;
+/**
+ * 设置企业微信账户配置
+ */
+export declare function setAccount(cfg: OpenClawConfig, account: Partial<DLConfig>, channelId: string): OpenClawConfig;

package/dist/src/policy.js

@@ -0,0 +1,205 @@
+import { resolveDLAccount } from "./account.js";
+import { resolveAllowlistMatchSimple } from "openclaw/plugin-sdk/allow-from";
+import { addWildcardAllowFrom } from "openclaw/plugin-sdk/setup";
+/**
+ * 检查群组是否在允许列表中
+ */
+function isInGroupAllowed(params) {
+    const { channelId, groupPolicy } = params;
+    if (groupPolicy === "disabled") {
+        return false;
+    }
+    if (groupPolicy === "open") {
+        return true;
+    }
+    // allowlist 模式：检查群组是否在允许列表中
+    const normalizedAllowFrom = params.allowFrom.map((entry) => String(entry).replace(new RegExp(`^${channelId}:`, "i"), "").trim());
+    if (normalizedAllowFrom.includes("*")) {
+        return true;
+    }
+    const normalizedGroupId = params.groupId.trim();
+    return normalizedAllowFrom.some((entry) => entry === normalizedGroupId || entry.toLowerCase() === normalizedGroupId.toLowerCase());
+}
+/**
+ * 检查群组内发送者是否在允许列表中
+ */
+function isGroupSenderAllowed(params) {
+    const { senderId, groupId, channelId, config } = params;
+    const groups = config.groups;
+    //不配置默认允许
+    if (!groups) {
+        return true;
+    }
+    const groupConfig = groups[groupId];
+    if (!groupConfig) {
+        return true;
+    }
+    const perGroupSenderAllowFrom = (groupConfig.allowFrom ?? []).map((v) => String(v));
+    //不配置默认允许
+    if (perGroupSenderAllowFrom.length === 0) {
+        return true;
+    }
+    if (perGroupSenderAllowFrom.includes("*") || perGroupSenderAllowFrom.includes(senderId)) {
+        return true;
+    }
+    return perGroupSenderAllowFrom.some((entry) => {
+        const normalized = entry.replace(new RegExp(`^${channelId}:`, "i"), "").trim();
+        return normalized === senderId || normalized === `user:${senderId}`;
+    });
+}
+export function checkGroupPolicy(params) {
+    const { channelId, chatId, senderId, account, logger } = params;
+    const { accountId } = account;
+    const groupPolicy = account.config.groupPolicy ?? "open";
+    const groupAllowFrom = account.config.groupAllowFrom ?? [];
+    const groupAllowed = isInGroupAllowed({
+        channelId,
+        groupPolicy,
+        allowFrom: groupAllowFrom,
+        groupId: chatId,
+    });
+    if (!groupAllowed) {
+        logger.warn(`account[${accountId}] Group ${chatId} not allowed (groupPolicy=${groupPolicy})`);
+        return { allowed: false };
+    }
+    const senderAllowed = isGroupSenderAllowed({
+        channelId,
+        senderId,
+        groupId: chatId,
+        config: account.config,
+    });
+    if (!senderAllowed) {
+        logger.warn(`account[${accountId}] Sender ${senderId} not in group ${chatId} sender allowlist`);
+        return { allowed: false };
+    }
+    return { allowed: true };
+}
+/**
+ * 检查发送者是否在允许列表中（通用）
+ */
+export function isSenderAllowed(senderId, allowFrom, channelId) {
+    if (allowFrom.includes("*")) {
+        return true;
+    }
+    return allowFrom.some((entry) => {
+        const normalized = entry.replace(new RegExp(`^${channelId}:`, "i"), "").trim();
+        return normalized === senderId || normalized === `user:${senderId}`;
+    });
+}
+/**
+ * 检查 DM Policy 访问控制
+ * @returns 检查结果，包含是否允许继续处理
+ */
+export async function checkDmPolicy(params) {
+    const { core, senderId, account, client, logger, channelId, streamId } = params;
+    const logPreTag = `account[${account.accountId}],Policy.ts[checkDmPolicy],`;
+    const dmPolicy = account.config.dmPolicy ?? "pairing"; //默认需要配对
+    logger.warn(`${logPreTag}Blocked DM from [${senderId}] (dmPolicy=${dmPolicy})`);
+    const configAllowFrom = (account.config.allowFrom ?? []).map((v) => String(v));
+    // 如果 dmPolicy 是 disabled直接拒绝
+    if (dmPolicy === "disabled") {
+        logger.warn(`未配对，直接拒绝...`);
+        return { allowed: false };
+    }
+    // 如果是 open 模式，允许所有人
+    if (dmPolicy === "open") {
+        return { allowed: true, allowFrom: [...configAllowFrom] };
+    }
+    // Compatibility fallback for newer OpenClaw implementations.
+    const storeAllowFrom = await core.channel.pairing
+        .readAllowFromStore({ channel: channelId, accountId: account.accountId })
+        .catch((e) => {
+        logger.error(`${logPreTag}get allow from store, error=[${String(e)}]`);
+        return [];
+    });
+    const effectiveAllowFrom = [...configAllowFrom, ...storeAllowFrom];
+    const senderAllowedResult = resolveAllowlistMatchSimple({
+        allowFrom: effectiveAllowFrom,
+        senderId: senderId,
+        allowNameMatching: false
+    });
+    logger.info(`${logPreTag}senderAllowedResult = ${JSON.stringify(senderAllowedResult)}, effectiveAllowFrom=[${effectiveAllowFrom.join(',')}]`);
+    if (senderAllowedResult && senderAllowedResult.allowed) {
+        return { allowed: true, allowFrom: [...effectiveAllowFrom] };
+    }
+    // 处理未授权用户
+    if (dmPolicy === "pairing") {
+        const { code, created } = await core.channel.pairing.upsertPairingRequest({
+            channel: channelId,
+            id: senderId,
+            accountId: account.accountId,
+            meta: { name: senderId },
+        });
+        if (created) {
+            logger.info(`${logPreTag}pairing request created for sender=${senderId}`);
+            const replayContent = core.channel.pairing.buildPairingReply({
+                channel: channelId,
+                idLine: `Your account[${account.accountId}] sedner=${senderId}`,
+                code
+            });
+            await client.publishToServer({
+                streamId,
+                content: replayContent,
+                kind: 'block',
+                finish: true
+            });
+            // 对码请求已创建，通过MQTT通知客户端可一键对码
+            client.publishEventToDLClient({
+                code, // 对码验证码
+                channelId, // 通道ID
+                senderId, // 发送者ID,实质是relayBotId
+                relayType: "OpenClaw"
+            }, 'onPairingRequest', '0').catch(err => logger.error(`${logPreTag}发送对码事件失败:${String(err)}`));
+        }
+        else {
+            logger.error(`${logPreTag}blocked unauthorized sender=${senderId} (dmPolicy=${dmPolicy})`);
+            //再发送对验证码要求对码
+            client.publishEventToDLClient({
+                code, // 对码验证码
+                channelId, // 通道ID
+                senderId, // 发送者ID,实质是relayBotId
+                relayType: "OpenClaw"
+            }, 'onPairingRequest', '0').catch(err => logger.error(`${logPreTag}发送对码事件失败:${String(err)}`));
+        }
+    }
+    logger.warn(`account[${account.accountId}] sender=${senderId} access denied`);
+    return { allowed: false };
+}
+/**
+ * 设置 dmPolicy
+ */
+export function setDmPolicy(cfg, dmPolicy, channelId) {
+    const account = resolveDLAccount({ cfg }, channelId);
+    const existingAllowFrom = account.config.allowFrom ?? [];
+    const allowFrom = dmPolicy === "open"
+        ? addWildcardAllowFrom(existingAllowFrom.map((x) => String(x)))
+        : existingAllowFrom.map((x) => String(x));
+    return setAccount(cfg, {
+        dmPolicy,
+        allowFrom,
+    }, channelId);
+}
+/**
+ * 设置企业微信账户配置
+ */
+export function setAccount(cfg, account, channelId) {
+    const existing = (cfg.channels?.[channelId] ?? {});
+    const merged = {
+        enabled: account.enabled ?? existing?.enabled ?? true,
+        apiKey: account.apiKey ?? existing?.apiKey ?? "",
+        secret: account.secret ?? existing?.secret ?? "",
+        baseUrl: account.baseUrl ?? existing?.baseUrl ?? "",
+        allowFrom: account.allowFrom ?? existing?.allowFrom,
+        dmPolicy: account.dmPolicy ?? existing?.dmPolicy,
+        ...(account.accountName || existing?.accountName
+            ? { name: account.accountName ?? existing?.accountName }
+            : {})
+    };
+    return {
+        ...cfg,
+        channels: {
+            ...cfg.channels,
+            [channelId]: merged,
+        },
+    };
+}

package/dist/src/runtime.d.ts

@@ -0,0 +1,9 @@
+import type { PluginLogger, PluginRuntime } from "openclaw/plugin-sdk";
+export declare function setDLRuntime(next: PluginRuntime): void;
+export declare function getDLRuntime(): PluginRuntime;
+export declare function setDLLogger(coreLogger: PluginLogger, msgPrefix: string): void;
+export declare function getDLLogger(): PluginLogger;
+/** 记录一个已停止的 runId（客户端点停止后由 services.ts 调用） */
+export declare function markRunStopped(runId: string): void;
+/** 检查 runId 是否处于已停止状态（before_tool_call 钩子调用） */
+export declare function isRunStopped(runId?: string): boolean;

package/dist/src/runtime.js

@@ -0,0 +1,65 @@
+let runtime = null;
+let logger = null;
+export function setDLRuntime(next) {
+    runtime = next;
+}
+export function getDLRuntime() {
+    if (!runtime) {
+        throw new Error("DLink runtime not initialized");
+    }
+    return runtime;
+}
+export function setDLLogger(coreLogger, msgPrefix) {
+    const log = {
+        info: (msg) => {
+            coreLogger.info(`${msgPrefix} ${msg}`);
+        },
+        warn: (msg) => {
+            coreLogger.warn(`${msgPrefix} ${msg}`);
+        },
+        error: (msg) => {
+            coreLogger.error(`${msgPrefix} ${msg}`);
+        },
+        debug: (msg) => {
+            if (coreLogger.debug) {
+                coreLogger.debug(`${msgPrefix} ${msg}`);
+                return;
+            }
+            if (process.env.NODE_ENV === 'dev') {
+                coreLogger.info(`DEBUG-${msgPrefix} ${msg}`);
+            }
+        }
+    };
+    logger = log;
+}
+export function getDLLogger() {
+    if (!logger) {
+        return console;
+    }
+    return logger;
+}
+// 2026-08-24 停止标记集合：客户端点“停止”触发 chat.abort 命令时记录 runId，
+// before_tool_call 钩子据此 block 该 run 的后续工具调用，实现“立即终止”。
+// 用 TTL 过期清理，防止 runId 无限堆积（runId 为网关唯一 ID，过期后不可能再命中）。
+const stoppedRuns = new Map();
+const STOPPED_RUN_TTL_MS = 10 * 60 * 1000; // 10 分钟过期
+/** 记录一个已停止的 runId（客户端点停止后由 services.ts 调用） */
+export function markRunStopped(runId) {
+    if (!runId)
+        return;
+    stoppedRuns.set(runId, Date.now());
+    getDLLogger().info(`markRunStopped: ${runId}`);
+}
+/** 检查 runId 是否处于已停止状态（before_tool_call 钩子调用） */
+export function isRunStopped(runId) {
+    if (!runId)
+        return false;
+    const ts = stoppedRuns.get(runId);
+    if (!ts)
+        return false;
+    if (Date.now() - ts > STOPPED_RUN_TTL_MS) {
+        stoppedRuns.delete(runId); // 过期自动清理
+        return false;
+    }
+    return true;
+}

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

@@ -0,0 +1,41 @@
+/**
+ * CMD 消息处理器
+ * 集成到 duolian 的消息处理流程中
+ */
+import { DLClient } from "../client/dl-client.js";
+import { ClawServiceOptions, CmdMessage, CmdResponse } from "./types.js";
+import { PluginLogger } from "openclaw/plugin-sdk";
+/**
+ * CMD 消息处理器
+ */
+export declare class CmdHandler {
+    private readonly dlClient;
+    private services;
+    private isInitialized;
+    constructor(config: ClawServiceOptions, dlClient: DLClient, logger: PluginLogger);
+    private log;
+    /**
+     * 初始化处理器
+     */
+    initialize(): Promise<boolean>;
+    /**
+     * 处理 CMD 消息
+     */
+    handleCmdMessage(rawMessage: CmdMessage): Promise<CmdResponse>;
+    /**
+     * 生成 CMD 响应消息（用于MQTT回复）
+     */
+    createCmdResponse(response: CmdResponse): any;
+    /**
+     * 清理资源
+     */
+    cleanup(): void;
+    /**
+     * 检查处理器是否就绪
+     */
+    isReady(): boolean;
+}
+/**
+ * 创建 CMD 处理器
+ */
+export declare function createCmdHandler(config: ClawServiceOptions, dlClient: DLClient, logger: PluginLogger): CmdHandler;

package/dist/src/services/index.js

@@ -0,0 +1,225 @@
+/**
+ * CMD 消息处理器
+ * 集成到 duolian 的消息处理流程中
+ */
+import ClawServices from "./services.js";
+const AGENT_RELAY_MAP = new Map();
+//const BATCH_COUNT = 10;
+//const BATCH_TRAJECTORY_MAP: Map<string, Array<any>> = new Map();
+/**
+ * CMD 消息处理器
+ */
+export class CmdHandler {
+    dlClient;
+    services;
+    isInitialized = false;
+    constructor(config, dlClient, logger) {
+        this.dlClient = dlClient;
+        this.services = new ClawServices(config, logger);
+    }
+    log(msg, type) {
+        this.services.log(msg, type);
+    }
+    /**
+     * 初始化处理器
+     */
+    async initialize() {
+        try {
+            this.services.on('onTick', (payload) => {
+                this.dlClient.publishEventToDLClient(payload, 'onTick', '0');
+                //this.dlClient.publishEventToServer({ "connected": true }, "onConnectState")
+            });
+            this.services.on('onHeartbeat', (_payload) => {
+                this.dlClient.publishEventToServer({ "connected": true }, "onConnectState");
+            });
+            this.services.on('onHealth', (payload) => {
+                this.dlClient.publishEventToDLClient(payload, 'onHealth', '0');
+            });
+            this.services.on('onHandshaked', (payload) => {
+                this.dlClient.publishEventToServer(payload, 'onHandshaked', '0');
+            });
+            this.services.on('onAgentReply', (payload) => {
+                const message = payload;
+                if (message.stream === 'lifecycle') {
+                    if (message.data.phase && message.data.phase === 'start') {
+                        AGENT_RELAY_MAP.set(message.runId, '');
+                    }
+                    else if (message.data.phase === 'end') {
+                        const content = AGENT_RELAY_MAP.get(message.runId);
+                        if (content && content.length > 0) {
+                            setTimeout(() => this.dlClient.publishEventToServer({
+                                runId: message.runId,
+                                sessionKey: message.sessionKey, //运行的agent SessionKey
+                                content,
+                                spawnedBy: message.spawnedBy //指派任务的agent SessionKey(通过消息协议入站执行agent.ask接口的该值为空)
+                            }, 'onAgentReply', '0'), 1000);
+                        }
+                        AGENT_RELAY_MAP.delete(message.runId);
+                    }
+                }
+                else if (message.stream === 'assistant') {
+                    if (AGENT_RELAY_MAP.has(message.runId)) {
+                        if (message.data.text && message.data.text.length > 0) {
+                            AGENT_RELAY_MAP.set(message.runId, message.data.text);
+                        }
+                    }
+                }
+            });
+            // this.services.on('onAgentChat', (payload) => { 这个不需要了，会与onAgentReply上面重复
+            //   if (!payload) return;
+            //   if (payload.state === 'final') {
+            //     setTimeout(() => this.dlClient.publishEventToServer({
+            //       runId: payload.runId,
+            //       sessionKey: payload.sessionKey,
+            //       message: payload.message
+            //     }, 'onAgentChat', '0'), 1000);
+            //   }
+            // });
+            this.services.on('onSessionsChanged', (_payload) => {
+                //this.log(`sessions.changed >>> ${JSON.stringify(payload)}`, 'info'); //暂时不需要处理
+            });
+            this.services.on('onSessionMessage', (payload) => {
+                if (!payload) {
+                    return;
+                }
+                try {
+                    const sessionKey = payload.sessionKey;
+                    const message = payload.message;
+                    const role = message.role;
+                    if (role !== 'assistant') {
+                        return;
+                    }
+                    //this.log(`onSessionMessage >>> ${JSON.stringify(payload)}`, 'warn');
+                    const stopReason = message.stopReason;
+                    const content = message.content ?? [];
+                    const result_contents = content.map(item => {
+                        if (item.type === 'thinking') {
+                            return item.thinking;
+                        }
+                        else if (item.type === 'text' && stopReason != 'stop') { //stop应该是最终回复了，被免重复推送这里过滤掉(最终回复已在别处处理)
+                            return item.text;
+                        }
+                        return '';
+                    });
+                    if (result_contents.length > 0) {
+                        const label = payload.origin.label || undefined;
+                        if (!label) {
+                            this.log(`不能StreamId...${label}`, 'error');
+                            this.dlClient.publishEventToServer({
+                                sessionKey,
+                                content: result_contents.join(),
+                            }, 'onAgentReply', '0');
+                            return;
+                        }
+                        if (label.includes('_')) {
+                            const streamId = label.split('_')[1];
+                            this.dlClient.publishProcessingState({
+                                streamId,
+                                content: result_contents.join(''),
+                                kind: 'plan',
+                                status: 'read'
+                            });
+                        }
+                    }
+                }
+                catch (e) {
+                    this.log(`onSessionMessage 发生错误 >>> ${String(e)}`, 'info');
+                }
+            });
+            this.services.on('onCron', (payload) => {
+                this.dlClient.publishEventToServer(payload, 'onCron', '0');
+            });
+            this.services.on('onShutdown', (_payload) => {
+                //TODO
+            });
+            this.services.on('onConnectState', (connected) => {
+                this.dlClient.publishEventToServer({ "connected": connected }, "onConnectState");
+            });
+            this.services.on('onError', (error) => {
+                this.dlClient.publishEventToServer({ "error": error }, "onError");
+            });
+            this.services.on('onPairingResult', data => this.dlClient.publishEventToServer(data, 'onPairingResult', '0'));
+            await this.services.initialize();
+            this.isInitialized = true;
+            this.log('CMD 处理器初始化成功!', 'info');
+            return true;
+        }
+        catch (error) {
+            this.log('CMD 处理器初始化失败:' + String(error), 'error');
+            this.isInitialized = false;
+            return false;
+        }
+    }
+    /**
+     * 处理 CMD 消息
+     */
+    async handleCmdMessage(rawMessage) {
+        if (!this.isInitialized || !this.services?.isReady()) {
+            this.log('CMD 处理器未初始化，尝试重新初始化...', 'warn');
+            const initialized = await this.initialize();
+            if (!initialized) {
+                return {
+                    success: false,
+                    error: 'CMD 处理器未初始化',
+                    timestamp: Date.now()
+                };
+            }
+        }
+        if (rawMessage.params?.message) {
+            const logMessage = {
+                ...rawMessage,
+                params: {
+                    ...rawMessage.params,
+                    message: '...'
+                }
+            };
+            this.log(`🔄CMD 指令:${rawMessage.cmd}, params=${JSON.stringify(logMessage)}`, 'info');
+        }
+        else {
+            this.log(`🔄CMD 指令:${rawMessage.cmd}, params=${JSON.stringify(rawMessage)}`, 'info');
+        }
+        try {
+            // 调用服务层处理
+            return await this.services.handleCmdMessage(rawMessage);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `cmd:[${rawMessage.cmd}]${error instanceof Error ? error.message : '处理失败'}`,
+                timestamp: Date.now()
+            };
+        }
+    }
+    /**
+     * 生成 CMD 响应消息（用于MQTT回复）
+     */
+    createCmdResponse(response) {
+        return {
+            type: 'cmd_response',
+            requestId: response.requestId,
+            success: response.success,
+            data: response.data,
+            error: response.error,
+            timestamp: response.timestamp
+        };
+    }
+    /**
+     * 清理资源
+     */
+    cleanup() {
+        this.services.cleanup();
+        this.isInitialized = false;
+    }
+    /**
+     * 检查处理器是否就绪
+     */
+    isReady() {
+        return this.isInitialized && (this.services?.isReady() || false);
+    }
+}
+/**
+ * 创建 CMD 处理器
+ */
+export function createCmdHandler(config, dlClient, logger) {
+    return new CmdHandler(config, dlClient, logger);
+}