@aka_openclaw_plugin/mychat 0.1.19 → 0.1.20

package/dist/channel-BVfWh6jv.js

@@ -0,0 +1,956 @@
+import { i as setMychatRuntime, n as init_runtime, o as __toCommonJS, r as runtime_exports, t as getMychatRuntime } from "./runtime-CkiGSF1r.js";
+import { n as resolveMychatAccounts, t as resolveMychatAccount } from "./accounts-BTv5784y.js";
+import { t as mychatConfigSchema } from "./config-schema-CjCqWPdP.js";
+import { createChannelPluginBase, createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
+import { createAccountStatusSink } from "openclaw/plugin-sdk/channel-lifecycle";
+import WebSocket from "ws";
+//#region extensions/mychat/src/logger.ts
+const PREFIX = "mychat";
+function mychatLogPrefix(feature) {
+	return `[${PREFIX}:${feature}]`;
+}
+function getMychatLogger() {
+	try {
+		const logger = ((init_runtime(), __toCommonJS(runtime_exports)).tryGetMychatRuntime?.())?.logger;
+		if (!logger) return null;
+		return {
+			debug: (m) => logger.debug?.(m),
+			info: (m) => logger.info(m),
+			warn: (m) => logger.warn(m),
+			error: (m) => logger.error(m)
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region extensions/mychat/src/outbound/outbound-payload.ts
+init_runtime();
+async function sendMychatOutboundPayload(ctx, body) {
+	const logger = getMychatLogger();
+	const prefix = mychatLogPrefix("outbound");
+	try {
+		const result = await ctx.httpClient.sendMessage(body);
+		if (result) {
+			if (logger) logger.debug(`${prefix} message sent id=${result.id} status=${result.status}`);
+			return {
+				messageId: result.id,
+				ok: true
+			};
+		}
+		return { ok: false };
+	} catch (error) {
+		if (logger) logger.error(`${prefix} send failed error=${error instanceof Error ? error.message : String(error)}`);
+		return { ok: false };
+	}
+}
+//#endregion
+//#region extensions/mychat/src/outbound/outbound-send-context.ts
+function createMychatOutboundSendContext(params) {
+	return {
+		account: params.account,
+		httpClient: params.httpClient
+	};
+}
+//#endregion
+//#region extensions/mychat/src/outbound/outbound-adapter.ts
+const TEXT_CHUNK_LIMIT = 4e3;
+function chunkText(text, limit) {
+	if (text.length <= limit) return [text];
+	const chunks = [];
+	let remaining = text;
+	while (remaining.length > 0) {
+		chunks.push(remaining.slice(0, limit));
+		remaining = remaining.slice(limit);
+	}
+	return chunks;
+}
+const mychatOutbound = {
+	deliveryMode: "direct",
+	textChunkLimit: TEXT_CHUNK_LIMIT,
+	async sendText(params) {
+		const logger = getMychatLogger();
+		const account = getMychatRuntime().mychat;
+		if (!account) {
+			if (logger) logger.error(`${mychatLogPrefix("outbound")} no runtime account`);
+			return {
+				channel: "mychat",
+				messageId: "",
+				ok: false
+			};
+		}
+		const ctx = createMychatOutboundSendContext({
+			account: params.account,
+			httpClient: account.httpClient
+		});
+		const chunks = chunkText(params.text, TEXT_CHUNK_LIMIT);
+		let lastOk = false;
+		let lastMessageId = "";
+		for (const chunk of chunks) {
+			const result = await sendMychatOutboundPayload(ctx, {
+				to: params.target ?? "",
+				text: chunk,
+				type: params.chatType ?? "direct",
+				replyTo: params.replyTo
+			});
+			lastOk = result.ok;
+			if (result.messageId) lastMessageId = result.messageId;
+		}
+		return {
+			channel: "mychat",
+			messageId: lastMessageId,
+			ok: lastOk
+		};
+	},
+	async sendMedia(params) {
+		const logger = getMychatLogger();
+		const account = getMychatRuntime().mychat;
+		if (!account) {
+			if (logger) logger.error(`${mychatLogPrefix("outbound")} no runtime account`);
+			return {
+				channel: "mychat",
+				messageId: "",
+				ok: false
+			};
+		}
+		if (params.media) {
+			const uploadResult = await account.httpClient.uploadFile({
+				file: params.media,
+				filename: params.filename ?? "upload",
+				mimeType: params.mimeType ?? "application/octet-stream"
+			});
+			if (uploadResult) {
+				const result = await sendMychatOutboundPayload(createMychatOutboundSendContext({
+					account: params.account,
+					httpClient: account.httpClient
+				}), {
+					to: params.target ?? "",
+					text: params.text ?? "",
+					type: params.chatType ?? "direct",
+					attachments: [uploadResult.attachment]
+				});
+				return {
+					channel: "mychat",
+					messageId: result.messageId ?? "",
+					ok: result.ok
+				};
+			}
+		}
+		return {
+			channel: "mychat",
+			messageId: "",
+			ok: false
+		};
+	},
+	async sendPayload(params) {
+		const logger = getMychatLogger();
+		const account = getMychatRuntime().mychat;
+		if (!account) {
+			if (logger) logger.error(`${mychatLogPrefix("outbound")} no runtime account`);
+			return {
+				channel: "mychat",
+				messageId: "",
+				ok: false
+			};
+		}
+		const result = await sendMychatOutboundPayload(createMychatOutboundSendContext({
+			account: params.account,
+			httpClient: account.httpClient
+		}), {
+			to: params.target ?? "",
+			text: params.text ?? "",
+			type: params.chatType ?? "direct",
+			replyTo: params.replyTo
+		});
+		return {
+			channel: "mychat",
+			messageId: result.messageId ?? "",
+			ok: result.ok
+		};
+	}
+};
+//#endregion
+//#region extensions/mychat/src/client/http-client.ts
+function createMychatHttpClient(params) {
+	const { baseUrl, token, logger } = params;
+	const base = baseUrl.replace(/\/+$/, "");
+	const prefix = mychatLogPrefix("http");
+	async function request(method, path, body) {
+		const url = `${base}${path}`;
+		try {
+			const headers = { authorization: `Bearer ${token}` };
+			if (body !== void 0) headers["content-type"] = "application/json";
+			const response = await fetch(url, {
+				method,
+				headers,
+				body: body !== void 0 ? JSON.stringify(body) : void 0
+			});
+			if (!response.ok) {
+				let errorBody = "";
+				try {
+					errorBody = await response.text();
+				} catch {}
+				const msg = `${prefix} ${method} ${url} failed: ${response.status} ${response.statusText}${errorBody ? ` body=${errorBody.slice(0, 200)}` : ""}`;
+				logger?.error(msg);
+				return null;
+			}
+			return await response.json();
+		} catch (err) {
+			const errMsg = err instanceof Error ? `${err.message}` : String(err);
+			logger?.error(`${prefix} ${method} ${url} error: ${errMsg}`);
+			return null;
+		}
+	}
+	return {
+		async getSelf() {
+			return request("GET", "/api/bot/self");
+		},
+		async getMe() {
+			return request("GET", "/api/auth/me");
+		},
+		async sendMessage(body) {
+			return request("POST", "/api/bot/messages", body);
+		},
+		async listMessages(params) {
+			const searchParams = new URLSearchParams();
+			if (params.conversationId) searchParams.set("conversationId", params.conversationId);
+			if (params.limit) searchParams.set("limit", String(params.limit));
+			if (params.after) searchParams.set("after", String(params.after));
+			const qs = searchParams.toString();
+			return (await request("GET", `/api/bot/messages${qs ? `?${qs}` : ""}`))?.messages ?? [];
+		},
+		async listConversations() {
+			return (await request("GET", "/api/bot/conversations"))?.conversations?.map((c) => c.id) ?? [];
+		},
+		async addReaction(messageId, body) {
+			return request("POST", `/api/bot/messages/${messageId}/reactions`, body);
+		},
+		async removeReaction(messageId, emoji) {
+			return request("POST", `/api/bot/messages/${messageId}/reactions`, {
+				emoji,
+				action: "remove"
+			});
+		},
+		async uploadFile(params) {
+			const url = `${base}/api/bot/uploads`;
+			try {
+				const formData = new FormData();
+				let blob;
+				if (params.file instanceof Blob) blob = params.file;
+				else {
+					const bytes = new Uint8Array(params.file.buffer, params.file.byteOffset, params.file.byteLength);
+					blob = new Blob([bytes], { type: params.mimeType });
+				}
+				formData.append("file", blob, params.filename);
+				if (params.scopeKind) formData.append("scopeKind", params.scopeKind);
+				if (params.scopeId) formData.append("scopeId", params.scopeId);
+				const response = await fetch(url, {
+					method: "POST",
+					headers: { authorization: `Bearer ${token}` },
+					body: formData
+				});
+				if (!response.ok) {
+					let errorBody = "";
+					try {
+						errorBody = await response.text();
+					} catch {}
+					logger?.error(`${prefix} POST ${url} failed: ${response.status} ${response.statusText}${errorBody ? ` body=${errorBody.slice(0, 200)}` : ""}`);
+					return null;
+				}
+				return await response.json();
+			} catch (err) {
+				const errMsg = err instanceof Error ? `${err.message}` : String(err);
+				logger?.error(`${prefix} POST ${url} error: ${errMsg}`);
+				return null;
+			}
+		},
+		async healthCheck() {
+			const url = `${base}/health`;
+			const start = Date.now();
+			try {
+				const response = await fetch(url);
+				const latencyMs = Date.now() - start;
+				if (!response.ok) logger?.error(`${prefix} health check failed: ${url} status=${response.status} latencyMs=${latencyMs}`);
+				return {
+					ok: response.ok,
+					latencyMs
+				};
+			} catch (err) {
+				const errMsg = err instanceof Error ? `${err.message}` : String(err);
+				logger?.error(`${prefix} health check error: ${url} error=${errMsg} latencyMs=${Date.now() - start}`);
+				return {
+					ok: false,
+					latencyMs: Date.now() - start
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region extensions/mychat/src/monitor/inbound-dedupe.ts
+const MAX_CACHE_SIZE = 500;
+function createMychatInboundDedupe() {
+	const seen = /* @__PURE__ */ new Set();
+	return { isDuplicate(messageId) {
+		if (seen.has(messageId)) return true;
+		seen.add(messageId);
+		if (seen.size > MAX_CACHE_SIZE) {
+			const first = seen.values().next().value;
+			if (first !== void 0) seen.delete(first);
+		}
+		return false;
+	} };
+}
+//#endregion
+//#region extensions/mychat/src/monitor/message-text.ts
+/** Extract plain text from a WebSocket message body. */
+function extractMychatMessageText(message) {
+	return message.body?.text ?? "";
+}
+/** Extract mention user IDs from a message. */
+function extractMentionUserIds(message) {
+	return (message.body?.mentions ?? []).map((m) => m.userId).filter(Boolean);
+}
+/** Check if the bot is mentioned in a message. */
+function isBotMentioned(message, botUserId) {
+	if (!botUserId) return false;
+	if (extractMentionUserIds(message).includes(botUserId)) return true;
+	return (message.body?.text ?? "").includes(`@${botUserId}`);
+}
+//#endregion
+//#region extensions/mychat/src/monitor/message-handler.preflight.ts
+/** Check if an inbound message should be accepted. */
+function mychatPreflight(message, account) {
+	const senderId = message.from?.id;
+	if (!senderId) return {
+		allowed: false,
+		reason: "no-sender"
+	};
+	if (senderId === account.accountId) return {
+		allowed: false,
+		reason: "self"
+	};
+	const toKind = message.to?.kind ?? "direct";
+	if (toKind === "direct" || toKind === "channel") {
+		if (account.dmPolicy === "disabled") return {
+			allowed: false,
+			reason: "dm-disabled"
+		};
+		if (account.dmPolicy === "allowlist" && account.allowFrom.length > 0) {
+			if (!account.allowFrom.includes(senderId)) return {
+				allowed: false,
+				reason: "dm-not-allowed"
+			};
+		}
+	}
+	if (toKind === "group") {
+		if (account.groupPolicy === "disabled") return {
+			allowed: false,
+			reason: "group-disabled"
+		};
+		if (account.groupPolicy === "allowlist" && account.groupAllowFrom.length > 0) {
+			if (!account.groupAllowFrom.includes(senderId)) return {
+				allowed: false,
+				reason: "group-not-allowed"
+			};
+		}
+		const groupId = message.to?.id;
+		if (groupId && account.groups[groupId]) {
+			const groupConfig = account.groups[groupId];
+			if (groupConfig.enabled === false) return {
+				allowed: false,
+				reason: "group-disabled"
+			};
+			if (groupConfig.requireMention && !isBotMentioned(message, account.accountId)) return {
+				allowed: false,
+				reason: "mention-required"
+			};
+		}
+		if (account.requireMention && !isBotMentioned(message, account.accountId)) return {
+			allowed: false,
+			reason: "mention-required"
+		};
+	}
+	return { allowed: true };
+}
+//#endregion
+//#region extensions/mychat/src/monitor/inbound-context.ts
+function buildMychatInboundContext(message, account) {
+	if (message.type !== "message" && message.type !== "stream") return null;
+	const senderId = message.from?.id;
+	if (!senderId) return null;
+	const text = message.body?.text ?? "";
+	const toKind = message.to?.kind ?? "direct";
+	const threadId = message.body?.parentId;
+	let chatType;
+	if (threadId) chatType = "thread";
+	else if (toKind === "group" || toKind === "channel") chatType = "group";
+	else chatType = "direct";
+	return {
+		messageId: message.id,
+		text,
+		senderId,
+		senderName: message.from?.name,
+		chatType,
+		conversationId: message.to?.id ?? message.body?.conversationId,
+		threadId,
+		replyTo: threadId,
+		mentions: message.body?.mentions ?? [],
+		attachments: message.body?.attachments ?? [],
+		timestamp: message.timestamp
+	};
+}
+//#endregion
+//#region extensions/mychat/src/monitor/message-media.ts
+/** Resolve media attachments from an inbound message. */
+function resolveMychatMediaAttachments(message) {
+	return (message.body?.attachments ?? []).filter((a) => a.url && (a.mimeType.startsWith("image/") || a.mimeType.startsWith("video/") || a.mimeType.startsWith("audio/") || a.mimeType === "application/pdf"));
+}
+//#endregion
+//#region extensions/mychat/src/monitor/message-handler.process.ts
+/** Process an inbound message into a structured result. */
+function processMychatInbound(message, account) {
+	const context = buildMychatInboundContext(message, account);
+	if (!context) return null;
+	return {
+		context,
+		text: extractMychatMessageText(message),
+		media: resolveMychatMediaAttachments(message)
+	};
+}
+//#endregion
+//#region extensions/mychat/src/monitor/message-handler.ts
+function createMychatMessageHandler(params) {
+	const { account, onInbound, logger } = params;
+	const dedupe = createMychatInboundDedupe();
+	const prefix = mychatLogPrefix("handler");
+	return { async handleMessage(message) {
+		logger?.debug(`${prefix} received messageId=${message.id} type=${message.type} from=${message.from?.id} to=${message.to?.id}:${message.to?.kind} text=${(message.body?.text ?? "").slice(0, 80)}`);
+		if (dedupe.isDuplicate(message.id)) {
+			logger?.debug(`${prefix} duplicate messageId=${message.id}, skipping`);
+			return;
+		}
+		const preflight = mychatPreflight(message, account);
+		if (!preflight.allowed) {
+			logger?.info(`${prefix} rejected messageId=${message.id} reason=${preflight.reason} from=${message.from?.id}`);
+			return;
+		}
+		const result = processMychatInbound(message, account);
+		if (!result) {
+			logger?.debug(`${prefix} process returned null for messageId=${message.id}`);
+			return;
+		}
+		logger?.info(`${prefix} accepted messageId=${result.context.messageId} chatType=${result.context.chatType} senderId=${result.context.senderId} text=${result.text.slice(0, 80)}`);
+		try {
+			await onInbound(result);
+			logger?.debug(`${prefix} dispatched messageId=${result.context.messageId}`);
+		} catch (err) {
+			const errMsg = err instanceof Error ? err.message : String(err);
+			logger?.error(`${prefix} dispatch failed messageId=${result.context.messageId}: ${errMsg}`);
+		}
+	} };
+}
+//#endregion
+//#region extensions/mychat/src/monitor/provider.lifecycle.ts
+const DEFAULT_READY_TIMEOUT_MS = 15e3;
+function createMychatProviderLifecycle(params) {
+	const { httpClient, wsClient, readyTimeoutMs = DEFAULT_READY_TIMEOUT_MS, logger } = params;
+	const prefix = mychatLogPrefix("lifecycle");
+	return {
+		async waitForReady() {
+			const start = Date.now();
+			logger?.info(`${prefix} starting timeoutMs=${readyTimeoutMs}`);
+			wsClient.connect();
+			let wsConnectedAt = null;
+			let getSelfAttempts = 0;
+			while (Date.now() - start < readyTimeoutMs) {
+				if (wsClient.isConnected()) {
+					if (!wsConnectedAt) {
+						wsConnectedAt = Date.now();
+						logger?.info(`${prefix} ws connected, fetching bot identity elapsedMs=${wsConnectedAt - start}`);
+					}
+					getSelfAttempts++;
+					const botSelf = await httpClient.getSelf();
+					if (botSelf) {
+						logger?.info(`${prefix} bot connected botId=${botSelf.botId} wsConnectMs=${wsConnectedAt - start} getSelfAttempts=${getSelfAttempts}`);
+						return botSelf;
+					}
+					logger?.warn(`${prefix} getSelf() failed attempt=${getSelfAttempts} elapsedMs=${Date.now() - start}`);
+				}
+				await new Promise((r) => setTimeout(r, 500));
+			}
+			const wsConnected = wsClient.isConnected();
+			const elapsed = Date.now() - start;
+			logger?.warn(`${prefix} ready timeout wsConnected=${wsConnected} wsConnectedAt=${wsConnectedAt ? wsConnectedAt - start : "never"} getSelfAttempts=${getSelfAttempts} elapsedMs=${elapsed} timeoutMs=${readyTimeoutMs}`);
+			return null;
+		},
+		shutdown() {
+			wsClient.disconnect();
+			logger?.info(`${prefix} shutdown`);
+		}
+	};
+}
+//#endregion
+//#region extensions/mychat/src/client/ws-client.ts
+const DEFAULT_INITIAL_DELAY_MS = 1e3;
+const DEFAULT_MAX_DELAY_MS = 3e4;
+const DEFAULT_BACKOFF_MULTIPLIER = 2;
+function createMychatWsClient(params) {
+	const { wsUrl, token, botSelfId, logger, reconnect } = params;
+	const initialDelay = reconnect?.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
+	const maxDelay = reconnect?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+	const backoffMultiplier = reconnect?.backoffMultiplier ?? DEFAULT_BACKOFF_MULTIPLIER;
+	const prefix = mychatLogPrefix("ws");
+	let ws = null;
+	let connected = false;
+	let reconnectTimer = null;
+	let currentDelay = initialDelay;
+	const handlers = /* @__PURE__ */ new Set();
+	function buildUrl() {
+		const url = new URL(wsUrl);
+		if (url.pathname.endsWith("/ws/bot")) {} else if (url.pathname.endsWith("/ws/")) url.pathname += "bot";
+		else if (url.pathname.endsWith("/ws")) url.pathname += "/bot";
+		else url.pathname = url.pathname.replace(/\/+$/, "") + "/ws/bot";
+		return url.toString();
+	}
+	function scheduleReconnect() {
+		if (reconnectTimer) return;
+		logger?.info(`${prefix} will reconnect in ${currentDelay}ms`);
+		reconnectTimer = setTimeout(() => {
+			reconnectTimer = null;
+			currentDelay = Math.min(currentDelay * backoffMultiplier, maxDelay);
+			connect();
+		}, currentDelay);
+	}
+	function connect() {
+		if (ws) return;
+		try {
+			const url = buildUrl();
+			logger?.info(`${prefix} connecting to ${url}`);
+			ws = new WebSocket(url, { headers: { Authorization: `Bearer ${token}` } });
+			ws.on("open", () => {
+				connected = true;
+				currentDelay = initialDelay;
+				logger?.info(`${prefix} connected botSelfId=${botSelfId ?? "none"}`);
+			});
+			ws.on("message", (data) => {
+				try {
+					const message = JSON.parse(String(data));
+					logger?.debug(`${prefix} recv type=${message.type} id=${message.id} from=${message.from?.id} to=${message.to?.id}:${message.to?.kind}`);
+					for (const handler of handlers) handler(message);
+				} catch (err) {
+					const errMsg = err instanceof Error ? err.message : String(err);
+					logger?.error(`${prefix} failed to parse message: ${errMsg} raw=${String(data).slice(0, 200)}`);
+				}
+			});
+			ws.on("close", (code, reason) => {
+				connected = false;
+				ws = null;
+				logger?.info(`${prefix} closed code=${code} reason=${reason?.toString() || "none"}`);
+				scheduleReconnect();
+			});
+			ws.on("error", (err) => {
+				const errMsg = err instanceof Error ? err.message : String(err);
+				logger?.error(`${prefix} error: ${errMsg}`);
+			});
+		} catch (err) {
+			const errMsg = err instanceof Error ? err.message : String(err);
+			logger?.error(`${prefix} connect exception: ${errMsg}`);
+			scheduleReconnect();
+		}
+	}
+	function disconnect() {
+		if (reconnectTimer) {
+			clearTimeout(reconnectTimer);
+			reconnectTimer = null;
+		}
+		connected = false;
+		ws?.close();
+		ws = null;
+	}
+	function subscribe(conversationId) {
+		if (!ws || !connected) {
+			logger?.warn(`${prefix} cannot subscribe, not connected`);
+			return;
+		}
+		const subMsg = JSON.stringify({
+			type: "subscribe",
+			body: { subscribe: { conversationId } }
+		});
+		logger?.info(`${prefix} subscribing to conversationId=${conversationId}`);
+		ws.send(subMsg);
+	}
+	return {
+		connect,
+		disconnect,
+		subscribe,
+		onMessage(handler) {
+			handlers.add(handler);
+			return () => {
+				handlers.delete(handler);
+			};
+		},
+		isConnected() {
+			return connected;
+		}
+	};
+}
+//#endregion
+//#region extensions/mychat/src/monitor/listeners.ts
+function createMychatMessageListener(params) {
+	const { handler } = params;
+	const logger = getMychatLogger();
+	const prefix = mychatLogPrefix("listener");
+	return { handle(message) {
+		logger?.debug(`${prefix} message type=${message.type} id=${message.id} from=${message.from?.id}`);
+		handler.handleMessage(message).catch((err) => {
+			const errMsg = err instanceof Error ? err.message : String(err);
+			logger?.error(`${prefix} handler error for messageId=${message.id}: ${errMsg}`);
+		});
+	} };
+}
+function createMychatReactionListener(params) {
+	const logger = getMychatLogger();
+	const prefix = mychatLogPrefix("reaction");
+	return { handle(message) {
+		const emoji = message.body?.reaction;
+		const action = message.body?.action ?? "add";
+		const target = message.body?.target;
+		const senderId = message.from?.id;
+		if (logger) logger.debug(`${prefix} ${action} ${emoji} on ${target} by ${senderId}`);
+	} };
+}
+function createMychatTypingListener(params) {
+	const logger = getMychatLogger();
+	const prefix = mychatLogPrefix("typing");
+	return { handle(message) {
+		const senderId = message.from?.id;
+		if (senderId === params.account.accountId) return;
+		if (logger) logger.debug(`${prefix} from ${senderId}`);
+	} };
+}
+//#endregion
+//#region extensions/mychat/src/monitor/provider.startup.ts
+function createMychatProviderClients(account, botSelfId, logger) {
+	return { wsClient: createMychatWsClient({
+		wsUrl: account.wsUrl,
+		token: account.token,
+		botSelfId,
+		logger,
+		reconnect: account.reconnect
+	}) };
+}
+function registerMychatMonitorListeners(params) {
+	const { account, handler, wsClient, logger } = params;
+	const prefix = mychatLogPrefix("router");
+	const messageListener = createMychatMessageListener({
+		account,
+		handler
+	});
+	const reactionListener = createMychatReactionListener({ account });
+	const typingListener = createMychatTypingListener({ account });
+	wsClient.onMessage((message) => {
+		switch (message.type) {
+			case "message":
+			case "stream":
+				messageListener.handle(message);
+				break;
+			case "reaction":
+				reactionListener.handle(message);
+				break;
+			case "typing":
+				typingListener.handle(message);
+				break;
+			case "ack":
+				logger?.info(`${prefix} ack conversationId=${message.body?.subscribe?.conversationId} status=${message.body?.status} cursor=${message.body?.currentCursor}`);
+				break;
+			default:
+				logger?.debug(`${prefix} unhandled type=${message.type} id=${message.id}`);
+				break;
+		}
+	});
+}
+//#endregion
+//#region extensions/mychat/src/monitor/provider.ts
+init_runtime();
+async function monitorMychatProvider(ctx) {
+	const { account, setStatus, log: logger } = ctx;
+	const prefix = mychatLogPrefix("provider");
+	logger?.info(`${prefix} starting accountId=${account.accountId}`);
+	setStatus({
+		connected: false,
+		mode: "websocket"
+	});
+	const httpClient = createMychatHttpClient({
+		baseUrl: account.baseUrl,
+		token: account.token,
+		logger
+	});
+	logger?.info(`${prefix} fetching bot identity baseUrl=${account.baseUrl}`);
+	const botSelf = await httpClient.getSelf();
+	if (!botSelf) {
+		const error = `MyChat provider failed to get bot identity (baseUrl=${account.baseUrl}, token=${account.token ? account.token.slice(0, 8) + "..." : "empty"})`;
+		logger?.error(`${prefix} ${error}`);
+		setStatus({
+			connected: false,
+			lastError: error
+		});
+		throw new Error(error);
+	}
+	logger?.info(`${prefix} got bot identity botId=${botSelf.botId} name=${botSelf.name ?? "unknown"}`);
+	const health = await httpClient.healthCheck();
+	if (!health.ok) logger?.warn(`${prefix} health check failed latencyMs=${health.latencyMs} baseUrl=${account.baseUrl}`);
+	else logger?.info(`${prefix} health check ok latencyMs=${health.latencyMs}`);
+	const { wsClient } = createMychatProviderClients(account, botSelf.botId, logger);
+	const rt = ctx.runtime;
+	rt.mychat = {
+		accountId: account.accountId,
+		httpClient,
+		wsClient,
+		botSelf
+	};
+	try {
+		setMychatRuntime(ctx.runtime);
+	} catch {}
+	registerMychatMonitorListeners({
+		account,
+		handler: createMychatMessageHandler({
+			account,
+			logger,
+			onInbound: async (result) => {
+				await dispatchMychatInbound(ctx, httpClient, result);
+			}
+		}),
+		wsClient,
+		logger
+	});
+	logger?.info(`${prefix} starting connection lifecycle`);
+	const lifecycle = createMychatProviderLifecycle({
+		httpClient,
+		wsClient,
+		logger
+	});
+	const readyBotSelf = await lifecycle.waitForReady();
+	if (!readyBotSelf) {
+		const error = "MyChat provider failed to connect";
+		logger?.error(`${prefix} ${error}`);
+		setStatus({
+			connected: false,
+			lastError: error
+		});
+		lifecycle.shutdown();
+		throw new Error(error);
+	}
+	setStatus({
+		connected: true,
+		lastConnectedAt: Date.now(),
+		lastEventAt: Date.now(),
+		mode: "websocket",
+		lastError: null
+	});
+	logger?.info(`${prefix} bot connected botId=${readyBotSelf.botId}`);
+	try {
+		const conversations = await httpClient.listConversations();
+		logger?.info(`${prefix} found ${conversations.length} conversations to subscribe`);
+		for (const convId of conversations) wsClient.subscribe(convId);
+	} catch (err) {
+		logger?.warn(`${prefix} failed to list conversations: ${err}`);
+	}
+	ctx.abortSignal?.addEventListener("abort", () => {
+		logger?.info(`${prefix} abort signal received, shutting down`);
+		lifecycle.shutdown();
+		setStatus({ connected: false });
+	});
+	return { unsubscribe() {
+		logger?.info(`${prefix} unsubscribe called, shutting down`);
+		lifecycle.shutdown();
+		setStatus({ connected: false });
+	} };
+}
+/** Dispatch an inbound message through the OpenClaw turn runtime. */
+async function dispatchMychatInbound(ctx, httpClient, result) {
+	const { runtime, cfg, account } = ctx;
+	const logger = ctx.log;
+	const prefix = mychatLogPrefix("dispatch");
+	const rt = runtime;
+	if (!rt.channel?.turn?.run) {
+		logger?.error(`${prefix} channel.turn.run not available on runtime, cannot dispatch inbound messageId=${result.context.messageId}`);
+		return;
+	}
+	logger?.info(`${prefix} dispatching inbound messageId=${result.context.messageId} senderId=${result.context.senderId} conversationId=${result.context.conversationId}`);
+	const conversationId = result.context.conversationId ?? result.context.senderId;
+	const senderId = result.context.senderId;
+	const chatType = result.context.chatType;
+	const messageId = result.context.messageId;
+	await rt.channel.turn.run({
+		channel: "mychat",
+		accountId: account.accountId,
+		raw: result,
+		adapter: {
+			ingest: () => ({
+				id: messageId,
+				timestamp: result.context.timestamp,
+				rawText: result.text,
+				textForAgent: result.text,
+				textForCommands: result.text,
+				raw: result
+			}),
+			resolveTurn: (input) => {
+				const msgCtx = rt.channel.turn.buildContext({
+					channel: "mychat",
+					accountId: account.accountId,
+					timestamp: input.timestamp,
+					from: `mychat:user:${senderId}`,
+					sender: {
+						id: senderId,
+						name: result.context.senderName
+					},
+					conversation: {
+						kind: chatType,
+						id: conversationId,
+						label: result.context.senderName ?? senderId,
+						routePeer: {
+							kind: chatType,
+							id: conversationId
+						}
+					},
+					route: {
+						agentId: void 0,
+						accountId: account.accountId
+					},
+					reply: {
+						to: `mychat:${conversationId}`,
+						originatingTo: `mychat:${conversationId}`
+					},
+					message: {
+						rawBody: input.rawText,
+						commandBody: input.textForCommands,
+						bodyForAgent: input.textForAgent,
+						envelopeFrom: result.context.senderName
+					}
+				});
+				return {
+					cfg,
+					channel: "mychat",
+					accountId: account.accountId,
+					ctxPayload: msgCtx,
+					dispatchReplyWithBufferedBlockDispatcher: rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
+					delivery: { deliver: async (payload) => {
+						const text = payload.text?.trim();
+						if (!text) return;
+						const sendResult = await httpClient.sendMessage({
+							to: conversationId,
+							text,
+							type: chatType === "group" || chatType === "thread" ? chatType : "direct"
+						});
+						if (logger) logger.debug(`${prefix} reply sent to=${conversationId} ok=${Boolean(sendResult)}`);
+					} }
+				};
+			}
+		}
+	});
+}
+//#endregion
+//#region extensions/mychat/src/shared.ts
+function createMychatPluginBase() {
+	return {
+		...createChannelPluginBase({
+			id: "mychat",
+			setup: { applyAccountConfig(params) {
+				return params.cfg;
+			} },
+			meta: {
+				label: "MyChat",
+				docsPath: "docs/plugins/mychat",
+				blurb: "Connect to MyChat server via bot token",
+				aliases: ["mychat"]
+			},
+			capabilities: {
+				chatTypes: [
+					"direct",
+					"group",
+					"thread"
+				],
+				reactions: true,
+				media: true,
+				threads: true
+			},
+			reload: { configPrefixes: ["channels.mychat"] },
+			configSchema: mychatConfigSchema,
+			config: {
+				listAccountIds(cfg) {
+					return resolveMychatAccounts(cfg).map((a) => a.accountId);
+				},
+				resolveAccount(cfg, accountId) {
+					return resolveMychatAccount({
+						cfg,
+						accountId
+					});
+				},
+				async inspectAccount(account) {
+					return {
+						accountId: account.accountId,
+						enabled: account.enabled,
+						label: account.name ?? account.baseUrl
+					};
+				}
+			}
+		}),
+		gateway: { async startAccount(ctx) {
+			const setStatus = createAccountStatusSink({
+				accountId: ctx.accountId,
+				setStatus: ctx.setStatus
+			});
+			const result = await monitorMychatProvider({
+				cfg: ctx.cfg,
+				runtime: ctx.runtime,
+				account: ctx.account,
+				setStatus,
+				abortSignal: ctx.abortSignal,
+				log: ctx.log
+			});
+			await new Promise((resolve) => {
+				const originalUnsubscribe = result.unsubscribe;
+				result.unsubscribe = () => {
+					originalUnsubscribe();
+					resolve();
+				};
+			});
+		} }
+	};
+}
+//#endregion
+//#region extensions/mychat/src/channel.ts
+const mychatPlugin = createChatChannelPlugin({
+	base: createMychatPluginBase(),
+	security: { dm: {
+		channelKey: "dmPolicy",
+		resolvePolicy(account) {
+			return account.dmPolicy ?? "open";
+		},
+		resolveAllowFrom(account) {
+			return account.allowFrom;
+		}
+	} },
+	pairing: { text: {
+		idLabel: "MyChat Username",
+		message: "To connect to MyChat, configure your bot token and server URL in the channel config.",
+		notify() {}
+	} },
+	threading: {
+		scopedAccountReplyToMode: {
+			resolveAccount: (cfg, accountId) => resolveMychatAccount({
+				cfg,
+				accountId
+			}),
+			resolveReplyToMode: () => "always",
+			fallback: "always"
+		},
+		sanitizeThreadName(name) {
+			return name.slice(0, 100).replace(/[^\w\s-]/g, "");
+		}
+	},
+	outbound: mychatOutbound
+});
+//#endregion
+export { mychatPlugin as t };