@ynhcj/xiaoyi-channel 1.1.19 → 1.1.21

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

@@ -0,0 +1,412 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+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()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+}
+function normalizeStringArray(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => (typeof item === "string" ? item.trim() : ""))
+            .filter(Boolean);
+    }
+    if (typeof value === "string" && value.trim()) {
+        return [value.trim()];
+    }
+    return [];
+}
+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 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}`
+        .replace(/"/g, '\\"')
+        .replace(/\r?\n/g, "\\n");
+    const lines = [
+        "---",
+        `name: "${params.title.replace(/"/g, '\\"')}"`,
+        `description: "${description}"`,
+        `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}`);
+    }
+    if (params.examples.length > 0) {
+        lines.push("", "## Examples");
+        for (const example of params.examples) {
+            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"));
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+export const saveSelfEvolutionSkillTool = {
+    name: "save_self_evolution_skill",
+    label: "Save Self Evolution Skill",
+    description: "将可复用的经验/脚本/教训等保存为skill技能，供下次执行类似任务时参考。仅用于通用、可复用的场景。",
+    parameters: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "所学技能的简短标题。**必须为英文，可用下划线或中划线分割。**",
+            },
+            summary: {
+                type: "string",
+                description: "技能的概括性总结，不要太长。",
+            },
+            when_to_use: {
+                type: "string",
+                description: "描述在未来任务中什么情况/哪些条件下使用此技能，描述尽量精准。",
+            },
+            rules: {
+                type: "array",
+                items: { type: "string" },
+                description: "具体、可复用的规则或checklist。",
+            },
+            examples: {
+                type: "array",
+                items: { type: "string" },
+                description: "陷阱示例或正确模式示例，可选",
+            },
+            tags: {
+                type: "array",
+                items: { type: "string" },
+                description: "用于未来发现的标签，可选。",
+            },
+            supplement: {
+                type: "string",
+                description: "补充说明。将其他想补充但不属于固定字段的内容放在这里。可选。",
+            },
+        },
+        required: ["title", "summary", "when_to_use", "rules"],
+    },
+    async execute(_toolCallId, params) {
+        if (!(await selfEvolutionManager.isEnabled())) {
+            throw new Error("Self-evolution is currently disabled by the user.");
+        }
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. This tool can only run during an active conversation.");
+        }
+        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 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 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(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: 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 });
+        try {
+            const existingContent = await fs.readFile(skillFilePath, "utf-8");
+            const existingHash = createHash("sha256").update(existingContent).digest("hex");
+            if (existingHash === nextHash) {
+                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.",
+                            }),
+                        },
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            if (error?.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        await fs.writeFile(skillFilePath, nextContent, "utf-8");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        deduped: false,
+                        sanitized: sanitized.changed,
+                        skillName: slug,
+                        path: skillFilePath,
+                        sessionId: sessionContext.sessionId,
+                        createdAt,
+                        updatedAt,
+                        message: updatedAt
+                            ? "Self-evolved skill updated successfully."
+                            : "Self-evolved skill saved successfully.",
+                    }),
+                },
+            ],
+        };
+    },
+};

package/dist/src/tools/session-manager.js

@@ -2,6 +2,7 @@
 // Stores active session contexts that tools can access
 import { AsyncLocalStorage } from "async_hooks";
 import { configManager } from "../utils/config-manager.js";
+import { toolCallNudgeManager } from "../utils/tool-call-nudge-manager.js";
 import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
 // Map of sessionKey -> SessionContextWithRef
 const activeSessions = new Map();
