@ynhcj/xiaoyi-channel 0.0.103-beta → 0.0.105-beta

package/dist/index.js

@@ -8,8 +8,8 @@ import { extractResultText, processText, parseSecurityResult, validateAndTruncat
 import { selfEvolutionManager } from "./src/utils/self-evolution-manager.js";
 import { TOOL_CALL_NUDGE_THRESHOLD, toolCallNudgeManager, } from "./src/utils/tool-call-nudge-manager.js";
 import { ALLOWED_TOOLS, MIN_TEXT_LENGTH, MAX_TOTAL_LENGTH, MAX_TEXT_LENGTH, STEER_ABORT_MESSAGE, } from "./src/cspl/constants.js";
-const SELF_EVOLUTION_NUDGE_MESSAGE = "[系统消息，非用户发言，不需要告知用户] 当前任务已经调用了较多工具。如果你识别到其中存在稳定、可复用的踩坑经验或排错模式，可以在完成当前主要任务后，正式回复用户前，阅读xiaoyi-self-evolution技能了解自进化规则。注意，不要打断当前主任务，已完成任务为最高优先级。";
-const SELF_EVOLUTION_KEYWORD_NUDGE_MESSAGE = "[系统消息，非用户发言，不需要告知用户] 当前用户请求中可能包含希望沉淀经验、避免重复踩坑的意图。如果你已经从当前问题中识别出稳定、可复用的处理规则或排错经验，可以在完成当前主要任务后，正式回复用户前，阅读xiaoyi-self-evolution技能了解自进化规则。注意，不要打断当前主任务，已完成任务为最高优先级。";
+const SELF_EVOLUTION_NUDGE_MESSAGE = "[系统消息，非用户发言，无需主动告知用户] 当前任务已经调用了较多工具。如果你识别到其中存在稳定、可复用的踩坑经验或排错模式，可以在完成当前主要任务后，正式回复用户前，阅读xiaoyi-self-evolution技能了解自进化规则。注意，不要打断当前主任务，以完成任务为最高优先级。";
+const SELF_EVOLUTION_KEYWORD_NUDGE_MESSAGE = "[系统消息，非用户发言，无需主动告知用户] 当前用户请求中可能包含希望沉淀经验、避免重复踩坑的意图。如果你已经从当前问题中识别出稳定、可复用的处理规则或排错经验，可以在完成当前主要任务后，正式回复用户前，阅读xiaoyi-self-evolution技能了解自进化规则。注意，不要打断当前主任务，以完成任务为最高优先级。";
 const SELF_EVOLUTION_KEYWORD_PATTERNS = [
     /进化/u,
     /记住/u,

package/dist/src/self-evolution-handler.js

@@ -1,5 +1,5 @@
 import { readFileSync, writeFileSync } from "fs";
-const XIAOYIENV_PATH = "/home/sandbox/.openclaw/.xiaoyienv";
+const XIAOYIRUNTIME_PATH = "/home/sandbox/.openclaw/.xiaoyiruntime";
 export function handleSelfEvolutionEvent(context, runtime) {
     const log = runtime?.log ?? console.log;
     const error = runtime?.error ?? console.error;
@@ -12,12 +12,12 @@ export function handleSelfEvolutionEvent(context, runtime) {
         log(`[SELF_EVOLUTION] received state: ${state}`);
         let content;
         try {
-            content = readFileSync(XIAOYIENV_PATH, "utf-8");
+            content = readFileSync(XIAOYIRUNTIME_PATH, "utf-8");
         }
         catch {
             // File doesn't exist yet — create it
-            log(`[SELF_EVOLUTION] ${XIAOYIENV_PATH} not found, creating new file`);
-            writeFileSync(XIAOYIENV_PATH, `selfEvolutionState=${state}\n`, "utf-8");
+            log(`[SELF_EVOLUTION] ${XIAOYIRUNTIME_PATH} not found, creating new file`);
+            writeFileSync(XIAOYIRUNTIME_PATH, `selfEvolutionState=${state}\n`, "utf-8");
             log(`[SELF_EVOLUTION] wrote selfEvolutionState=${state}`);
             return;
         }
@@ -34,12 +34,12 @@ export function handleSelfEvolutionEvent(context, runtime) {
         if (!found) {
             // Ensure trailing newline before appending
             const trimmed = content.trimEnd();
-            writeFileSync(XIAOYIENV_PATH, `${trimmed}\n${key}=${state}\n`, "utf-8");
+            writeFileSync(XIAOYIRUNTIME_PATH, `${trimmed}\n${key}=${state}\n`, "utf-8");
         }
         else {
-            writeFileSync(XIAOYIENV_PATH, updated.join("\n"), "utf-8");
+            writeFileSync(XIAOYIRUNTIME_PATH, updated.join("\n"), "utf-8");
         }
-        log(`[SELF_EVOLUTION] updated selfEvolutionState=${state} in ${XIAOYIENV_PATH}`);
+        log(`[SELF_EVOLUTION] updated selfEvolutionState=${state} in ${XIAOYIRUNTIME_PATH}`);
     }
     catch (err) {
         error("[SELF_EVOLUTION] failed to handle event:", err);

package/dist/src/tools/save-self-evolution-skill-tool.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { getCurrentSessionContext } from "./session-manager.js";
 import { selfEvolutionManager } from "../utils/self-evolution-manager.js";
 const SELF_EVOLVED_SKILL_ROOT = "/home/sandbox/.openclaw/workspace/skills";
+const ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/u;
 function slugifyTitle(title) {
     return title
         .trim()
@@ -23,19 +24,141 @@ function normalizeStringArray(value) {
     }
     return [];
 }
-function containsSensitiveContent(text) {
-    const lower = text.toLowerCase();
-    const sensitivePatterns = [
-        /api[_ -]?key/u,
-        /access[_ -]?token/u,
-        /bearer\s+[a-z0-9._-]+/iu,
-        /password/u,
-        /secret/u,
-        /\/home\/sandbox\//u,
-        /\/tmp\//u,
-        /[a-z]:\\/iu,
+function normalizeWhitespace(text) {
+    return text.replace(/\s+/gu, " ").trim();
+}
+function normalizeForFingerprint(text) {
+    return normalizeWhitespace(text)
+        .toLowerCase()
+        .replace(/[`"'()[\]{}:;,.!?]/gu, "")
+        .replace(/\s+/gu, " ")
+        .trim();
+}
+function normalizeForComparison(items) {
+    return items
+        .map((item) => normalizeForFingerprint(item))
+        .filter(Boolean)
+        .sort();
+}
+function sanitizeLine(text) {
+    let value = text;
+    let changed = false;
+    const replacements = [
+        [/(bearer\s+)[a-z0-9._=-]{12,}/giu, "$1[REDACTED_TOKEN]"],
+        [/((?:api[_ -]?key|access[_ -]?token|refresh[_ -]?token|password|secret)\s*[:=]\s*)([^\s,;]+)/giu, "$1[REDACTED_SECRET]"],
+        [/(-----BEGIN [A-Z ]*PRIVATE KEY-----)[\s\S]*?(-----END [A-Z ]*PRIVATE KEY-----)/gu, "$1\n[REDACTED_PRIVATE_KEY]\n$2"],
+        [/\b(?:[a-zA-Z]:\\(?:[^\\\r\n]+\\)*[^\\\r\n\s]+|\/(?:home|Users|tmp|var|private|etc)\/[^\s"'`<>]+)/gu, "[REDACTED_PATH]"],
+        [/\b(sk-[a-zA-Z0-9]{16,}|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z\-_]{20,})\b/gu, "[REDACTED_SECRET]"],
+    ];
+    for (const [pattern, replacement] of replacements) {
+        const next = value.replace(pattern, replacement);
+        if (next !== value) {
+            value = next;
+            changed = true;
+        }
+    }
+    return { value, changed };
+}
+function sanitizeStringArray(values) {
+    let changed = false;
+    const sanitized = values.map((value) => {
+        const result = sanitizeLine(value);
+        changed = changed || result.changed;
+        return result.value;
+    });
+    return { values: sanitized, changed };
+}
+function sanitizeSkillContent(params) {
+    const titleResult = sanitizeLine(params.title);
+    const summaryResult = sanitizeLine(params.summary);
+    const whenToUseResult = sanitizeLine(params.whenToUse);
+    const supplementResult = sanitizeLine(params.supplement);
+    const rulesResult = sanitizeStringArray(params.rules);
+    const examplesResult = sanitizeStringArray(params.examples);
+    const tagsResult = sanitizeStringArray(params.tags);
+    return {
+        title: titleResult.value,
+        summary: summaryResult.value,
+        whenToUse: whenToUseResult.value,
+        supplement: supplementResult.value,
+        rules: rulesResult.values,
+        examples: examplesResult.values,
+        tags: tagsResult.values,
+        changed: titleResult.changed ||
+            summaryResult.changed ||
+            whenToUseResult.changed ||
+            supplementResult.changed ||
+            rulesResult.changed ||
+            examplesResult.changed ||
+            tagsResult.changed,
+    };
+}
+function containsHighlySensitiveContent(text) {
+    const highRiskPatterns = [
+        /-----BEGIN [A-Z ]*PRIVATE KEY-----/u,
+        /bearer\s+[a-z0-9._=-]{12,}/iu,
+        /\b(?:sk-[a-zA-Z0-9]{16,}|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z\-_]{20,})\b/u,
+        /(?:api[_ -]?key|access[_ -]?token|refresh[_ -]?token|password|secret)\s*[:=]\s*[^\s,;]{8,}/iu,
     ];
-    return sensitivePatterns.some((pattern) => pattern.test(lower));
+    return highRiskPatterns.some((pattern) => pattern.test(text));
+}
+function buildSkillFingerprint(params) {
+    const normalized = {
+        title: normalizeForFingerprint(params.title),
+        summary: normalizeForFingerprint(params.summary),
+        whenToUse: normalizeForFingerprint(params.whenToUse),
+        supplement: normalizeForFingerprint(params.supplement),
+        rules: normalizeForComparison(params.rules),
+        examples: normalizeForComparison(params.examples),
+        tags: normalizeForComparison(params.tags),
+    };
+    return createHash("sha256").update(JSON.stringify(normalized)).digest("hex");
+}
+function parseFrontmatterValue(content, key) {
+    const match = content.match(new RegExp(`^${key}:\\s*"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"`, "m"));
+    if (match) {
+        return match[1].replace(/\\"/g, '"').replace(/\\n/g, "\n");
+    }
+    return null;
+}
+function parseTimestampFromExistingSkill(content, key) {
+    const value = parseFrontmatterValue(content, key);
+    if (!value) {
+        return null;
+    }
+    return ISO_DATE_PATTERN.test(value) ? value : null;
+}
+async function findDuplicateSkillByFingerprint(targetFingerprint) {
+    try {
+        const entries = await fs.readdir(SELF_EVOLVED_SKILL_ROOT, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || !entry.name.startsWith("evolving-")) {
+                continue;
+            }
+            const skillFilePath = path.join(SELF_EVOLVED_SKILL_ROOT, entry.name, "SKILL.md");
+            try {
+                const existingContent = await fs.readFile(skillFilePath, "utf-8");
+                const fingerprint = parseFrontmatterValue(existingContent, "fingerprint");
+                if (fingerprint && fingerprint === targetFingerprint) {
+                    return {
+                        path: skillFilePath,
+                        slug: entry.name.replace(/^evolving-/u, ""),
+                    };
+                }
+            }
+            catch (error) {
+                if (error?.code !== "ENOENT") {
+                    throw error;
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (error?.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    return null;
 }
 function buildSkillMarkdown(params) {
     const description = `${params.summary}\n\nWhen to use: ${params.whenToUse}`
@@ -45,12 +168,17 @@ function buildSkillMarkdown(params) {
         "---",
         `name: "${params.title.replace(/"/g, '\\"')}"`,
         `description: "${description}"`,
-        "---",
-        "",
-        `# ${params.title}`,
-        "",
-        "## Rules",
+        `fingerprint: "${params.fingerprint}"`,
+        `created_at: "${params.createdAt}"`,
     ];
+    if (params.updatedAt) {
+        lines.push(`updated_at: "${params.updatedAt}"`);
+    }
+    lines.push("---", "", `# ${params.title}`, "", "## Metadata", `- Created At: ${params.createdAt}`);
+    if (params.updatedAt) {
+        lines.push(`- Updated At: ${params.updatedAt}`);
+    }
+    lines.push("", "## Rules");
     for (const rule of params.rules) {
         lines.push(`- ${rule}`);
     }
@@ -60,6 +188,9 @@ function buildSkillMarkdown(params) {
             lines.push(`- ${example}`);
         }
     }
+    if (params.supplement) {
+        lines.push("", "## Supplement", params.supplement);
+    }
     if (params.tags.length > 0) {
         lines.push("", "## Tags", params.tags.map((tag) => `- ${tag}`).join("\n"));
     }
@@ -75,7 +206,7 @@ export const saveSelfEvolutionSkillTool = {
         properties: {
             title: {
                 type: "string",
-                description: "所学技能的简短、可复用标题。",
+                description: "所学技能的简短标题。**必须为英文，可用下划线或中划线分割。**",
             },
             summary: {
                 type: "string",
@@ -83,7 +214,7 @@ export const saveSelfEvolutionSkillTool = {
             },
             when_to_use: {
                 type: "string",
-                description: "描述在未来任务中什么情况/哪些条件下使用此技能。",
+                description: "描述在未来任务中什么情况/哪些条件下使用此技能，描述尽量精准。",
             },
             rules: {
                 type: "array",
@@ -93,13 +224,17 @@ export const saveSelfEvolutionSkillTool = {
             examples: {
                 type: "array",
                 items: { type: "string" },
-                description: "陷阱示例以及正确模式示例，可选",
+                description: "陷阱示例或正确模式示例，可选",
             },
             tags: {
                 type: "array",
                 items: { type: "string" },
                 description: "用于未来发现的标签，可选。",
             },
+            supplement: {
+                type: "string",
+                description: "补充说明。将其他想补充但不属于固定字段的内容放在这里。可选。",
+            },
         },
         required: ["title", "summary", "when_to_use", "rules"],
     },
@@ -114,32 +249,114 @@ export const saveSelfEvolutionSkillTool = {
         const title = typeof params.title === "string" ? params.title.trim() : "";
         const summary = typeof params.summary === "string" ? params.summary.trim() : "";
         const whenToUse = typeof params.when_to_use === "string" ? params.when_to_use.trim() : "";
-        const rules = normalizeStringArray(params.rules);
-        const examples = normalizeStringArray(params.examples);
-        const tags = normalizeStringArray(params.tags);
-        if (!title || !summary || !whenToUse || rules.length === 0) {
+        const supplement = typeof params.supplement === "string" ? params.supplement.trim() : "";
+        const rawRules = normalizeStringArray(params.rules);
+        const rawExamples = normalizeStringArray(params.examples);
+        const rawTags = normalizeStringArray(params.tags);
+        if (!title || !summary || !whenToUse || rawRules.length === 0) {
             throw new Error("Missing required fields. title, summary, when_to_use, and at least one rule are required.");
         }
         if (title.length < 6 || summary.length < 10 || whenToUse.length < 10) {
             throw new Error("Skill content is too short. Provide a reusable title, summary, and usage guidance.");
         }
-        const combinedText = [title, summary, whenToUse, ...rules, ...examples, ...tags].join("\n");
-        if (containsSensitiveContent(combinedText)) {
+        const sanitized = sanitizeSkillContent({
+            title,
+            summary,
+            whenToUse,
+            supplement,
+            rules: rawRules,
+            examples: rawExamples,
+            tags: rawTags,
+        });
+        const combinedText = [
+            sanitized.title,
+            sanitized.summary,
+            sanitized.whenToUse,
+            sanitized.supplement,
+            ...sanitized.rules,
+            ...sanitized.examples,
+            ...sanitized.tags,
+        ].join("\n");
+        if (containsHighlySensitiveContent(combinedText)) {
             throw new Error("Skill content appears to contain sensitive or environment-specific data and was rejected.");
         }
-        const slug = slugifyTitle(title);
+        const slug = slugifyTitle(sanitized.title);
         if (!slug) {
             throw new Error("Title could not be normalized into a valid skill name.");
         }
         const skillDir = path.join(SELF_EVOLVED_SKILL_ROOT, `evolving-${slug}`);
         const skillFilePath = path.join(skillDir, "SKILL.md");
+        const fingerprint = buildSkillFingerprint({
+            title: sanitized.title,
+            summary: sanitized.summary,
+            whenToUse: sanitized.whenToUse,
+            supplement: sanitized.supplement,
+            rules: sanitized.rules,
+            examples: sanitized.examples,
+            tags: sanitized.tags,
+        });
+        const duplicateSkill = await findDuplicateSkillByFingerprint(fingerprint);
+        if (duplicateSkill && duplicateSkill.path !== skillFilePath) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            deduped: true,
+                            sanitized: sanitized.changed,
+                            skillName: duplicateSkill.slug,
+                            path: duplicateSkill.path,
+                            message: "A semantically identical self-evolved skill already exists.",
+                        }),
+                    },
+                ],
+            };
+        }
+        const nowIso = new Date().toISOString();
+        let createdAt = nowIso;
+        let updatedAt;
+        try {
+            const existingContent = await fs.readFile(skillFilePath, "utf-8");
+            const existingFingerprint = parseFrontmatterValue(existingContent, "fingerprint");
+            const existingCreatedAt = parseTimestampFromExistingSkill(existingContent, "created_at");
+            createdAt = existingCreatedAt ?? nowIso;
+            if (existingFingerprint === fingerprint) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                deduped: true,
+                                sanitized: sanitized.changed,
+                                skillName: slug,
+                                path: skillFilePath,
+                                createdAt,
+                                message: "An identical self-evolved skill already exists.",
+                            }),
+                        },
+                    ],
+                };
+            }
+            updatedAt = nowIso;
+        }
+        catch (error) {
+            if (error?.code !== "ENOENT") {
+                throw error;
+            }
+        }
         const nextContent = buildSkillMarkdown({
-            title,
-            summary,
-            whenToUse,
-            rules,
-            examples,
-            tags,
+            title: sanitized.title,
+            summary: sanitized.summary,
+            whenToUse: sanitized.whenToUse,
+            supplement: sanitized.supplement,
+            rules: sanitized.rules,
+            examples: sanitized.examples,
+            tags: sanitized.tags,
+            fingerprint,
+            createdAt,
+            updatedAt,
         });
         const nextHash = createHash("sha256").update(nextContent).digest("hex");
         await fs.mkdir(skillDir, { recursive: true });
@@ -154,15 +371,16 @@ export const saveSelfEvolutionSkillTool = {
                             text: JSON.stringify({
                                 success: true,
                                 deduped: true,
+                                sanitized: sanitized.changed,
                                 skillName: slug,
                                 path: skillFilePath,
+                                createdAt,
                                 message: "An identical self-evolved skill already exists.",
                             }),
                         },
                     ],
                 };
             }
