@linxiraos/pi-channels 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## [Unreleased]
+
+### Fixed
+
+- Published tarballs now carry real dependency versions instead of Bun's `catalog:` protocol (1.1.0 installs failed with "Unsupported URL Type catalog:").
+
+## [1.1.0] - 2026-08-25
+
+### Changed
+
+- 同步上游 OMP v18.0.3 / v18.0.4（内部运行时与构建改进，无独立用户可见变更）。
+
+## [1.0.11] - 2026-08-22
+
+### Added
+
+- IM channel adapters extracted from @linxiraos/zeta: WeChat (ClawBot / iLink), Feishu / Lark, and Telegram channels plus the `ChannelHost` coordinator bridge, session router, workspace router, IM control, plan approval, and plan image helpers. The channel runtime now lives in its own publishable package.

package/README.md

@@ -0,0 +1,8 @@
+# @linxiraos/pi-channels
+
+IM channel adapters for Zeta: WeChat (ClawBot / iLink), Feishu / Lark, and
+Telegram, plus the `ChannelHost` coordinator bridge, session router, workspace
+router, IM control, plan-approval, and plan-image helpers.
+
+The channel runtime is embedded in `zeta serve`; the CLI never imports this
+package directly (no channel listeners exist outside a `ZetaServer`).

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@linxiraos/pi-channels",
+  "version": "1.1.0",
+  "type": "module",
+  "description": "IM channel adapters for Zeta (WeChat / Feishu / Telegram)",
+  "homepage": "https://linxira-os.github.io/zeta/",
+  "author": "Can Boluk",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Linxira-OS/linxira-zeta.git",
+    "directory": "packages/channels"
+  },
+  "bugs": {
+    "url": "https://github.com/Linxira-OS/linxira-zeta/issues"
+  },
+  "keywords": [
+    "wechat",
+    "feishu",
+    "telegram",
+    "channels",
+    "im"
+  ],
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "scripts": {
+    "check": "biome check . && bun run check:types",
+    "check:types": "tsgo -p tsconfig.json --noEmit",
+    "lint": "biome lint .",
+    "fix": "biome check --write --unsafe .",
+    "fmt": "biome format --write .",
+    "test": "bun test --parallel"
+  },
+  "dependencies": {
+    "@linxiraos/pi-utils": "1.1.0",
+    "@larksuiteoapi/node-sdk": "^1.71.1"
+  },
+  "devDependencies": {
+    "@linxiraos/pi-ai": "1.1.0",
+    "@types/bun": "^1.3.14"
+  },
+  "peerDependencies": {
+    "@linxiraos/pi-ai": "1.1.0"
+  },
+  "engines": {
+    "bun": ">=1.3.14"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts"
+    },
+    "./*": {
+      "types": "./src/*.ts",
+      "import": "./src/*.ts"
+    },
+    "./*.js": "./src/*.ts"
+  }
+}

package/src/channel.ts

@@ -0,0 +1,23 @@
+/**
+ * Minimal IM channel abstraction for `zeta serve` (web/desktop mode only).
+ *
+ * A `ChatChannel` owns one platform connection: start/stop lifecycle plus
+ * outbound text/image delivery. Inbound messages are pushed through the
+ * channel's `onMessage` callback (registered at construction) into the
+ * coordinator session via `ChannelHost.deliver`.
+ */
+
+export type ChannelId = "wechat" | "feishu" | "telegram";
+
+export interface ChatImage {
+	data: Uint8Array;
+	mime: "image/png" | "image/jpeg";
+}
+
+export interface ChatChannel {
+	readonly id: ChannelId;
+	start(): Promise<void>;
+	stop(): Promise<void>;
+	sendText(to: string, text: string): Promise<void>;
+	sendImage(to: string, image: ChatImage, caption?: string): Promise<void>;
+}

package/src/feishu.ts