@@ -40,6 +41,7 @@ export function unregisterSession(sessionKey) {
     if (existing.refCount <= 0) {
         activeSessions.delete(sessionKey);
         configManager.clearSession(existing.sessionId);
+        toolCallNudgeManager.clearSession(sessionKey);
     }
 }
 /**

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.d.ts

@@ -0,0 +1,5 @@
+declare class SelfEvolutionManager {
+    isEnabled(): Promise<boolean>;
+}
+export declare const selfEvolutionManager: SelfEvolutionManager;
+export {};

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

@@ -0,0 +1,47 @@
+import fs from "node:fs/promises";
+const SELF_EVOLUTION_ENV_FILE = "/home/sandbox/.openclaw/.xiaoyiruntime";
+const SELF_EVOLUTION_ENV_KEY = "selfEvolutionState";
+function parseBooleanLike(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true") {
+        return true;
+    }
+    if (normalized === "false") {
+        return false;
+    }
+    return null;
+}
+class SelfEvolutionManager {
+    async isEnabled() {
+        try {
+            const envData = await fs.readFile(SELF_EVOLUTION_ENV_FILE, "utf-8");
+            for (const line of envData.split(/\r?\n/u)) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith("#")) {
+                    continue;
+                }
+                const eqIndex = trimmed.indexOf("=");
+                if (eqIndex === -1) {
+                    continue;
+                }
+                const key = trimmed.slice(0, eqIndex).trim();
+                if (key !== SELF_EVOLUTION_ENV_KEY) {
+                    continue;
+                }
+                const value = trimmed.slice(eqIndex + 1).trim();
+                const parsed = parseBooleanLike(value);
+                if (parsed !== null) {
+                    return parsed;
+                }
+            }
+            return false;
+        }
+        catch (error) {
+            if (error?.code !== "ENOENT") {
+                console.error(`[SELF_EVOLUTION] Failed to read ${SELF_EVOLUTION_ENV_FILE}:`, error);
+            }
+            return false;
+        }
+    }
+}
+export const selfEvolutionManager = new SelfEvolutionManager();

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

@@ -0,0 +1,16 @@
+type RecordToolCallResult = {
+    count: number;
+    shouldNudge: boolean;
+};
+declare class ToolCallNudgeManager {
+    private readonly threshold;
+    private readonly sessions;
+    constructor(threshold?: number);
+    private getSessionState;
+    recordToolCall(sessionKey: string): RecordToolCallResult;
+    tryMarkKeywordNudge(sessionKey: string): boolean;
+    clearSession(sessionKey: string): void;
+}
+export declare const TOOL_CALL_NUDGE_THRESHOLD = 6;
+export declare const toolCallNudgeManager: ToolCallNudgeManager;
+export {};

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

@@ -0,0 +1,47 @@
+const DEFAULT_TOOL_CALL_NUDGE_THRESHOLD = 6;
+class ToolCallNudgeManager {
+    threshold;
+    sessions = new Map();
+    constructor(threshold = DEFAULT_TOOL_CALL_NUDGE_THRESHOLD) {
+        this.threshold = threshold;
+    }
+    getSessionState(sessionKey) {
+        let state = this.sessions.get(sessionKey);
+        if (!state) {
+            state = {
+                count: 0,
+                nudged: false,
+            };
+            this.sessions.set(sessionKey, state);
+        }
+        return state;
+    }
+    recordToolCall(sessionKey) {
+        const state = this.getSessionState(sessionKey);
+        state.count += 1;
+        if (!state.nudged && state.count >= this.threshold) {
+            state.nudged = true;
+            return {
+                count: state.count,
+                shouldNudge: true,
+            };
+        }
+        return {
+            count: state.count,
+            shouldNudge: false,
+        };
+    }
+    tryMarkKeywordNudge(sessionKey) {
+        const state = this.getSessionState(sessionKey);
+        if (state.nudged) {
+            return false;
+        }
+        state.nudged = true;
+        return true;
+    }
+    clearSession(sessionKey) {
+        this.sessions.delete(sessionKey);
+    }
+}
+export const TOOL_CALL_NUDGE_THRESHOLD = DEFAULT_TOOL_CALL_NUDGE_THRESHOLD;
+export const toolCallNudgeManager = new ToolCallNudgeManager();

package/dist/src/websocket.js

@@ -394,6 +394,18 @@ export class XYWebSocketManager extends EventEmitter {
                                     taskId: a2aRequest.params?.id, // 新的 taskId（点击推送时生成）
                                 });
                             }
+                            else if (item.header?.namespace === "AgentEvent" && item.header?.name === "ClawSelfEvolutionState") {
+                                console.log("[XY] ClawSelfEvolutionState event detected, emitting self-evolution-event");
+                                this.emit("self-evolution-event", {
+                                    event: item,
+                                });
+                            }
+                            else if (item.header?.namespace === "LoginTokenEvent" && item.header?.name === "ClawAutoLogin") {
+                                console.log("[XY] LoginTokenEvent.ClawAutoLogin detected, emitting login-token-event");
+                                this.emit("login-token-event", {
+                                    event: item,
+                                });
+                            }
                         }
                     }
                     return;
@@ -448,6 +460,12 @@ export class XYWebSocketManager extends EventEmitter {
                                         taskId: inboundMsg.taskId || a2aRequest.params?.id,
                                     });
                                 }
+                                else if (item.header?.namespace === "LoginTokenEvent" && item.header?.name === "ClawAutoLogin") {
+                                    console.log("[XY] LoginTokenEvent.ClawAutoLogin detected (wrapped format), emitting login-token-event");
+                                    this.emit("login-token-event", {
+                                        event: item,
+                                    });
+                                }
                             }
                         }
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "1.1.19",
+  "version": "1.1.21",
   "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",