dlinkclaw-openclaw 1.0.0

package/dist/src/services/index.js

@@ -0,0 +1,245 @@
+/**
+ * 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('onHealth', (_payload) => {
+                //this.dlClient.publishEventToDLClient(payload, 'onHealth', '0')
+            });
+            this.services.on('onHeartbeat', (_payload) => {
+                this.dlClient.publishEventToServer({ "connected": true }, "onConnectState");
+            });
+            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) => {
+                // 2026-08-28 会话变更推送（直接推客户端）：
+                // 原方案 publishEventToServer 走服务端 MQTT 转发，但服务端未定义 onSessionsChanged 接收端，事件会丢；
+                // 且网关 sessions.changed 是全量快照(payload 大、每条消息都触发)，不宜走服务端转发。
+                // 改为 publishEventToDLClient 直接推给 openUserTopics(客户端订阅的 chatTopic 集合，onTick/onHealth 同款通道)，
+                // 并精简 payload 只保留会话上下文占用所需字段，避免快照体积。
+                if (!payload) {
+                    return;
+                }
+                // 精简：丢弃全量快照，只保留客户端显示上下文占用百分比所需字段
+                const slimPayload = {
+                    sessionKey: payload.sessionKey,
+                    totalTokens: payload.totalTokens,
+                    contextTokens: payload.contextTokens,
+                    totalTokensFresh: payload.totalTokensFresh,
+                    model: payload.model,
+                };
+                this.dlClient.publishEventToDLClient(slimPayload, 'onSessionsChanged', '0');
+            });
+            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 content = result_contents.join('').trim();
+                        if (content.length === 0) {
+                            return;
+                        }
+                        const label = payload.origin.label || undefined;
+                        if (!label) {
+                            this.log(`不能StreamId...${label}`, 'error');
+                            this.dlClient.publishEventToServer({
+                                sessionKey,
+                                content,
+                            }, 'onAgentReply', '0');
+                            return;
+                        }
+                        if (label.includes('_')) {
+                            const streamId = label.split('_')[1];
+                            this.dlClient.publishProcessingState({
+                                streamId,
+                                content,
+                                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);
+}

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

@@ -0,0 +1,169 @@
+/**
+ * Claw-Services 主服务接口
+ * 为 duolian 插件提供 OpenClaw API 封装
+ */
+import EventEmitter from 'events';
+import { ClawServiceOptions, CmdMessage, CmdResponse } from './types.js';
+import { PluginLogger } from 'openclaw/plugin-sdk/core';
+/**
+ * Claw-Services 主类
+ * 处理 CMD 消息并调用相应的 OpenClaw API
+ */
+export declare class ClawServices extends EventEmitter {
+    private client;
+    private readonly options;
+    private isInitialized;
+    private readonly logger;
+    constructor(options: ClawServiceOptions, logger: PluginLogger);
+    log(msg: string, type: 'info' | 'warn' | 'error' | 'debug'): void;
+    /**
+     * 初始化服务
+     */
+    initialize(): Promise<boolean>;
+    /**
+     * 检查服务是否已初始化
+     */
+    isReady(): boolean;
+    /**
+     * 处理 CMD 消息
+     */
+    handleCmdMessage(cmdMessage: CmdMessage): Promise<CmdResponse>;
+    private handleAskAgent;
+    /**
+     * 更新
+     * @param agentId
+     * @param userId
+     */
+    private handleUpdateSessionModel;
+    /**
+     * 2026-08-28 解析 direct 会话的真实 sessionKey（兼容 chatId 后缀）
+     * 背景：客户端拼的 key 是 agent:<agentId>:<channelId>:direct:<empId>（无后缀），
+     * 但网关按 chatId 生成的会话 key 带后缀（agent:<agentId>:<channelId>:direct:<empId>-<botId>-<botType>），
+     * store 中两套 key 同时存在时，无后缀 key 可能命中旧遗留会话（模型覆盖过期），
+     * 导致 sessions.currentModel 返回旧模型、sessions.patch 写入旧会话。
+     * 策略：先精确匹配传入 key；查不到 entry 时，用前缀匹配 store 中 updatedAt 最新的 direct 会话。
+     */
+    private resolveDirectSessionKey;
+    /**
+     * 查询当前会话的模型覆盖（用于 ChatPage 恢复选中状态）
+     * 2026-08-28 修复：客户端直接传 sessionKey（不再传 agentId+userId 让插件拼 key）
+     */
+    private handleCurrentSessionModel;
+    private handleAgentList;
+    private handleAgentCreate;
+    private handleAgentUpdate;
+    private handleAgentDelete;
+    private handleAgentGet;
+    private handleTaskList;
+    private handleTaskCreate;
+    private handleTaskUpdate;
+    private handleTaskDelete;
+    private handleTaskRun;
+    private handleStatusHealth;
+    private handleStatusSystem;
+    private handleStatusUsage;
+    private handleListModels;
+    private handleSessionList;
+    private handleSessionGet;
+    private handleSessionsDescribe;
+    private handleSessionsResolve;
+    /**
+     * 创建新会话
+     * sessionKey: agent:<agentId>:<channelId>-<suffix>:<chatType>:<userId>
+     * 例: agent:main:workrelay-00001:direct:I35916630580137984
+     */
+    private handleSessionCreate;
+    /**
+     * 归档会话
+     * 入参: { sessionKey }
+     * - sessionKey: 完整的 sessionKey，如 "agent:main:workrelay-00001:direct:i35916630580137984"
+     */
+    private handleSessionArchive;
+    /**
+     * 恢复（取消归档）会话
+     * 入参: { sessionKey }
+     * - sessionKey: 完整的 sessionKey
+     */
+    private handleSessionRestore;
+    /**
+     * 删除会话
+     * 入参: { sessionKey, deleteFiles? }
+     * - sessionKey:  完整的 sessionKey
+     * - deleteFiles: 是否同时删除会话相关文件（可选，默认 false）
+     */
+    private handleSessionDelete;
+    private handleSessionReset;
+    private handleChatHistories;
+    private handleSkillsStatus;
+    private handleSkillsSearch;
+    private handleSkillDetail;
+    private handleSkillInstall;
+    private handleSkillUpdate;
+    private handleSkillsSecurityVerdicts;
+    private handleUsageCost;
+    private handleSessionsUsage;
+    private handleSessionsUsageLogs;
+    /**
+     * 取消当前Agent执行，通过Gateway /queue interrupt 中断活跃run
+     */
+    private handleCancelMessage;
+    /**
+     * 强制停止当前Agent run（/stop，比 /queue interrupt 更快）
+     * 新增 cmd 通道 agent.stop 指令
+     */
+    private handleStopAgent;
+    private handlChatAbout;
+    /**
+     * 2026-09-06 适配 openclaw 2026.9.1：对码审批改走宿主 RPC channels.pairing.approve（按 requestId）
+     * - 9.1 起 approveChannelPairingCode 不再从 plugin-sdk 导出（安全收敛：审批权与对码解耦、插件不再直写宿主 store）
+     * - requestId 由插件创建对码时通过 channels.pairing.list 获取，随 onPairingRequest 事件下发给客户端
+     * - notify=false：不触发宿主 notifyApproval（其内部 dlClient.approved 走 HTTP /guest/relayBot/approved，
+     *   服务端暂无该端点会 404 噪音）；服务端回调沿用下方 onPairingResult MQTT 事件（7.1 同款链路）
+     */
+    private handleApprove;
+    /** artifacts.list - 列出会话工件 */
+    handleArtifactsList(cmdMessage: CmdMessage): Promise<any>;
+    /** artifacts.get - 获取单个工件详情 */
+    handleArtifactsGet(cmdMessage: CmdMessage): Promise<any>;
+    /** artifacts.download - 下载工件 */
+    handleArtifactsDownload(cmdMessage: CmdMessage): Promise<any>;
+    /** agents.files.list - 列出 Agent 工作区文件 */
+    handleAgentFilesList(cmdMessage: CmdMessage): Promise<any>;
+    /** agents.files.get - 获取工作区文件内容 */
+    handleAgentFilesGet(cmdMessage: CmdMessage): Promise<any>;
+    /**
+     * extCapabilities.status - 查询扩展能力安装状态
+     * params: { name: 'workrelay-speak' | 'workrelay-transcribe' }
+     * 执行 ext_capabilities/<name>/status.sh，返回 JSON 供客户端展示
+     */
+    handleExtCapabilityStatus(params: Record<string, any>): Promise<any>;
+    /**
+     * 2026-08-10 检测指定扩展能力的安装进程是否真实在跑（存活检测）
+     * 注意：不能用 pgrep -f "...install.sh" —— 该命令经 bash -c 执行时，bash 进程
+     * 自身命令行包含 install.sh 字符串，pgrep 会永远自匹配，导致 installing 恒为 true。
+     * 改用 ps + grep 方括号技巧（grep 自身命令行不含字面 install.sh，不会自匹配）。
+     */
+    private isExtCapabilityInstalling;
+    /**
+     * extCapabilities.check - 检查扩展能力安装前置条件
+     * params: { name: 'workrelay-speak' | 'workrelay-transcribe' }
+     * 读取 ext_capabilities/<name>/manifest.json，逐条执行 requirements[].check（shell 表达式），
+     * exit 0 = 条件满足。返回每条条件是否满足，客户端据此展示"安装条件"清单。
+     * 2026-08-11 新增：通用适配——每个能力自带前置条件清单，用户安装前即可看到环境是否满足。
+     */
+    handleExtCapabilityCheck(params: Record<string, any>): Promise<any>;
+    /**
+     * extCapabilities.install - 安装扩展能力（长任务，后台执行）
+     * params: { name: 'workrelay-speak' | 'workrelay-transcribe' }
+     * install.sh 可能需要 5-15 分钟（下载模型），后台 spawn 立即返回"已开始"，
+     * 客户端通过轮询 extCapabilities.status 感知进度
+     */
+    handleExtCapabilityInstall(params: Record<string, any>): Promise<any>;
+    /**
+     * 2026-08-10 读取日志文件尾部内容（供安装失败报错）
+     */
+    private readLogTail;
+    private formatUptime;
+    cleanup(): void;
+}
+export default ClawServices;