@honor-claw/yoyo 1.3.0-alpha.3 → 1.3.0-alpha.4

package/dist/apis/claw-cloud.mjs

@@ -0,0 +1,74 @@
+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";
+//#region src/apis/claw-cloud.ts
+var i = class {
+	httpClient;
+	constructor(e, t) {
+		this.httpClient = new r(e, t);
+	}
+	async registerDevice(t, n, r) {
+		let i = {
+			"x-trace-id": e(),
+			"x-jwt-token": n.token,
+			"x-device-id": t.deviceId
+		}, a = {
+			businessTag: "YOYO_CLAW",
+			role: "yoyoclaw",
+			deviceInfo: {
+				...t,
+				manufacture: t.manufacture,
+				brand: t.brand,
+				bizExtInfo: r
+			}
+		};
+		return this.httpClient.post("/v1/device/registry", {
+			headers: i,
+			body: a
+		});
+	}
+	async logoutDevice(t, n) {
+		let r = {
+			"x-trace-id": e(),
+			"x-jwt-token": n.token,
+			"x-device-id": t.deviceId
+		}, i = {
+			businessTag: "YOYO_CLAW",
+			deviceInfo: {
+				...t,
+				manufacture: t.manufacture,
+				brand: t.brand
+			}
+		};
+		return this.httpClient.post("/v1/user/logout", {
+			headers: r,
+			body: i
+		});
+	}
+	async exchangeToken(n, r) {
+		let i = e(), a = {
+			"Content-Type": "application/json",
+			"x-device-id": n.deviceId,
+			"x-trace-id": i
+		}, o = {};
+		"userId" in r ? a["x-agw-userId"] = r.userId : o = {
+			clientId: r.authConfig.clientId,
+			code: r.code,
+			redirectUri: "http://127.0.0.1:8081/deepLink"
+		};
+		let s = await this.httpClient.post("/v1/user/jwtToken", {
+			body: o,
+			headers: a,
+			timeout: 15e3
+		});
+		if (t(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);
+}
+//#endregion
+export { i as ClawCloudClient, a as createClawCloudClient };

package/dist/apis/helpers.mjs

@@ -0,0 +1,6 @@
+//#region src/apis/helpers.ts
+function e(e) {
+	return e.status >= 200 && e.status < 300 && e.data.code === "1";
+}
+//#endregion
+export { e as isOKResponse };

package/dist/apis/hosts.mjs

@@ -0,0 +1,28 @@
+import { getYoyoEnvInfo as e } from "../runtime.mjs";
+//#region src/apis/hosts.ts
+function t() {
+	let t = e(), n;
+	switch (t.env) {
+		case "dev":
+			n = {
+				clawCloud: "omni-dev-drcn.hiboard.hihonorcloud.com",
+				ics: "api-agd-test-drcn.hiboard.hihonorcloud.com"
+			};
+			break;
+		case "test":
+			n = {
+				clawCloud: "omni-pre-drcn.hiboard.hihonorcloud.com",
+				ics: "api-agd-test-drcn.hiboard.hihonorcloud.com"
+			};
+			break;
+		default:
+			n = {
+				clawCloud: "yoyoclaw-drcn.hiboard.hihonorcloud.com",
+				ics: "api-prd-drcn.hiboard.hihonorcloud.com"
+			};
+			break;
+	}
+	return t.grayTag && (n.grayTag = t.grayTag), n;
+}
+//#endregion
+export { t as takeApiHost };

package/dist/apis/http-client.mjs

@@ -0,0 +1,97 @@
+import { wrapError as e } from "../utils/error.mjs";
+import { getProxyUrl as t, shouldUseProxy as n } from "../utils/proxy.mjs";
+import { ProxyAgent as r, request as i } from "undici";
+//#region src/apis/http-client.ts
+var a = class extends Error {
+	constructor(e, t, n) {
+		super(n), this.status = e, this.data = t, this.name = "HttpError";
+	}
+}, o = class {
+	baseUrl;
+	defaultHeaders;
+	defaultTimeout;
+	proxyAgent;
+	constructor(e, n) {
+		this.baseUrl = e.replace(/\/$/, ""), this.defaultHeaders = n?.defaultHeaders || {}, this.defaultTimeout = n?.defaultTimeout || 3e4;
+		let i = t(n?.proxy);
+		i && (this.proxyAgent = new r(i));
+	}
+	async request(r) {
+		let { method: o = "GET", headers: s = {}, body: c, timeout: l = this.defaultTimeout, query: u } = r, d = r.url;
+		if (!d.startsWith("http://") && !d.startsWith("https://") && (d = `${this.baseUrl}${d.startsWith("/") ? "" : "/"}${d}`), u && Object.keys(u).length > 0) {
+			let e = new URLSearchParams();
+			Object.entries(u).forEach(([t, n]) => {
+				n !== void 0 && e.append(t, String(n));
+			});
+			let t = e.toString();
+			t && (d += (d.includes("?") ? "&" : "?") + t);
+		}
+		let f = {
+			...this.defaultHeaders,
+			...s
+		};
+		c && !f["Content-Type"] && (f["Content-Type"] = "application/json");
+		let p;
+		c != null && (p = typeof c == "string" ? c : JSON.stringify(c));
+		try {
+			let e = n(t(), r.disableProxy) && this.proxyAgent ? this.proxyAgent : void 0, s = await i(d, {
+				method: o,
+				headers: f,
+				body: p,
+				headersTimeout: l,
+				bodyTimeout: l,
+				dispatcher: e
+			}), c = await s.body.text(), u;
+			try {
+				u = c ? JSON.parse(c) : {};
+			} catch {
+				u = c;
+			}
+			if (s.statusCode >= 200 && s.statusCode < 300) return {
+				data: u,
+				status: s.statusCode,
+				headers: s.headers
+			};
+			throw new a(s.statusCode, u, `HTTP request failed with status ${s.statusCode}`);
+		} catch (t) {
+			throw t instanceof a ? t : e(t, "HTTP request failed");
+		}
+	}
+	async get(e, t) {
+		return this.request({
+			...t,
+			url: e,
+			method: "GET"
+		});
+	}
+	async post(e, t) {
+		return this.request({
+			...t,
+			url: e,
+			method: "POST"
+		});
+	}
+	async put(e, t) {
+		return this.request({
+			...t,
+			url: e,
+			method: "PUT"
+		});
+	}
+	async delete(e, t) {
+		return this.request({
+			...t,
+			url: e,
+			method: "DELETE"
+		});
+	}
+	async patch(e, t) {
+		return this.request({
+			...t,
+			url: e,
+			method: "PATCH"
+		});
+	}
+};
+//#endregion
+export { o as HttpClient, a as HttpError };

package/dist/apis/index.mjs

@@ -0,0 +1,3 @@
+import "./helpers.mjs";
+import "./http-client.mjs";
+import "./claw-cloud.mjs";

package/dist/cloud-channel/admin-client-manager.mjs

@@ -0,0 +1,75 @@
+import { useClawLogger as e } from "../utils/logger.mjs";
+import { getConfigManager as t } from "../modules/configs/config-manager.mjs";
+import { StatusEventType as n } from "../services/connection/status-tracker/events.mjs";
+import r from "../gateway-client/admin-client.mjs";
+//#region src/cloud-channel/admin-client-manager.ts
+var i = class {
+	client = null;
+	ready = !1;
+	options;
+	pendingReadyRequests = /* @__PURE__ */ new Map();
+	requestIdCounter = 0;
+	constructor(e = {}) {
+		this.options = e;
+	}
+	init() {
+		if (this.client !== null) return;
+		let i = t().getGatewayAuthConfig(), a = typeof i?.token == "string" ? i.token : "", o = typeof i?.password == "string" ? i.password : "";
+		this.client = new r({
+			token: a,
+			password: o,
+			onAuthenticated: () => {
+				e().info("[yoyoclaw-channel] admin gateway client authenticated"), this.ready = !0, this.resolveAllPending(!0);
+			},
+			onClose: (t) => {
+				e().info(`[yoyoclaw-channel] admin gateway client closed: ${t}`), this.ready = !1;
+			},
+			onReconnectFailed: () => {
+				e().error("[yoyoclaw-channel] admin gateway client reconnect failed, notifying status tracker"), this.options.onStatusEvent?.({
+					type: n.ADMIN_CLIENT_RECONNECT_FAILED,
+					timestamp: Date.now(),
+					data: {}
+				});
+			}
+		});
+	}
+	connect() {
+		this.client?.connect();
+	}
+	destroy() {
+		this.client &&= (this.client.stop(), null), this.ready = !1, this.cancelAllPending(), e().info("[yoyoclaw-channel] admin gateway client closed");
+	}
+	cancelAllPending() {
+		for (let [e, t] of this.pendingReadyRequests) clearTimeout(t.timeout), t.resolve(!1);
+		this.pendingReadyRequests.clear();
+	}
+	isReady() {
+		return this.ready;
+	}
+	getClient() {
+		return this.client;
+	}
+	canOperate() {
+		return this.client !== null && this.ready;
+	}
+	ensureConnected() {
+		return this.client === null && (e().info("[yoyoclaw-channel] admin gateway client is null, initializing"), this.init()), this.ready || (e().info("[yoyoclaw-channel] admin gateway client not ready, connecting"), this.connect()), this.canOperate();
+	}
+	waitForReady(t = 5e3) {
+		return this.canOperate() ? Promise.resolve(!0) : new Promise((n) => {
+			let r = `req_${++this.requestIdCounter}`, i = setTimeout(() => {
+				this.pendingReadyRequests.delete(r), this.pendingReadyRequests.size === 0 && e().warn("[yoyoclaw-channel] admin gateway client waitForReady timeout, all requests rejected"), n(!1);
+			}, t);
+			this.pendingReadyRequests.set(r, {
+				resolve: n,
+				timeout: i
+			}), this.ensureConnected();
+		});
+	}
+	resolveAllPending(e) {
+		for (let [t, n] of this.pendingReadyRequests) clearTimeout(n.timeout), n.resolve(e);
+		this.pendingReadyRequests.clear();
+	}
+};
+//#endregion
+export { i as AdminClientManager };

package/dist/cloud-channel/channel.mjs

@@ -0,0 +1,60 @@
+import { useClawLogger as e } from "../utils/logger.mjs";
+import { AdminClientManager as t } from "./admin-client-manager.mjs";
+import { ClawCloudSocketClient as n } from "./client.mjs";
+import { MessageHandler as r } from "./message-handler.mjs";
+import { SessionManager as i } from "./session-manager.mjs";
+//#region src/cloud-channel/channel.ts
+var a = class {
+	cloudClient;
+	sessionManager;
+	adminClientManager;
+	messageHandler;
+	config;
+	constructor(e) {
+		this.config = e, this.sessionManager = new i(), this.adminClientManager = new t({ onStatusEvent: this.handleStatusEvent }), this.messageHandler = new r({
+			sessionManager: this.sessionManager,
+			adminClientManager: this.adminClientManager,
+			config: {
+				deviceInfo: e.deviceInfo,
+				onStatusEvent: this.handleStatusEvent,
+				onReply: (e) => this.cloudClient.send(e)
+			}
+		}), this.cloudClient = new n({
+			deviceInfo: e.deviceInfo,
+			userInfo: e.userInfo,
+			onMessage: this.messageHandler.handleCloudMessage,
+			onOpen: this.handleCloudOpen,
+			onClose: this.handleCloudClose,
+			onRemoteDeviceOffline: this.handleRemoteDeviceOffline,
+			onDeviceNotRegistered: this.handleDeviceNotRegistered,
+			onUnauthorized: this.handleUnauthorized,
+			onStatusEvent: this.handleStatusEvent
+		}), this.adminClientManager.init();
+	}
+	start() {
+		e().info("[yoyoclaw-channel] starting connection"), this.adminClientManager.ensureConnected(), this.cloudClient.connect();
+	}
+	destroy() {
+		e().info("[yoyoclaw-channel] closing connection"), this.sessionManager.closeAllNodeGatewayClients(), this.adminClientManager.destroy(), this.cloudClient.close();
+	}
+	handleCloudOpen = () => {
+		e().info("[yoyoclaw-channel] cloud connection established"), this.config.onOpen?.();
+	};
+	handleStatusEvent = (e) => {
+		this.config.onStatusEvent?.(e);
+	};
+	handleCloudClose = () => {
+		e().info("[yoyoclaw-channel] cloud connection closed"), this.config.onClose?.();
+	};
+	handleRemoteDeviceOffline = (e) => {
+		this.sessionManager.closeNodeGatewayClient(e);
+	};
+	handleDeviceNotRegistered = () => {
+		e().info("[yoyoclaw-channel] device not registered, notifying connection layer"), this.config.onDeviceNotRegistered?.();
+	};
+	handleUnauthorized = () => {
+		e().info("[yoyoclaw-channel] unauthorized connection, notifying connection layer"), this.config.onUnauthorized?.();
+	};
+};
+//#endregion
+export { a as ClawChannel };

package/dist/cloud-channel/client.mjs

@@ -0,0 +1,160 @@
+import { useClawLogger as e } from "../utils/logger.mjs";
+import { StatusEventType as t } from "../services/connection/status-tracker/events.mjs";
+import { rawDataToString as n } from "../utils/ws.mjs";
+import { buildCloudSocketConnectParams as r } from "./utils.mjs";
+import i from "ws";
+//#region src/cloud-channel/client.ts
+var a = 3e4, o = 4e3, s = 1e3, c = 2, l = 999, u = class {
+	ws = null;
+	options;
+	retryCount = 0;
+	retryTimer = null;
+	isManualClose = !1;
+	isRetryPaused = !1;
+	pingTimer = null;
+	currentTraceId = "";
+	constructor(e) {
+		this.options = e;
+	}
+	connect(e = !1) {
+		if (this.ws?.readyState === i.OPEN) return;
+		this.clearRetryTimer();
+		let { deviceInfo: n, userInfo: a } = this.options, { url: o, traceId: s, wsOptions: c } = r(n, a);
+		this.currentTraceId = s, this.options.onStatusEvent?.({
+			type: t.CLOUD_SOCKET_CONNECTING,
+			timestamp: Date.now(),
+			data: { url: o }
+		}), this.ws = new i(o, c), this.ws.on("open", this.handleOpen.bind(this, o, e)), this.ws.on("message", this.onMessage), this.ws.on("pong", this.handlePong), this.ws.on("close", this.handleClose), this.ws.on("error", this.handleError);
+	}
+	handleOpen = (n, r) => {
+		let i = r ? "reconnected" : "connected";
+		e().info(`[claw-cloud-socket][${this.currentTraceId}] ${i} to ${n.slice(0, 15)}`), this.clearRetryTimer(), this.isManualClose = !1, this.retryCount = 0, this.isRetryPaused = !1, this.startPingTimer(), this.options.onStatusEvent?.({
+			type: t.CLOUD_SOCKET_CONNECTED,
+			timestamp: Date.now(),
+			data: {
+				url: n,
+				connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		}), this.options.onOpen?.();
+	};
+	handlePong = () => {
+		e().debug?.("[claw-cloud-socket] received pong from server");
+	};
+	handleClose = (n, r) => {
+		let i = r.toString();
+		e().info(`[claw-cloud-socket][${this.currentTraceId}] connection closed: ${n} - ${i}`), this.options.onStatusEvent?.({
+			type: t.CLOUD_SOCKET_DISCONNECTED,
+			timestamp: Date.now(),
+			data: {
+				reason: i,
+				code: n,
+				disconnectedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		}), this.isManualClose ? (this.stopPingTimer(), this.options.onClose?.()) : this.scheduleReconnect();
+	};
+	handleError = (n) => {
+		e().error(`[claw-cloud-socket][${this.currentTraceId}] connect errorred: ${n.message}`), n.message.includes("401") && (e().warn(`[claw-cloud-socket][${this.currentTraceId}] unauthorized connection (401), pausing retry and notifying client`), this.pauseRetry(), this.options.onUnauthorized?.()), this.options.onStatusEvent?.({
+			type: t.CLOUD_SOCKET_ERROR,
+			timestamp: Date.now(),
+			data: {
+				error: n.message,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		});
+	};
+	send(t) {
+		if (!this.ws || this.ws.readyState !== i.OPEN) return e().error("[claw-cloud-socket] cannot send message: connection not open"), !1;
+		try {
+			let e = JSON.stringify(t);
+			return this.ws.send(e), !0;
+		} catch (n) {
+			return e().error(`[claw-cloud-socket] failed to send message to cloud session ${t.targetDeviceId},
+        ${n instanceof Error ? n.message : String(n)}`), !1;
+		}
+	}
+	close() {
+		this.isManualClose = !0, this.reset(), this.ws &&= (this.ws.close(), null);
+	}
+	reset() {
+		this.clearRetryTimer(), this.stopPingTimer();
+	}
+	onMessage = async (t) => {
+		try {
+			let r = n(t), i = JSON.parse(r);
+			if (e().debug?.(`[yoyoclaw-channel] received cloud message from session ${i.wsOutputEvent?.sourceDeviceId}, deviceId ${i.wsOutputEvent?.sourceDeviceInfo?.deviceId || "nil"}, ${r.slice(0, 3e3)}`), i.code === "YOYO_CLAW_100000") {
+				if (i.wsOutputEvent) {
+					i.sessionInfo && (i.wsOutputEvent.sessionInfo = i.sessionInfo), this.options.onMessage?.(i.wsOutputEvent);
+					return;
+				}
+			} else if (i.code === "YOYO_CLAW_100002") {
+				if (i.extData?.offlineSocketId) {
+					e().info(`[claw-cloud-socket] remote device offline, session: ${i.extData.offlineSocketId}`), this.options.onRemoteDeviceOffline?.(i.extData.offlineSocketId);
+					return;
+				}
+			} else if (i.code === "YOYO_CLAW_100001") {
+				this.pauseRetry(), e().info("[claw-cloud-socket] device not registered, closing connection"), this.options.onDeviceNotRegistered?.();
+				return;
+			}
+			e().warn(`[claw-cloud-socket] unexpected message: ${i.cnMessage}, code: ${i.code}`);
+		} catch (t) {
+			e().error(`[claw-cloud-socket] failed to parse message: ${t instanceof Error ? t.message : String(t)}`);
+		}
+	};
+	scheduleReconnect() {
+		if (this.isRetryPaused) {
+			e().info("[claw-cloud-socket] retry paused, skipping reconnect"), this.reset(), this.options.onClose?.();
+			return;
+		}
+		this.clearRetryTimer();
+		let n = this.calculateRetryDelay();
+		this.retryCount = Math.min(this.retryCount + 1, l), e().info(`[claw-cloud-socket] scheduling reconnect attempt ${this.retryCount} in ${n}ms`), this.options.onStatusEvent?.({
+			type: t.CLOUD_SOCKET_RETRY,
+			timestamp: Date.now(),
+			data: {
+				retryCount: this.retryCount,
+				delay: n
+			}
+		}), this.retryTimer = setTimeout(() => {
+			this.connect(!0);
+		}, n);
+	}
+	clearRetryTimer() {
+		this.retryTimer &&= (clearTimeout(this.retryTimer), null);
+	}
+	calculateRetryDelay() {
+		let e = s * c ** +Math.min(this.retryCount, 2);
+		return Math.min(e, o);
+	}
+	startPingTimer() {
+		this.pingTimer = setInterval(() => {
+			if (!this.ws || this.ws.readyState !== i.OPEN) {
+				this.stopPingTimer();
+				return;
+			}
+			this.ws.ping(), e().debug?.("[claw-cloud-socket] sent ping to server");
+			let { deviceInfo: t } = this.options, n = {
+				msgType: "pingMessage",
+				sourceRole: "yoyoclaw",
+				sourceDeviceId: t.deviceId,
+				targetRole: "node",
+				port: t.port
+			};
+			try {
+				this.ws.send(JSON.stringify(n)), e().debug?.("[claw-cloud-socket] sent pingMessage to server");
+			} catch {
+				e().error("[claw-cloud-socket] failed to send pingMessage");
+			}
+		}, a);
+	}
+	stopPingTimer() {
+		this.pingTimer &&= (clearInterval(this.pingTimer), null);
+	}
+	pauseRetry() {
+		this.isRetryPaused || (this.isRetryPaused = !0, this.clearRetryTimer(), e().info("[claw-cloud-socket] retry paused"));
+	}
+	resumeRetry() {
+		this.isRetryPaused && (this.isRetryPaused = !1, e().info("[claw-cloud-socket] retry resumed"), (!this.ws || this.ws.readyState !== i.OPEN) && (this.retryCount = 0, this.connect(!0)));
+	}
+};
+//#endregion
+export { u as ClawCloudSocketClient };