dlinkclaw-openclaw 1.0.0

package/dist/src/outbound.js

@@ -0,0 +1,78 @@
+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}`);
+            // 2026-09-01 修复：mediaUrl 与 mediaUrls 可能同时携带同一文件（语音场景），去重避免重复发送导致空语音
+            const mediaFile = [...new Set([...(payload.mediaUrl ? [payload.mediaUrl] : []), ...(payload.mediaUrls ?? [])])];
+            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/core";
+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,216 @@
+// 2026-09-06 适配 openclaw 2026.9.1：审批改按 requestId，经宿主 RPC list 获取（9.1 起按 code 审批 API 不再公开）
+import { listPairingRequests } from "./services/gateway-rpc.js";
+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
+            });
+        }
+        else {
+            logger.error(`${logPreTag}blocked unauthorized sender=${senderId} (dmPolicy=${dmPolicy})`);
+        }
+        // 2026-09-06 适配 openclaw 2026.9.1：审批改按 requestId（宿主 RPC），
+        // 通过 channels.pairing.list 获取本次 requestId 随事件下发；
+        // 同 sender 幂等 upsert(id=senderId)，pending 中按 senderId 唯一定位
+        let pairingRequestId;
+        try {
+            const pending = await listPairingRequests(channelId, account.accountId);
+            pairingRequestId = pending.find(r => r.senderId === senderId)?.requestId;
+            if (!pairingRequestId) {
+                logger.warn(`${logPreTag}list 未匹配到 sender=${senderId} 的配对请求`);
+            }
+        }
+        catch (e) {
+            logger.error(`${logPreTag}获取 requestId 失败:${String(e)}`);
+        }
+        // 对码请求已创建/已存在，通过MQTT通知客户端可一键对码（带 requestId 供 9.1 审批使用）
+        const pairingEvent = {
+            code, // 对码验证码
+            requestId: pairingRequestId, // 2026-09-06 新增：宿主配对请求 id（9.1 起审批必需）
+            channelId, // 通道ID
+            senderId, // 发送者ID,实质是relayBotId
+            relayType: "OpenClaw"
+        };
+        client.publishEventToDLClient(pairingEvent, '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/core";
+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/gateway-rpc.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 2026-09-06 适配 openclaw 2026.9.1：宿主 Gateway RPC 调用工具（配对审批等）
+ *
+ * 背景：9.1 起 approveChannelPairingCode 等 pairing-store 函数不再从 plugin-sdk 导出，
+ * 官方改为宿主 Gateway RPC（channels.pairing.list / channels.pairing.approve），
+ * 且审批按 requestId（不透明 id）进行，不再暴露配对码 code。
+ * 本模块通过插件自有的 WSClient（已认证的 Gateway WebSocket）调用宿主 RPC，
+ * 实例由 ClawServices 初始化后注入（setGatewayClient）。
+ */
+import type WSClient from './ws-client.js';
+/** 注入 Gateway WebSocket 客户端（ClawServices.initialize 成功后调用） */
+export declare function setGatewayClient(client: WSClient | null): void;
+export declare function getGatewayClient(): WSClient | null;
+/** channels.pairing.list 返回的单个配对请求（宿主 publicRequest 结构） */
+export interface PairingRequestItem {
+    requestId: string;
+    channel: string;
+    channelLabel?: string;
+    accountId?: string;
+    senderId?: string;
+    senderLabel?: string;
+    metadata?: Record<string, string>;
+    createdAt?: string;
+}
+/** channels.pairing.list：列出指定通道/账号下 pending 的配对请求 */
+export declare function listPairingRequests(channel: string, accountId: string): Promise<PairingRequestItem[]>;
+/**
+ * channels.pairing.approve：审批配对请求
+ * notify=true 时宿主回调本通道 pairing.notifyApproval（→ dlClient.approved(true)）
+ * 返回宿主响应 { requestId, senderId, notification, commandOwnerBootstrap }
+ */
+export declare function approvePairingRequest(channel: string, accountId: string, requestId: string, notify?: boolean): Promise<{
+    requestId: string;
+    senderId?: string;
+    notification?: string;
+    commandOwnerBootstrap?: string;
+}>;

package/dist/src/services/gateway-rpc.js

@@ -0,0 +1,37 @@
+let gwClient = null;
+/** 注入 Gateway WebSocket 客户端（ClawServices.initialize 成功后调用） */
+export function setGatewayClient(client) {
+    gwClient = client;
+}
+export function getGatewayClient() {
+    return gwClient;
+}
+/** channels.pairing.list：列出指定通道/账号下 pending 的配对请求 */
+export async function listPairingRequests(channel, accountId) {
+    if (!gwClient) {
+        throw new Error('Gateway RPC 客户端未初始化（setGatewayClient 未调用）');
+    }
+    const res = await gwClient.callGatewayMethod('channels.pairing.list', {
+        channel,
+        accountId,
+    });
+    // 宿主返回 { accounts: [...], requests: [...] }，requestId 在 requests 中
+    const requests = res?.requests ?? [];
+    return requests.filter((r) => r.accountId === accountId || !r.accountId);
+}
+/**
+ * channels.pairing.approve：审批配对请求
+ * notify=true 时宿主回调本通道 pairing.notifyApproval（→ dlClient.approved(true)）
+ * 返回宿主响应 { requestId, senderId, notification, commandOwnerBootstrap }
+ */
+export async function approvePairingRequest(channel, accountId, requestId, notify = true) {
+    if (!gwClient) {
+        throw new Error('Gateway RPC 客户端未初始化（setGatewayClient 未调用）');
+    }
+    return await gwClient.callGatewayMethod('channels.pairing.approve', {
+        channel,
+        accountId,
+        requestId,
+        notify,
+    });
+}

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/core";
+/**
+ * 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;