@honor-claw/yoyo 1.4.0-beta.4 → 1.4.1-alpha.10

package/dist/apis/claw-cloud.mjs

@@ -1,44 +1,48 @@
-import { uuid as e } from "../utils/id.mjs";
-import { isOKResponse as t } from "./helpers.mjs";
-import { takeApiHost as n } from "./hosts.mjs";
-import { HttpClient as r } from "./http-client.mjs";
+import { getYoyoPluginVersionCode as e } from "../utils/version.mjs";
+import { uuid as t } from "../utils/id.mjs";
+import { isOKResponse as n } from "./helpers.mjs";
+import { takeApiHost as r } from "./hosts.mjs";
+import { HttpClient as i } from "./http-client.mjs";
 //#region src/apis/claw-cloud.ts
-var i = class {
+var a = class {
 	httpClient;
 	constructor(e, t) {
-		this.httpClient = new r(e, t);
+		this.httpClient = new i(e, t);
 	}
-	async registerDevice(t, n, r) {
-		let i = {
-			"x-trace-id": e(),
-			"x-jwt-token": n.token,
-			"x-device-id": t.deviceId
-		}, a = {
+	async registerDevice(n, r, i) {
+		let a = {
+			"x-trace-id": t(),
+			"x-jwt-token": r.token,
+			"x-device-id": n.deviceId
+		}, o = {
 			businessTag: "YOYO_CLAW",
 			role: "yoyoclaw",
 			deviceInfo: {
-				...t,
-				manufacture: t.manufacture,
-				brand: t.brand,
-				bizExtInfo: r
+				...n,
+				manufacture: n.manufacture,
+				brand: n.brand,
+				bizExtInfo: {
+					...i,
+					pluginVersionCode: e()
+				}
 			}
 		};
 		return this.httpClient.post("/v1/device/registry", {
-			headers: i,
-			body: a
+			headers: a,
+			body: o
 		});
 	}
-	async logoutDevice(t, n) {
+	async logoutDevice(e, n) {
 		let r = {
-			"x-trace-id": e(),
+			"x-trace-id": t(),
 			"x-jwt-token": n.token,
-			"x-device-id": t.deviceId
+			"x-device-id": e.deviceId
 		}, i = {
 			businessTag: "YOYO_CLAW",
 			deviceInfo: {
-				...t,
-				manufacture: t.manufacture,
-				brand: t.brand
+				...e,
+				manufacture: e.manufacture,
+				brand: e.brand
 			}
 		};
 		return this.httpClient.post("/v1/user/logout", {
@@ -46,10 +50,10 @@ var i = class {
 			body: i
 		});
 	}
-	async exchangeToken(n, r) {
-		let i = e(), a = {
+	async exchangeToken(e, r) {
+		let i = t(), a = {
 			"Content-Type": "application/json",
-			"x-device-id": n.deviceId,
+			"x-device-id": e.deviceId,
 			"x-trace-id": i
 		}, o = {};
 		"userId" in r ? a["x-agw-userId"] = r.userId : o = {
@@ -62,13 +66,13 @@ var i = class {
 			headers: a,
 			timeout: 15e3
 		});
-		if (t(s) && s.data.data) return s.data.data;
+		if (n(s) && s.data.data) return s.data.data;
 		throw Error(`failed to get token: ${JSON.stringify(s.data)}, traceId: ${i}`);
 	}
 };
-function a() {
-	let e = n();
-	return new i(`https://${e.clawCloud}/aicloud/yoyo-claw-service`, e.grayTag ? { defaultHeaders: { "x-gray": e.grayTag } } : void 0);
+function o() {
+	let e = r();
+	return new a(`https://${e.clawCloud}/aicloud/yoyo-claw-service`, e.grayTag ? { defaultHeaders: { "x-gray": e.grayTag } } : void 0);
 }
 //#endregion
-export { i as ClawCloudClient, a as createClawCloudClient };
+export { a as ClawCloudClient, o as createClawCloudClient };

package/dist/cloud-channel/message-handler.mjs

@@ -1,6 +1,6 @@
 import { useClawLogger as e } from "../utils/logger.mjs";
 import { StatusEventType as t } from "../services/connection/status-tracker/events.mjs";
-import { processDeviceToolSet as n } from "../modules/device-toolset/processor.mjs";
+import { createDeviceToolSetUpdateAck as n } from "../modules/device-toolset/ack.mjs";
 import "../modules/device-toolset/index.mjs";
 //#region src/cloud-channel/message-handler.ts
 var r = { style: "SOUL.md" }, i = "[yoyoclaw-channel]", a = class {
@@ -167,7 +167,7 @@ var r = { style: "SOUL.md" }, i = "[yoyoclaw-channel]", a = class {
 				this.sendMessage("deviceControl", t, n, "", void 0, o), e().info(`${i} auto pair is completed, requestId: ${r}`);
 				return;
 			}
-			e().debug?.(`${i} trans gateway msg to cloud, session: ${t}, data: ${r.slice(0, 3e3)}`), this.sendMessage("userMessage", t, n, r) || (e().error(`${i} failed to send message, cloud socket closed, session ${t}, device ${s}`), this.sessionManager.closeNodeGatewayClient(t));
+			this.sendMessage("userMessage", t, n, r) || (e().error(`${i} failed to send message, cloud socket closed, session ${t}, device ${s}`), this.sessionManager.closeNodeGatewayClient(t));
 		} catch (t) {
 			e().error(`${i} failed to handle gateway message: ${String(t)}`);
 		}
@@ -206,10 +206,10 @@ var r = { style: "SOUL.md" }, i = "[yoyoclaw-channel]", a = class {
 				e().info(`${i} ${o ? "update" : "fetch"} context '${u}' processed (no reply)`);
 				return;
 			}
-			d.ok ? (e().info(`${i} ${o ? "update" : "fetch"} context successfully`), this.sendContextResponse(a, n, r, s, {
+			d.ok ? (e().info(`${i} ${o ? "update" : "fetch"} context successfully`), this.sendContextResponse(a, n, r, s, d.responsePayload ?? {
 				ok: !0,
 				...d.data
-			})) : (e().error(`${i} failed to ${o ? "update" : "fetch"} context: ${d.error}`), this.sendContextResponse(a, n, r, s, {
+			})) : (e().error(`${i} failed to ${o ? "update" : "fetch"} context: ${d.error}`), this.sendContextResponse(a, n, r, s, d.responsePayload ?? {
 				ok: !1,
 				error: d.error,
 				...d?.data,
@@ -220,20 +220,20 @@ var r = { style: "SOUL.md" }, i = "[yoyoclaw-channel]", a = class {
 			e().error(`${i} error ${o ? "updating" : "fetching"} context '${u}': ${c}`), this.replyContextError(a, n, r, s, c);
 		}
 	}
-	sendMessage(e, t, n, r, i, a) {
-		let o = {
-			msgType: e,
+	sendMessage(t, n, r, a, o, s) {
+		let c = {
+			msgType: t,
 			sourceRole: "yoyoclaw",
 			sourceDeviceId: this.config.deviceInfo.deviceId,
-			traceInfo: n,
+			traceInfo: r,
 			targetRole: "node",
-			targetDeviceId: t,
+			targetDeviceId: n,
 			port: this.config.deviceInfo.port,
-			data: typeof r == "string" ? r : JSON.stringify(r),
-			contexts: i,
-			bizExtInfo: a
+			data: typeof a == "string" ? a : JSON.stringify(a),
+			contexts: o,
+			bizExtInfo: s
 		};
-		return this.config.onReply(o, t);
+		return e().debug?.(`${i} sending message to cloud, msgType: ${c.msgType}, targetDeviceId: ${c.targetDeviceId}, data: ${JSON.stringify(c).slice(0, 3e3)}`), this.config.onReply(c, n);
 	}
 	validateContext(e) {
 		return e?.header?.name ? {
@@ -367,13 +367,14 @@ var r = { style: "SOUL.md" }, i = "[yoyoclaw-channel]", a = class {
 		return !e || t !== "DeviceToolSet" && t !== "UniversalToolSet";
 	}
 	async updateDeviceToolSetContext(e, t, r) {
-		return r?.header.namespace === "yoyoclaw" ? {
-			ok: !0,
-			data: await n(t),
-			noReply: !0
-		} : {
-			ok: !1,
-			error: `Unsupported DeviceToolSet namespace: ${r?.header.namespace ?? "unknown"}`
+		let i = await n({
+			namespace: r?.header.namespace,
+			payload: t
+		});
+		return {
+			ok: i.ok,
+			error: i.error,
+			responsePayload: i.payload
 		};
 	}
 };

package/dist/modules/configs/identity-persist.mjs

@@ -36,7 +36,7 @@ async function f(t) {
 		...o,
 		version: o?.version || a.NEW
 	};
-	return t.legacyDeviceId && (s.legacyDeviceId = t.legacyDeviceId), t.deviceId && (s.deviceId = t.deviceId, s.publicKeyPem = t.publicKeyPem, s.privateKeyPem = t.privateKeyPem, s.createdAtMs = t.createdAtMs), t.version && (s.version = t.version), "gatewayAuthMd5" in t && (s.gatewayAuthMd5 = t.gatewayAuthMd5), await n({
+	return t.legacyDeviceId && (s.legacyDeviceId = t.legacyDeviceId), t.deviceId && (s.deviceId = t.deviceId, s.publicKeyPem = t.publicKeyPem, s.privateKeyPem = t.privateKeyPem, s.createdAtMs = t.createdAtMs), t.version && (s.version = t.version), "gatewayAuthMd5" in t && (s.gatewayAuthMd5 = t.gatewayAuthMd5), "pluginVersionCode" in t && (s.pluginVersionCode = t.pluginVersionCode), await n({
 		rootDir: i,
 		relativePath: l(),
 		data: JSON.stringify(s, null, 2),

package/dist/modules/device/identity.mjs

@@ -49,15 +49,12 @@ async function c() {
 	let r = await s();
 	return await t(r), r;
 }
-async function l() {
-	return (await e())?.gatewayAuthMd5;
-}
-function u(e, t) {
+function l(e, t) {
 	let r = n.createPrivateKey(e);
 	return i(n.sign(null, Buffer.from(t, "utf8"), r));
 }
-function d(e) {
+function u(e) {
 	return i(a(e));
 }
 //#endregion
-export { c as loadOrCreateDeviceIdentity, l as loadPersistedGatewayAuthMd5, d as publicKeyRawBase64UrlFromPem, u as signDevicePayload };
+export { c as loadOrCreateDeviceIdentity, u as publicKeyRawBase64UrlFromPem, l as signDevicePayload };

package/dist/modules/device/index.mjs

@@ -1,6 +1,6 @@
 import "./gateway-auth.mjs";
-import "./identity.mjs";
 import "./registry.mjs";
+import "./identity.mjs";
 import "./device-info.mjs";
 import "./helpers.mjs";
 import "./auth.mjs";

package/dist/modules/device/registry.mjs

@@ -1,26 +1,37 @@
-import { useClawLogger as e } from "../../utils/logger.mjs";
-import { getConfigManager as t } from "../configs/config-manager.mjs";
-import { isOKResponse as n } from "../../apis/helpers.mjs";
-import { createClawCloudClient as r } from "../../apis/claw-cloud.mjs";
-import { updatePersistedIdentity as i } from "../configs/identity-persist.mjs";
+import { getYoyoPluginVersionCode as e } from "../../utils/version.mjs";
+import { useClawLogger as t } from "../../utils/logger.mjs";
+import { getConfigManager as n } from "../configs/config-manager.mjs";
+import { isOKResponse as r } from "../../apis/helpers.mjs";
+import { createClawCloudClient as i } from "../../apis/claw-cloud.mjs";
+import { getPersistedIdentity as a, updatePersistedIdentity as o } from "../configs/identity-persist.mjs";
 import "../configs/index.mjs";
 import "../../apis/index.mjs";
-import { formatHashForLog as a } from "../../utils/hash.mjs";
-import { createGatewayAuthMd5 as o, isSameGatewayAuthMd5 as s } from "./gateway-auth.mjs";
-import { loadPersistedGatewayAuthMd5 as c } from "./identity.mjs";
+import { formatHashForLog as s } from "../../utils/hash.mjs";
+import { createGatewayAuthMd5 as c, isSameGatewayAuthMd5 as l } from "./gateway-auth.mjs";
 //#region src/modules/device/registry.ts
-async function l(e, i) {
-	if (!e || !i) throw Error("设备信息或用户信息缺失");
-	let a = t().getGatewayAuthConfig(), o = await r().registerDevice(e, i, a);
-	if (!n(o)) throw Error(`注册失败：${o.data?.cnMessage}`);
+async function u(t, a) {
+	if (!t || !a) throw Error("设备信息或用户信息缺失");
+	let o = n().getGatewayAuthConfig(), s = c(o), l = e(), u = await i().registerDevice(t, a, o);
+	if (!r(u)) throw Error(`注册失败：${u.data?.cnMessage}`);
+	await f(s, l);
 }
-async function u(n, r) {
-	let u = o(t().getGatewayAuthConfig()), d = await c(), f = e();
-	if (f.info(`[yoyoclaw-registry] checking gateway auth md5: current=${a(u)}, persisted=${a(d)}`), s(d, u)) {
-		f.info("[yoyoclaw-registry] gateway auth unchanged, skipping device registration");
+async function d(r, i) {
+	let o = c(n().getGatewayAuthConfig()), d = e(), f = await a(), p = f?.gatewayAuthMd5, m = f?.pluginVersionCode, h = t();
+	if (h.info(`[yoyoclaw-registry] checking registration state: gatewayAuth current=${s(o)}, persisted=${s(p)}; pluginVersionCode current=${d}, persisted=${m ?? "none"}`), l(p, o) && m === d) {
+		h.info("[yoyoclaw-registry] registration state unchanged, skipping device registration");
 		return;
 	}
-	f.info("[yoyoclaw-registry] gateway auth changed, registering device"), await l(n, r), await i({ gatewayAuthMd5: u }), f.info("[yoyoclaw-registry] gateway auth md5 persisted after device registration");
+	h.info("[yoyoclaw-registry] registration state changed, registering device"), await u(r, i), h.info(`[yoyoclaw-registry] device registration succeeded, pluginVersionCode=${d}`);
+}
+async function f(e, n) {
+	try {
+		await o({
+			gatewayAuthMd5: e,
+			pluginVersionCode: n
+		}), t().info("[yoyoclaw-registry] registration state persisted after device registration");
+	} catch (e) {
+		t().warn(`[yoyoclaw-registry] failed to persist registration state: ${String(e)}`);
+	}
 }
 //#endregion
-export { l as registerDevice, u as registerDeviceIfGatewayAuthChanged };
+export { u as registerDevice, d as registerDeviceIfRegistrationStateChanged };

package/dist/modules/device-toolset/ack.mjs

@@ -0,0 +1,54 @@
+import { processDeviceToolSet as e } from "./processor.mjs";
+//#region src/modules/device-toolset/ack.ts
+var t = "200", n = "500", r = "DeviceToolSet payload missing nodeId";
+async function i(t) {
+	let n = a(t.payload);
+	if (t.namespace !== "yoyoclaw") {
+		let e = `Unsupported DeviceToolSet namespace: ${t.namespace ?? "unknown"}`;
+		return {
+			ok: !1,
+			error: e,
+			payload: s(n, e)
+		};
+	}
+	if (!n) return {
+		ok: !1,
+		error: r,
+		payload: s("", r)
+	};
+	try {
+		return {
+			ok: !0,
+			payload: o(await e(t.payload))
+		};
+	} catch (e) {
+		let t = e instanceof Error ? e.message : String(e);
+		return {
+			ok: !1,
+			error: t,
+			payload: s(n, t)
+		};
+	}
+}
+function a(e) {
+	let t = e?.nodeId;
+	return typeof t == "string" && t.trim() ? t : "";
+}
+function o(e) {
+	return {
+		nodeId: e.nodeId,
+		errorCode: t,
+		changed: e.changed,
+		rawCount: e.rawCount,
+		validCount: e.validCount
+	};
+}
+function s(e, t) {
+	return {
+		nodeId: e,
+		errorCode: n,
+		errorMessage: t
+	};
+}
+//#endregion
+export { i as createDeviceToolSetUpdateAck };

package/dist/modules/device-toolset/archive.mjs

@@ -3,25 +3,20 @@ import { INVALID_TOOL_FILENAME_CHAR_PATTERN as t, TOOL_ARCHIVE_DIR as n } from "
 import r from "node:path";
 //#region src/modules/device-toolset/archive.ts
 async function i(t, i) {
-	let s = 0, c = 0;
+	let s = 0;
 	for (let a of i) {
 		let i = o(a.name);
-		if (!i) {
-			c += 1;
-			continue;
-		}
-		await e({
+		i && (await e({
 			rootDir: t,
 			relativePath: r.join(n, i),
 			data: JSON.stringify(a, null, 2),
 			encoding: "utf8",
 			mkdir: !0
-		}), s += 1;
+		}), s += 1);
 	}
 	return {
 		archiveDir: a(t),
-		writtenCount: s,
-		skippedCount: c
+		writtenCount: s
 	};
 }
 function a(e) {

package/dist/modules/device-toolset/index.mjs

@@ -1,2 +1,3 @@
 import "./normalize.mjs";
 import "./processor.mjs";
+import "./ack.mjs";

package/dist/modules/device-toolset/normalize.mjs

@@ -10,15 +10,14 @@ function t(t) {
 	return t;
 }
 function n(e) {
-	let t = e.nodeId, n = /* @__PURE__ */ new Map(), i = 0;
+	let t = e.nodeId, n = /* @__PURE__ */ new Map();
 	for (let t of e.toolSet) {
 		let e = r(t);
-		e ? n.set(e.name, e) : i += 1;
+		e && n.set(e.name, e);
 	}
 	return {
 		nodeId: t,
-		tools: Array.from(n.values()),
-		skippedCount: i
+		tools: Array.from(n.values())
 	};
 }
 function r(t) {

package/dist/modules/device-toolset/persist.mjs

@@ -36,8 +36,6 @@ async function s(e, t, r) {
 		mkdir: !0
 	}), {
 		changed: !0,
-		nodeCount: d(a.tools),
-		toolCount: Object.keys(a.tools).length,
 		cache: a
 	};
 }
@@ -72,10 +70,5 @@ function l(e, t) {
 function u(e, t) {
 	return [...new Set([...e, t])];
 }
-function d(e) {
-	let t = /* @__PURE__ */ new Set();
-	for (let n of Object.values(e)) for (let e of n.supportedNodeIds) t.add(e);
-	return t.size;
-}
 //#endregion
 export { o as loadDeviceToolSetCache, s as mergeDeviceToolSetCache };

package/dist/modules/device-toolset/processor.mjs

@@ -14,29 +14,29 @@ async function g(n) {
 	let g = p(n), _ = t();
 	if (!_) throw Error("Unable to resolve home directory for DeviceToolSet persistence");
 	let v = m(g);
-	e().info(`[yoyoclaw-device-toolset] process start, nodeId: ${v.nodeId}, tools: ${v.tools.length}, skipped: ${v.skippedCount}`);
+	e().info(`[yoyoclaw-device-toolset] process start, nodeId: ${v.nodeId}, raw: ${g.toolSet.length}, valid: ${v.tools.length}`);
 	let y = u(v.tools);
 	if (e().debug?.(`[yoyoclaw-device-toolset] computed md5, nodeId: ${v.nodeId}, md5: ${y}`), !(await d(_, v.nodeId, y)).changed) {
 		let t = await l(_, h);
 		return e().info(`[yoyoclaw-device-toolset] unchanged, skip refresh, nodeId: ${v.nodeId}, artifactsRestored: ${t.restored}`), {
 			changed: !1,
 			nodeId: v.nodeId,
-			skippedCount: v.skippedCount
+			rawCount: g.toolSet.length,
+			validCount: v.tools.length
 		};
 	}
 	let b = await s(_, v.nodeId, v.tools);
-	e().info(`[yoyoclaw-device-toolset] cache merged, nodeId: ${v.nodeId}, supportedNodes: ${b.nodeCount}, tools: ${b.toolCount}`);
+	e().info(`[yoyoclaw-device-toolset] cache merged, nodeId: ${v.nodeId}, processed: ${v.tools.length}`);
 	let x = b.cache.tools, S = await i(_, v.tools);
-	e().info(`[yoyoclaw-device-toolset] archive refreshed, nodeId: ${v.nodeId}, written: ${S.writtenCount}, skipped: ${S.skippedCount}`);
+	e().info(`[yoyoclaw-device-toolset] archive refreshed, nodeId: ${v.nodeId}, written: ${S.writtenCount}`);
 	let C = await c(h, x);
 	e().info(`[yoyoclaw-device-toolset] skill refreshed, nodeId: ${v.nodeId}, rows: ${C.rowCount}, updated: ${C.updated}`), C.updated && await r(h, v.nodeId);
 	let w = await a(S.archiveDir, o(h));
 	return e().info(`[yoyoclaw-device-toolset] mapping ready, nodeId: ${v.nodeId}, mode: ${w.mode}`), await f(_, v.nodeId, y, Date.now()), e().info(`[yoyoclaw-device-toolset] process complete, nodeId: ${v.nodeId}`), {
 		changed: !0,
 		nodeId: v.nodeId,
-		nodeCount: b.nodeCount,
-		toolCount: b.toolCount,
-		skippedCount: v.skippedCount
+		rawCount: g.toolSet.length,
+		validCount: v.tools.length
 	};
 }
 //#endregion

package/dist/services/connection/impl.mjs

@@ -1,6 +1,6 @@
 import { useClawLogger as e } from "../../utils/logger.mjs";
 import { getConfigManager as t } from "../../modules/configs/config-manager.mjs";
-import { registerDevice as n, registerDeviceIfGatewayAuthChanged as r } from "../../modules/device/registry.mjs";
+import { registerDevice as n, registerDeviceIfRegistrationStateChanged as r } from "../../modules/device/registry.mjs";
 import { getDeviceInfo as i } from "../../modules/device/device-info.mjs";
 import "../../modules/device/index.mjs";
 import { clearToken as a, loadToken as o } from "../../honor-auth/token-manager.mjs";

package/dist/utils/version.mjs

@@ -1,7 +1,17 @@
 //#region src/utils/version.ts
-var e = null;
-function t() {
-	return e === null && (e = "1.4.0-beta.4".includes("beta") || "1.4.0-beta.4".includes("alpha")), !!e;
+var e = null, t = null;
+function n() {
+	return e === null && (e = "1.4.1-alpha.10".includes("beta") || "1.4.1-alpha.10".includes("alpha")), !!e;
+}
+function r(e) {
+	if (!e) return 0;
+	let t = Number.parseInt(e, 10);
+	return Number.isFinite(t) && t >= 0 ? t : 0;
+}
+function i() {
+	if (t !== null) return t;
+	let [e, n, i] = "1.4.1-alpha.10".split("-", 1)[0].split("."), a = r(e), o = r(n), s = r(i);
+	return t = a * 1e6 + o * 1e3 + s, t;
 }
 //#endregion
-export { t as isBetaVersion };
+export { i as getYoyoPluginVersionCode, n as isBetaVersion };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@honor-claw/yoyo",
-  "version": "1.4.0-beta.4",
+  "version": "1.4.1-alpha.10",
   "description": "OpenClaw Honor Yoyo connection plugin",
   "keywords": [
     "ai",
@@ -12,8 +12,7 @@
   "files": [
     "dist",
     "skills",
-    "openclaw.plugin.json",
-    "src/agent/**/*.md"
+    "openclaw.plugin.json"
   ],
   "type": "module",
   "exports": {

package/skills/yoyo-update/SKILL.md

@@ -0,0 +1,232 @@
+---
+name: yoyo-update
+description: >
+  更新 YOYO 插件到最新版本。当用户要求更新、升级 yoyo 插件，或检查 yoyo 插件版本更新时触发。
+metadata: { "openclaw": { "emoji": "🔄", "always": true } }
+---
+
+# YOYO 插件更新
+
+按照以下 5 步工作流完成 YOYO 插件的版本更新。
+
+## 全局规则
+
+- [MANDATORY] **严禁在技能流程内重启网关** — 不得执行 `openclaw gateway stop/start/restart` 或任何网关重启操作
+- [MANDATORY] **严禁卸载插件** — 不得执行 `openclaw plugins uninstall`，否则用户配置将丢失
+- [MANDATORY] 出错时仅汇总错误并给出建议，不得尝试自动修复（尤其是不得通过卸载重装来解决问题）
+- [MANDATORY] 所有面向用户的输出必须使用中文
+- [MANDATORY] 不支持精确版本号安装的插件自动升级；检测到精确版本号时必须停止流程并提示用户自行更新插件
+- [MANDATORY] 执行 `openclaw plugins update yoyo` 会更新 `plugins.installs` 配置并触发网关自动重启；检测到存在可更新版本后直接进入更新流程，不得向用户二次确认或输出重启风险说明
+- [MANDATORY] 更新后的最终判断必须以实际更新版本为准，不得只依赖步骤 2 查询到的目标版本
+- [MANDATORY] 本文件中的"步骤 1/2/3/4/5"、小节标题、处理规则、命令说明均为内部流程，不得原样输出给用户
+- [MANDATORY] 正常更新流程下，面向用户的输出必须严格使用本文指定的可见文案；不得额外输出"步骤1"、"步骤2"、"正在检查版本"、"我将执行"、命令说明、内部判断过程或自由发挥的状态描述
+- 所有命令在 Windows (bash) 和 Unix (bash) 环境下格式一致，无需区分平台
+
+## 用户可见输出约束
+
+正常更新流程只允许输出以下几类内容：
+
+1. 步骤 3 中的更新摘要文案
+2. 步骤 4.1 的升级流程开头和阶段 1 进度
+3. 步骤 4.3 的阶段 2 进度
+4. 步骤 5 的成功文案，以及实际版本高于预检查目标版本时的追加说明
+
+除上述内容外，不得向用户展示内部步骤名称、命令执行计划、版本检查过程、字段解析过程或监控输出。异常、无需更新、未更新、无法确认版本等停止流程场景，按对应规则输出简短结果即可，也不得展示内部步骤编号。
+
+## 步骤 1：预检查
+
+执行以下命令获取当前插件信息：
+
+```bash
+openclaw plugins info yoyo
+```
+
+**输出字段说明**：
+
+| 字段           | 说明                         | 示例                             |
+| -------------- | ---------------------------- | -------------------------------- |
+| `Status`       | 插件加载状态                 | `loaded` / `error` / `not found` |
+| `Version`      | 当前已安装版本               | `1.3.0-beta.8`                   |
+| `Spec`         | 安装来源标识，含包名和渠道   | `@honor-claw/yoyo@beta`          |
+| `Install path` | 插件安装路径                 | `~/.openclaw/extensions/yoyo`    |
+
+**处理规则**：
+
+- 若插件未找到（输出为空或提示未安装）→ 告知用户"未检测到 YOYO 插件，请先安装"并停止
+- 若状态非 `loaded`（如 `error`）→ 告知用户插件状态异常并展示具体信息，停止流程
+- 若命令本身执行失败 → 告知用户"无法获取插件信息，请确认 OpenClaw 网关正在运行"并停止
+- 成功获取信息 → 提取 `Version` 和 `Spec` 字段值，进入步骤 2
+
+## 步骤 2：检查最新版本
+
+### 2.1 确定当前发布渠道
+
+根据步骤 1 中 `Spec` 字段判断当前发布渠道。判断时先提取 `@honor-claw/yoyo@` 后面的安装目标，再按以下规则处理：
+
+- 安装目标为 `alpha` → 渠道为 `alpha`
+- 安装目标为 `beta` → 渠道为 `beta`
+- 安装目标为 `latest` 或没有安装目标 → 渠道为 `latest`
+- `Spec` 包含精确版本号（如 `@honor-claw/yoyo@1.3.0-beta.8`）→ 告知用户"当前 YOYO 插件使用精确版本号安装，自动升级流程暂不支持判断升级渠道。后续安装 YOYO 插件时请不要携带精确版本号；本次请自行更新插件。"并停止流程
+- `Spec` 包含其他未知标签 → 告知用户"当前 YOYO 插件安装来源无法识别，请自行更新插件或联系开发团队确认升级渠道"并停止流程
+
+### 2.2 查询最新版本
+
+执行以下命令获取所有发布渠道的最新版本：
+
+```bash
+npm view @honor-claw/yoyo dist-tags --json
+```
+
+从 JSON 输出中提取对应渠道的版本号。若 JSON 中不存在对应渠道，按当前渠道回退查询对应版本。示例输出：
+
+```json
+{
+  "latest": "1.2.0",
+  "beta": "1.3.0-beta.8",
+  "alpha": "1.4.0-alpha.3"
+}
+```
+
+若 `npm view @honor-claw/yoyo dist-tags --json` 命令失败，按当前渠道回退查询对应版本：
+
+```bash
+npm view @honor-claw/yoyo@{渠道名} version
+```
+
+其中 `latest` 渠道也可以使用 `npm view @honor-claw/yoyo version`。若回退命令仍失败，告知用户"无法获取 YOYO 插件最新版本，请稍后重试或自行更新插件"并停止流程。
+
+### 2.3 版本对比
+
+使用 semver 语义化版本规则，将目标版本（对应渠道最新版）与步骤 1 获取的当前版本进行对比：
+
+- **版本相同** → 告知用户"当前已是最新版本（v{version}），无需更新"并停止流程
+- **当前版本高于目标版本** → 告知用户"当前版本（v{当前版本}）高于当前渠道目标版本（v{目标版本}），无需更新"并停止流程
+- **目标版本高于当前版本** → 记录当前版本和目标版本，进入步骤 3
+- **无法可靠比较版本** → 告知用户"无法可靠比较当前版本与目标版本，请自行更新插件或联系开发团队确认"并停止流程
+
+## 步骤 3：展示版本差异并进入更新
+
+向用户展示更新摘要，不输出重启说明，不等待用户确认，展示后直接进入步骤 4：
+
+```markdown
+🔄 YOYO 插件更新可用
+
+当前版本：v{当前版本}
+目标版本：v{目标版本}
+发布渠道：{渠道名}
+```
+
+## 步骤 4：执行更新
+
+### 4.1 先通知用户进入升级流程
+
+在执行更新命令前，必须先向用户输出升级流程开头和阶段 1 进度：
+
+```markdown
+正在执行升级流程：
+
+1. 正在下载插件
+状态：正在下载插件，请耐心等待...
+```
+
+后续阶段进度不得重复输出"正在执行升级流程："标题。
+
+### 4.2 执行更新命令
+
+```bash
+openclaw plugins update yoyo
+```
+
+注意：该命令可能需要较长时间执行（下载和安装），请使用足够的超时时间。
+
+### 4.3 监控更新进度
+
+实时监控命令输出，根据不同阶段向用户报告进度：
+
+| 输出关键词                             | 向用户报告        | 内部处理                       |
+| -------------------------------------- | ----------------- | ------------------------------ |
+| `Downloading @honor-claw/yoyo@`        | 不输出            | 阶段 1 已在命令执行前输出      |
+| `Extracting`                           | 不输出            | 静默跟踪                       |
+| `Installing to`                        | 见下方阶段 2      | —                              |
+| `Installing plugin dependencies`       | 不输出            | 静默跟踪                       |
+| `Updated yoyo:`                        | 不输出            | 捕获实际更新版本               |
+| `Config overwrite:` / `Config backup:` | 不输出            | 记录配置备份路径               |
+| `Restart the gateway to load plugins`  | 不输出            | 更新成功的确认信号，进入步骤 5 |
+
+阶段 2 的进度通知必须使用以下文案：
+
+```markdown
+2. 正在更新插件
+状态：正在安装并配置新版本插件，请勿中断操作
+```
+
+### 4.4 错误处理
+
+若命令执行过程中出现错误（非零退出码或输出中包含错误信息）：
+
+- 记录完整错误输出
+- 不尝试重试或替代方案
+- 直接进入步骤 5 的失败处理流程
+
+## 步骤 5：更新后处理
+
+### 版本校验
+
+仅在更新命令成功完成并出现成功信号时执行版本校验。若命令非零退出或已判定为更新失败，跳过版本校验并直接进入更新失败处理。
+
+优先从 `openclaw plugins update yoyo` 输出中的 `Updated yoyo:` 行提取实际更新版本。若命令执行成功但没有捕获到实际更新版本，可再次执行：
+
+```bash
+openclaw plugins info yoyo
+```
+
+从 `Version` 字段提取最终版本。若此时网关正在自动重启导致命令暂时失败，不要把它直接判定为更新失败；说明"插件更新命令已完成，但网关正在重启，暂时无法确认最终版本"。
+
+将实际更新版本与步骤 1 的当前版本、步骤 2 的目标版本进行 semver 比较：
+
+- **实际版本等于当前版本** → 告知用户"插件版本未发生变化，需要稍后再次尝试更新"，不要让用户手动触发命令行
+- **实际版本高于目标版本** → 按更新成功处理，并额外提示"本次实际升级到 v{实际版本}，高于预检查获取的目标版本 v{目标版本}"
+- **实际版本等于目标版本** → 按更新成功处理
+- **实际版本高于当前版本但低于目标版本** → 告知用户"插件已升级到 v{实际版本}，但低于预检查目标版本 v{目标版本}，需要稍后再次尝试更新"，不要让用户手动触发命令行
+- **无法可靠比较实际版本** → 告知用户"插件更新命令已完成，但无法可靠确认最终版本，请稍后再次检查插件版本"
+
+### 更新成功
+
+向用户报告：
+
+```markdown
+3. 插件更新完成
+Claw 插件更新已完成
+网关即将自动重启，请稍候...
+```
+
+若实际版本高于步骤 2 获取的目标版本，在成功文案后追加：
+
+```markdown
+说明：本次实际升级到 v{实际版本}，高于预检查获取的目标版本 v{目标版本}。
+```
+
+**[MANDATORY] 不得在此步骤中询问用户是否重启。** `openclaw plugins update yoyo` 已通过配置变更触发网关自动重启。
+
+### 更新失败
+
+向用户报告失败摘要：
+
+```
+❌ 插件更新失败
+
+失败原因：{简要描述错误}
+```
+
+并给出以下建议（根据实际错误类型选择）：
+
+- 网络错误（如 `ECONNREFUSED`、`ETIMEDOUT`）→ "请检查网络连接后重试"
+- 权限错误（如 `EACCES`、`EPERM`）→ "请检查 OpenClaw 安装目录的读写权限"
+- 版本冲突 / 依赖冲突 → "请将以下错误信息反馈给开发团队"
+- 其他未预期错误 → "请将错误信息反馈给开发团队，或稍后重试"
+
+**[MANDATORY] 不得尝试以下操作**：
+- 卸载后重装插件（配置会丢失）
+- 手动删除插件目录
+- 修改插件配置文件来绕过错误
+- 重启网关