@aka_openclaw_plugin/mychat 0.1.4 → 0.1.5

package/dist/channel-D_abyn0t.js

@@ -1,946 +0,0 @@
-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.includes("/ws/bot")) 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 };