@@ -0,0 +1,200 @@
+/**
+ * Feishu / Lark channel — official `@larksuiteoapi/node-sdk` with the
+ * WebSocket long-connection mode (no public webhook needed).
+ *
+ * Inbound: `im.message.receive_v1` events; only text messages are forwarded.
+ * The peer is the `chat_id` (works for both p2p chats and groups), and
+ * replies go back with `receive_id_type: "chat_id"`.
+ *
+ * Outbound: `im.message.create` for text, `im.image.create` (message type)
+ * + image message for pictures. The SDK handles `tenant_access_token`
+ * internally.
+ */
+
+import * as Lark from "@larksuiteoapi/node-sdk";
+import { logger } from "@linxiraos/pi-utils";
+import type { ChatChannel, ChatImage } from "./channel";
+
+export type FeishuInboundHandler = (peer: string, body: string, messageId?: string) => void;
+
+export interface FeishuChannelOptions {
+	appId: string;
+	appSecret: string;
+	domain?: "feishu" | "lark";
+	onMessage: FeishuInboundHandler;
+}
+
+interface FeishuTextEventData {
+	message?: {
+		message_id?: string;
+		chat_id?: string;
+		message_type?: string;
+		content?: string;
+	};
+}
+
+/** `bot_p2p_chat_entered` v2 event payload (first contact in a private chat). */
+interface FeishuP2pEnteredData {
+	chat_id?: string;
+	event?: { chat_id?: string };
+}
+
+const P2P_ONBOARDING_TEXT =
+	"你好！我是 Zeta 助手。发送消息即可开始对话。\n\nHello! I'm the Zeta assistant. Send a message to start chatting.";
+
+export class FeishuChannel implements ChatChannel {
+	readonly id = "feishu" as const;
+	readonly #options: FeishuChannelOptions;
+	readonly #onMessage: FeishuInboundHandler;
+	#client: Lark.Client | null = null;
+	#ws: Lark.WSClient | null = null;
+	#started = false;
+	#startPromise: Promise<void> | null = null;
+
+	constructor(options: FeishuChannelOptions) {
+		this.#options = options;
+		this.#onMessage = options.onMessage;
+	}
+
+	#sdkDomain(): Lark.Domain {
+		return this.#options.domain === "lark" ? Lark.Domain.Lark : Lark.Domain.Feishu;
+	}
+
+	async start(): Promise<void> {
+		if (this.#started) return;
+		this.#started = true;
+		this.#startPromise = this.#connect();
+		await this.#startPromise;
+	}
+
+	async #connect(): Promise<void> {
+		const { appId, appSecret } = this.#options;
+		this.#client = new Lark.Client({
+			appId,
+			appSecret,
+			appType: Lark.AppType.SelfBuild,
+			domain: this.#sdkDomain(),
+		});
+		const dispatcher = new Lark.EventDispatcher({});
+		dispatcher.register({
+			"im.message.receive_v1": (data: FeishuTextEventData) => this.#onEvent(data),
+			bot_p2p_chat_entered: (data: FeishuP2pEnteredData) => this.#onP2pEntered(data),
+		});
+
+		const ws = new Lark.WSClient({
+			appId,
+			appSecret,
+			domain: this.#sdkDomain(),
+			loggerLevel: Lark.LoggerLevel.error,
+			wsConfig: { pingTimeout: 3 },
+			onError: err => {
+				logger.warn("Feishu WebSocket error", {
+					error: err instanceof Error ? err.message : String(err),
+				});
+			},
+		});
+		this.#ws = ws;
+		await ws.start({ eventDispatcher: dispatcher });
+		logger.info("Feishu channel connected (WebSocket long connection)");
+	}
+
+	async stop(): Promise<void> {
+		if (!this.#started) return;
+		this.#started = false;
+		try {
+			this.#ws?.close({ force: true });
+		} catch (error) {
+			logger.warn("Feishu WebSocket close failed", {
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+		this.#ws = null;
+		this.#client = null;
+		this.#startPromise = null;
+	}
+
+	#onEvent(data: FeishuTextEventData): void {
+		const message = data.message;
+		if (message?.message_type !== "text") return;
+		const chatId = message.chat_id;
+		let text = "";
+		try {
+			const parsed = JSON.parse(message.content ?? "{}") as { text?: string };
+			text = parsed.text ?? "";
+		} catch {
+			text = message.content ?? "";
+		}
+		if (typeof chatId !== "string" || chatId === "") return;
+		// Feishu renders `@` as mention placeholders (`@_user_1`); strip them so
+		// command text and prompts arrive clean (a bot @-mention in a group is
+		// not part of the user's actual message). Only collapse the mention
+		// gaps — preserve intentional newlines in multi-line prompts.
+		text = text
+			.replace(/@_user_\d+/g, " ")
+			.replace(/[ \t]{2,}/g, " ")
+			.replace(/\n{3,}/g, "\n\n")
+			.trim();
+		if (text === "") return;
+		logger.debug("Feishu message received", { chatId, length: text.length });
+		this.#onMessage(chatId, text, message.message_id);
+	}
+
+	#onP2pEntered(data: FeishuP2pEnteredData): void {
+		const chatId = data.chat_id ?? data.event?.chat_id;
+		if (typeof chatId !== "string" || chatId === "") return;
+		logger.info("Feishu first p2p contact; sending onboarding", { chatId });
+		void this.sendText(chatId, P2P_ONBOARDING_TEXT).catch(error => {
+			logger.warn("Feishu onboarding reply failed", {
+				error: error instanceof Error ? error.message : String(error),
+			});
+		});
+	}
+
+	#requireClient(): Lark.Client {
+		if (!this.#client) throw new Error("Feishu channel is not started");
+		return this.#client;
+	}
+
+	async sendText(to: string, text: string): Promise<void> {
+		const client = this.#requireClient();
+		const res = await client.im.message.create({
+			params: { receive_id_type: "chat_id" },
+			data: {
+				receive_id: to,
+				msg_type: "text",
+				content: JSON.stringify({ text }),
+			},
+		});
+		if (res.code !== 0) {
+			throw new Error(`Feishu sendMessage failed: code=${String(res.code)} msg=${res.msg ?? ""}`);
+		}
+	}
+
+	async sendImage(to: string, image: ChatImage, caption?: string): Promise<void> {
+		const client = this.#requireClient();
+		const upload = await client.im.image.create({
+			data: {
+				image_type: "message",
+				image: Buffer.from(image.data),
+			},
+		});
+		const imageKey = upload?.image_key;
+		if (!imageKey) {
+			throw new Error("Feishu image upload failed: no image_key returned");
+		}
+		const res = await client.im.message.create({
+			params: { receive_id_type: "chat_id" },
+			data: {
+				receive_id: to,
+				msg_type: "image",
+				content: JSON.stringify({ image_key: imageKey }),
+			},
+		});
+		if (res.code !== 0) {
+			throw new Error(`Feishu image message failed: code=${String(res.code)} msg=${res.msg ?? ""}`);
+		}
+		if (caption && caption !== "") {
+			await this.sendText(to, caption);
+		}
+	}
+}

package/src/host.ts

@@ -0,0 +1,138 @@
+/**
+ * ChannelHost — bridges IM channels into the coordinator `AgentSession`.
+ *
+ * Inbound: each channel message becomes an `IrcMessage` delivered through
+ * `AgentSession.deliverIrcMessage` (the same IRC injection path agents use),
+ * so interrupts, asides, plan-mode handling, and ephemeral auto-replies all
+ * behave identically to IRC traffic.
+ *
+ * Outbound: the agent's final reply to a channel message is forwarded back
+ * to the sender. Two paths exist:
+ * - a real woken turn → the turn's final assistant text is captured from the
+ *   `turn_end` session event;
+ * - the IRC ephemeral auto-reply path (busy session with async disabled, or
+ *   plan-mode idle) → `IrcBridge` reports the reply text through the
+ *   `onAutoReply` hook.
+ *
+ * The agent can also push progress proactively with the `channel_send` tool
+ * (Phase 3); working-tool output is never forwarded automatically.
+ */
+
+import type { AssistantMessage, TextContent } from "@linxiraos/pi-ai";
+import { logger, Snowflake } from "@linxiraos/pi-utils";
+import type { ChannelId } from "./channel";
+import type { ChannelSession, ChannelSessionEvent, IrcMessage } from "./types";
+
+/** Outbound sink: resolves a channel + peer to a `sendText` call. */
+export type ChannelSendFn = (channelId: ChannelId, to: string, text: string) => Promise<void>;
+
+interface PendingReply {
+	channelId: ChannelId;
+	peer: string;
+}
+
+function assistantText(message: AssistantMessage | undefined): string {
+	if (message?.role !== "assistant" || !Array.isArray(message.content)) return "";
+	return message.content
+		.filter((content): content is TextContent => content.type === "text")
+		.map(content => content.text)
+		.join("")
+		.trim();
+}
+
+export class ChannelHost {
+	readonly #session: ChannelSession;
+	readonly #send: ChannelSendFn;
+	readonly #allowedPeers: readonly string[];
+	#pending: PendingReply[] = [];
+	#unsubscribe: (() => void) | null = null;
+	#lastInbound: { channelId: ChannelId; peer: string } | null = null;
+
+	constructor(session: ChannelSession, send: ChannelSendFn, allowedPeers?: readonly string[]) {
+		this.#session = session;
+		this.#send = send;
+		this.#allowedPeers = allowedPeers ?? [];
+	}
+
+	get session(): ChannelSession {
+		return this.#session;
+	}
+
+	/** Most recent successfully injected inbound (channel, peer) — the default
+	 *  target for `channel_send` calls that omit `to`/`channel`. */
+	get lastInbound(): { channelId: ChannelId; peer: string } | null {
+		return this.#lastInbound;
+	}
+
+	/** Attach the session event listener + IRC auto-reply hook. */
+	start(): void {
+		if (this.#unsubscribe) return;
+		this.#unsubscribe = this.#session.subscribe(event => this.#onSessionEvent(event));
+		this.#session.setIrcAutoReplyListener((msg, replyText) => this.#onAutoReply(msg, replyText));
+	}
+
+	/** Detach listeners and drop pending reply bindings. */
+	stop(): void {
+		this.#unsubscribe?.();
+		this.#unsubscribe = null;
+		this.#session.setIrcAutoReplyListener(null);
+		this.#pending = [];
+	}
+
+	/**
+	 * Inject one inbound channel message into the coordinator session and
+	 * bind the sender so the turn's final reply returns to them.
+	 */
+	async deliver(channelId: ChannelId, peer: string, body: string): Promise<void> {
+		// Optional allowlist: when configured, only listed peers may reach the
+		// agent (empty allowlist = everyone, unchanged behavior).
+		if (this.#allowedPeers.length > 0 && !this.#allowedPeers.includes(peer)) {
+			logger.debug("Channel message from non-allowed peer dropped", { channel: channelId, peer });
+			return;
+		}
+		const agentId = this.#session.getAgentId();
+		if (!agentId) throw new Error("Session has no agent id");
+		const msg: IrcMessage = {
+			id: Snowflake.next(),
+			from: peer,
+			to: agentId,
+			body,
+			ts: Date.now(),
+		};
+		this.#pending.push({ channelId, peer });
+		try {
+			await this.#session.deliverIrcMessage(msg, { expectsReply: true });
+			this.#lastInbound = { channelId, peer };
+		} catch (error) {
+			this.#pending = this.#pending.filter(p => !(p.channelId === channelId && p.peer === peer));
+			throw error;
+		}
+	}
+
+	#onSessionEvent(event: ChannelSessionEvent): void {
+		if (event.type !== "turn_end") return;
+		const pending = this.#pending.shift();
+		if (!pending) return;
+		const text = assistantText(event.message as AssistantMessage);
+		if (!text) return;
+		void this.#send(pending.channelId, pending.peer, text).catch(error => {
+			logger.warn("Channel reply delivery failed", {
+				channel: pending.channelId,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		});
+	}
+
+	#onAutoReply(_msg: IrcMessage, replyText: string): void {
+		const pending = this.#pending.shift();
+		if (!pending) return;
+		const body = replyText.trim();
+		if (!body) return;
+		void this.#send(pending.channelId, pending.peer, body).catch(error => {
+			logger.warn("Channel auto-reply delivery failed", {
+				channel: pending.channelId,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		});
+	}
+}