-            throw new Error(`A different skill with the same title already exists: ${skillFilePath}`);
         }
         catch (error) {
             if (error?.code !== "ENOENT") {
@@ -177,10 +395,15 @@ export const saveSelfEvolutionSkillTool = {
                     text: JSON.stringify({
                         success: true,
                         deduped: false,
+                        sanitized: sanitized.changed,
                         skillName: slug,
                         path: skillFilePath,
                         sessionId: sessionContext.sessionId,
-                        message: "Self-evolved skill saved successfully.",
+                        createdAt,
+                        updatedAt,
+                        message: updatedAt
+                            ? "Self-evolved skill updated successfully."
+                            : "Self-evolved skill saved successfully.",
                     }),
                 },
             ],

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

@@ -28,8 +28,30 @@ export async function saveRuntimeInfo(webSocketSessionId, conversationId, taskId
     }
     try {
         await ensureDirectoryExists(RUNTIME_FILE);
-        const content = `SESSION_ID=${webSocketSessionId}\nCONVERSATION_ID=${conversationId}\nTASK_ID=${taskId}\n`;
-        await fs.writeFile(RUNTIME_FILE, content, "utf-8");
+        const updates = {
+            SESSION_ID: webSocketSessionId,
+            CONVERSATION_ID: conversationId,
+            TASK_ID: taskId,
+        };
+        let lines = [];
+        try {
+            const content = await fs.readFile(RUNTIME_FILE, "utf-8");
+            lines = content.split("\n");
+        }
+        catch {
+            // File doesn't exist yet
+        }
+        for (const [key, value] of Object.entries(updates)) {
+            const index = lines.findIndex((line) => line.startsWith(`${key}=`));
+            if (index !== -1) {
+                lines[index] = `${key}=${value}`;
+            }
+            else {
+                lines.push(`${key}=${value}`);
+            }
+        }
+        const result = lines.filter((line) => line.trim() !== "").join("\n") + "\n";
+        await fs.writeFile(RUNTIME_FILE, result, "utf-8");
         logger.log(`[RuntimeManager] ✅ Saved runtime info to .xiaoyiruntime`);
         logger.log(`[RuntimeManager]   - SESSION_ID: ${webSocketSessionId}`);
         logger.log(`[RuntimeManager]   - CONVERSATION_ID: ${conversationId}`);

package/dist/src/utils/self-evolution-manager.js

@@ -1,5 +1,5 @@
 import fs from "node:fs/promises";
-const SELF_EVOLUTION_ENV_FILE = "/home/sandbox/.openclaw/.xiaoyienv";
+const SELF_EVOLUTION_ENV_FILE = "/home/sandbox/.openclaw/.xiaoyiruntime";
 const SELF_EVOLUTION_ENV_KEY = "selfEvolutionState";
 function parseBooleanLike(value) {
     const normalized = value.trim().toLowerCase();

package/dist/src/utils/tool-call-nudge-manager.d.ts

@@ -11,6 +11,6 @@ declare class ToolCallNudgeManager {
     tryMarkKeywordNudge(sessionKey: string): boolean;
     clearSession(sessionKey: string): void;
 }
-export declare const TOOL_CALL_NUDGE_THRESHOLD = 5;
+export declare const TOOL_CALL_NUDGE_THRESHOLD = 6;
 export declare const toolCallNudgeManager: ToolCallNudgeManager;
 export {};

package/dist/src/utils/tool-call-nudge-manager.js

@@ -1,4 +1,4 @@
-const DEFAULT_TOOL_CALL_NUDGE_THRESHOLD = 5;
+const DEFAULT_TOOL_CALL_NUDGE_THRESHOLD = 6;
 class ToolCallNudgeManager {
     threshold;
     sessions = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "0.0.103-beta",
+  "version": "0.0.105-beta",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",
@@ -16,7 +16,7 @@
     "openclaw.plugin.json"
   ],
   "scripts": {
-    "build": "tsc"
+    "build": "node ./node_modules/typescript/bin/tsc"
   },
   "keywords": [
     "openclaw",