@ynhcj/xiaoyi-channel 0.0.38-beta → 0.0.40-beta

package/dist/src/tools/view-push-result-tool.js

@@ -0,0 +1,118 @@
+import { searchPushData, getAllPushData } from "../utils/pushdata-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * 查看推送任务执行结果工具
+ * 支持关键词搜索或查看最近的推送记录
+ */
+export const viewPushResultTool = {
+    name: "view_push_result",
+    label: "View Push Task Result",
+    description: `查看定时任务或推送消息的执行结果。当用户说"查看我xxx的定时任务执行结果"、"查看我的xxxx的推送消息"或类似语料时调用此工具。
+
+功能说明：
+- 支持关键词搜索：如果用户提到具体任务名称或内容，可以按关键词筛选
+- 无关键词时：返回最近的推送记录（默认10条）
+- 返回内容包括：推送ID、时间、内容摘要
+
+使用场景：
+- "查看我昨天的定时任务执行结果"
+- "帮我看看天气推送消息"
+- "查看最近的推送记录"
+- "我的提醒任务执行了吗"`,
+    parameters: {
+        type: "object",
+        properties: {
+            keywords: {
+                type: "string",
+                description: "可选的搜索关键词，用于筛选推送记录。如果用户提到具体任务名称或内容，将其作为关键词传入。例如：'天气'、'提醒'、'会议'等。",
+            },
+            limit: {
+                type: "number",
+                description: "返回的最大记录数，默认10条，最多50条",
+                default: 10,
+            },
+        },
+        required: [],
+    },
+    async execute(toolCallId, params) {
+        logger.log(`[VIEW_PUSH_RESULT_TOOL] 🚀 Starting execution`);
+        logger.log(`[VIEW_PUSH_RESULT_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[VIEW_PUSH_RESULT_TOOL]   - params:`, JSON.stringify(params));
+        const keywords = params.keywords?.trim();
+        const limit = Math.min(params.limit || 10, 50); // 限制最多50条
+        try {
+            logger.log(`[VIEW_PUSH_RESULT_TOOL] 🔍 Searching push data...`);
+            logger.log(`[VIEW_PUSH_RESULT_TOOL]   - keywords: ${keywords || '(none)'}`);
+            logger.log(`[VIEW_PUSH_RESULT_TOOL]   - limit: ${limit}`);
+            // 根据是否有关键词决定调用哪个方法
+            let results = keywords
+                ? await searchPushData(keywords)
+                : await getAllPushData();
+            logger.log(`[VIEW_PUSH_RESULT_TOOL] Found ${results.length} items before limit`);
+            // 按时间倒序排序（最新的在前）
+            results.sort((a, b) => b.time.localeCompare(a.time));
+            // 限制返回条数
+            results = results.slice(0, limit);
+            if (results.length === 0) {
+                logger.log(`[VIEW_PUSH_RESULT_TOOL] ⚠️ No results found`);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                count: 0,
+                                items: [],
+                                message: keywords
+                                    ? `未找到包含关键词"${keywords}"的推送记录`
+                                    : "暂无推送记录",
+                            }),
+                        },
+                    ],
+                };
+            }
+            // 格式化返回结果
+            const formattedItems = results.map((item) => ({
+                pushDataId: item.pushDataId.substring(0, 8), // 只显示前8位
+                fullPushDataId: item.pushDataId, // 完整ID用于追溯
+                time: item.time,
+                dataDetail: item.dataDetail.length > 200
+                    ? item.dataDetail.substring(0, 200) + "..."
+                    : item.dataDetail,
+                fullLength: item.dataDetail.length,
+            }));
+            logger.log(`[VIEW_PUSH_RESULT_TOOL] ✅ Returning ${formattedItems.length} items`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            count: formattedItems.length,
+                            totalMatched: results.length,
+                            items: formattedItems,
+                            message: keywords
+                                ? `找到 ${formattedItems.length} 条包含"${keywords}"的推送记录`
+                                : `返回最近 ${formattedItems.length} 条推送记录`,
+                        }),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error(`[VIEW_PUSH_RESULT_TOOL] ❌ Failed to execute:`, error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error),
+                            message: "查询推送记录失败",
+                        }),
+                    },
+                ],
+            };
+        }
+    },
+};

