@nextclaw/channel-extension-weixin 0.1.1

package/dist/services/weixin-channel-adapter.service.js

@@ -0,0 +1,303 @@
+import { FileWeixinAccountStore } from "../stores/weixin-account.store.js";
+import { HttpWeixinApiClient } from "./weixin-api.service.js";
+import { NcpEventQueue, TERMINAL_NCP_EVENT_TYPES, WeixinReplyChat } from "./weixin-reply-chat.service.js";
+import { resolveWeixinInboundAttachments } from "../utils/weixin-inbound-media.utils.js";
+import { readWeixinEventSessionId, resolveWeixinSessionRoute } from "../utils/weixin-session-route.utils.js";
+import { WeixinTypingController } from "./weixin-typing-controller.service.js";
+import { NcpReplyConsumer } from "@nextclaw/ncp-toolkit";
+//#region src/services/weixin-channel-adapter.service.ts
+const DEFAULT_WEIXIN_BASE_URL = "https://ilinkai.weixin.qq.com";
+const DEFAULT_WEIXIN_POLL_TIMEOUT_MS = 35e3;
+const WEIXIN_MESSAGE_ITEM_TYPE_IMAGE = 2;
+const WEIXIN_MESSAGE_ITEM_TYPE_VOICE = 3;
+const WEIXIN_MESSAGE_ITEM_TYPE_FILE = 4;
+const WEIXIN_MESSAGE_ITEM_TYPE_VIDEO = 5;
+async function defaultSleep(ms, signal) {
+	await new Promise((resolve) => {
+		const timer = setTimeout(resolve, Math.max(0, ms));
+		const onAbort = () => {
+			clearTimeout(timer);
+			resolve();
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function readStringArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
+}
+function isAllowedSender(allowFrom, senderId) {
+	if (allowFrom.length === 0) return true;
+	if (allowFrom.includes(senderId)) return true;
+	return senderId.includes("|") && senderId.split("|").some((part) => allowFrom.includes(part));
+}
+function normalizeRouteKey(conversationId) {
+	return conversationId.toLowerCase();
+}
+function isSyntheticAttachmentText(text) {
+	return text === "[收到图片]" || text === "[收到视频]" || text === "[收到语音]" || /^\[收到文件(?:: .+)?]$/.test(text);
+}
+function extractText(message) {
+	const items = Array.isArray(message.item_list) ? message.item_list : [];
+	for (const item of items) {
+		const text = item.text_item?.text?.trim();
+		if (text) return text;
+		const voiceText = item.voice_item?.text?.trim();
+		if (voiceText) return voiceText;
+	}
+	for (const item of items) {
+		if (item.type === WEIXIN_MESSAGE_ITEM_TYPE_IMAGE) return "[收到图片]";
+		if (item.type === WEIXIN_MESSAGE_ITEM_TYPE_VIDEO) return "[收到视频]";
+		if (item.type === WEIXIN_MESSAGE_ITEM_TYPE_VOICE) return "[收到语音]";
+		if (item.type === WEIXIN_MESSAGE_ITEM_TYPE_FILE) {
+			const fileName = item.file_item?.file_name?.trim();
+			return fileName ? `[收到文件: ${fileName}]` : "[收到文件]";
+		}
+	}
+	return "";
+}
+var WeixinChannelAdapter = class {
+	messageHandler = null;
+	api;
+	store;
+	sleep;
+	logger;
+	replyConsumer;
+	typingController;
+	contextTokens = /* @__PURE__ */ new Map();
+	accountControllers = /* @__PURE__ */ new Map();
+	pollTasks = [];
+	replySessions = /* @__PURE__ */ new Map();
+	canonicalRoutes = /* @__PURE__ */ new Map();
+	running = false;
+	config = {};
+	constructor(deps = {}) {
+		this.api = deps.api ?? new HttpWeixinApiClient();
+		this.store = deps.store ?? new FileWeixinAccountStore();
+		this.sleep = deps.sleep ?? defaultSleep;
+		this.logger = deps.logger ?? console;
+		this.typingController = new WeixinTypingController({
+			fetchTicket: async (runtime) => {
+				return (await this.api.fetchConfig({
+					baseUrl: runtime.baseUrl,
+					token: runtime.token,
+					ilinkUserId: runtime.userId,
+					contextToken: runtime.contextToken
+				})).typing_ticket?.trim();
+			},
+			sendTyping: async (params) => {
+				const { baseUrl, status, ticket, token, userId } = params;
+				await this.api.sendTyping({
+					baseUrl,
+					token,
+					toUserId: userId,
+					typingTicket: ticket,
+					status
+				});
+			}
+		});
+		this.replyConsumer = new NcpReplyConsumer(new WeixinReplyChat({
+			resolveAccount: this.resolveSendAccount,
+			resolveContextToken: this.resolveContextToken,
+			sendText: this.sendText,
+			typingController: this.typingController
+		}));
+	}
+	configure = async (config) => {
+		this.config = config;
+		if (!this.running) return;
+		await this.stop();
+		await this.start();
+	};
+	start = async () => {
+		if (this.running) return;
+		this.running = true;
+		for (const accountId of this.listAvailableAccountIds()) {
+			const controller = new AbortController();
+			this.accountControllers.set(accountId, controller);
+			this.pollTasks.push(this.runPollingLoop(accountId, controller.signal));
+		}
+	};
+	stop = async () => {
+		if (!this.running) return;
+		this.running = false;
+		for (const controller of this.accountControllers.values()) controller.abort();
+		this.accountControllers.clear();
+		for (const session of this.replySessions.values()) session.queue.close();
+		this.replySessions.clear();
+		await Promise.allSettled(this.pollTasks.splice(0, this.pollTasks.length));
+		await this.typingController.stopAll();
+	};
+	onMessage = (handler) => {
+		this.messageHandler = handler;
+		return () => {
+			if (this.messageHandler === handler) this.messageHandler = null;
+		};
+	};
+	sendNcpEvent = async (event) => {
+		if (!this.running) return;
+		const route = resolveWeixinSessionRoute(event);
+		if (!route) return;
+		const sessionId = readWeixinEventSessionId(event);
+		if (!sessionId) return;
+		const session = this.resolveReplySession(sessionId, this.resolveCanonicalRoute(route));
+		session.queue.push(event);
+		if (TERMINAL_NCP_EVENT_TYPES.has(event.type)) {
+			session.queue.close();
+			this.replySessions.delete(sessionId);
+			await session.consuming;
+		}
+	};
+	emitMessageForTest = async (message) => {
+		await this.messageHandler?.(message);
+	};
+	sendText = async (params) => {
+		const { account, contextToken, conversationId, text } = params;
+		await this.api.sendTextMessage({
+			baseUrl: account.baseUrl,
+			token: account.token,
+			toUserId: conversationId,
+			text,
+			contextToken
+		});
+	};
+	resolveReplySession = (sessionId, route) => {
+		const existing = this.replySessions.get(sessionId);
+		if (existing) return existing;
+		const queue = new NcpEventQueue();
+		const session = {
+			queue,
+			consuming: this.replyConsumer.consume({
+				target: {
+					conversationId: route.conversationId,
+					...route.accountId ? { accountId: route.accountId } : {}
+				},
+				eventStream: queue
+			})
+		};
+		this.replySessions.set(sessionId, session);
+		return session;
+	};
+	listAvailableAccountIds = () => {
+		return Array.from(new Set([
+			...this.config.defaultAccountId ? [this.config.defaultAccountId] : [],
+			...Object.keys(this.config.accounts ?? {}),
+			...this.store.listAccountIds()
+		]));
+	};
+	resolveCanonicalRoute = (route) => {
+		const remembered = this.canonicalRoutes.get(normalizeRouteKey(route.conversationId));
+		if (remembered) return {
+			...remembered,
+			...route.accountId ? { accountId: route.accountId } : {}
+		};
+		return this.resolveConfiguredCanonicalRoute(route.conversationId) ?? route;
+	};
+	resolveConfiguredCanonicalRoute = (conversationId) => {
+		const routeKey = normalizeRouteKey(conversationId);
+		const globalMatch = readStringArray(this.config.allowFrom).find((candidate) => normalizeRouteKey(candidate) === routeKey);
+		if (globalMatch) return { conversationId: globalMatch };
+		for (const [accountId, accountConfig] of Object.entries(this.config.accounts ?? {})) {
+			const accountMatch = readStringArray(accountConfig.allowFrom).find((candidate) => normalizeRouteKey(candidate) === routeKey);
+			if (accountMatch) return {
+				accountId,
+				conversationId: accountMatch
+			};
+		}
+		return null;
+	};
+	resolveRuntimeAccount = (accountId) => {
+		const stored = this.store.loadAccount(accountId);
+		if (!stored?.token) return null;
+		const accountConfig = this.config.accounts?.[accountId] ?? {};
+		return {
+			accountId,
+			token: stored.token,
+			enabled: accountConfig.enabled !== false && this.config.enabled !== false,
+			baseUrl: accountConfig.baseUrl || stored.baseUrl || this.config.baseUrl || DEFAULT_WEIXIN_BASE_URL,
+			pollTimeoutMs: this.config.pollTimeoutMs ?? DEFAULT_WEIXIN_POLL_TIMEOUT_MS,
+			allowFrom: Array.from(new Set([...readStringArray(this.config.allowFrom), ...readStringArray(accountConfig.allowFrom)]))
+		};
+	};
+	resolveSelectedAccountId = (requestedAccountId) => {
+		if (requestedAccountId) return requestedAccountId;
+		if (this.config.defaultAccountId) return this.config.defaultAccountId;
+		const accountIds = this.listAvailableAccountIds();
+		if (accountIds.length === 1 && accountIds[0]) return accountIds[0];
+		throw new Error("weixin send failed: accountId is required when multiple accounts are configured");
+	};
+	resolveSendAccount = (target) => {
+		const account = this.resolveRuntimeAccount(this.resolveSelectedAccountId(target.accountId));
+		if (!account?.enabled || !account.token) throw new Error(`weixin send failed: account "${target.accountId ?? this.config.defaultAccountId ?? ""}" is not logged in`);
+		return account;
+	};
+	resolveContextToken = (target, accountId) => {
+		const metadataToken = target.metadata?.context_token;
+		if (typeof metadataToken === "string" && metadataToken.trim()) return metadataToken.trim();
+		return this.contextTokens.get(`${accountId}:${target.conversationId}`);
+	};
+	runPollingLoop = async (accountId, signal) => {
+		while (this.running && !signal.aborted) try {
+			const account = this.resolveRuntimeAccount(accountId);
+			if (!account?.enabled) {
+				await this.sleep(3e3, signal);
+				continue;
+			}
+			const response = await this.api.fetchUpdates({
+				baseUrl: account.baseUrl,
+				token: account.token,
+				cursor: this.store.loadCursor(accountId),
+				timeoutMs: account.pollTimeoutMs,
+				signal
+			});
+			if (response.get_updates_buf !== void 0) this.store.saveCursor(accountId, response.get_updates_buf);
+			for (const message of response.msgs ?? []) await this.handleInboundMessage(account, message);
+		} catch (error) {
+			if (!signal.aborted) {
+				const message = error instanceof Error ? error.message : String(error);
+				if (message.includes("errcode=-14") || message.includes("session timeout")) {
+					this.store.deleteCursor(accountId);
+					await this.sleep(1e3, signal);
+					continue;
+				}
+				this.logger.warn(`[weixin] polling failed for ${accountId}: ${message}`);
+				await this.sleep(3e3, signal);
+			}
+		}
+	};
+	handleInboundMessage = async (account, message) => {
+		const senderId = message.from_user_id?.trim();
+		if (!senderId || senderId === account.accountId || !isAllowedSender(account.allowFrom, senderId)) return;
+		const attachments = await resolveWeixinInboundAttachments({
+			message,
+			baseUrl: account.baseUrl
+		});
+		const extractedText = extractText(message);
+		const text = attachments.length > 0 && isSyntheticAttachmentText(extractedText) ? "" : extractedText;
+		if (!text && attachments.length === 0) return;
+		const contextToken = message.context_token?.trim();
+		if (contextToken) this.contextTokens.set(`${account.accountId}:${senderId}`, contextToken);
+		this.canonicalRoutes.set(normalizeRouteKey(senderId), {
+			accountId: account.accountId,
+			conversationId: senderId
+		});
+		if (contextToken) this.typingController.start({
+			accountId: account.accountId,
+			userId: senderId,
+			contextToken,
+			baseUrl: account.baseUrl,
+			token: account.token
+		});
+		await this.messageHandler?.({
+			conversationId: senderId,
+			senderId,
+			text,
+			attachments,
+			accountId: account.accountId,
+			...contextToken ? { contextToken } : {},
+			raw: message
+		});
+	};
+};
+//#endregion
+export { WeixinChannelAdapter };

package/dist/services/weixin-extension-runtime.service.d.ts

@@ -0,0 +1,19 @@
+import { WeixinChannelAdapter } from "../types/weixin-extension.types.js";
+import { ExtensionChannel } from "@nextclaw/extension-sdk";
+
+//#region src/services/weixin-extension-runtime.service.d.ts
+declare class WeixinExtensionRuntime {
+  private readonly channel;
+  private readonly adapter;
+  private unsubscribeConfig;
+  private unsubscribeMessages;
+  private unsubscribeNcpEvents;
+  constructor(channel: ExtensionChannel, adapter: WeixinChannelAdapter);
+  readonly start: () => Promise<void>;
+  readonly stop: () => Promise<void>;
+  private readonly applyConfig;
+  private readonly submitMessage;
+  private readonly sendNcpEvent;
+}
+//#endregion
+export { WeixinExtensionRuntime };

package/dist/services/weixin-extension-runtime.service.js

@@ -0,0 +1,65 @@
+//#region src/services/weixin-extension-runtime.service.ts
+var WeixinExtensionRuntime = class {
+	unsubscribeConfig = null;
+	unsubscribeMessages = null;
+	unsubscribeNcpEvents = null;
+	constructor(channel, adapter) {
+		this.channel = channel;
+		this.adapter = adapter;
+	}
+	start = async () => {
+		this.unsubscribeMessages = this.adapter.onMessage(this.submitMessage);
+		this.unsubscribeNcpEvents = this.channel.onNcpEvent(this.sendNcpEvent);
+		this.unsubscribeConfig = this.channel.config.onChange(async () => {
+			await this.applyConfig();
+		});
+		await this.applyConfig();
+	};
+	stop = async () => {
+		this.unsubscribeConfig?.();
+		this.unsubscribeMessages?.();
+		this.unsubscribeNcpEvents?.();
+		this.unsubscribeConfig = null;
+		this.unsubscribeMessages = null;
+		this.unsubscribeNcpEvents = null;
+		await this.adapter.stop();
+	};
+	applyConfig = async () => {
+		const config = await this.channel.config.get();
+		await this.adapter.configure(config);
+		if (config.enabled === false) {
+			await this.adapter.stop();
+			return;
+		}
+		await this.adapter.start();
+	};
+	submitMessage = async (message) => {
+		await this.channel.submitMessage({
+			conversationId: message.conversationId,
+			senderId: message.senderId,
+			content: {
+				type: "text",
+				text: message.text
+			},
+			...message.attachments ? { attachments: message.attachments } : {},
+			metadata: {
+				...message.accountId ? {
+					accountId: message.accountId,
+					account_id: message.accountId
+				} : {},
+				...message.contextToken ? { context_token: message.contextToken } : {},
+				...message.raw === void 0 ? {} : { raw: message.raw }
+			}
+		});
+	};
+	sendNcpEvent = async (event) => {
+		try {
+			await this.adapter.sendNcpEvent(event);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			console.warn(`[weixin] failed to send NCP event: ${message}`);
+		}
+	};
+};
+//#endregion
+export { WeixinExtensionRuntime };

package/dist/services/weixin-login.service.d.ts

@@ -0,0 +1,55 @@
+import { WeixinAccountStore } from "../stores/weixin-account.store.js";
+import { WeixinApiClient } from "./weixin-api.service.js";
+
+//#region src/services/weixin-login.service.d.ts
+type WeixinLoginParams = {
+  pluginConfig?: Record<string, unknown>;
+  requestedAccountId?: string | null;
+  baseUrl?: string | null;
+  verbose?: boolean;
+};
+type WeixinAuthStartResult = {
+  channel: string;
+  kind: "qr_code";
+  sessionId: string;
+  qrCode: string;
+  qrCodeUrl: string;
+  expiresAt: string;
+  intervalMs: number;
+  note?: string;
+};
+type WeixinAuthPollResult = {
+  channel: string;
+  status: "pending" | "scanned" | "authorized" | "expired" | "error";
+  message?: string;
+  nextPollMs?: number;
+  accountId?: string | null;
+  notes?: string[];
+  pluginConfig?: Record<string, unknown>;
+};
+type WeixinLoginServiceDeps = {
+  api?: WeixinApiClient;
+  store?: WeixinAccountStore;
+};
+declare class WeixinLoginService {
+  private readonly api;
+  private readonly store;
+  private readonly sessions;
+  constructor(deps?: WeixinLoginServiceDeps);
+  readonly start: (params: WeixinLoginParams) => Promise<WeixinAuthStartResult>;
+  readonly poll: ({
+    sessionId
+  }: {
+    sessionId: string;
+  }) => Promise<WeixinAuthPollResult | null>;
+  readonly login: (params: WeixinLoginParams) => Promise<{
+    pluginConfig: Record<string, unknown>;
+    accountId?: string | null;
+    notes?: string[];
+  }>;
+  private readonly confirmLogin;
+  private readonly resolveReplacementAccountIds;
+  private readonly cleanupExpiredSessions;
+}
+//#endregion
+export { WeixinAuthPollResult, WeixinAuthStartResult, WeixinLoginParams, WeixinLoginService };

package/dist/services/weixin-login.service.js

@@ -0,0 +1,203 @@
+import { FileWeixinAccountStore } from "../stores/weixin-account.store.js";
+import { HttpWeixinApiClient } from "./weixin-api.service.js";
+import { WEIXIN_CHANNEL_ID, buildLoggedInWeixinChannelConfig, normalizeWeixinChannelConfig } from "../utils/weixin-config.utils.js";
+import { randomUUID } from "node:crypto";
+//#region src/services/weixin-login.service.ts
+const WEIXIN_LOGIN_TIMEOUT_MS = 8 * 6e4;
+const WEIXIN_AUTH_POLL_INTERVAL_MS = 2e3;
+const WEIXIN_AUTH_STATUS_TIMEOUT_MS = 5e3;
+async function sleep(ms) {
+	await new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}
+function resolveLoginBaseUrl(params, currentConfig) {
+	return params.baseUrl?.trim() || currentConfig.baseUrl || "https://ilinkai.weixin.qq.com";
+}
+function normalizeQrStatus(status) {
+	const normalized = status?.trim().toLowerCase() ?? "";
+	if (normalized === "scaned" || normalized === "scanned") return "scanned";
+	if (normalized === "confirmed" || normalized === "authorized" || normalized === "success") return "authorized";
+	if (normalized === "expired" || normalized === "timeout") return "expired";
+	return "pending";
+}
+function hasAuthorizedCredentials(status) {
+	return Boolean(status.bot_token?.trim() && status.ilink_bot_id?.trim());
+}
+var WeixinLoginService = class {
+	api;
+	store;
+	sessions = /* @__PURE__ */ new Map();
+	constructor(deps = {}) {
+		this.api = deps.api ?? new HttpWeixinApiClient();
+		this.store = deps.store ?? new FileWeixinAccountStore();
+	}
+	start = async (params) => {
+		this.cleanupExpiredSessions();
+		const currentConfig = normalizeWeixinChannelConfig(params.pluginConfig);
+		const baseUrl = resolveLoginBaseUrl(params, currentConfig);
+		const qrCode = await this.api.fetchQrCode({ baseUrl });
+		const qrCodeUrl = qrCode.qrcode_img_content?.trim();
+		const qrCodeValue = qrCode.qrcode?.trim();
+		if (!qrCodeUrl || !qrCodeValue) throw new Error("weixin login failed: QR code is unavailable");
+		const sessionId = randomUUID();
+		const expiresAtMs = Date.now() + WEIXIN_LOGIN_TIMEOUT_MS;
+		this.sessions.set(sessionId, {
+			currentConfig,
+			requestedAccountId: params.requestedAccountId,
+			baseUrl,
+			qrCode: qrCodeValue,
+			expiresAtMs
+		});
+		return {
+			channel: WEIXIN_CHANNEL_ID,
+			kind: "qr_code",
+			sessionId,
+			qrCode: qrCodeValue,
+			qrCodeUrl,
+			expiresAt: new Date(expiresAtMs).toISOString(),
+			intervalMs: WEIXIN_AUTH_POLL_INTERVAL_MS,
+			note: "请使用微信扫码，并在手机上确认登录。"
+		};
+	};
+	poll = async ({ sessionId }) => {
+		this.cleanupExpiredSessions();
+		const session = this.sessions.get(sessionId);
+		if (!session) return null;
+		if (session.expiresAtMs <= Date.now()) {
+			this.sessions.delete(sessionId);
+			return {
+				channel: WEIXIN_CHANNEL_ID,
+				status: "expired",
+				message: "二维码已过期，请重新扫码。"
+			};
+		}
+		try {
+			const status = await this.api.fetchQrStatus({
+				baseUrl: session.baseUrl,
+				qrcode: session.qrCode,
+				timeoutMs: WEIXIN_AUTH_STATUS_TIMEOUT_MS
+			});
+			const normalizedStatus = hasAuthorizedCredentials(status) ? "authorized" : normalizeQrStatus(status.status);
+			if (normalizedStatus === "scanned") return {
+				channel: WEIXIN_CHANNEL_ID,
+				status: "scanned",
+				message: "二维码已扫码，请在微信中确认登录。",
+				nextPollMs: WEIXIN_AUTH_POLL_INTERVAL_MS
+			};
+			if (normalizedStatus === "authorized") {
+				const result = this.confirmLogin(session, status);
+				this.sessions.delete(sessionId);
+				return {
+					channel: WEIXIN_CHANNEL_ID,
+					status: "authorized",
+					message: "微信已连接。",
+					nextPollMs: 0,
+					accountId: result.accountId,
+					notes: result.notes,
+					pluginConfig: result.pluginConfig
+				};
+			}
+			if (normalizedStatus === "expired") {
+				this.sessions.delete(sessionId);
+				return {
+					channel: WEIXIN_CHANNEL_ID,
+					status: "expired",
+					message: "二维码已过期，请重新扫码。"
+				};
+			}
+			return {
+				channel: WEIXIN_CHANNEL_ID,
+				status: "pending",
+				nextPollMs: WEIXIN_AUTH_POLL_INTERVAL_MS
+			};
+		} catch (error) {
+			return {
+				channel: WEIXIN_CHANNEL_ID,
+				status: "error",
+				message: error instanceof Error ? error.message : String(error)
+			};
+		}
+	};
+	login = async (params) => {
+		const started = await this.start(params);
+		console.log("使用微信扫描以下二维码链接完成连接：");
+		console.log(started.qrCodeUrl);
+		console.log("");
+		console.log("等待扫码确认...");
+		let seenScanned = false;
+		while (Date.now() < new Date(started.expiresAt).getTime()) {
+			const status = await this.poll({ sessionId: started.sessionId });
+			if (!status) throw new Error("weixin login failed: auth session not found");
+			if (status.status === "scanned" && !seenScanned) {
+				console.log(status.message ?? "二维码已扫码，请在微信中确认登录。");
+				seenScanned = true;
+			}
+			if (status.status === "authorized") return {
+				pluginConfig: status.pluginConfig ?? {},
+				accountId: status.accountId,
+				notes: status.notes
+			};
+			if (status.status === "expired") throw new Error(status.message ?? "weixin login failed: QR code expired, please retry");
+			if (status.status === "error") throw new Error(status.message ?? "weixin login failed");
+			if (params.verbose) process.stdout.write(".");
+			await sleep(status.nextPollMs ?? WEIXIN_AUTH_POLL_INTERVAL_MS);
+		}
+		throw new Error("weixin login timed out");
+	};
+	confirmLogin = (session, status) => {
+		const token = status.bot_token?.trim();
+		const accountId = status.ilink_bot_id?.trim() || session.requestedAccountId?.trim();
+		const baseUrl = status.baseurl?.trim() || session.baseUrl;
+		const userId = status.ilink_user_id?.trim() || void 0;
+		if (!token || !accountId) throw new Error("weixin login failed: missing bot token or account id");
+		const replacementAccountIds = this.resolveReplacementAccountIds({
+			currentConfig: session.currentConfig,
+			requestedAccountId: session.requestedAccountId,
+			accountId,
+			userId
+		});
+		for (const replacementAccountId of replacementAccountIds) {
+			this.store.deleteAccount(replacementAccountId);
+			this.store.deleteCursor(replacementAccountId);
+		}
+		this.store.saveAccount({
+			accountId,
+			token,
+			baseUrl,
+			userId,
+			savedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		return {
+			accountId,
+			notes: [
+				...session.requestedAccountId?.trim() && session.requestedAccountId.trim() !== accountId ? [`Weixin account resolved to ${accountId}.`] : [],
+				...replacementAccountIds.map((replacementAccountId) => `Replaced previous Weixin account: ${replacementAccountId}`),
+				...userId ? [`Authorized initial user: ${userId}`] : []
+			],
+			pluginConfig: buildLoggedInWeixinChannelConfig({
+				config: session.currentConfig,
+				accountId,
+				baseUrl,
+				allowUserId: userId,
+				replaceAccountIds: replacementAccountIds
+			})
+		};
+	};
+	resolveReplacementAccountIds = (params) => {
+		const { accountId, currentConfig, requestedAccountId: requestedAccountIdRaw, userId } = params;
+		const replacementIds = /* @__PURE__ */ new Set();
+		const requestedAccountId = requestedAccountIdRaw?.trim();
+		const defaultAccountId = currentConfig.defaultAccountId?.trim();
+		if (requestedAccountId && requestedAccountId !== accountId) replacementIds.add(requestedAccountId);
+		else if (!requestedAccountId && defaultAccountId && defaultAccountId !== accountId) replacementIds.add(defaultAccountId);
+		if (userId) {
+			for (const [candidateAccountId, accountConfig] of Object.entries(currentConfig.accounts ?? {})) if (candidateAccountId !== accountId && accountConfig.allowFrom?.includes(userId)) replacementIds.add(candidateAccountId);
+			for (const candidateAccountId of this.store.listAccountIds()) if (candidateAccountId !== accountId && this.store.loadAccount(candidateAccountId)?.userId === userId) replacementIds.add(candidateAccountId);
+		}
+		return [...replacementIds];
+	};
+	cleanupExpiredSessions = (now = Date.now()) => {
+		for (const [sessionId, session] of this.sessions.entries()) if (session.expiresAtMs <= now) this.sessions.delete(sessionId);
+	};
+};
+//#endregion
+export { WeixinLoginService };