@xopcai/xopc 0.0.81 → 0.0.83

package/dist/src/channels/manager.js

@@ -1,440 +1,100 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { mergeTtsConfigFromAppConfig } from "../voice/tts/merge-config.js";
-import { maybeApplyTtsToPayload } from "../voice/tts/payload.js";
-import "./internal-outbound.js";
 import { ChannelHealthMonitor } from "./health-monitor.js";
-import { deliverOutboundMessage } from "./outbound/deliver.js";
-import { OutboundPersistStore } from "./outbound/persist-store.js";
-import { syncChannelPluginsFromManager } from "./plugins/registry.js";
-import { CHANNEL_RESTART_POLICY, computeBackoff } from "./restart-policy.js";
+import { ChannelHeartbeatScheduler } from "./heartbeat-scheduler.js";
+import { ChannelPluginRegistry } from "./plugin-registry.js";
+import { ChannelOutboundSender } from "./outbound-sender.js";
+import { ChannelLifecycleSupervisor } from "./lifecycle-supervisor.js";
 //#region src/channels/manager.ts
 init_logger();
 const log = createLogger("ChannelManager");
-function asChannelConfig(raw) {
-	if (raw && typeof raw === "object" && !Array.isArray(raw)) return raw;
-}
 var ChannelManager = class {
-	plugins = /* @__PURE__ */ new Map();
-	/** Plugins that completed `init()` successfully (skipped channels are not listed). */
-	initializedPluginIds = /* @__PURE__ */ new Set();
-	bus;
 	config;
-	initialized = false;
-	running = false;
-	restartAttempts = /* @__PURE__ */ new Map();
-	/** When set, failed-start auto-restart is suppressed for that channel id. */
-	manuallyStopped = /* @__PURE__ */ new Set();
-	heartbeatTimers = /* @__PURE__ */ new Map();
-	outboundHooks;
-	persistStore;
-	_lastHeartbeatRestartAt = /* @__PURE__ */ new Map();
+	registry = new ChannelPluginRegistry();
 	healthMonitor = new ChannelHealthMonitor();
+	lifecycle;
+	heartbeat;
+	outbound;
 	sessionModelHooks;
-	/** Plugins that skipped `start()` until `startDeferredConnects()` (see `ChannelMeta.deferConnectUntilAfterListen`). */
-	deferredConnectPending = /* @__PURE__ */ new Set();
 	constructor(config, bus) {
-		this.bus = bus;
 		this.config = config;
+		this.heartbeat = new ChannelHeartbeatScheduler({
+			getConfig: () => this.config,
+			healthMonitor: this.healthMonitor,
+			requestSoftRestart: (channelId) => {
+				this.lifecycle.softRestart(channelId);
+			}
+		});
+		this.lifecycle = new ChannelLifecycleSupervisor({
+			bus,
+			registry: this.registry,
+			getConfig: () => this.config,
+			getSessionModelHooks: () => this.sessionModelHooks,
+			onPluginStarted: (plugin) => this.heartbeat.schedule(plugin),
+			onPluginStopped: (pluginId) => this.heartbeat.clear(pluginId)
+		});
+		this.outbound = new ChannelOutboundSender({
+			registry: this.registry,
+			getConfig: () => this.config
+		});
 	}
 	setOutboundHooks(hooks) {
-		this.outboundHooks = hooks;
+		this.outbound.setHooks(hooks);
 	}
-	/** Call before `initialize()` so plugins can persist per-session model overrides (e.g. Telegram /models UI). */
+	/** Call before `initialize()` so plugins can persist per-session model overrides. */
 	setSessionModelHooks(hooks) {
 		this.sessionModelHooks = hooks;
 	}
 	enableOutboundPersistence(agentDir) {
-		this.persistStore = new OutboundPersistStore(agentDir);
-	}
-	/**
-	* Redeliver persisted outbound items (after channels are started). Best-effort; may duplicate if prior send succeeded but ack did not.
-	*/
-	async replayPendingOutboundMessages() {
-		if (!this.persistStore) return;
-		const pending = [...this.persistStore.peek()];
-		for (const p of pending) try {
-			await this.send(p.message, { skipPersist: true });
-			this.persistStore.ack(p.id);
-		} catch (err) {
-			log.error({
-				id: p.id,
-				err
-			}, "Failed to replay outbound message");
-		}
+		this.outbound.enablePersistence(agentDir);
 	}
 	registerPlugin(plugin) {
-		if (this.plugins.has(plugin.id)) log.warn({ channel: plugin.id }, "Channel plugin already registered, overwriting");
-		this.plugins.set(plugin.id, plugin);
-		syncChannelPluginsFromManager(this.getAllPlugins());
-		log.debug({ channel: plugin.id }, "Registered channel plugin");
+		this.registry.register(plugin);
 	}
 	getPlugin(id) {
-		return this.plugins.get(id);
-	}
-	/**
-	* Optional channel hook before AgentService consumes an inbound message (e.g. Feishu card actions).
-	*/
-	async dispatchInboundMessageAction(msg) {
-		const handle = this.plugins.get(msg.channel)?.actions?.handleAction;
-		if (!handle) return;
-		const meta = msg.metadata;
-		if (msg.channel !== "feishu" || meta?.feishuEventType !== "card.action.trigger") return;
-		const cardAction = meta.cardAction;
-		const actionTag = cardAction && typeof cardAction.tag === "string" && cardAction.tag.trim() ? cardAction.tag.trim() : "feishu.card_action";
-		const cardCtx = meta.cardContext;
-		const openMsg = cardCtx && typeof cardCtx.open_message_id === "string" ? cardCtx.open_message_id.trim() : "";
-		const fallbackMsgId = typeof meta.messageId === "string" ? meta.messageId.trim() : "";
-		const messageId = openMsg || fallbackMsgId;
-		const accountId = typeof meta.accountId === "string" && meta.accountId.trim() ? meta.accountId.trim() : "default";
-		try {
-			await handle({
-				action: actionTag,
-				data: JSON.stringify({
-					cardAction: meta.cardAction,
-					cardContext: meta.cardContext,
-					cardActionText: meta.cardActionText
-				}),
-				messageId,
-				senderId: msg.sender_id,
-				chatId: msg.chat_id,
-				accountId,
-				metadata: {
-					feishuEventType: meta.feishuEventType,
-					raw: meta.raw,
-					sessionKey: meta.sessionKey,
-					userContent: msg.content
-				}
-			});
-		} catch (err) {
-			const em = err instanceof Error ? err.message : String(err);
-			log.error({
-				err,
-				channel: msg.channel,
-				accountId,
-				em
-			}, "dispatchInboundMessageAction failed");
-		}
+		return this.registry.get(id);
 	}
 	getAllPlugins() {
-		return Array.from(this.plugins.values());
+		return this.registry.all();
 	}
-	async initialize() {
-		if (this.initialized) {
-			log.warn({ pluginCount: this.plugins.size }, "initialize() called again; channels already initialized — skipping");
-			return;
-		}
-		const initPromises = [];
-		for (const [id, plugin] of this.plugins) {
-			const channelConfig = asChannelConfig(this.config.channels?.[id]);
-			const initPromise = this.initializePlugin(plugin, channelConfig ?? {});
-			initPromises.push(initPromise);
-		}
-		await Promise.allSettled(initPromises);
-		this.initialized = true;
-		log.info("All channel plugins initialized");
-	}
-	/**
-	* Builtin channels require `channels.<id>.enabled`. Extension-managed channels run unless explicitly disabled.
-	*/
-	shouldRunChannelPlugin(plugin, channelConfig) {
-		if (plugin.extensionManagedConfig) return channelConfig?.enabled !== false;
-		return !!channelConfig?.enabled;
-	}
-	async initializePlugin(plugin, channelConfig) {
-		try {
-			const options = {
-				bus: this.bus,
-				config: this.config,
-				channelConfig,
-				sessionModel: this.sessionModelHooks
-			};
-			await plugin.init(options);
-			this.initializedPluginIds.add(plugin.id);
-			log.debug({ channel: plugin.id }, "Channel plugin initialized");
-		} catch (err) {
-			log.error({
-				channel: plugin.id,
-				err
-			}, "Failed to initialize channel plugin");
-		}
+	/** Backward-compat alias for `getAllPlugins`. */
+	getAllChannels() {
+		return this.registry.all();
 	}
-	/**
-	* Channel ids that would run and declare `meta.deferConnectUntilAfterListen` (for logging / metrics).
-	*/
-	listDeferConnectChannelIds(cfg) {
-		const out = [];
-		for (const [id, plugin] of this.plugins) {
-			const channelConfig = asChannelConfig(cfg.channels?.[id]);
-			if (!this.shouldRunChannelPlugin(plugin, channelConfig)) continue;
-			if (plugin.meta.deferConnectUntilAfterListen === true) out.push(id);
-		}
-		return out;
+	/** Channel IDs whose runtime reports connected (e.g. Telegram polling active). */
+	getRunningChannels() {
+		return this.registry.runningChannelIds(this.config, (id) => this.lifecycle.isInitialized(id));
 	}
-	/**
-	* Phase 1: start every enabled channel except those in `deferConnectPluginIds` (they stay pending).
-	*/
-	async start(options) {
-		if (!this.initialized) throw new Error("Channels not initialized");
-		if (this.running) {
-			log.warn({ pluginCount: this.plugins.size }, "start() called while channels already running — skipping");
-			return;
-		}
-		const deferIds = options?.deferConnectPluginIds ?? /* @__PURE__ */ new Set();
-		this.deferredConnectPending.clear();
-		const startPromises = [];
-		for (const [id, plugin] of this.plugins) {
-			const channelConfig = asChannelConfig(this.config.channels?.[id]);
-			if (!this.shouldRunChannelPlugin(plugin, channelConfig)) continue;
-			if (deferIds.has(id)) {
-				this.deferredConnectPending.add(id);
-				log.info({ channel: id }, "Channel connect deferred until HTTP listen");
-				continue;
-			}
-			const startPromise = this.startPlugin(plugin, {}).catch((err) => {
-				log.error({
-					channel: id,
-					err
-				}, "Failed to start channel plugin");
-			});
-			startPromises.push(startPromise);
-		}
-		await Promise.allSettled(startPromises);
-		this.running = true;
-		log.info({ deferred: [...this.deferredConnectPending] }, this.deferredConnectPending.size > 0 ? "Channel plugins started (deferred connects pending)" : "All channel plugins started");
+	initialize() {
+		return this.lifecycle.initialize();
 	}
-	/** Phase 2: run `start()` for channels deferred at `start()`. No-op if none pending. */
-	async startDeferredConnects() {
-		if (this.deferredConnectPending.size === 0) return;
-		if (!this.running) {
-			log.warn("startDeferredConnects called before channel phase-1 start; skipping");
-			return;
-		}
-		const ids = [...this.deferredConnectPending];
-		this.deferredConnectPending.clear();
-		const startPromises = [];
-		for (const id of ids) {
-			const plugin = this.plugins.get(id);
-			if (!plugin) continue;
-			const channelConfig = asChannelConfig(this.config.channels?.[id]);
-			if (!this.shouldRunChannelPlugin(plugin, channelConfig)) continue;
-			startPromises.push(this.startPlugin(plugin, {}).catch((err) => {
-				log.error({
-					channel: id,
-					err
-				}, "Failed to start deferred channel plugin");
-			}));
-		}
-		await Promise.allSettled(startPromises);
-		log.info({ channels: ids }, "Deferred channel connects completed");
+	start(options) {
+		return this.lifecycle.start(options);
 	}
-	async startPlugin(plugin, opts) {
-		const options = {};
-		try {
-			await plugin.start(options);
-			if (!opts.preserveRestartAttempts) this.restartAttempts.delete(plugin.id);
-			this._scheduleHeartbeat(plugin);
-			log.debug({ channel: plugin.id }, "Channel plugin started");
-		} catch (err) {
-			const attempt = (this.restartAttempts.get(plugin.id) ?? 0) + 1;
-			this.restartAttempts.set(plugin.id, attempt);
-			if (attempt <= CHANNEL_RESTART_POLICY.maxAttempts) {
-				const delayMs = computeBackoff(CHANNEL_RESTART_POLICY, attempt);
-				log.warn({
-					channel: plugin.id,
-					attempt,
-					delayMs,
-					err
-				}, "Channel failed to start, scheduling restart");
-				setTimeout(() => {
-					if (this.manuallyStopped.has(plugin.id)) {
-						log.debug({ channel: plugin.id }, "Skipping scheduled restart (manual stop)");
-						return;
-					}
-					this.startPlugin(plugin, { preserveRestartAttempts: true }).catch((e) => {
-						log.error({
-							channel: plugin.id,
-							err: e
-						}, "Channel restart attempt failed");
-					});
-				}, delayMs);
-			} else log.error({
-				channel: plugin.id,
-				err
-			}, "Channel exceeded max restart attempts");
-		}
+	startDeferredConnects() {
+		return this.lifecycle.startDeferredConnects();
 	}
 	async stop() {
-		if (!this.running) return;
-		this.deferredConnectPending.clear();
-		const stopPromises = [];
-		for (const id of this.initializedPluginIds) {
-			const plugin = this.plugins.get(id);
-			if (!plugin) continue;
-			const stopPromise = this.stopPlugin(plugin).catch((err) => {
-				log.error({
-					channel: id,
-					err
-				}, "Failed to stop channel plugin");
-			});
-			stopPromises.push(stopPromise);
-		}
-		await Promise.allSettled(stopPromises);
-		this.running = false;
-		log.info("All channel plugins stopped");
+		await this.lifecycle.stop();
+		this.heartbeat.clearAll();
 	}
-	async stopPlugin(plugin) {
-		this._clearHeartbeatTimers(plugin.id);
-		await plugin.stop();
-		log.info({ channel: plugin.id }, "Channel plugin stopped");
+	stopChannel(channelId) {
+		return this.lifecycle.stopChannel(channelId);
 	}
-	_clearHeartbeatTimers(pluginId) {
-		const prefix = `${pluginId}:`;
-		for (const key of [...this.heartbeatTimers.keys()]) if (key.startsWith(prefix)) {
-			clearInterval(this.heartbeatTimers.get(key));
-			this.heartbeatTimers.delete(key);
-		}
+	startChannel(channelId) {
+		return this.lifecycle.startChannel(channelId);
 	}
-	_scheduleHeartbeat(plugin) {
-		const hb = plugin.heartbeat;
-		if (!hb) return;
-		this._clearHeartbeatTimers(plugin.id);
-		let accountIds = [];
-		try {
-			accountIds = plugin.config.listAccountIds(this.config);
-		} catch (e) {
-			log.warn({
-				channel: plugin.id,
-				err: e
-			}, "Heartbeat: failed to list accounts");
-			return;
-		}
-		for (const accountId of accountIds) {
-			const key = `${plugin.id}:${accountId}`;
-			const timer = setInterval(() => {
-				(async () => {
-					try {
-						const r = await hb.check({
-							cfg: this.config,
-							accountId
-						});
-						this.healthMonitor.set(plugin.id, accountId, {
-							healthy: r.healthy,
-							lastCheckAt: Date.now(),
-							detail: typeof r.details === "string" ? r.details : r.details != null ? JSON.stringify(r.details) : void 0
-						});
-						if (!r.healthy) {
-							log.warn({
-								channel: plugin.id,
-								accountId,
-								detail: r.details
-							}, "Channel heartbeat unhealthy");
-							const now = Date.now();
-							if (now - (this._lastHeartbeatRestartAt.get(plugin.id) ?? 0) < 6e4) return;
-							this._lastHeartbeatRestartAt.set(plugin.id, now);
-							this._softRestartChannel(plugin.id);
-						}
-					} catch (err) {
-						this.healthMonitor.set(plugin.id, accountId, {
-							healthy: false,
-							lastCheckAt: Date.now(),
-							detail: err instanceof Error ? err.message : String(err)
-						});
-						log.error({
-							channel: plugin.id,
-							accountId,
-							err
-						}, "Channel heartbeat check failed");
-					}
-				})();
-			}, hb.intervalMs);
-			this.heartbeatTimers.set(key, timer);
-		}
+	listDeferConnectChannelIds(cfg) {
+		return this.lifecycle.listDeferConnectChannelIds(cfg);
 	}
-	async _softRestartChannel(channelId) {
-		if (this.manuallyStopped.has(channelId)) return;
-		const plugin = this.plugins.get(channelId);
-		if (!plugin || !this.initializedPluginIds.has(channelId)) return;
-		this._clearHeartbeatTimers(channelId);
-		try {
-			await plugin.stop();
-			await this.startPlugin(plugin, {});
-		} catch (err) {
-			log.error({
-				channel: channelId,
-				err
-			}, "Channel soft restart after heartbeat failed");
-		}
+	send(msg, options) {
+		return this.outbound.send(msg, options);
 	}
-	cloneOutbound(m) {
-		return structuredClone(m);
-	}
-	async send(msg, options) {
-		log.debug({
-			type: msg.type,
-			channel: msg.channel,
-			chatId: msg.chat_id
-		}, "Received outbound message");
-		let processedMsg = await this.applyTtsIfNeeded(msg);
-		const queueId = !options?.skipPersist && this.persistStore ? this.persistStore.enqueue(this.cloneOutbound(processedMsg)) : null;
-		try {
-			if (this.outboundHooks) {
-				const hookResult = await this.outboundHooks.runMessageSending(processedMsg.chat_id, processedMsg.content ?? "", processedMsg.channel);
-				if (!hookResult.send) {
-					if (queueId) this.persistStore.ack(queueId);
-					return;
-				}
-				processedMsg = {
-					...processedMsg,
-					content: hookResult.content ?? processedMsg.content
-				};
-			}
-			if (processedMsg.channel === "__xopc_internal") {
-				log.debug({ chatId: processedMsg.chat_id }, "Outbound dropped (internal session — not a real channel)");
-				if (queueId) this.persistStore.ack(queueId);
-				return;
-			}
-			const plugin = this.plugins.get(processedMsg.channel);
-			if (!plugin?.outbound) {
-				log.error({ channel: processedMsg.channel }, "Unknown channel or no outbound adapter");
-				if (queueId) this.persistStore.ack(queueId);
-				return;
-			}
-			const result = await deliverOutboundMessage({
-				cfg: this.config,
-				plugin,
-				processedMsg
-			});
-			if (this.outboundHooks) {
-				const err = result && !result.success ? result.error : void 0;
-				await this.outboundHooks.runMessageSent(processedMsg.chat_id, processedMsg.content ?? "", result?.success ?? false, err, processedMsg.channel);
-			}
-			if (!result) {
-				if (queueId) this.persistStore.ack(queueId);
-				return;
-			}
-			if (result.success) log.info({
-				channel: processedMsg.channel,
-				chatId: processedMsg.chat_id,
-				messageId: result.messageId
-			}, "Message sent");
-			else log.error({
-				channel: processedMsg.channel,
-				chatId: processedMsg.chat_id,
-				error: result.error
-			}, "Failed to send message");
-			if (queueId) this.persistStore.ack(queueId);
-		} catch (err) {
-			log.error({
-				channel: processedMsg.channel,
-				chatId: processedMsg.chat_id,
-				err
-			}, "Outbound send threw");
-			if (!queueId) throw err;
-		}
+	replayPendingOutboundMessages() {
+		return this.outbound.replayPending();
 	}
 	startStream(channel, chatId, accountId, opts) {
-		const plugin = this.plugins.get(channel);
+		const plugin = this.registry.get(channel);
 		if (!plugin) {
 			log.error({ channel }, "Unknown channel");
 			return null;
@@ -447,7 +107,7 @@ var ChannelManager = class {
 		}) ?? null;
 	}
 	async getChannelStatus(channel) {
-		const plugin = this.plugins.get(channel);
+		const plugin = this.registry.get(channel);
 		if (!plugin) return { error: "Unknown channel" };
 		if (!plugin.status?.buildChannelSummary) return { status: "unknown" };
 		try {
@@ -468,100 +128,70 @@ var ChannelManager = class {
 			return { error: String(err) };
 		}
 	}
+	/**
+	* Optional channel hook before `AgentService` consumes an inbound message
+	* (e.g. Feishu card-action triggers).
+	*/
+	async dispatchInboundMessageAction(msg) {
+		const handle = this.registry.get(msg.channel)?.actions?.handleAction;
+		if (!handle) return;
+		const meta = msg.metadata;
+		if (msg.channel !== "feishu" || meta?.feishuEventType !== "card.action.trigger") return;
+		const cardAction = meta.cardAction;
+		const actionTag = cardAction && typeof cardAction.tag === "string" && cardAction.tag.trim() ? cardAction.tag.trim() : "feishu.card_action";
+		const cardCtx = meta.cardContext;
+		const openMsg = cardCtx && typeof cardCtx.open_message_id === "string" ? cardCtx.open_message_id.trim() : "";
+		const fallbackMsgId = typeof meta.messageId === "string" ? meta.messageId.trim() : "";
+		const messageId = openMsg || fallbackMsgId;
+		const accountId = typeof meta.accountId === "string" && meta.accountId.trim() ? meta.accountId.trim() : "default";
+		try {
+			await handle({
+				action: actionTag,
+				data: JSON.stringify({
+					cardAction: meta.cardAction,
+					cardContext: meta.cardContext,
+					cardActionText: meta.cardActionText
+				}),
+				messageId,
+				senderId: msg.sender_id,
+				chatId: msg.chat_id,
+				accountId,
+				metadata: {
+					feishuEventType: meta.feishuEventType,
+					raw: meta.raw,
+					sessionKey: meta.sessionKey,
+					userContent: msg.content
+				}
+			});
+		} catch (err) {
+			const em = err instanceof Error ? err.message : String(err);
+			log.error({
+				err,
+				channel: msg.channel,
+				accountId,
+				em
+			}, "dispatchInboundMessageAction failed");
+		}
+	}
 	async updateConfig(config) {
 		this.config = config;
-		for (const id of this.initializedPluginIds) {
-			const plugin = this.plugins.get(id);
-			if (plugin?.onConfigUpdated) await Promise.resolve(plugin.onConfigUpdated(config));
-		}
+		await this.lifecycle.forwardConfigUpdate(config);
 		log.info("Channel config updated");
 	}
 	/** Replace in-memory config without running plugin `onConfigUpdated` hooks. */
 	setRuntimeConfig(config) {
 		this.config = config;
 	}
-	async applyTtsIfNeeded(msg) {
-		if (msg.type && msg.type !== "message") return msg;
-		if (!msg.content?.trim()) return msg;
-		if (msg.mediaUrl) return msg;
-		const ttsConfig = mergeTtsConfigFromAppConfig(this.config.messages?.tts);
-		if (!ttsConfig.enabled) return msg;
-		const inboundAudio = msg.metadata?.transcribedVoice === true;
-		return maybeApplyTtsToPayload(msg, {
-			config: ttsConfig,
-			channel: msg.channel,
-			inboundAudio,
-			appConfig: this.config
-		});
-	}
-	/**
-	* Stop a single channel and suppress automatic restart until `startChannel` is called.
-	*/
-	async stopChannel(channelId) {
-		this.manuallyStopped.add(channelId);
-		const plugin = this.plugins.get(channelId);
-		if (!plugin || !this.initializedPluginIds.has(channelId)) return;
-		await this.stopPlugin(plugin).catch((err) => {
-			log.error({
-				channel: channelId,
-				err
-			}, "Failed to stop channel plugin");
-		});
-	}
-	/**
-	* Clear manual-stop and start one channel (requires prior `initialize()`).
-	*/
-	async startChannel(channelId) {
-		this.manuallyStopped.delete(channelId);
-		const plugin = this.plugins.get(channelId);
-		if (!plugin) {
-			log.warn({ channel: channelId }, "Unknown channel");
-			return;
-		}
-		if (!this.initialized) {
-			log.warn({ channel: channelId }, "Channels not initialized");
-			return;
-		}
-		const channelConfig = asChannelConfig(this.config.channels?.[channelId]);
-		if (!this.shouldRunChannelPlugin(plugin, channelConfig)) {
-			log.debug({ channel: channelId }, "Channel disabled in config, skipping start");
-			return;
-		}
-		if (!this.initializedPluginIds.has(channelId)) {
-			log.warn({ channel: channelId }, "Channel was never initialized; call initialize() first");
-			return;
-		}
-		await this.startPlugin(plugin, {});
-	}
 	getRuntimeSnapshot() {
 		return {
-			initialized: this.initialized,
-			running: this.running,
-			pluginIds: [...this.plugins.keys()],
-			initializedPluginIds: [...this.initializedPluginIds],
-			manuallyStopped: [...this.manuallyStopped],
-			restartAttempts: Object.fromEntries(this.restartAttempts),
+			...this.lifecycle.snapshot(),
+			pluginIds: this.registry.ids(),
 			channelHealth: this.healthMonitor.toJSON()
 		};
 	}
 	getHealthMonitor() {
 		return this.healthMonitor;
 	}
-	/**
-	* Channel IDs whose runtime reports connected (e.g. Telegram polling active).
-	*/
-	getRunningChannels() {
-		const result = [];
-		for (const id of this.initializedPluginIds) {
-			const plugin = this.plugins.get(id);
-			if (!plugin?.channelIsRunning) continue;
-			if (plugin.channelIsRunning(this.config)) result.push(id);
-		}
-		return result;
-	}
-	getAllChannels() {
-		return this.getAllPlugins();
-	}
 };
 function createChannelManager(config, bus) {
 	return new ChannelManager(config, bus);