package/dist/src/tools/xiaoyi-collection-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XY collection tool - retrieves user's collection data from XiaoYi.
+ * Returns personalized knowledge data saved in user's collection.
+ */
+export declare const xiaoyiCollectionTool: any;

package/dist/src/tools/xiaoyi-collection-tool.js

@@ -0,0 +1,190 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY collection tool - retrieves user's collection data from XiaoYi.
+ * Returns personalized knowledge data saved in user's collection.
+ */
+export const xiaoyiCollectionTool = {
+    name: "xiaoyi_collection",
+    label: "XiaoYi Collection",
+    description: "检索用户在小艺收藏中记下来的公共知识数据，可以给用户提供个性化体验。当用户语料中涉及从我的小艺收藏或者查看我的收藏或者我xx时候收藏的xxx帮我看一下这种类型的语料的时候需要使用此工具。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    parameters: {
+        type: "object",
+        properties: {
+            queryAll: {
+                type: "string",
+                description: "描述是否需要查询用户所有收藏数据，默认为true",
+                default: "true",
+            },
+        },
+        required: [],
+    },
+    async execute(toolCallId, params) {
+        logger.log(`[XIAOYI_COLLECTION_TOOL] 🚀 Starting execution`);
+        logger.log(`[XIAOYI_COLLECTION_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[XIAOYI_COLLECTION_TOOL]   - params:`, JSON.stringify(params));
+        logger.log(`[XIAOYI_COLLECTION_TOOL]   - timestamp: ${new Date().toISOString()}`);
+        // Get session context
+        logger.log(`[XIAOYI_COLLECTION_TOOL] 🔍 Attempting to get session context...`);
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            logger.error(`[XIAOYI_COLLECTION_TOOL] ❌ FAILED: No active session found!`);
+            logger.error(`[XIAOYI_COLLECTION_TOOL]   - toolCallId: ${toolCallId}`);
+            throw new Error("No active XY session found. XiaoYi collection tool can only be used during an active conversation.");
+        }
+        logger.log(`[XIAOYI_COLLECTION_TOOL] ✅ Session context found`);
+        logger.log(`[XIAOYI_COLLECTION_TOOL]   - sessionId: ${sessionContext.sessionId}`);
+        logger.log(`[XIAOYI_COLLECTION_TOOL]   - taskId: ${sessionContext.taskId}`);
+        logger.log(`[XIAOYI_COLLECTION_TOOL]   - messageId: ${sessionContext.messageId}`);
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        logger.log(`[XIAOYI_COLLECTION_TOOL] 🔌 Getting WebSocket manager...`);
+        const wsManager = getXYWebSocketManager(config);
+        logger.log(`[XIAOYI_COLLECTION_TOOL] ✅ WebSocket manager obtained`);
+        // Build QueryCollection command
+        logger.log(`[XIAOYI_COLLECTION_TOOL] 📦 Building QueryCollection command...`);
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "QueryCollection",
+                    bundleName: "com.huawei.hmos.vassistant",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam: {
+                        queryAll: params.queryAll || "true",
+                    },
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        // Send command and wait for response (60 second timeout)
+        logger.log(`[XIAOYI_COLLECTION_TOOL] ⏳ Setting up promise to wait for collection query response...`);
+        logger.log(`[XIAOYI_COLLECTION_TOOL]   - Timeout: 60 seconds`);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                logger.error(`[XIAOYI_COLLECTION_TOOL] ⏰ Timeout: No response received within 60 seconds`);
+                wsManager.off("data-event", handler);
+                reject(new Error("查询小艺收藏超时（60秒）"));
+            }, 60000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                logger.log(`[XIAOYI_COLLECTION_TOOL] 📨 Received data event:`, JSON.stringify(event));
+                if (event.intentName === "QueryCollection") {
+                    logger.log(`[XIAOYI_COLLECTION_TOOL] 🎯 QueryCollection event received`);
+                    logger.log(`[XIAOYI_COLLECTION_TOOL]   - status: ${event.status}`);
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        logger.log(`[XIAOYI_COLLECTION_TOOL] ✅ Collection query completed successfully`);
+                        logger.log(`[XIAOYI_COLLECTION_TOOL]   - outputs:`, JSON.stringify(event.outputs));
+                        // Check for error code first
+                        if (event.outputs.code && event.outputs.code !== 0) {
+                            logger.error(`[XIAOYI_COLLECTION_TOOL] ❌ Query failed with error code: ${event.outputs.code}`);
+                            reject(new Error(`查询小艺收藏失败 (错误码: ${event.outputs.code})`));
+                            return;
+                        }
+                        // Get the result from outputs
+                        const result = event.outputs.result;
+                        // Check if result exists
+                        if (!result) {
+                            logger.warn(`[XIAOYI_COLLECTION_TOOL] ⚠️ No collection data found`);
+                            resolve({
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: JSON.stringify({
+                                            success: true,
+                                            memoryInfo: [],
+                                            message: "未找到收藏数据"
+                                        }),
+                                    },
+                                ],
+                            });
+                            return;
+                        }
+                        // Extract memoryInfo from the nested result structure
+                        const memoryInfo = result.result?.memoryInfo || [];
+                        logger.log(`[XIAOYI_COLLECTION_TOOL] 📊 Collections found: ${memoryInfo.length} items`);
+                        // Process and simplify the collection data
+                        const simplifiedCollections = memoryInfo.map((item) => ({
+                            uuid: item.uuid,
+                            type: item.type,
+                            status: item.status,
+                            collectionTime: item.collectionTime,
+                            editTime: item.editTime,
+                            title: item.linkTitle || item.aiTitle || item.textTitle || item.imageTitle || item.podcastTitle || "",
+                            description: item.description || item.abstract || "",
+                            content: item.textContent || "",
+                            linkUrl: item.linkUrl,
+                            linkType: item.linkType,
+                            appName: item.appNameFromPab || item.appName || "",
+                            labels: item.label || [],
+                            collectionMethod: item.collectionMethod,
+                        }));
+                        // Return the result with valid string content
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        success: true,
+                                        totalResults: simplifiedCollections.length,
+                                        collections: simplifiedCollections,
+                                        message: result.message,
+                                    }),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        logger.error(`[XIAOYI_COLLECTION_TOOL] ❌ Collection query failed`);
+                        logger.error(`[XIAOYI_COLLECTION_TOOL]   - status: ${event.status}`);
+                        reject(new Error(`查询小艺收藏失败: ${event.status}`));
+                    }
+                }
+            };
+            // Register event handler
+            logger.log(`[XIAOYI_COLLECTION_TOOL] 📡 Registering data-event handler on WebSocket manager`);
+            wsManager.on("data-event", handler);
+            // Send the command
+            logger.log(`[XIAOYI_COLLECTION_TOOL] 📤 Sending QueryCollection command...`);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => {
+                logger.log(`[XIAOYI_COLLECTION_TOOL] ✅ Command sent successfully, waiting for response...`);
+            })
+                .catch((error) => {
+                logger.error(`[XIAOYI_COLLECTION_TOOL] ❌ Failed to send command:`, error);
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/trigger-handler.d.ts

@@ -0,0 +1,19 @@
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+/**
+ * Trigger 事件上下文
+ */
+export interface TriggerEventContext {
+    event: any;
+    sessionId: string;
+    taskId: string;
+}
+/**
+ * 处理 Trigger 事件
+ * 当用户在手机侧点击推送消息时触发
+ *
+ * @param context - Trigger 事件上下文（包含 event, sessionId, taskId）
+ * @param cfg - OpenClaw 配置
+ * @param runtime - 运行时环境
+ * @param accountId - 账号ID
+ */
+export declare function handleTriggerEvent(context: TriggerEventContext, cfg: ClawdbotConfig, runtime: RuntimeEnv, accountId: string): Promise<void>;

package/dist/src/trigger-handler.js

@@ -0,0 +1,91 @@
+// Trigger 事件处理器
+import { randomUUID } from "crypto";
+import { getPushDataById } from "./utils/pushdata-manager.js";
+import { handleXYMessage } from "./bot.js";
+/**
+ * 处理 Trigger 事件
+ * 当用户在手机侧点击推送消息时触发
+ *
+ * @param context - Trigger 事件上下文（包含 event, sessionId, taskId）
+ * @param cfg - OpenClaw 配置
+ * @param runtime - 运行时环境
+ * @param accountId - 账号ID
+ */
+export async function handleTriggerEvent(context, cfg, runtime, accountId) {
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    try {
+        const { event, sessionId, taskId } = context;
+        log(`[TRIGGER_HANDLER] 📌 Received Trigger event`);
+        log(`[TRIGGER_HANDLER] Event:`, JSON.stringify(event, null, 2));
+        log(`[TRIGGER_HANDLER] Context - sessionId: ${sessionId}, taskId: ${taskId}`);
+        if (!sessionId) {
+            error(`[TRIGGER_HANDLER] ❌ Missing sessionId in context`);
+            return;
+        }
+        if (!taskId) {
+            error(`[TRIGGER_HANDLER] ❌ Missing taskId in context`);
+            return;
+        }
+        // 从 event.payload.dataMap 中提取 pushDataId
+        const pushDataId = event.payload?.dataMap?.pushDataId;
+        if (!pushDataId) {
+            error(`[TRIGGER_HANDLER] ❌ Missing pushDataId in Trigger event payload`);
+            return;
+        }
+        log(`[TRIGGER_HANDLER] 🔍 Looking up pushDataId: ${pushDataId}`);
+        // 根据 pushDataId 查询原始数据
+        const pushDataItem = await getPushDataById(pushDataId);
+        if (!pushDataItem) {
+            error(`[TRIGGER_HANDLER] ❌ pushData not found for ID: ${pushDataId}`);
+            return;
+        }
+        log(`[TRIGGER_HANDLER] ✅ Found pushData`);
+        log(`[TRIGGER_HANDLER]   - pushDataId: ${pushDataItem.pushDataId}`);
+        log(`[TRIGGER_HANDLER]   - time: ${pushDataItem.time}`);
+        log(`[TRIGGER_HANDLER]   - dataDetail length: ${pushDataItem.dataDetail.length} chars`);
+        // 拼接消息
+        const prefixMessage = "这是定时任务的执行结果，你检查一下是否依赖手机侧的工具执行，如果依赖则在本轮任务中完成手机侧任务执行，如果不依赖，则直接把完整的执行结果返回给用户";
+        const fullMessage = `${prefixMessage}\n\n${pushDataItem.dataDetail}`;
+        log(`[TRIGGER_HANDLER] 📝 Constructed message (length: ${fullMessage.length} chars)`);
+        // 构造 A2A 消息
+        // 使用从 WebSocket 传递过来的 sessionId 和 taskId（新的 taskId）
+        // 这样可以触发 steer 模式，覆盖之前正在执行的任务
+        const messageId = randomUUID();
+        const a2aMessage = {
+            jsonrpc: "2.0",
+            method: "sendMessage",
+            id: messageId,
+            params: {
+                id: taskId, // 使用新的 taskId（点击推送时生成）
+                sessionId: sessionId, // 使用原始会话 sessionId
+                agentLoginSessionId: "",
+                message: {
+                    role: "user",
+                    parts: [
+                        {
+                            kind: "text",
+                            text: fullMessage,
+                        },
+                    ],
+                },
+            },
+        };
+        log(`[TRIGGER_HANDLER] 🚀 Dispatching A2A message to bot handler`);
+        log(`[TRIGGER_HANDLER]   - sessionId: ${sessionId}`);
+        log(`[TRIGGER_HANDLER]   - taskId: ${taskId} (NEW - will trigger steer mode if configured)`);
+        log(`[TRIGGER_HANDLER]   - messageId: ${messageId}`);
+        // 透传给 openclaw 处理
+        // 如果配置了 steer 模式，且该 sessionId 有活跃任务，这个新的 taskId 会覆盖旧的
+        await handleXYMessage({
+            cfg,
+            runtime,
+            message: a2aMessage,
+            accountId,
+        });
+        log(`[TRIGGER_HANDLER] ✅ Trigger event handled successfully`);
+    }
+    catch (err) {
+        error(`[TRIGGER_HANDLER] ❌ Failed to handle Trigger event:`, err);
+    }
+}

package/dist/src/types.d.ts

@@ -1,7 +1,6 @@
 export interface XYChannelConfig {
     enabled: boolean;
-    wsUrl1: string;
-    wsUrl2: string;
+    wsUrl: string;
     apiKey: string;
     uid: string;
     agentId: string;
@@ -159,9 +158,3 @@ export interface FileUploadCompleteRequest {
 export interface FileUploadCompleteResponse {
     fileId: string;
 }
-export type ServerIdentifier = "server1" | "server2";
-export interface SessionBinding {
-    sessionId: string;
-    server: ServerIdentifier;
-    boundAt: number;
-}

package/dist/src/types.js

@@ -1,2 +1,6 @@
 // Type definitions for XY Channel - A2A protocol and configuration
 export {};
+// ============================================================================
+// Session Management
+// ============================================================================
+// ✅ Removed ServerIdentifier and SessionBinding - no longer needed with single connection

package/dist/src/utils/pushdata-manager.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 推送数据项
+ */
+export interface PushDataItem {
+    pushDataId: string;
+    dataDetail: string;
+    time: string;
+}
+/**
+ * 保存推送数据，返回 pushDataId
+ */
+export declare function savePushData(dataDetail: string): Promise<string>;
+/**
+ * 根据 pushDataId 获取推送数据
+ */
+export declare function getPushDataById(pushDataId: string): Promise<PushDataItem | null>;
+/**
+ * 搜索推送数据（支持关键词模糊匹配）
+ */
+export declare function searchPushData(keywords?: string): Promise<PushDataItem[]>;
+/**
+ * 获取所有推送数据
+ */
+export declare function getAllPushData(): Promise<PushDataItem[]>;
+/**
+ * 清空所有推送数据（用于测试或重置）
+ */
+export declare function clearAllPushData(): Promise<void>;

package/dist/src/utils/pushdata-manager.js

@@ -0,0 +1,171 @@
+// pushData 持久化管理器
+import { promises as fs } from "fs";
+import * as path from "path";
+import { randomUUID } from "crypto";
+import { logger } from "./logger.js";
+const PUSHDATA_FILE = "/home/snadbox/.openclaw/pushData.json";
+const MAX_PUSHDATA_ITEMS = 1000; // 最多保留 1000 条记录
+/**
+ * 格式化北京时间（UTC+8）
+ */
+function formatBeijingTime(date) {
+    // 转换为北京时间（UTC+8）
+    const beijingTime = new Date(date.getTime() + 8 * 60 * 60 * 1000);
+    const iso = beijingTime.toISOString(); // 2024-03-22T10:30:45.123Z
+    // 转换为 YYYYMMDD HHmmss 格式
+    return iso
+        .replace(/T/, ' ')
+        .replace(/\.\d+Z$/, '')
+        .replace(/-/g, '')
+        .replace(/:/g, '')
+        .substring(0, 15); // 取前15个字符：YYYYMMDD HHmmss
+}
+/**
+ * 确保目录存在
+ */
+async function ensureDirectoryExists(filePath) {
+    const dir = path.dirname(filePath);
+    try {
+        await fs.mkdir(dir, { recursive: true });
+    }
+    catch (error) {
+        logger.error(`[PushDataManager] Failed to create directory ${dir}:`, error);
+    }
+}
+/**
+ * 读取 pushData 列表
+ */
+async function readPushDataList() {
+    try {
+        await ensureDirectoryExists(PUSHDATA_FILE);
+        const content = await fs.readFile(PUSHDATA_FILE, "utf-8");
+        const list = JSON.parse(content);
+        if (!Array.isArray(list)) {
+            logger.warn(`[PushDataManager] pushData.json is not an array, returning empty array`);
+            return [];
+        }
+        return list;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            // 文件不存在，返回空数组
+            return [];
+        }
+        logger.error(`[PushDataManager] Failed to read pushData:`, error);
+        return [];
+    }
+}
+/**
+ * 写入 pushData 列表
+ */
+async function writePushDataList(list) {
+    try {
+        await ensureDirectoryExists(PUSHDATA_FILE);
+        // 限制数据条数，保留最近的 MAX_PUSHDATA_ITEMS 条
+        const limitedList = list.slice(-MAX_PUSHDATA_ITEMS);
+        await fs.writeFile(PUSHDATA_FILE, JSON.stringify(limitedList, null, 2), "utf-8");
+        if (list.length > MAX_PUSHDATA_ITEMS) {
+            logger.log(`[PushDataManager] Trimmed pushData list from ${list.length} to ${limitedList.length} items`);
+        }
+    }
+    catch (error) {
+        logger.error(`[PushDataManager] Failed to write pushData:`, error);
+        throw error;
+    }
+}
+/**
+ * 保存推送数据，返回 pushDataId
+ */
+export async function savePushData(dataDetail) {
+    const pushDataId = randomUUID();
+    const time = formatBeijingTime(new Date());
+    const item = {
+        pushDataId,
+        dataDetail,
+        time,
+    };
+    try {
+        const list = await readPushDataList();
+        list.push(item);
+        await writePushDataList(list);
+        logger.log(`[PushDataManager] ✅ Saved pushData`);
+        logger.log(`[PushDataManager]   - pushDataId: ${pushDataId}`);
+        logger.log(`[PushDataManager]   - time: ${time}`);
+        logger.log(`[PushDataManager]   - dataDetail length: ${dataDetail.length} chars`);
+        logger.log(`[PushDataManager]   - Total items: ${list.length}`);
+        return pushDataId;
+    }
+    catch (error) {
+        logger.error(`[PushDataManager] Failed to save pushData:`, error);
+        throw error;
+    }
+}
+/**
+ * 根据 pushDataId 获取推送数据
+ */
+export async function getPushDataById(pushDataId) {
+    try {
+        const list = await readPushDataList();
+        const item = list.find((item) => item.pushDataId === pushDataId);
+        if (item) {
+            logger.log(`[PushDataManager] Found pushData: ${pushDataId}`);
+        }
+        else {
+            logger.warn(`[PushDataManager] pushData not found: ${pushDataId}`);
+        }
+        return item || null;
+    }
+    catch (error) {
+        logger.error(`[PushDataManager] Failed to get pushData by id:`, error);
+        return null;
+    }
+}
+/**
+ * 搜索推送数据（支持关键词模糊匹配）
+ */
+export async function searchPushData(keywords) {
+    try {
+        const list = await readPushDataList();
+        if (!keywords || keywords.trim() === "") {
+            // 无关键词，返回所有数据
+            logger.log(`[PushDataManager] Search with no keywords, returning all ${list.length} items`);
+            return list;
+        }
+        // 关键词模糊匹配（在 dataDetail 和 pushDataId 中搜索）
+        const lowerKeywords = keywords.toLowerCase();
+        const results = list.filter((item) => item.dataDetail.toLowerCase().includes(lowerKeywords) ||
+            item.pushDataId.toLowerCase().includes(lowerKeywords));
+        logger.log(`[PushDataManager] Search with keywords "${keywords}": found ${results.length} items`);
+        return results;
+    }
+    catch (error) {
+        logger.error(`[PushDataManager] Failed to search pushData:`, error);
+        return [];
+    }
+}
+/**
+ * 获取所有推送数据
+ */
+export async function getAllPushData() {
+    try {
+        const list = await readPushDataList();
+        logger.log(`[PushDataManager] Retrieved ${list.length} pushData items`);
+        return list;
+    }
+    catch (error) {
+        logger.error(`[PushDataManager] Failed to get all pushData:`, error);
+        return [];
+    }
+}
+/**
+ * 清空所有推送数据（用于测试或重置）
+ */
+export async function clearAllPushData() {
+    try {
+        await writePushDataList([]);
+        logger.log(`[PushDataManager] Cleared all pushData`);
+    }
+    catch (error) {
+        logger.error(`[PushDataManager] Failed to clear pushData:`, error);
+    }
+}

package/dist/src/utils/pushid-manager.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 添加新的 pushId（去重）
+ */
+export declare function addPushId(pushId: string): Promise<void>;
+/**
+ * 获取所有 pushId
+ */
+export declare function getAllPushIds(): Promise<string[]>;
+/**
+ * 清空所有 pushId（用于测试或重置）
+ */
+export declare function clearAllPushIds(): Promise<void>;