@aka_openclaw_plugin/mychat 0.1.5 → 0.1.7

package/channel-CoROTtFt.js

@@ -0,0 +1,948 @@
+import { i as setMychatRuntime, n as init_runtime, o as __toCommonJS, r as runtime_exports, t as getMychatRuntime } from "./runtime-7z_VfQ27.js";
+import { t as mychatConfigSchema } from "./config-schema-C42X7OSY.js";
+import { createChannelPluginBase, createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
+import { createAccountStatusSink } from "openclaw/plugin-sdk/channel-lifecycle";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/channel-plugin-common";
+//#region src/accounts.ts
+const DEFAULT_DM_POLICY = "open";
+const DEFAULT_GROUP_POLICY = "open";
+const DEFAULT_HISTORY_LIMIT = 50;
+const DEFAULT_MEDIA_MAX_MB = 10;
+function resolveWsUrl(baseUrl) {
+	const url = new URL(baseUrl);
+	url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+	url.pathname = url.pathname.replace(/\/+$/, "") + "/ws/bot";
+	return url.toString();
+}
+function mergeAccountConfig(channel, account) {
+	if (!account) return channel;
+	return {
+		...channel,
+		...account,
+		actions: {
+			messages: account.actions?.messages ?? channel.actions?.messages ?? true,
+			threads: account.actions?.threads ?? channel.actions?.threads ?? true,
+			reactions: account.actions?.reactions ?? channel.actions?.reactions ?? true
+		},
+		groups: {
+			...channel.groups ?? {},
+			...account.groups ?? {}
+		},
+		reconnect: account.reconnect ?? channel.reconnect
+	};
+}
+function resolveMychatAccounts(cfg) {
+	const mychatConfig = cfg.channels?.mychat;
+	if (!mychatConfig) return [];
+	const accounts = mychatConfig.accounts ?? {};
+	const accountIds = Object.keys(accounts);
+	if (accountIds.length === 0) {
+		const resolved = resolveSingleAccount({
+			accountId: DEFAULT_ACCOUNT_ID,
+			config: mychatConfig
+		});
+		return resolved ? [resolved] : [];
+	}
+	return accountIds.map((id) => {
+		return resolveSingleAccount({
+			accountId: id,
+			config: mergeAccountConfig(mychatConfig, accounts[id])
+		});
+	}).filter(Boolean);
+}
+function resolveSingleAccount(params) {
+	const { accountId, config } = params;
+	const enabled = config.enabled ?? true;
+	if (!enabled) return null;
+	const token = resolveToken(config);
+	if (!token) return null;
+	const baseUrl = config.baseUrl.replace(/\/+$/, "");
+	const wsUrl = config.wsUrl ?? resolveWsUrl(baseUrl);
+	return {
+		accountId: normalizeAccountId(accountId),
+		enabled,
+		name: config.name,
+		baseUrl,
+		wsUrl,
+		token,
+		defaultTo: config.defaultTo,
+		dmPolicy: config.dmPolicy ?? DEFAULT_DM_POLICY,
+		groupPolicy: config.groupPolicy ?? DEFAULT_GROUP_POLICY,
+		allowFrom: config.allowFrom ?? [],
+		groupAllowFrom: config.groupAllowFrom ?? [],
+		requireMention: config.requireMention ?? false,
+		historyLimit: config.historyLimit ?? DEFAULT_HISTORY_LIMIT,
+		mediaMaxMb: config.mediaMaxMb ?? DEFAULT_MEDIA_MAX_MB,
+		actions: {
+			messages: config.actions?.messages ?? true,
+			threads: config.actions?.threads ?? true,
+			reactions: config.actions?.reactions ?? true
+		},
+		groups: config.groups ?? {},
+		reconnect: config.reconnect ?? {}
+	};
+}
+function resolveToken(config) {
+	if (config.token) return config.token;
+	if (typeof process !== "undefined") {
+		const envToken = process.env.MYCHAT_BOT_TOKEN;
+		if (envToken) return envToken;
+	}
+	return null;
+}
+function resolveMychatAccount(params) {
+	const accounts = resolveMychatAccounts(params.cfg);
+	if (accounts.length === 0) return null;
+	if (!params.accountId) return accounts[0];
+	return accounts.find((a) => a.accountId === params.accountId) ?? accounts[0] ?? null;
+}
+//#endregion
+//#region src/client/http-client.ts
+function createMychatHttpClient(params) {
+	const { baseUrl, token } = params;
+	const base = baseUrl.replace(/\/+$/, "");
+	async function request(method, path, body) {
+		try {
+			const headers = { authorization: `Bearer ${token}` };
+			if (body !== void 0) headers["content-type"] = "application/json";
+			const response = await fetch(`${base}${path}`, {
+				method,
+				headers,
+				body: body !== void 0 ? JSON.stringify(body) : void 0
+			});
+			if (!response.ok) {
+				console.error(`[mychat] HTTP ${method} ${path} failed: ${response.status} ${response.statusText}`);
+				return null;
+			}
+			return await response.json();
+		} catch (err) {
+			console.error(`[mychat] HTTP ${method} ${path} error:`, err);
+			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 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) {
+			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(`${base}/api/bot/uploads`, {
+					method: "POST",
+					headers: { authorization: `Bearer ${token}` },
+					body: formData
+				});
+				if (!response.ok) return null;
+				return await response.json();
+			} catch {
+				return null;
+			}
+		},
+		async healthCheck() {
+			const start = Date.now();
+			try {
+				const response = await fetch(`${base}/health`);
+				const latencyMs = Date.now() - start;
+				return {
+					ok: response.ok,
+					latencyMs
+				};
+			} catch {
+				return {
+					ok: false,
+					latencyMs: Date.now() - start
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region src/client/ws-client.ts
+init_runtime();
+const DEFAULT_INITIAL_DELAY_MS = 1e3;
+const DEFAULT_MAX_DELAY_MS = 3e4;
+const DEFAULT_BACKOFF_MULTIPLIER = 2;
+function createMychatWsClient(params) {
+	const { wsUrl, token, botSelfId, 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;
+	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;
+		reconnectTimer = setTimeout(() => {
+			reconnectTimer = null;
+			currentDelay = Math.min(currentDelay * backoffMultiplier, maxDelay);
+			connect();
+		}, currentDelay);
+	}
+	function connect() {
+		if (ws) return;
+		try {
+			const url = buildUrl();
+			const urlWithToken = new URL(url);
+			urlWithToken.searchParams.set("token", token);
+			console.log(`[mychat] WS connecting to ${urlWithToken.origin}${urlWithToken.pathname}`);
+			ws = new WebSocket(urlWithToken.toString());
+			ws.onopen = () => {
+				connected = true;
+				currentDelay = initialDelay;
+				if (botSelfId) ws?.send(JSON.stringify({
+					type: "subscribe",
+					body: { subscribe: { conversationId: botSelfId } }
+				}));
+			};
+			ws.onmessage = (event) => {
+				try {
+					const message = JSON.parse(event.data);
+					for (const handler of handlers) handler(message);
+				} catch {}
+			};
+			ws.onclose = () => {
+				connected = false;
+				ws = null;
+				scheduleReconnect();
+			};
+			ws.onerror = (event) => {
+				console.error(`[mychat] WS error:`, event);
+				ws?.close();
+			};
+		} catch {
+			scheduleReconnect();
+		}
+	}
+	function disconnect() {
+		if (reconnectTimer) {
+			clearTimeout(reconnectTimer);
+			reconnectTimer = null;
+		}
+		connected = false;
+		ws?.close();
+		ws = null;
+	}
+	return {
+		connect,
+		disconnect,
+		onMessage(handler) {
+			handlers.add(handler);
+			return () => {
+				handlers.delete(handler);
+			};
+		},
+		isConnected() {
+			return connected;
+		}
+	};
+}
+//#endregion
+//#region 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 src/monitor/listeners.ts
+function createMychatMessageListener(params) {
+	const { handler } = params;
+	return { handle(message) {
+		handler.handleMessage(message).catch(() => {});
+	} };
+}
+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 src/monitor/provider.startup.ts
+function createMychatProviderClients(account, botSelfId) {
+	return { wsClient: createMychatWsClient({
+		wsUrl: account.wsUrl,
+		token: account.token,
+		botSelfId,
+		reconnect: account.reconnect
+	}) };
+}
+function registerMychatMonitorListeners(params) {
+	const { account, handler, wsClient } = params;
+	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;
+			default: break;
+		}
+	});
+}
+//#endregion
+//#region src/monitor/provider.lifecycle.ts
+const DEFAULT_READY_TIMEOUT_MS = 15e3;
+function createMychatProviderLifecycle(params) {
+	const { httpClient, wsClient, readyTimeoutMs = DEFAULT_READY_TIMEOUT_MS } = params;
+	const logger = getMychatLogger();
+	const prefix = mychatLogPrefix("lifecycle");
+	return {
+		async waitForReady() {
+			const start = Date.now();
+			wsClient.connect();
+			while (Date.now() - start < readyTimeoutMs) {
+				if (wsClient.isConnected()) {
+					const botSelf = await httpClient.getSelf();
+					if (botSelf) {
+						logger?.info(`${prefix} bot connected botId=${botSelf.botId}`);
+						return botSelf;
+					}
+					logger?.warn(`${prefix} ws connected but getSelf() failed`);
+				}
+				await new Promise((r) => setTimeout(r, 500));
+			}
+			const wsConnected = wsClient.isConnected();
+			logger?.warn(`${prefix} ready timeout wsConnected=${wsConnected} elapsedMs=${Date.now() - start}`);
+			return null;
+		},
+		shutdown() {
+			wsClient.disconnect();
+			logger?.info(`${prefix} shutdown`);
+		}
+	};
+}
+//#endregion
+//#region 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 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 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 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 chatType = toKind === "group" || toKind === "channel" ? "group" : "direct";
+	return {
+		messageId: message.id,
+		text,
+		senderId,
+		senderName: message.from?.name,
+		chatType,
+		conversationId: message.to?.id ?? message.body?.conversationId,
+		threadId: message.body?.parentId,
+		replyTo: message.body?.parentId,
+		mentions: message.body?.mentions ?? [],
+		attachments: message.body?.attachments ?? [],
+		timestamp: message.timestamp
+	};
+}
+//#endregion
+//#region 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 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 src/monitor/message-handler.ts
+function createMychatMessageHandler(params) {
+	const { account, onInbound } = params;
+	const dedupe = createMychatInboundDedupe();
+	const logger = getMychatLogger();
+	const prefix = mychatLogPrefix("handler");
+	return { async handleMessage(message) {
+		if (dedupe.isDuplicate(message.id)) return;
+		const preflight = mychatPreflight(message, account);
+		if (!preflight.allowed) {
+			if (logger) logger.debug(`${prefix} message rejected reason=${preflight.reason} messageId=${message.id}`);
+			return;
+		}
+		const result = processMychatInbound(message, account);
+		if (!result) return;
+		if (logger) logger.debug(`${prefix} message accepted messageId=${result.context.messageId} chatType=${result.context.chatType}`);
+		await onInbound(result);
+	} };
+}
+//#endregion
+//#region src/monitor/provider.ts
+async function monitorMychatProvider(ctx) {
+	const { account, setStatus } = ctx;
+	const logger = getMychatLogger();
+	const prefix = mychatLogPrefix("provider");
+	if (logger) logger.info(`${prefix} starting accountId=${account.accountId}`);
+	setStatus({
+		connected: false,
+		mode: "websocket"
+	});
+	const httpClient = createMychatHttpClient({
+		baseUrl: account.baseUrl,
+		token: account.token
+	});
+	const botSelf = await httpClient.getSelf();
+	if (!botSelf) {
+		const error = "MyChat provider failed to get bot identity";
+		if (logger) logger.error(`${prefix} ${error}`);
+		setStatus({
+			connected: false,
+			lastError: error
+		});
+		throw new Error(error);
+	}
+	const health = await httpClient.healthCheck();
+	if (!health.ok) {
+		if (logger) logger.warn(`${prefix} health check failed latencyMs=${health.latencyMs}`);
+	}
+	const { wsClient } = createMychatProviderClients(account, botSelf.botId);
+	const rt = ctx.runtime;
+	rt.mychat = {
+		accountId: account.accountId,
+		httpClient,
+		wsClient,
+		botSelf
+	};
+	try {
+		setMychatRuntime(ctx.runtime);
+	} catch {}
+	registerMychatMonitorListeners({
+		account,
+		handler: createMychatMessageHandler({
+			account,
+			onInbound: async (result) => {
+				await dispatchMychatInbound(ctx, httpClient, result);
+			}
+		}),
+		wsClient
+	});
+	const lifecycle = createMychatProviderLifecycle({
+		httpClient,
+		wsClient
+	});
+	const readyBotSelf = await lifecycle.waitForReady();
+	if (!readyBotSelf) {
+		const error = "MyChat provider failed to connect";
+		if (logger) 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
+	});
+	if (logger) logger.info(`${prefix} bot connected botId=${readyBotSelf.botId}`);
+	ctx.abortSignal?.addEventListener("abort", () => {
+		if (logger) logger.info(`${prefix} abort signal received, shutting down`);
+		lifecycle.shutdown();
+		setStatus({ connected: false });
+	});
+	return { unsubscribe() {
+		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 = getMychatLogger();
+	const prefix = mychatLogPrefix("dispatch");
+	const rt = runtime;
+	if (!rt.channel?.turn?.run) {
+		if (logger) logger.warn(`${prefix} channel turn runtime not available, skipping inbound`);
+		return;
+	}
+	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" ? "group" : "direct"
+						});
+						if (logger) logger.debug(`${prefix} reply sent to=${conversationId} ok=${Boolean(sendResult)}`);
+					} }
+				};
+			}
+		}
+	});
+}
+//#endregion
+//#region 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
+			});
+			return { unsubscribe: (await monitorMychatProvider({
+				cfg: ctx.cfg,
+				runtime: ctx.runtime,
+				account: ctx.account,
+				setStatus,
+				abortSignal: ctx.abortSignal,
+				log: ctx.log
+			})).unsubscribe };
+		} }
+	};
+}
+//#endregion
+//#region src/outbound/outbound-payload.ts
+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 src/outbound/outbound-send-context.ts
+function createMychatOutboundSendContext(params) {
+	return {
+		account: params.account,
+		httpClient: params.httpClient
+	};
+}
+//#endregion
+//#region src/outbound/outbound-adapter.ts
+init_runtime();
+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,
+				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,
+					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,
+			replyTo: params.replyTo
+		});
+		return {
+			channel: "mychat",
+			messageId: result.messageId ?? "",
+			ok: result.ok
+		};
+	}
+};
+//#endregion
+//#region 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: {
+		replyToMode: "always",
+		resolveReplyTo(params) {
+			return {
+				threadId: params.inbound?.threadId ?? params.inbound?.conversationId,
+				replyTo: params.inbound?.messageId
+			};
+		},
+		sanitizeThreadName(name) {
+			return name.slice(0, 100).replace(/[^\w\s-]/g, "");
+		}
+	},
+	outbound: mychatOutbound
+});
+//#endregion
+export { mychatPlugin as t };