package/src/index.ts

@@ -0,0 +1,246 @@
+/**
+ * Channel bootstrapping for `zeta serve` (web/desktop mode only).
+ *
+ * Enables every channel marked `enabled` in the web config and routes its
+ * inbound messages into the coordinator session through `ChannelHost`.
+ * Channels missing required credentials are skipped with a warning — a
+ * misconfigured channel must never prevent the server from starting.
+ *
+ * The CLI never imports this module: `zeta`/`zeta --interactive` sessions
+ * don't create a ZetaServer, so no channel listeners exist there and
+ * `channel_send`/`workspace_run` stay unavailable.
+ */
+
+import { logger } from "@linxiraos/pi-utils";
+import type { ChannelId, ChatChannel, ChatImage } from "./channel";
+import { FeishuChannel } from "./feishu";
+import { ChannelHost } from "./host";
+import { TelegramChannel } from "./telegram";
+import type { ChannelSession, ChannelsWebConfig } from "./types";
+import { WeChatChannel, type WeChatQrStatus } from "./wechat";
+
+export type { ChannelId, ChatChannel, ChatImage } from "./channel";
+export { FeishuChannel, type FeishuChannelOptions, type FeishuInboundHandler } from "./feishu";
+export { ChannelHost } from "./host";
+export { TelegramChannel, type TelegramChannelOptions, type TelegramInboundHandler } from "./telegram";
+export type { ChannelSession, ChannelSessionEvent, ChannelsWebConfig, IrcMessage } from "./types";
+export { WeChatChannel, type WeChatChannelOptions, type WeChatInboundHandler, type WeChatQrStatus } from "./wechat";
+
+/**
+ * Module-level QR-login state bridge between the running channel and the web
+ * gateway (the gateway dispatches in-process, so a plain module variable is
+ * the shared seam — mirroring `running-sessions.ts`).
+ */
+let pendingWechatQr: WeChatQrStatus | null = null;
+let reconnectWechat: (() => Promise<void>) | null = null;
+let unbindWechat: (() => Promise<void>) | null = null;
+let restartChannels: (() => Promise<void>) | null = null;
+let mainSessionId: string | null = null;
+let channelStatus: (() => ChannelStatus[]) | null = null;
+
+/** One channel's runtime state, surfaced to the gateway (`/api/channels/status`). */
+export interface ChannelStatus {
+	id: ChannelId;
+	running: boolean;
+}
+
+export function registerChannelStatus(fn: (() => ChannelStatus[]) | null): void {
+	channelStatus = fn;
+}
+
+export function getChannelStatus(): ChannelStatus[] {
+	return channelStatus?.() ?? [];
+}
+
+export function setPendingWechatQr(payload: WeChatQrStatus | null): void {
+	pendingWechatQr = payload;
+}
+
+export function getPendingWechatQr(): WeChatQrStatus | null {
+	return pendingWechatQr;
+}
+
+/**
+ * Register the serve process's shared coordinator session id (zeta-server
+ * wires this). External clients (web-ui default chat, `zeta attach`) resolve
+ * the shared session through `GET /api/agent/current`, which reads this.
+ */
+export function registerMainSessionId(id: string | null): void {
+	mainSessionId = id;
+}
+
+/** The persistent id of the serve process's shared coordinator session, if any. */
+export function getMainSessionId(): string | null {
+	return mainSessionId;
+}
+
+/** Register the running WeChat channel's reconnect hook (zeta-server wires this). */
+export function registerWechatReconnect(fn: (() => Promise<void>) | null): void {
+	reconnectWechat = fn;
+}
+
+/** Trigger a fresh QR login on the running WeChat channel, if any. */
+export function triggerWechatReconnect(): Promise<void> | null {
+	return reconnectWechat?.() ?? null;
+}
+
+/** Register the running WeChat channel's unbind hook (zeta-server wires this). */
+export function registerWechatUnbind(fn: (() => Promise<void>) | null): void {
+	unbindWechat = fn;
+}
+
+/** Unbind the running WeChat channel (clears credentials + peer bindings). */
+export function triggerWechatUnbind(): Promise<void> | null {
+	return unbindWechat?.() ?? null;
+}
+
+/** Register the live channel (re)start hook (zeta-server wires this). */
+export function registerRestartChannels(fn: (() => Promise<void>) | null): void {
+	restartChannels = fn;
+}
+
+/**
+ * Re-apply the channel config against the running serve process: stop the
+ * current runtime and start whichever channels web.yml now enables. The web
+ * gateway calls this after a `channels.*` PUT so toggling a channel in the UI
+ * takes effect immediately (QR login included) without a serve restart.
+ */
+export function triggerRestartChannels(): Promise<void> | null {
+	return restartChannels?.() ?? null;
+}
+
+export interface ChannelRuntime {
+	/** Started channels keyed by id (enabled + configured only). */
+	readonly channels: ReadonlyMap<ChannelId, ChatChannel>;
+	/** Host binding the coordinator session to the channels. */
+	readonly host: ChannelHost;
+	/** Send a text message through one channel. */
+	sendText(channelId: ChannelId, to: string, text: string): Promise<void>;
+	/** Send an image through one channel (falls back to caller on error). */
+	sendImage(channelId: ChannelId, to: string, image: ChatImage, caption?: string): Promise<void>;
+	/** Stop every channel and detach the host. */
+	stop(): Promise<void>;
+}
+
+/** Handle one inbound channel message (the Phase-3 routing seam lives here). */
+export type ChannelInboundHandler = (channelId: ChannelId, peer: string, body: string, messageId?: string) => void;
+
+/**
+ * Start all enabled channels for the given coordinator session.
+ * `onInbound` receives every inbound message after channel-level filtering;
+ * default wiring injects into the session via the host.
+ */
+export async function startChannels(
+	session: ChannelSession,
+	webConfig: ChannelsWebConfig,
+	onInbound?: ChannelInboundHandler,
+	wechatQrHandler?: (payload: WeChatQrStatus) => void,
+): Promise<ChannelRuntime> {
+	const data = webConfig.getData();
+	const host = new ChannelHost(
+		session,
+		(channelId, to, text) => sendText(channelId, to, text),
+		data.channels.allowedPeers,
+	);
+	const channels = new Map<ChannelId, ChatChannel>();
+
+	const routeInbound: ChannelInboundHandler =
+		onInbound ??
+		((channelId, peer, body) => {
+			void host.deliver(channelId, peer, body).catch(error => {
+				logger.warn("Channel message injection failed", {
+					channel: channelId,
+					error: error instanceof Error ? error.message : String(error),
+				});
+			});
+		});
+
+	// Telegram
+	if (data.channels.telegram.enabled) {
+		const botToken = data.channels.telegram.botToken;
+		if (botToken) {
+			channels.set(
+				"telegram",
+				new TelegramChannel({
+					botToken,
+					onMessage: (peer, body, messageId) => routeInbound("telegram", peer, body, messageId),
+				}),
+			);
+		} else {
+			logger.warn("Telegram channel is enabled but missing botToken; skipping");
+		}
+	}
+
+	// WeChat (ClawBot / iLink)
+	if (data.channels.wechat.enabled) {
+		channels.set(
+			"wechat",
+			new WeChatChannel({
+				config: {
+					botToken: data.channels.wechat.botToken,
+					ilinkBotId: data.channels.wechat.ilinkBotId,
+					ilinkUserId: data.channels.wechat.ilinkUserId,
+					baseUrl: data.channels.wechat.baseUrl,
+					endpoint: data.channels.wechat.endpoint,
+					peerTokens: data.channels.wechat.peerTokens,
+				},
+				webConfig,
+				onMessage: (peer, body, messageId) => routeInbound("wechat", peer, body, messageId),
+				onQrCode: wechatQrHandler,
+			}),
+		);
+	}
+
+	// Feishu / Lark
+	if (data.channels.feishu.enabled) {
+		const appId = data.channels.feishu.appId;
+		const appSecret = data.channels.feishu.appSecret;
+		if (appId && appSecret) {
+			channels.set(
+				"feishu",
+				new FeishuChannel({
+					appId,
+					appSecret,
+					domain: data.channels.feishu.domain,
+					onMessage: (peer, body, messageId) => routeInbound("feishu", peer, body, messageId),
+				}),
+			);
+		} else {
+			logger.warn("Feishu channel is enabled but missing appId/appSecret; skipping");
+		}
+	}
+
+	host.start();
+
+	const sendText = async (channelId: ChannelId, to: string, text: string): Promise<void> => {
+		const channel = channels.get(channelId);
+		if (!channel) throw new Error(`Channel not enabled: ${channelId}`);
+		await channel.sendText(to, text);
+	};
+
+	for (const channel of channels.values()) {
+		try {
+			await channel.start();
+		} catch (error) {
+			logger.warn(`Channel ${channel.id} failed to start`, {
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+
+	return {
+		channels,
+		host,
+		sendText,
+		sendImage: async (channelId, to, image, caption) => {
+			const channel = channels.get(channelId);
+			if (!channel) throw new Error(`Channel not enabled: ${channelId}`);
+			await channel.sendImage(to, image, caption);
+		},
+		stop: async () => {
+			host.stop();
+			await Promise.allSettled([...channels.values()].map(channel => channel.stop()));
+			channels.clear();
+		},
+	};
+}