hyperclaw 4.0.2 → 5.0.1

package/dist/runner-CJFJUtPm.js

@@ -0,0 +1,1271 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_paths = require('./paths-AIyBxIzm.js');
+const require_paths$1 = require('./paths-DPovhojT.js');
+const require_delivery = require('./delivery-DpMX0Yyc.js');
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const http = require_chunk.__toESM(require("http"));
+
+//#region src/routing/broadcast.ts
+/**
+
+* Check whether `peerId` is in the broadcast config.
+
+* Returns the list of agent IDs and strategy, or null if not found.
+
+*
+
+* @param peerId WhatsApp JID, E.164 number, or other peer ID
+
+* @param cfg    The top-level `broadcast` config block
+
+*/
+function resolveBroadcast(peerId, cfg) {
+	if (!cfg) return null;
+	const strategy = cfg.strategy === "sequential" ? "sequential" : "parallel";
+	const agentIds = cfg[peerId];
+	if (!Array.isArray(agentIds) || agentIds.length === 0) return null;
+	return {
+		agentIds,
+		strategy
+	};
+}
+/**
+
+* Dispatch an inbound message to all agents in a broadcast group.
+
+*
+
+* - Parallel (default): all agents are invoked concurrently.
+
+* - Sequential: agents run in array order; each waits for the previous.
+
+*
+
+* Agents fail independently — one failure does not stop others.
+
+*
+
+* @param message   Raw inbound text to send to each agent.
+
+* @param peerId    Peer ID the message arrived in.
+
+* @param channel   Channel name (e.g. "whatsapp").
+
+* @param target    Resolved broadcast target (agentIds + strategy).
+
+* @param sendFn    Sends the message to one agent and returns its text response.
+
+* @param replyFn   Delivers the agent's response back to the peer.
+
+* @returns         Map of agentId → response (or error string).
+
+*/
+async function dispatchBroadcast(message, peerId, channel, target, sendFn, replyFn) {
+	const results = /* @__PURE__ */ new Map();
+	const runAgent = async (agentId) => {
+		const sessionKey = buildBroadcastSessionKey(agentId, channel, peerId);
+		try {
+			const response = await sendFn(message, {
+				agentId,
+				peerId,
+				sessionKey,
+				channel
+			});
+			results.set(agentId, response);
+			if (response) await replyFn(peerId, agentId, response).catch((e) => console.error(`[broadcast] reply failed for agent "${agentId}": ${e.message}`));
+		} catch (e) {
+			const errMsg = `Error (${agentId}): ${e.message}`;
+			results.set(agentId, errMsg);
+			console.error(`[broadcast] agent "${agentId}" failed: ${e.message}`);
+		}
+	};
+	if (target.strategy === "sequential") for (const agentId of target.agentIds) await runAgent(agentId);
+	else await Promise.all(target.agentIds.map(runAgent));
+	return results;
+}
+/**
+
+* Build a broadcast session key for one agent in a group.
+
+*
+
+* Format: agent:<agentId>:<channel>:group:<peerId>
+
+* For DMs:    agent:<agentId>:<channel>:dm:<peerId>
+
+*/
+function buildBroadcastSessionKey(agentId, channel, peerId) {
+	const isDM = peerId.startsWith("+") || /^\d+$/.test(peerId);
+	const chatType = isDM ? "dm" : "group";
+	return `agent:${agentId}:${channel}:${chatType}:${peerId}`;
+}
+/**
+
+* Extract the broadcast config from the full app config object.
+
+* Accepts any config shape (config may not be typed at call sites).
+
+*/
+function extractBroadcastConfig(cfg) {
+	if (!cfg || typeof cfg !== "object") return null;
+	const b = cfg.broadcast;
+	if (!b || typeof b !== "object") return null;
+	return b;
+}
+
+//#endregion
+//#region src/routing/binding-resolver.ts
+/**
+
+* Resolve which agentId should handle an inbound message.
+
+*
+
+* @param ctx      Inbound message context.
+
+* @param bindings The `bindings` array from config.
+
+* @param agents   The `agents.list` array from config (for default resolution).
+
+* @returns        agentId string, or "main" as the ultimate fallback.
+
+*/
+function resolveBinding(ctx, bindings, agents) {
+	if (bindings && bindings.length > 0) {
+		const peerExact = bindings.find((b) => matchChannel(b, ctx) && matchAccount(b, ctx) && b.match.peer?.id === ctx.peerId);
+		if (peerExact) return peerExact.agentId;
+		if (ctx.threadId) {
+			const parentId = ctx.peerId;
+			const parentMatch = bindings.find((b) => matchChannel(b, ctx) && matchAccount(b, ctx) && b.match.peer?.id === parentId);
+			if (parentMatch) return parentMatch.agentId;
+		}
+		if (ctx.guildId && ctx.senderRoles && ctx.senderRoles.length > 0) {
+			const guildRoles = bindings.find((b) => matchChannel(b, ctx) && b.match.guildId === ctx.guildId && b.match.roles && b.match.roles.every((r) => ctx.senderRoles.includes(r)));
+			if (guildRoles) return guildRoles.agentId;
+		}
+		if (ctx.guildId) {
+			const guildOnly = bindings.find((b) => matchChannel(b, ctx) && b.match.guildId === ctx.guildId && !b.match.roles);
+			if (guildOnly) return guildOnly.agentId;
+		}
+		if (ctx.teamId) {
+			const team = bindings.find((b) => matchChannel(b, ctx) && b.match.teamId === ctx.teamId);
+			if (team) return team.agentId;
+		}
+		if (ctx.accountId) {
+			const account = bindings.find((b) => matchChannel(b, ctx) && b.match.accountId === ctx.accountId && !b.match.peer);
+			if (account) return account.agentId;
+		}
+		const channelOnly = bindings.find((b) => b.match.channel === ctx.channel && !b.match.peer && !b.match.accountId && !b.match.guildId && !b.match.teamId);
+		if (channelOnly) return channelOnly.agentId;
+		const wildcard = bindings.find((b) => b.match.channel === "*" && !b.match.peer && !b.match.guildId && !b.match.teamId);
+		if (wildcard) return wildcard.agentId;
+	}
+	return resolveDefaultAgent(agents);
+}
+/** Resolve the default agentId from agents.list. */
+function resolveDefaultAgent(agents) {
+	if (!agents || agents.length === 0) return "main";
+	const defaultAgent = agents.find((a) => a.default);
+	if (defaultAgent) return defaultAgent.id;
+	return agents[0].id;
+}
+function matchChannel(binding, ctx) {
+	const ch = binding.match.channel;
+	return !ch || ch === "*" || ch === ctx.channel;
+}
+function matchAccount(binding, ctx) {
+	const acc = binding.match.accountId;
+	return !acc || acc === "*" || acc === ctx.accountId;
+}
+/** Extract bindings array from raw config (tolerates untyped config objects). */
+function extractBindings(cfg) {
+	if (!cfg || !Array.isArray(cfg.bindings)) return [];
+	return cfg.bindings;
+}
+/** Extract agents list from raw config. */
+function extractAgentsList(cfg) {
+	if (!cfg?.agents?.list || !Array.isArray(cfg.agents.list)) return [];
+	return cfg.agents.list;
+}
+/** Build InboundContext from the message envelope emitted by a connector. */
+function buildInboundContext(msg, channelId) {
+	const peerId = String(msg.chatId);
+	const chatType = msg.isDM ? "dm" : msg.isGroup ? "group" : "channel";
+	return {
+		channel: channelId,
+		accountId: msg.accountId,
+		peerId,
+		chatType,
+		threadId: msg.threadId,
+		guildId: msg.guildId,
+		teamId: msg.teamId,
+		senderRoles: msg.senderRoles
+	};
+}
+
+//#endregion
+//#region src/routing/session-keys.ts
+/**
+
+* Build a session key based on the chat type and dmScope setting.
+
+*/
+function buildSessionKey(opts) {
+	const { agentId, channel, chatType, peerId, accountId = "default", threadId, dmScope = "main", mainKey = "main" } = opts;
+	const effectivePeerId = opts.canonicalPeerId || peerId;
+	if (chatType === "group") {
+		const base = `agent:${agentId}:${channel}:group:${effectivePeerId}`;
+		if (threadId) return `${base}:topic:${threadId}`;
+		return base;
+	}
+	if (chatType === "channel") {
+		const base = `agent:${agentId}:${channel}:channel:${effectivePeerId}`;
+		if (threadId) return `${base}:thread:${threadId}`;
+		return base;
+	}
+	switch (dmScope) {
+		case "main": return `agent:${agentId}:${mainKey}`;
+		case "per-peer": return `agent:${agentId}:dm:${effectivePeerId}`;
+		case "per-channel-peer": return `agent:${agentId}:${channel}:dm:${effectivePeerId}`;
+		case "per-account-channel-peer": return `agent:${agentId}:${channel}:${accountId}:dm:${effectivePeerId}`;
+		default: return `agent:${agentId}:${mainKey}`;
+	}
+}
+/**
+
+* Resolve a provider-prefixed peer ID to a canonical identity if a link exists.
+
+*
+
+* identityLinks shape:
+
+* {
+
+*   "alice": ["telegram:123456789", "discord:987654321012345678"]
+
+* }
+
+*
+
+* Returns the canonical identity key if found, otherwise returns the raw peerId.
+
+*/
+function resolveIdentityLink(channel, peerId, identityLinks) {
+	if (!identityLinks) return peerId;
+	const providerPeerId = `${channel}:${peerId}`;
+	for (const [canonical, links] of Object.entries(identityLinks)) if (links.includes(providerPeerId)) return canonical;
+	return peerId;
+}
+/** Extract session config from raw config object. */
+function extractSessionConfig(cfg) {
+	const session = cfg?.session || {};
+	return {
+		dmScope: session.dmScope || "main",
+		mainKey: session.mainKey || "main",
+		identityLinks: session.identityLinks || {}
+	};
+}
+
+//#endregion
+//#region src/channels/runner.ts
+require_paths$1.init_paths();
+const HC_DIR = require_paths.getHyperClawDir();
+const connectors = [];
+let emailConnectorRef = null;
+const webhookConnectors = {};
+async function startChannelRunners(opts) {
+	const port = opts.port;
+	const baseUrl = `http://${opts.bind || "127.0.0.1"}:${port}`;
+	const authToken = opts.authToken || "";
+	let cfg = {};
+	try {
+		cfg = await fs_extra.default.readJson(require_paths.getConfigPath());
+	} catch {}
+	let channelConfigs = {};
+	let configChannels = [];
+	try {
+		const configPath = path.default.join(HC_DIR, "config.json");
+		if (await fs_extra.default.pathExists(configPath)) {
+			const c2 = await fs_extra.default.readJson(configPath);
+			channelConfigs = c2.channelConfigs || {};
+			configChannels = Array.isArray(c2.channels) ? c2.channels : [];
+		}
+	} catch {}
+	const enabledIds = (cfg.gateway?.enabledChannels?.length ? cfg.gateway.enabledChannels : configChannels) || [];
+	const ids = Array.isArray(enabledIds) ? enabledIds : [];
+	if (ids.length === 0) return { stop: async () => {} };
+	const broadcastCfg = extractBroadcastConfig(cfg);
+	const bindings = extractBindings(cfg);
+	const agentsList = extractAgentsList(cfg);
+	const sessionCfg = extractSessionConfig(cfg);
+	const wrap = (c) => {
+		const ty = c.sendTyping;
+		return {
+			sendMessage: (id, t) => c.sendMessage(String(id), t),
+			sendTyping: ty ? (id) => ty(String(id)) : void 0
+		};
+	};
+	/**
+	
+	* Handles one inbound message from any channel connector.
+	
+	* Supports broadcast groups (multi-agent) and binding resolution.
+	
+	*/
+	const handleMsg = async (msg, conn, channelId) => {
+		try {
+			conn.sendTyping?.(msg.chatId).catch(() => {});
+			const { enrichVoiceNote } = await Promise.resolve().then(() => require("./delivery-DVHmv1IR.js"));
+			const text = await enrichVoiceNote(msg);
+			const peerId = String(msg.chatId);
+			const broadcastTarget = resolveBroadcast(peerId, broadcastCfg);
+			if (broadcastTarget) {
+				await dispatchBroadcast(text, peerId, channelId, broadcastTarget, async (message, dispatchOpts) => {
+					return await require_delivery.withRetry(() => postChat(baseUrl, message, channelId, authToken, dispatchOpts.agentId, dispatchOpts.sessionKey), { onRetry: (n, err) => console.error(`[broadcast] ${dispatchOpts.agentId} retry ${n}: ${err.message}`) });
+				}, async (_peerId, _agentId, response$1) => {
+					const chunks$1 = require_delivery.chunkForChannel(response$1, channelId);
+					for (const chunk of chunks$1) await require_delivery.withRetry(() => conn.sendMessage(msg.chatId, chunk), { onRetry: (n, err) => console.error(`[broadcast] send retry ${n}: ${err.message}`) });
+				});
+				return;
+			}
+			const inboundCtx = buildInboundContext(msg, channelId);
+			const agentId = resolveBinding(inboundCtx, bindings, agentsList);
+			const canonicalPeerId = resolveIdentityLink(channelId, peerId, sessionCfg.identityLinks);
+			const sessionKey = buildSessionKey({
+				agentId,
+				channel: channelId,
+				chatType: inboundCtx.chatType,
+				peerId,
+				accountId: msg.accountId,
+				threadId: msg.threadId,
+				dmScope: sessionCfg.dmScope,
+				mainKey: sessionCfg.mainKey,
+				canonicalPeerId
+			});
+			const response = await require_delivery.withRetry(() => postChat(baseUrl, text, channelId, authToken, agentId, sessionKey), { onRetry: (n, err) => console.error(`[channels] ${channelId} agent retry ${n}: ${err.message}`) });
+			const chunks = require_delivery.chunkForChannel(response, channelId);
+			for (const chunk of chunks) await require_delivery.withRetry(() => conn.sendMessage(msg.chatId, chunk), { onRetry: (n, err) => console.error(`[channels] ${channelId} send retry ${n}: ${err.message}`) });
+		} catch (e) {
+			console.error(`[channels] ${channelId} error: ${e.message}`);
+			await conn.sendMessage(msg.chatId, `Error: ${e.message}`).catch(() => {});
+		}
+	};
+	for (const id of ids) {
+		const chCfg = cfg.channels?.[id] || channelConfigs[id];
+		const dmObj = chCfg?.dmPolicy;
+		const dmPolicy = (typeof dmObj === "object" ? dmObj?.policy : dmObj) || "pairing";
+		const allowFrom = chCfg?.allowFrom || (typeof dmObj === "object" ? dmObj?.allowFrom : []) || [];
+		const allowFromArr = Array.isArray(allowFrom) ? allowFrom : [];
+		if (id === "telegram") {
+			const token = chCfg?.token || chCfg?.botToken || process.env.TELEGRAM_BOT_TOKEN;
+			if (!token) continue;
+			const groupAllowFrom = Array.isArray(chCfg?.groupAllowFrom) ? chCfg.groupAllowFrom.map(String) : [];
+			const groupActivation = chCfg?.groupActivation === "always" ? "always" : "mention";
+			try {
+				const { TelegramConnector } = await Promise.resolve().then(() => require("./connector-B8R3iBY1.js"));
+				const conn = new TelegramConnector(token, {
+					dmPolicy,
+					allowFrom: allowFromArr,
+					groupAllowFrom,
+					groupActivation,
+					pendingPairings: {},
+					approvedPairings: []
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "telegram"));
+				await conn.connect();
+				connectors.push({ stop: async () => {
+					await conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Telegram failed to start: ${e.message}`);
+			}
+		} else if (id === "discord") {
+			const token = chCfg?.token || process.env.DISCORD_BOT_TOKEN;
+			if (!token) continue;
+			try {
+				const { DiscordConnector } = await Promise.resolve().then(() => require("./connector-DrnEiiyP.js"));
+				const { PairingStore } = await Promise.resolve().then(() => require("./pairing-dGoiGepK.js"));
+				const discordStore = new PairingStore("discord");
+				const pairingBridge = {
+					isApproved: (senderId) => discordStore.isApproved(senderId),
+					createRequest: (senderId) => discordStore.createRequest(senderId),
+					verify: (code, senderId) => discordStore.verify(code, senderId)
+				};
+				const listenGuildIds = Array.isArray(chCfg?.listenGuildIds) ? chCfg.listenGuildIds : chCfg?.guilds ? Object.keys(chCfg.guilds) : [];
+				const requireMentionInGuild = chCfg?.requireMentionInGuild;
+				const conn = new DiscordConnector(token, {
+					dmPolicy,
+					allowFrom: allowFromArr,
+					pendingPairings: {},
+					approvedPairings: [],
+					pairingBridge,
+					listenGuildIds: listenGuildIds.filter(Boolean),
+					requireMentionInGuild: requireMentionInGuild === false ? false : true
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "discord"));
+				await conn.connect();
+				connectors.push({ stop: async () => {
+					await conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Discord failed to start: ${e.message}`);
+			}
+		} else if (id === "slack") {
+			const botToken = chCfg?.botToken || chCfg?.token || process.env.SLACK_BOT_TOKEN;
+			const appToken = chCfg?.appToken || process.env.SLACK_APP_TOKEN;
+			const signingSecret = chCfg?.signingSecret || process.env.SLACK_SIGNING_SECRET;
+			const mode = chCfg?.mode || "socket";
+			if (!botToken) continue;
+			if (mode === "socket" && !appToken) {
+				console.error("[channels] Slack Socket Mode requires appToken (xapp-...). Set SLACK_APP_TOKEN or switch to mode: http");
+				continue;
+			}
+			if (mode === "http" && !signingSecret) {
+				console.error("[channels] Slack HTTP mode requires signingSecret. Set SLACK_SIGNING_SECRET or switch to mode: socket");
+				continue;
+			}
+			try {
+				const { SlackConnector } = await Promise.resolve().then(() => require("./connector-u3ICd3Ic.js"));
+				const conn = new SlackConnector({
+					botToken,
+					...appToken ? { appToken } : {},
+					...signingSecret ? { signingSecret } : {},
+					mode,
+					...chCfg?.userToken ? { userToken: chCfg.userToken } : {},
+					userTokenReadOnly: chCfg?.userTokenReadOnly !== false,
+					dmPolicy: dmPolicy ?? "pairing",
+					allowFrom: allowFromArr,
+					dm: {
+						enabled: chCfg?.dm?.enabled !== false,
+						policy: chCfg?.dm?.policy ?? chCfg?.dmPolicy ?? dmPolicy ?? "pairing",
+						allowFrom: chCfg?.dm?.allowFrom ?? allowFromArr,
+						groupEnabled: chCfg?.dm?.groupEnabled === true,
+						groupChannels: chCfg?.dm?.groupChannels,
+						replyToMode: chCfg?.dm?.replyToMode
+					},
+					groupPolicy: chCfg?.groupPolicy || "allowlist",
+					channels: chCfg?.channels || {},
+					replyToMode: chCfg?.replyToMode || "off",
+					replyToModeByChatType: chCfg?.replyToModeByChatType,
+					thread: {
+						historyScope: chCfg?.thread?.historyScope || "thread",
+						inheritParent: chCfg?.thread?.inheritParent === true,
+						initialHistoryLimit: chCfg?.thread?.initialHistoryLimit ?? 20
+					},
+					textChunkLimit: chCfg?.textChunkLimit ? Number(chCfg.textChunkLimit) : void 0,
+					chunkMode: chCfg?.chunkMode || "length",
+					mediaMaxMb: chCfg?.mediaMaxMb ? Number(chCfg.mediaMaxMb) : void 0,
+					streaming: chCfg?.streaming || "partial",
+					nativeStreaming: chCfg?.nativeStreaming !== false,
+					ackReaction: chCfg?.ackReaction,
+					typingReaction: chCfg?.typingReaction,
+					actions: chCfg?.actions || {},
+					commands: chCfg?.commands || {},
+					slashCommand: chCfg?.slashCommand || {},
+					configWrites: chCfg?.configWrites !== false,
+					accounts: chCfg?.accounts || {},
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => {
+					const send = (id$1, t) => conn.sendMessage(String(id$1), t, msg.threadTs);
+					const typing = conn.sendTyping ? (id$1) => conn.sendTyping(String(id$1)) : void 0;
+					handleMsg({
+						chatId: msg.chatId,
+						text: msg.text
+					}, {
+						sendMessage: send,
+						sendTyping: typing
+					}, "slack");
+				});
+				await conn.connect();
+				if (mode === "http") webhookConnectors["slack"] = {
+					handleWebhook: async (body, opts$1) => await conn.handleWebhook(body, opts$1?.signature ?? "", opts$1?.timestamp ?? "") ?? void 0,
+					verifyWebhook: void 0
+				};
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Slack failed to start: ${e.message}`);
+			}
+		} else if (id === "signal") {
+			const signalCliUrl = chCfg?.signalCliUrl || process.env.SIGNAL_CLI_URL || "http://localhost:8080";
+			const phoneNumber = chCfg?.phoneNumber || chCfg?.token || process.env.SIGNAL_PHONE_NUMBER;
+			if (!phoneNumber) continue;
+			try {
+				const { SignalConnector } = await Promise.resolve().then(() => require("./connector-DXTp5PE8.js"));
+				const conn = new SignalConnector({
+					httpUrl: signalCliUrl,
+					account: phoneNumber,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "signal"));
+				await conn.connect();
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Signal failed to start: ${e.message}`);
+			}
+		} else if (id === "matrix") {
+			const homeserver = chCfg?.homeserver || chCfg?.homeserverUrl || process.env.MATRIX_HOMESERVER;
+			const accessToken = chCfg?.accessToken || chCfg?.token || process.env.MATRIX_ACCESS_TOKEN;
+			const userId = chCfg?.userId || process.env.MATRIX_USER_ID;
+			const password = chCfg?.password || process.env.MATRIX_PASSWORD;
+			const hasAccounts = chCfg?.accounts && Object.keys(chCfg.accounts).length > 0;
+			if (!homeserver && !hasAccounts) continue;
+			if (!hasAccounts && !accessToken && !password) continue;
+			try {
+				const { MatrixConnector } = await Promise.resolve().then(() => require("./connector-sW5yhU1m.js"));
+				const conn = new MatrixConnector({
+					homeserver: homeserver || "",
+					...accessToken ? { accessToken } : {},
+					...userId ? { userId } : {},
+					...password ? { password } : {},
+					...chCfg?.deviceName ? { deviceName: chCfg.deviceName } : {},
+					encryption: chCfg?.encryption === true || chCfg?.encryption === "true",
+					dm: {
+						policy: chCfg?.dm?.policy ?? chCfg?.dmPolicy ?? dmPolicy ?? "pairing",
+						allowFrom: chCfg?.dm?.allowFrom ?? allowFromArr
+					},
+					groupPolicy: chCfg?.groupPolicy || "allowlist",
+					groupAllowFrom: Array.isArray(chCfg?.groupAllowFrom) ? chCfg.groupAllowFrom : [],
+					groups: chCfg?.groups || {},
+					rooms: chCfg?.rooms || {},
+					threadReplies: chCfg?.threadReplies || "inbound",
+					replyToMode: chCfg?.replyToMode || "off",
+					textChunkLimit: chCfg?.textChunkLimit ? Number(chCfg.textChunkLimit) : void 0,
+					chunkMode: chCfg?.chunkMode || "length",
+					mediaMaxMb: chCfg?.mediaMaxMb ? Number(chCfg.mediaMaxMb) : void 0,
+					autoJoin: chCfg?.autoJoin || "always",
+					autoJoinAllowlist: Array.isArray(chCfg?.autoJoinAllowlist) ? chCfg.autoJoinAllowlist : [],
+					accounts: chCfg?.accounts || {},
+					actions: chCfg?.actions || {},
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => {
+					const send = (id$1, t) => conn.sendMessage(String(id$1), t, msg.threadId);
+					handleMsg({
+						chatId: msg.chatId,
+						text: msg.text
+					}, { sendMessage: send }, "matrix");
+				});
+				await conn.connect();
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Matrix failed to start: ${e.message}`);
+			}
+		} else if (id === "nostr") {
+			const privateKeyHex = chCfg?.privateKeyHex || process.env.NOSTR_PRIVATE_KEY;
+			const relays = chCfg?.relays || (process.env.NOSTR_RELAYS || "wss://relay.damus.io,wss://nos.lol").split(",");
+			if (!privateKeyHex || !Array.isArray(relays) || relays.length === 0) continue;
+			try {
+				const { NostrConnector } = await Promise.resolve().then(() => require("./connector-BiiSJpx3.js"));
+				const conn = new NostrConnector({
+					privateKeyHex,
+					relays,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "nostr"));
+				await conn.connect();
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Nostr failed to start: ${e.message}`);
+			}
+		} else if (id === "line") {
+			const channelAccessToken = chCfg?.channelAccessToken || chCfg?.token || process.env.LINE_CHANNEL_ACCESS_TOKEN;
+			const channelSecret = chCfg?.channelSecret || process.env.LINE_CHANNEL_SECRET;
+			const tokenFile = chCfg?.tokenFile;
+			const secretFile = chCfg?.secretFile;
+			const hasCredentials = channelAccessToken && channelSecret || tokenFile && secretFile;
+			if (!hasCredentials) continue;
+			try {
+				const { LINEConnector } = await Promise.resolve().then(() => require("./connector-Tky_qS_K.js"));
+				const conn = new LINEConnector({
+					...channelAccessToken ? { channelAccessToken } : {},
+					...channelSecret ? { channelSecret } : {},
+					...tokenFile ? { tokenFile } : {},
+					...secretFile ? { secretFile } : {},
+					...chCfg?.webhookPath ? { webhookPath: chCfg.webhookPath } : {},
+					...chCfg?.mediaMaxMb != null ? { mediaMaxMb: Number(chCfg.mediaMaxMb) } : {},
+					dmPolicy,
+					allowFrom: allowFromArr,
+					groupPolicy: chCfg?.groupPolicy || "allowlist",
+					groupAllowFrom: Array.isArray(chCfg?.groupAllowFrom) ? chCfg.groupAllowFrom : [],
+					groups: chCfg?.groups || {},
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", async (msg) => {
+					const send = (id$1, t) => msg.replyToken ? conn.replyMessage(msg.replyToken, t) : conn.pushMessage(String(id$1), t);
+					await handleMsg({
+						chatId: msg.chatId,
+						text: msg.text
+					}, { sendMessage: send }, "line");
+				});
+				await conn.connect();
+				webhookConnectors["line"] = {
+					handleWebhook: (body, opts$1) => conn.handleWebhook(body, opts$1?.signature ?? ""),
+					verifyWebhook: void 0
+				};
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] LINE failed to start: ${e.message}`);
+			}
+		} else if (id === "feishu" || id === "lark") {
+			const appId = chCfg?.appId || process.env.FEISHU_APP_ID;
+			const appSecret = chCfg?.appSecret || process.env.FEISHU_APP_SECRET;
+			if (!appId || !appSecret) continue;
+			try {
+				const { FeishuConnector } = await Promise.resolve().then(() => require("./connector-BDmwwaVc.js"));
+				const conn = new FeishuConnector({
+					appId,
+					appSecret,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "feishu"));
+				await conn.connect();
+				const feishuHandler = {
+					handleWebhook: async (body) => {
+						const ch = conn.handleChallenge?.(body);
+						if (ch) return ch;
+						await conn.handleWebhook(body);
+					},
+					verifyWebhook: void 0
+				};
+				webhookConnectors["feishu"] = feishuHandler;
+				if (id === "lark") webhookConnectors["lark"] = feishuHandler;
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Feishu failed to start: ${e.message}`);
+			}
+		} else if (id === "msteams" || id === "teams") {
+			const appId = chCfg?.appId || process.env.MSTEAMS_APP_ID;
+			const appPassword = chCfg?.appPassword || chCfg?.password || process.env.MSTEAMS_APP_PASSWORD;
+			if (!appId || !appPassword) continue;
+			try {
+				const { MSTeamsConnector } = await Promise.resolve().then(() => require("./connector-BAM-08NN.js"));
+				const conn = new MSTeamsConnector({
+					appId,
+					appPassword,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => {
+					const m = msg;
+					const send = (id$1, t) => conn.reply(m.serviceUrl, String(id$1), m.activity, t);
+					handleMsg(msg, { sendMessage: send }, "msteams");
+				});
+				await conn.connect();
+				webhookConnectors["msteams"] = {
+					handleWebhook: (body) => conn.handleWebhook(body),
+					verifyWebhook: void 0
+				};
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] MS Teams failed to start: ${e.message}`);
+			}
+		} else if (id === "bluebubbles" || id === "imessage") {
+			const serverUrl = chCfg?.serverUrl || process.env.BLUEBUBBLES_SERVER_URL;
+			const password = chCfg?.password || process.env.BLUEBUBBLES_PASSWORD;
+			if (!serverUrl || !password) continue;
+			try {
+				const { BlueBubblesConnector } = await Promise.resolve().then(() => require("./connector-BC8FIVu4.js"));
+				const conn = new BlueBubblesConnector({
+					serverUrl,
+					password,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "bluebubbles"));
+				await conn.connect();
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] BlueBubbles failed to start: ${e.message}`);
+			}
+		} else if (id === "imessage-native" && process.platform === "darwin") try {
+			const { IMessageNativeConnector } = await Promise.resolve().then(() => require("./connector-BGjbBy69.js"));
+			const cliPath = chCfg?.cliPath || process.env.IMSG_PATH;
+			const dbPath = chCfg?.dbPath;
+			const conn = new IMessageNativeConnector({
+				...cliPath ? { cliPath } : {},
+				...dbPath ? { dbPath } : {},
+				dmPolicy,
+				allowFrom: allowFromArr,
+				approvedPairings: [],
+				pendingPairings: {}
+			});
+			conn.on("message", (msg) => handleMsg(msg, wrap(conn), "imessage-native"));
+			await conn.connect();
+			connectors.push({ stop: async () => {
+				conn.disconnect();
+			} });
+		} catch (e) {
+			console.error(`[channels] imessage-native failed: ${e.message}. Install imsg (github.com/steipete/imsg) and grant Full Disk Access + Automation.`);
+		}
+		else if (id === "instagram") {
+			const pageAccessToken = chCfg?.pageAccessToken || chCfg?.token || process.env.INSTAGRAM_PAGE_ACCESS_TOKEN;
+			const instagramAccountId = chCfg?.instagramAccountId || chCfg?.instagramAccountID || process.env.INSTAGRAM_ACCOUNT_ID;
+			const verifyToken = chCfg?.verifyToken || process.env.INSTAGRAM_VERIFY_TOKEN || "hyperclaw";
+			if (!pageAccessToken || !instagramAccountId) continue;
+			try {
+				const { InstagramConnector } = await Promise.resolve().then(() => require("./connector-DAnRJ0oP.js"));
+				const conn = new InstagramConnector({
+					pageAccessToken,
+					instagramAccountId,
+					verifyToken,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "instagram"));
+				await conn.connect();
+				webhookConnectors["instagram"] = {
+					handleWebhook: (body) => conn.handleWebhook(body),
+					verifyWebhook: (mode, token, challenge) => conn.verifyWebhook(mode, token, challenge)
+				};
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Instagram failed: ${e.message}`);
+			}
+		} else if (id === "messenger") {
+			const pageAccessToken = chCfg?.pageAccessToken || chCfg?.token || process.env.MESSENGER_PAGE_ACCESS_TOKEN;
+			const verifyToken = chCfg?.verifyToken || process.env.MESSENGER_VERIFY_TOKEN || "hyperclaw";
+			const appSecret = chCfg?.appSecret || process.env.MESSENGER_APP_SECRET;
+			const pageId = chCfg?.pageId || chCfg?.page_id || process.env.MESSENGER_PAGE_ID;
+			if (!pageAccessToken || !verifyToken || !appSecret || !pageId) continue;
+			try {
+				const { MessengerConnector } = await Promise.resolve().then(() => require("./connector-Dih6dUPP.js"));
+				const conn = new MessengerConnector({
+					pageAccessToken,
+					verifyToken,
+					appSecret,
+					pageId,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "messenger"));
+				await conn.connect();
+				webhookConnectors["messenger"] = {
+					handleWebhook: async (body, opts$1) => {
+						await conn.handleWebhook(body, opts$1?.signature ?? "");
+					},
+					verifyWebhook: (mode, token, challenge) => conn.verifyWebhook(mode, token, challenge)
+				};
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Messenger failed: ${e.message}`);
+			}
+		} else if (id === "twitter") {
+			const bearerToken = chCfg?.bearerToken || process.env.TWITTER_BEARER_TOKEN;
+			const apiKey = chCfg?.apiKey || process.env.TWITTER_API_KEY;
+			const apiSecret = chCfg?.apiSecret || process.env.TWITTER_API_SECRET;
+			const accessToken = chCfg?.accessToken || process.env.TWITTER_ACCESS_TOKEN;
+			const accessTokenSecret = chCfg?.accessTokenSecret || process.env.TWITTER_ACCESS_TOKEN_SECRET;
+			if (!bearerToken || !apiKey || !apiSecret || !accessToken || !accessTokenSecret) continue;
+			try {
+				const { TwitterConnector } = await Promise.resolve().then(() => require("./connector-CjtZIEDj.js"));
+				const conn = new TwitterConnector({
+					bearerToken,
+					apiKey,
+					apiSecret,
+					accessToken,
+					accessTokenSecret,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap({ sendMessage: (id$1, t) => conn.sendDM(id$1, t) }), "twitter"));
+				await conn.connect();
+				webhookConnectors["twitter"] = {
+					handleWebhook: (body) => conn.handleWebhook(body),
+					verifyWebhook: (mode, token) => conn.handleCRC ? conn.handleCRC(token) : null
+				};
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Twitter failed: ${e.message}`);
+			}
+		} else if (id === "viber") {
+			const authToken$1 = chCfg?.authToken || chCfg?.token || process.env.VIBER_AUTH_TOKEN;
+			const botName = chCfg?.botName || chCfg?.bot_name || "HyperClaw";
+			const webhookUrl = chCfg?.webhookUrl || process.env.VIBER_WEBHOOK_URL || `${baseUrl}/webhook/viber`;
+			if (!authToken$1) continue;
+			try {
+				const { ViberConnector } = await Promise.resolve().then(() => require("./connector-DqTH_tPX.js"));
+				const conn = new ViberConnector({
+					authToken: authToken$1,
+					botName,
+					webhookUrl,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "viber"));
+				await conn.connect();
+				webhookConnectors["viber"] = {
+					handleWebhook: async (body, opts$1) => {
+						await conn.handleWebhook(body, opts$1?.signature ?? "");
+					},
+					verifyWebhook: void 0
+				};
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Viber failed: ${e.message}`);
+			}
+		} else if (id === "zalo-personal") {
+			const cookie = chCfg?.cookie || process.env.ZALO_PERSONAL_COOKIE;
+			if (!cookie) continue;
+			try {
+				const { ZaloPersonalConnector } = await Promise.resolve().then(() => require("./connector-BfXky0L3.js"));
+				const conn = new ZaloPersonalConnector({
+					cookie,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "zalo-personal"));
+				await conn.connect();
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Zalo Personal failed: ${e.message}`);
+			}
+		} else if (id === "zalo") {
+			const botToken = chCfg?.botToken || chCfg?.token || process.env.ZALO_BOT_TOKEN;
+			const tokenFile = chCfg?.tokenFile;
+			const hasAccounts = chCfg?.accounts && Object.keys(chCfg.accounts).length > 0;
+			if (!botToken && !tokenFile && !hasAccounts) continue;
+			try {
+				const { ZaloConnector } = await Promise.resolve().then(() => require("./connector-B3v0qcXg.js"));
+				const conn = new ZaloConnector({
+					...botToken ? { botToken } : {},
+					...tokenFile ? { tokenFile } : {},
+					dmPolicy: dmPolicy ?? "pairing",
+					allowFrom: allowFromArr,
+					groupPolicy: chCfg?.groupPolicy || "allowlist",
+					groupAllowFrom: Array.isArray(chCfg?.groupAllowFrom) ? chCfg.groupAllowFrom : [],
+					...chCfg?.webhookUrl ? { webhookUrl: chCfg.webhookUrl } : {},
+					...chCfg?.webhookSecret ? { webhookSecret: chCfg.webhookSecret } : {},
+					...chCfg?.webhookPath ? { webhookPath: chCfg.webhookPath } : {},
+					mediaMaxMb: chCfg?.mediaMaxMb ? Number(chCfg.mediaMaxMb) : void 0,
+					...chCfg?.proxy ? { proxy: chCfg.proxy } : {},
+					accounts: chCfg?.accounts || {},
+					approvedPairings: [],
+					pendingPairings: {},
+					pendingPairingTs: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "zalo"));
+				await conn.connect();
+				if (chCfg?.webhookUrl) {
+					const wPath = chCfg?.webhookPath || new URL(chCfg.webhookUrl).pathname || "/zalo-webhook";
+					webhookConnectors[wPath] = {
+						handleWebhook: async (body, opts$1) => {
+							const secret = opts$1?.secret || opts$1?.signature || "";
+							await conn.handleWebhook(body, secret);
+						},
+						verifyWebhook: void 0
+					};
+					webhookConnectors["zalo"] = webhookConnectors[wPath];
+				}
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Zalo failed to start: ${e.message}`);
+			}
+		} else if (id === "email") {
+			const imapHost = chCfg?.imapHost || process.env.EMAIL_IMAP_HOST;
+			const imapPort = chCfg?.imapPort ?? parseInt(process.env.EMAIL_IMAP_PORT || "993", 10);
+			const smtpHost = chCfg?.smtpHost || process.env.EMAIL_SMTP_HOST;
+			const smtpPort = chCfg?.smtpPort ?? parseInt(process.env.EMAIL_SMTP_PORT || "587", 10);
+			const username = chCfg?.username || process.env.EMAIL_USERNAME;
+			const password = chCfg?.password || process.env.EMAIL_PASSWORD;
+			if (!imapHost || !smtpHost || !username || !password) continue;
+			try {
+				const { EmailConnector } = await Promise.resolve().then(() => require("./connector-D8Kelee0.js"));
+				const conn = new EmailConnector({
+					imapHost,
+					imapPort,
+					smtpHost,
+					smtpPort,
+					username,
+					password,
+					pollIntervalMs: 3e4,
+					inboxFolder: "INBOX",
+					markAsRead: true,
+					subjectPrefix: "",
+					fromAllowlist: allowFromArr
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "email"));
+				await conn.connect();
+				emailConnectorRef = conn;
+				webhookConnectors["gmail-pubsub"] = {
+					handleWebhook: async (body) => {
+						try {
+							const json = JSON.parse(body || "{}");
+							if (json.message?.data) emailConnectorRef?.triggerPoll?.();
+						} catch {}
+					},
+					verifyWebhook: void 0
+				};
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+					emailConnectorRef = null;
+					delete webhookConnectors["gmail-pubsub"];
+				} });
+			} catch (e) {
+				console.error(`[channels] Email failed to start: ${e.message}`);
+			}
+		} else if (id === "sms") {
+			const accountSid = chCfg?.accountSid || process.env.TWILIO_ACCOUNT_SID;
+			const authToken$1 = chCfg?.authToken || process.env.TWILIO_AUTH_TOKEN;
+			const fromNumber = chCfg?.fromNumber || process.env.TWILIO_FROM_NUMBER;
+			if (!accountSid || !authToken$1 || !fromNumber) continue;
+			try {
+				const { SMSConnector } = await Promise.resolve().then(() => require("./connector-C1HSoUyk.js"));
+				const conn = new SMSConnector({
+					accountSid,
+					authToken: authToken$1,
+					fromNumber,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "sms"));
+				await conn.connect();
+				webhookConnectors["sms"] = {
+					handleWebhook: (body, opts$1) => conn.handleWebhook(body, opts$1?.twilioSignature ?? "", opts$1?.webhookUrl ?? ""),
+					verifyWebhook: void 0
+				};
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] SMS failed to start: ${e.message}`);
+			}
+		} else if (id === "whatsapp-baileys") try {
+			const { WhatsAppBaileysConnector } = await Promise.resolve().then(() => require("./connector-DtR5GGTX.js"));
+			const conn = new WhatsAppBaileysConnector({
+				dmPolicy,
+				allowFrom: allowFromArr,
+				approvedPairings: [],
+				pendingPairings: {}
+			});
+			conn.on("message", (msg) => handleMsg(msg, wrap(conn), "whatsapp-baileys"));
+			await conn.connect();
+			connectors.push({ stop: () => {
+				conn.disconnect();
+				return Promise.resolve();
+			} });
+		} catch (e) {
+			console.error(`[channels] WhatsApp Baileys failed: ${e.message}. Install: npm install @whiskeysockets/baileys`);
+		}
+		else if (id === "whatsapp") {
+			const phoneNumberId = chCfg?.phoneNumberId || process.env.WHATSAPP_PHONE_NUMBER_ID;
+			const accessToken = chCfg?.accessToken || chCfg?.token || process.env.WHATSAPP_ACCESS_TOKEN;
+			const verifyToken = chCfg?.verifyToken || process.env.WHATSAPP_VERIFY_TOKEN || "hyperclaw-verify";
+			if (!phoneNumberId || !accessToken) continue;
+			try {
+				const { WhatsAppConnector } = await Promise.resolve().then(() => require("./connector-5N0-X_xs.js"));
+				const conn = new WhatsAppConnector({
+					phoneNumberId,
+					accessToken,
+					verifyToken,
+					dmPolicy,
+					allowFrom: allowFromArr
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "whatsapp"));
+				await conn.connect();
+				webhookConnectors["whatsapp"] = {
+					handleWebhook: (body) => conn.handleWebhook(body),
+					verifyWebhook: (mode, token, challenge) => conn.verifyWebhook(mode, token, challenge)
+				};
+				connectors.push({ stop: () => {
+					conn.disconnect();
+					return Promise.resolve();
+				} });
+			} catch (e) {
+				console.error(`[channels] WhatsApp failed to start: ${e.message}`);
+			}
+		} else if (id === "irc") {
+			const server = chCfg?.server || process.env.IRC_SERVER;
+			const nick = chCfg?.nick || process.env.IRC_NICK || "hyperclaw";
+			const channels = (chCfg?.channels || process.env.IRC_CHANNELS || "").split(",").filter(Boolean).map((c) => c.trim());
+			if (!server) continue;
+			try {
+				const { IrcConnector } = await Promise.resolve().then(() => require("./connector-BO2SRzfG.js"));
+				const conn = new IrcConnector({
+					server,
+					nick,
+					channels,
+					dmPolicy,
+					allowFrom: allowFromArr
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "irc"));
+				await conn.connect();
+				connectors.push({ stop: async () => {
+					await conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] IRC failed to start: ${e.message}`);
+			}
+		} else if (id === "mattermost") {
+			const serverUrl = chCfg?.serverUrl || process.env.MATTERMOST_SERVER_URL;
+			const token = chCfg?.token || process.env.MATTERMOST_TOKEN;
+			const webhookToken = chCfg?.webhookToken || process.env.MATTERMOST_WEBHOOK_TOKEN;
+			if (!serverUrl || !token || !webhookToken) continue;
+			try {
+				const { MattermostConnector } = await Promise.resolve().then(() => require("./connector-Ck6JtOsX.js"));
+				const conn = new MattermostConnector({
+					baseUrl: serverUrl,
+					botToken: token,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "mattermost"));
+				await conn.connect();
+				webhookConnectors["mattermost"] = {
+					handleWebhook: async (body, _opts) => {
+						await conn.handleWebhook(body, webhookToken ?? "");
+					},
+					verifyWebhook: void 0
+				};
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Mattermost failed to start: ${e.message}`);
+			}
+		} else if (id === "gchat" || id === "google-chat") try {
+			const { GoogleChatConnector } = await Promise.resolve().then(() => require("./connector-BnDmIhIu.js"));
+			const conn = new GoogleChatConnector({ baseUrl });
+			await conn.connect();
+			webhookConnectors["gchat"] = {
+				handleWebhook: (body) => conn.handleWebhook(body),
+				verifyWebhook: void 0
+			};
+			if (id === "google-chat") webhookConnectors["google-chat"] = webhookConnectors["gchat"];
+			connectors.push({ stop: async () => {
+				conn.disconnect();
+			} });
+		} catch (e) {
+			console.error(`[channels] Google Chat failed to start: ${e.message}`);
+		}
+		else if (id === "nextcloud-talk" || id === "nextcloud") {
+			const baseUrl$1 = chCfg?.baseUrl || chCfg?.serverUrl || chCfg?.token || process.env.NEXTCLOUD_TALK_BASE_URL;
+			const botSecret = chCfg?.botSecret || process.env.NEXTCLOUD_TALK_BOT_SECRET;
+			const botSecretFile = chCfg?.botSecretFile;
+			if (!baseUrl$1 || !botSecret && !botSecretFile) continue;
+			try {
+				const { NextcloudTalkConnector } = await Promise.resolve().then(() => require("./connector-Ci9glMD-.js"));
+				const conn = new NextcloudTalkConnector({
+					baseUrl: baseUrl$1,
+					...botSecret ? { botSecret } : {},
+					...botSecretFile ? { botSecretFile } : {},
+					...chCfg?.apiUser ? { apiUser: chCfg.apiUser } : {},
+					...chCfg?.apiPassword ? { apiPassword: chCfg.apiPassword } : {},
+					...chCfg?.apiPasswordFile ? { apiPasswordFile: chCfg.apiPasswordFile } : {},
+					...chCfg?.webhookPort != null ? { webhookPort: Number(chCfg.webhookPort) } : {},
+					...chCfg?.webhookHost ? { webhookHost: chCfg.webhookHost } : {},
+					...chCfg?.webhookPath ? { webhookPath: chCfg.webhookPath } : {},
+					...chCfg?.webhookPublicUrl ? { webhookPublicUrl: chCfg.webhookPublicUrl } : {},
+					dmPolicy: dmPolicy ?? "pairing",
+					allowFrom: allowFromArr,
+					groupPolicy: chCfg?.groupPolicy || "allowlist",
+					groupAllowFrom: Array.isArray(chCfg?.groupAllowFrom) ? chCfg.groupAllowFrom : [],
+					rooms: chCfg?.rooms || {},
+					...chCfg?.textChunkLimit != null ? { textChunkLimit: Number(chCfg.textChunkLimit) } : {},
+					...chCfg?.chunkMode ? { chunkMode: chCfg.chunkMode } : {},
+					...chCfg?.mediaMaxMb != null ? { mediaMaxMb: Number(chCfg.mediaMaxMb) } : {},
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "nextcloud-talk"));
+				await conn.connect();
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Nextcloud Talk failed to start: ${e.message}`);
+			}
+		} else if (id === "synology-chat") {
+			const incomingWebhookUrl = chCfg?.incomingWebhookUrl || chCfg?.token || process.env.SYNOLOGY_CHAT_WEBHOOK_URL;
+			const webhookToken = chCfg?.webhookToken || process.env.SYNOLOGY_CHAT_OUTGOING_TOKEN;
+			const webhookPort = chCfg?.webhookPort || process.env.SYNOLOGY_CHAT_WEBHOOK_PORT;
+			if (!incomingWebhookUrl) continue;
+			try {
+				const { SynologyChatConnector } = await Promise.resolve().then(() => require("./connector-ZSc3oTTy.js"));
+				const conn = new SynologyChatConnector({
+					incomingUrl: incomingWebhookUrl,
+					token: webhookToken,
+					...webhookPort ? { webhookPort: Number(webhookPort) } : {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "synology-chat"));
+				await conn.connect();
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Synology Chat failed to start: ${e.message}`);
+			}
+		} else if (id === "twitch") {
+			const username = chCfg?.username || process.env.TWITCH_BOT_USERNAME;
+			const oauthToken = chCfg?.oauthToken || chCfg?.token || process.env.TWITCH_OAUTH_TOKEN;
+			const channels = String(chCfg?.channels || process.env.TWITCH_CHANNELS || "").split(",").map((c) => c.trim()).filter(Boolean);
+			if (!username || !oauthToken || channels.length === 0) continue;
+			try {
+				const { TwitchConnector } = await Promise.resolve().then(() => require("./connector-CRl-iidy.js"));
+				const conn = new TwitchConnector({
+					username,
+					oauthToken,
+					channels,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					commandPrefix: chCfg?.commandPrefix,
+					whispers: chCfg?.whispers,
+					modsBypass: chCfg?.modsBypass,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "twitch"));
+				await conn.connect();
+				connectors.push({ stop: async () => {
+					await conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Twitch failed to start: ${e.message}`);
+			}
+		} else if (id === "tlon") {
+			const shipUrl = chCfg?.shipUrl || process.env.TLON_SHIP_URL;
+			const ship = chCfg?.ship || process.env.TLON_SHIP;
+			const code = chCfg?.code || chCfg?.token || process.env.TLON_CODE;
+			const group = chCfg?.group || process.env.TLON_GROUP;
+			if (!shipUrl || !ship || !code) continue;
+			try {
+				const { TlonConnector } = await Promise.resolve().then(() => require("./connector-CKQHZOXg.js"));
+				const conn = new TlonConnector({
+					url: shipUrl,
+					ship,
+					code,
+					...group ? { group } : {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "tlon"));
+				await conn.connect();
+				connectors.push({ stop: async () => {
+					conn.disconnect();
+				} });
+			} catch (e) {
+				console.error(`[channels] Tlon failed to start: ${e.message}`);
+			}
+		}
+	}
+	return {
+		stop: async () => {
+			for (const c of connectors) await c.stop().catch(() => {});
+			connectors.length = 0;
+			emailConnectorRef = null;
+			Object.keys(webhookConnectors).forEach((k) => delete webhookConnectors[k]);
+		},
+		handleWebhook: async (channelId, body, opts$1) => {
+			const h = webhookConnectors[channelId];
+			if (h) {
+				const result = await h.handleWebhook(body, opts$1);
+				return result;
+			}
+		},
+		verifyWebhook: (channelId, mode, token, challenge) => {
+			const h = webhookConnectors[channelId];
+			return h?.verifyWebhook ? h.verifyWebhook(mode, token, challenge) : null;
+		}
+	};
+}
+function postChat(baseUrl, message, source, authToken, agentId, sessionKey) {
+	return new Promise((resolve, reject) => {
+		const body = { message };
+		if (agentId) body.agentId = agentId;
+		if (sessionKey) body.sessionKey = sessionKey;
+		const payload = JSON.stringify(body);
+		const headers = {
+			"Content-Type": "application/json",
+			"Content-Length": String(Buffer.byteLength(payload))
+		};
+		if (source) headers["X-HyperClaw-Source"] = source;
+		if (authToken) headers["Authorization"] = `Bearer ${authToken}`;
+		const url = new URL(`${baseUrl}/api/chat`);
+		const req = http.default.request({
+			hostname: url.hostname,
+			port: url.port || 80,
+			path: url.pathname,
+			method: "POST",
+			headers
+		}, (res) => {
+			let data = "";
+			res.on("data", (c) => data += c);
+			res.on("end", () => {
+				try {
+					const j = JSON.parse(data);
+					if (j.error) reject(new Error(j.error));
+					else resolve(j.response || "");
+				} catch {
+					reject(new Error("Invalid response"));
+				}
+			});
+		});
+		req.on("error", reject);
+		req.setTimeout(6e4, () => {
+			req.destroy();
+			reject(new Error("Timeout"));
+		});
+		req.write(payload);
+		req.end();
+	});
+}
+
+//#endregion
+exports.startChannelRunners = startChannelRunners;