hyperclaw 4.0.0 → 4.0.2

package/dist/runner-Bu--_RXw.js

@@ -0,0 +1,810 @@
+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-B-SJqXLn.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/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 wrap = (c) => {
+		const ty = c.sendTyping;
+		return {
+			sendMessage: (id, t) => c.sendMessage(String(id), t),
+			sendTyping: ty ? (id) => ty(String(id)) : void 0
+		};
+	};
+	const handleMsg = async (msg, conn, channelId) => {
+		try {
+			conn.sendTyping?.(msg.chatId).catch(() => {});
+			const { enrichVoiceNote, withRetry } = await Promise.resolve().then(() => require("./delivery-VgFeuu2J.js"));
+			const text = await enrichVoiceNote(msg);
+			const response = await withRetry(() => postChat(baseUrl, text, channelId, authToken), { 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 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;
+			try {
+				const { TelegramConnector } = await Promise.resolve().then(() => require("./connector-BVron-00.js"));
+				const conn = new TelegramConnector(token, {
+					dmPolicy,
+					allowFrom: allowFromArr,
+					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-DRv1ahC_.js"));
+				const conn = new DiscordConnector(token, {
+					dmPolicy,
+					allowFrom: allowFromArr,
+					pendingPairings: {},
+					approvedPairings: []
+				});
+				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 signingSecret = chCfg?.signingSecret || process.env.SLACK_SIGNING_SECRET;
+			if (!botToken || !signingSecret) continue;
+			try {
+				const { SlackConnector } = await Promise.resolve().then(() => require("./connector-DzcW1ftI.js"));
+				const conn = new SlackConnector({
+					botToken,
+					signingSecret,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					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();
+				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 () => {} });
+			} 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-DL06atry.js"));
+				const conn = new SignalConnector({
+					signalCliUrl,
+					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;
+			if (!homeserver || !accessToken || !userId) continue;
+			try {
+				const { MatrixConnector } = await Promise.resolve().then(() => require("./connector-8nWTSbSS.js"));
+				const conn = new MatrixConnector({
+					homeserver,
+					accessToken,
+					userId,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "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-CT5EB6IY.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;
+			if (!channelAccessToken || !channelSecret) continue;
+			try {
+				const { LINEConnector } = await Promise.resolve().then(() => require("./connector-Dl28lj5s.js"));
+				const conn = new LINEConnector({
+					channelAccessToken,
+					channelSecret,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					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-BGEml3Es.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-upqdANzX.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-DNCBKuW2.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-xPvJqcXm.js"));
+			const conn = new IMessageNativeConnector({
+				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-BBHOSEqx.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-DX7IaRQK.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-CQ8DnjRg.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-DRW3HV-q.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-Cvag_mW8.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 appId = chCfg?.appId || process.env.ZALO_APP_ID;
+			const appSecret = chCfg?.appSecret || process.env.ZALO_APP_SECRET;
+			const oaAccessToken = chCfg?.oaAccessToken || chCfg?.token || process.env.ZALO_OA_ACCESS_TOKEN;
+			if (!appId || !appSecret || !oaAccessToken) continue;
+			try {
+				const { ZaloConnector } = await Promise.resolve().then(() => require("./connector-DHffkQWw.js"));
+				const conn = new ZaloConnector({
+					appId,
+					appSecret,
+					oaAccessToken,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "zalo"));
+				await conn.connect();
+				webhookConnectors["zalo"] = {
+					handleWebhook: (body) => conn.handleWebhook(body),
+					verifyWebhook: void 0
+				};
+				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-BggIDel_.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-DFcVFrTM.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-qy96-Zlk.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-lGrnqUcv.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-BoZh71uW.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-DVKb2piB.js"));
+				const conn = new MattermostConnector({
+					serverUrl,
+					token,
+					webhookToken,
+					dmPolicy,
+					allowFrom: allowFromArr,
+					approvedPairings: [],
+					pendingPairings: {}
+				});
+				conn.on("message", (msg) => handleMsg(msg, wrap(conn), "mattermost"));
+				await conn.connect();
+				webhookConnectors["mattermost"] = {
+					handleWebhook: async (body, opts$1) => {
+						await conn.handleWebhook(body, opts$1 ? { contentType: opts$1.contentType } : void 0);
+					},
+					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-CkVYePmY.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 === "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-nXSTTPmC.js"));
+				const conn = new SynologyChatConnector({
+					incomingWebhookUrl,
+					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-DJ5T80Zu.js"));
+				const conn = new TwitchConnector({
+					username,
+					oauthToken,
+					channels
+				});
+				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-DspyzGKN.js"));
+				const conn = new TlonConnector({
+					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) {
+	return new Promise((resolve, reject) => {
+		const payload = JSON.stringify({ message });
+		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;