@ynhcj/xiaoyi-channel 1.1.19 → 1.1.21

package/dist/src/skill-retriever/tool-search.js

@@ -0,0 +1,159 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+const SKILL_ID = "celia_find_skills";
+const PLUGIN_LOG_PREFIX = "[skill-retriever]";
+export function extractUserQuery(fullPrompt) {
+    const lastNewlineIndex = fullPrompt.lastIndexOf("\n");
+    if (lastNewlineIndex === -1) {
+        return fullPrompt.trim();
+    }
+    const afterLastNewline = fullPrompt.slice(lastNewlineIndex + 1).trim();
+    if (!afterLastNewline || afterLastNewline === "```") {
+        return "";
+    }
+    return afterLastNewline;
+}
+function expandPath(filePath) {
+    if (filePath.startsWith("~")) {
+        return path.join(os.homedir(), filePath.slice(1).replace(/^\/+/, ""));
+    }
+    return filePath;
+}
+export function readEnvFile(filePath) {
+    const expandedPath = expandPath(filePath);
+    const envDict = {};
+    try {
+        const content = fs.readFileSync(expandedPath, "utf-8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#")) {
+                continue;
+            }
+            const eqIndex = trimmed.indexOf("=");
+            if (eqIndex > 0) {
+                let key = trimmed.substring(0, eqIndex).trim();
+                const value = trimmed.substring(eqIndex + 1).trim();
+                key = key.replace(/-/g, "_");
+                envDict[key] = value;
+            }
+        }
+    }
+    catch {
+        // File not found or read error - return empty config
+    }
+    return envDict;
+}
+export function getInstalledSkills() {
+    const skillsDir = expandPath("~/.openclaw/workspace/skills");
+    const installedSkills = [];
+    try {
+        if (fs.existsSync(skillsDir) && fs.statSync(skillsDir).isDirectory()) {
+            const entries = fs.readdirSync(skillsDir);
+            for (const entry of entries) {
+                const entryPath = path.join(skillsDir, entry);
+                if (fs.statSync(entryPath).isDirectory()) {
+                    installedSkills.push(entry);
+                }
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist or read error - return empty list
+    }
+    return installedSkills;
+}
+function formatSkillData(rawSkills, installedSkills) {
+    const formattedSkills = [];
+    for (const skill of rawSkills) {
+        const isInstalled = installedSkills.includes(skill.skillId);
+        formattedSkills.push({
+            skillId: skill.skillId,
+            skillName: skill.skillName,
+            skillDesc: skill.skillDesc,
+            downloadPath: skill.packUrl,
+            status: isInstalled ? "已安装" : "未安装",
+        });
+    }
+    return formattedSkills;
+}
+export async function searchTools(options) {
+    const { query, maxTools = 5, includeUninstalledOnly = true, envFilePath = "~/.openclaw/.xiaoyienv", serviceUrl: configServiceUrl, apiKey: configApiKey, uid: configUid, timeoutMs = 1000, } = options;
+    const envConfig = readEnvFile(envFilePath);
+    const hasRequiredConfig = !!envConfig.SERVICE_URL && !!envConfig.PERSONAL_API_KEY && !!envConfig.PERSONAL_UID;
+    const serviceUrl = configServiceUrl ?? envConfig.SERVICE_URL;
+    const apiKey = configApiKey ?? envConfig.PERSONAL_API_KEY;
+    const uid = configUid ?? envConfig.PERSONAL_UID;
+    if (!serviceUrl || !apiKey || !uid) {
+        console.warn(`${PLUGIN_LOG_PREFIX} Missing required configuration. serviceUrl: "${serviceUrl}", apiKey: "${apiKey ? '(set)' : '(missing)'} ", uid: "${uid ? '(set)' : '(missing)'}"`);
+        return null;
+    }
+    const traceId = crypto.randomUUID();
+    const apiUrl = `${serviceUrl}/celia-claw/v1/rest-api/skill/execute`;
+    const headers = {
+        "Content-Type": "application/json",
+        "x-skill-id": SKILL_ID,
+        "x-hag-trace-id": traceId,
+        "x-uid": uid,
+        "x-api-key": apiKey,
+        "x-request-from": "openclaw",
+    };
+    const payload = { query };
+    try {
+        const response = await fetch(apiUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok) {
+            console.warn(`${PLUGIN_LOG_PREFIX} HTTP error: ${response.status} ${response.statusText}`);
+            return null;
+        }
+        console.log(`${PLUGIN_LOG_PREFIX} Received response, status: ${response.status}`);
+        const responseData = await response.json();
+        if (responseData.errorCode === "0" &&
+            responseData.content &&
+            responseData.content.skills) {
+            const rawSkills = responseData.content.skills;
+            const installedSkills = getInstalledSkills();
+            const formattedData = formatSkillData(rawSkills, installedSkills);
+            const topTools = formattedData.slice(0, 2);
+            const allInstalled = topTools.every((tool) => tool.status === "已安装");
+            if (allInstalled) {
+                console.log(`${PLUGIN_LOG_PREFIX} [DEBUG] All top 2 skills are installed, returning null`);
+                return null;
+            }
+            let filteredTools = topTools.filter((tool) => tool.status === "未安装");
+            console.log(`${PLUGIN_LOG_PREFIX} [DEBUG] After filtering uninstalled: ${filteredTools.length}, ids: ${filteredTools.map((t) => t.skillId).join(", ")}`);
+            return {
+                tools: filteredTools,
+                query,
+                timestamp: Date.now(),
+            };
+        }
+        console.warn(`${PLUGIN_LOG_PREFIX} Invalid response format: ${JSON.stringify(responseData).slice(0, 200)}`);
+        return null;
+    }
+    catch (error) {
+        const errorName = error instanceof Error ? error.name : "Unknown";
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorCause = error instanceof Error && error.cause ? JSON.stringify(error.cause) : "N/A";
+        const errorStack = error instanceof Error ? error.stack?.split("\n").slice(0, 3).join(" | ") : "N/A";
+        console.warn(`${PLUGIN_LOG_PREFIX} [ERROR] Fetch failed - name: ${errorName}, message: ${errorMessage}, cause: ${errorCause}, stack: ${errorStack}`);
+        return null;
+    }
+}
+export function formatToolsForContext(result, includeInstallUrl = true) {
+    if (!result.tools || result.tools.length === 0) {
+        return "";
+    }
+    const toolDescriptions = [];
+    for (const tool of result.tools) {
+        let description = `### ${tool.skillName}\n`;
+        description += `name: ${tool.skillId}\n`;
+        description += `description: ${tool.skillDesc}\n`;
+        toolDescriptions.push(description);
+    }
+    return toolDescriptions.join("\n\n");
+}

package/dist/src/skill-retriever/types.d.ts

@@ -0,0 +1,34 @@
+export interface ToolRetrieverConfig {
+    enabled: boolean;
+    maxTools: number;
+    includeUninstalledOnly: boolean;
+    envFilePath: string;
+    serviceUrl?: string;
+    apiKey?: string;
+    uid?: string;
+    timeoutMs?: number;
+}
+export interface RawSkill {
+    skillId: string;
+    skillName: string;
+    skillDesc: string;
+    packUrl: string;
+}
+export interface FormattedSkill {
+    skillId: string;
+    skillName: string;
+    skillDesc: string;
+    downloadPath: string;
+    status: "已安装" | "未安装";
+}
+export interface ToolSearchResult {
+    tools: FormattedSkill[];
+    query: string;
+    timestamp: number;
+}
+export interface EnvConfig {
+    PERSONAL_API_KEY?: string;
+    PERSONAL_UID?: string;
+    SERVICE_URL?: string;
+    [key: string]: string | undefined;
+}

package/dist/src/skill-retriever/types.js

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

package/dist/src/tools/call-device-tool.js

@@ -20,6 +20,8 @@ import { saveMediaToGalleryTool } from "./save-media-to-gallery-tool.js";
 import { searchFileTool } from "./search-file-tool.js";
 import { uploadFileTool } from "./upload-file-tool.js";
 import { saveFileToPhoneTool } from "./save-file-to-phone-tool.js";
+import { sendEmailTool } from "./send-email-tool.js";
+import { searchEmailTool } from "./search-email-tool.js";
 import { sendStatusUpdate } from "../formatter.js";
 import { getCurrentSessionContext } from "./session-manager.js";
 import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
@@ -49,6 +51,8 @@ const deviceToolRegistry = new Map([
     [searchFileTool.name, searchFileTool],
     [uploadFileTool.name, uploadFileTool],
     [saveFileToPhoneTool.name, saveFileToPhoneTool],
+    [sendEmailTool.name, sendEmailTool],
+    [searchEmailTool.name, searchEmailTool],
 ]);
 /**
  * call_device_tool - 通用端工具调度器。

package/dist/src/tools/get-email-tool-schema.d.ts

@@ -0,0 +1,16 @@
+export declare const getEmailToolSchemaTool: {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: "object";
+        properties: {};
+        required: string[];
+    };
+    execute(_toolCallId: string, _params: any): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+};

package/dist/src/tools/get-email-tool-schema.js

@@ -0,0 +1,9 @@
+import { createSchemaTool } from "./schema-tool-factory.js";
+import { sendEmailTool } from "./send-email-tool.js";
+import { searchEmailTool } from "./search-email-tool.js";
+export const getEmailToolSchemaTool = createSchemaTool({
+    name: "get_email_tool_schema",
+    label: "Get Email Tool Schema",
+    description: "获取可在用户设备上发送邮件、检索邮件的相关端工具列表。",
+    tools: [sendEmailTool, searchEmailTool],
+});

package/dist/src/tools/login-token-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * get_login_token 工具
+ * 当 skill 依赖用户获取鉴权信息时，此工具协助用户快速获取鉴权信息。
+ */
+export declare const loginTokenTool: any;

package/dist/src/tools/login-token-tool.js

@@ -0,0 +1,136 @@
+// Login Token tool - 自动获取用户授权信息
+import { v4 as uuidv4 } from "uuid";
+import { getXYWebSocketManager } from "../client.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
+import { readFileSync, existsSync } from "fs";
+import { logger } from "../utils/logger.js";
+const TOKEN_FILE_PATH = "/home/sandbox/.openclaw/.xiaoyitoken.json";
+const POLL_INTERVAL_MS = 5000; // 5 seconds
+const TIMEOUT_MS = 60000; // 1 minute
+const TOKEN_VALIDITY_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * get_login_token 工具
+ * 当 skill 依赖用户获取鉴权信息时，此工具协助用户快速获取鉴权信息。
+ */
+export const loginTokenTool = {
+    name: "get_login_token",
+    label: "Get Login Token",
+    description: "获取用户授权信息。当skill需要用户鉴权时调用此工具，工具会向用户端发送授权请求，等待用户完成授权后返回结果。请勿重复调用此工具。",
+    parameters: {
+        type: "object",
+        properties: {
+            clientId: {
+                type: "string",
+                description: "账号服务唯一标识，在执行具体skill过程中会提供",
+            },
+            skillName: {
+                type: "string",
+                description: "具体skill的名称",
+            },
+        },
+        required: ["clientId", "skillName"],
+    },
+    async execute(toolCallId, params) {
+        const { clientId, skillName } = params;
+        if (!clientId || typeof clientId !== "string" || clientId.trim() === "") {
+            throw new Error("Missing required parameter: clientId must be a non-empty string");
+        }
+        if (!skillName || typeof skillName !== "string" || skillName.trim() === "") {
+            throw new Error("Missing required parameter: skillName must be a non-empty string");
+        }
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. Login token tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+        const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
+        // (1) Build and send getLoginToken artifact
+        const artifactId = uuidv4();
+        const artifact = {
+            taskId: currentTaskId,
+            kind: "artifact-update",
+            append: false,
+            lastChunk: true,
+            final: false,
+            artifact: {
+                artifactId,
+                parts: [
+                    {
+                        kind: "getLoginToken",
+                        clientId: clientId.trim(),
+                        skillName: skillName.trim(),
+                    },
+                ],
+            },
+        };
+        const jsonRpcResponse = {
+            jsonrpc: "2.0",
+            id: currentMessageId,
+            result: artifact,
+        };
+        const wsManager = getXYWebSocketManager(config);
+        const outboundMessage = {
+            msgType: "agent_response",
+            agentId: config.agentId,
+            sessionId,
+            taskId: currentTaskId,
+            msgDetail: JSON.stringify(jsonRpcResponse),
+        };
+        logger.log(`[LOGIN_TOKEN] Sending getLoginToken artifact for clientId=${clientId}, skillName=${skillName}`);
+        await wsManager.sendMessage(sessionId, outboundMessage);
+        logger.log(`[LOGIN_TOKEN] Artifact sent successfully`);
+        // (2) Poll .xiaoyitoken.json every 5 seconds
+        const startTime = Date.now();
+        return new Promise((resolve) => {
+            const poll = () => {
+                const elapsed = Date.now() - startTime;
+                if (elapsed >= TIMEOUT_MS) {
+                    // (4) Timeout after 1 minute
+                    logger.log(`[LOGIN_TOKEN] Timeout: failed to get login token for clientId=${clientId}`);
+                    resolve({
+                        content: [
+                            {
+                                type: "text",
+                                text: "获取用户授权失败",
+                            },
+                        ],
+                    });
+                    return;
+                }
+                try {
+                    if (existsSync(TOKEN_FILE_PATH)) {
+                        const content = readFileSync(TOKEN_FILE_PATH, "utf-8");
+                        const tokens = JSON.parse(content);
+                        const match = tokens.find((t) => t.clientId === clientId.trim());
+                        if (match) {
+                            const tokenTime = Number(match.timestamp);
+                            const diff = Date.now() - tokenTime;
+                            if (diff <= TOKEN_VALIDITY_MS) {
+                                // (3) Found valid token
+                                logger.log(`[LOGIN_TOKEN] Successfully got login token for clientId=${clientId}`);
+                                resolve({
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: "获取用户授权成功",
+                                        },
+                                    ],
+                                });
+                                return;
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    logger.log(`[LOGIN_TOKEN] Error reading token file: ${err}`);
+                }
+                // Not found or not valid, poll again after 5 seconds
+                setTimeout(poll, POLL_INTERVAL_MS);
+            };
+            // Start polling after 5 seconds
+            setTimeout(poll, POLL_INTERVAL_MS);
+        });
+    },
+};

package/dist/src/tools/query-app-message-tool.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 查询指定时间范围内的设备通知消息。
+ */
+export declare const queryAppMessageTool: any;

package/dist/src/tools/query-app-message-tool.js

@@ -0,0 +1,138 @@
+// QueryAppMessage tool implementation
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+class ToolInputError extends Error {
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = "ToolInputError";
+    }
+}
+/**
+ * 查询指定时间范围内的设备通知消息。
+ */
+export const queryAppMessageTool = {
+    name: "query_app_message",
+    label: "Query App Message",
+    description: `获取指定时间范围内的设备通知消息。适用于需要查询历史通知、按应用筛选通知、或仅查看未读通知的场景。支持按时间范围、应用包名、已读/未读状态进行过滤。
+注意：
+a. 操作超时时间为60秒，请勿重复调用此工具
+b. 如果遇到各类调用失败场景，最多只能重试一次，不可以重复调用多次。
+c. 调用工具前需认真检查调用参数是否满足工具要求
+
+回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。`,
+    parameters: {
+        type: "object",
+        properties: {
+            startTime: {
+                type: "string",
+                description: "查询通知的起始时间（ISO 8601 字符串）。若endTime为空，则默认值为24小时前。",
+            },
+            endTime: {
+                type: "string",
+                description: "查询通知的结束时间（ISO 8601 字符串）。默认值为当前时间。",
+            },
+            packageName: {
+                type: "string",
+                description: "按应用名称过滤通知（例如「微信」「小红书」）。默认值为所有应用。",
+            },
+            state: {
+                type: "integer",
+                description: "通知的已读/未读状态。0 = 全部，1 = 仅未读。默认值为 0。",
+            },
+        },
+        required: [],
+    },
+    async execute(_toolCallId, params) {
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        const wsManager = getXYWebSocketManager(config);
+        const intentParam = {};
+        if (params.startTime !== undefined)
+            intentParam.startTime = params.startTime;
+        if (params.endTime !== undefined)
+            intentParam.endTime = params.endTime;
+        if (params.packageName !== undefined)
+            intentParam.packageName = params.packageName;
+        if (params.state !== undefined) {
+            if (params.state !== 0 && params.state !== 1) {
+                throw new ToolInputError("state 参数只能为 0（全部）或 1（仅未读）");
+            }
+            intentParam.state = params.state;
+        }
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "QueryAppMessage",
+                    bundleName: "com.huawei.hmos.vassistant",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam,
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                wsManager.off("data-event", handler);
+                reject(new Error("查询通知消息超时（60秒）"));
+            }, 60000);
+            const handler = (event) => {
+                if (event.intentName === "QueryAppMessage") {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(event.outputs),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        reject(new Error(`查询通知消息失败: ${event.status}`));
+                    }
+                }
+            };
+            wsManager.on("data-event", handler);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => { })
+                .catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/query-memory-data-tool.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 查询存储在设备本地的结构化记忆数据。
+ */
+export declare const queryMemoryDataTool: any;