hyperclaw 4.0.1 → 5.0.0

package/dist/connector-u3ICd3Ic.js

@@ -0,0 +1,552 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const os = require_chunk.__toESM(require("os"));
+const crypto = require_chunk.__toESM(require("crypto"));
+const https = require_chunk.__toESM(require("https"));
+const events = require_chunk.__toESM(require("events"));
+
+//#region extensions/slack/src/connector.ts
+const STATE_BASE = path.default.join(os.default.homedir(), ".hyperclaw");
+const DEFAULT_CHUNK = 3e3;
+function slackApi(token, method, body = {}) {
+	return new Promise((resolve, reject) => {
+		const payload = JSON.stringify(body);
+		const req = https.default.request({
+			hostname: "slack.com",
+			port: 443,
+			path: `/api/${method}`,
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"Content-Type": "application/json; charset=utf-8",
+				"Content-Length": Buffer.byteLength(payload)
+			}
+		}, (res) => {
+			let data = "";
+			res.on("data", (c) => data += c);
+			res.on("end", () => {
+				try {
+					const r = JSON.parse(data);
+					if (!r.ok) reject(new Error(r.error || "Slack API error"));
+					else resolve(r);
+				} catch {
+					reject(new Error("Slack: invalid JSON"));
+				}
+			});
+		});
+		req.on("error", reject);
+		req.setTimeout(3e4, () => {
+			req.destroy();
+			reject(new Error("Slack API timeout"));
+		});
+		req.write(payload);
+		req.end();
+	});
+}
+function chunkText(text, limit, mode) {
+	if (mode === "newline") {
+		const paras = text.split(/\n\n+/);
+		const chunks$1 = [];
+		let cur = "";
+		for (const p of paras) if ((cur + "\n\n" + p).length > limit && cur) {
+			chunks$1.push(cur.trim());
+			cur = p;
+		} else cur = cur ? cur + "\n\n" + p : p;
+		if (cur) chunks$1.push(cur.trim());
+		return chunks$1.filter(Boolean);
+	}
+	const chunks = [];
+	for (let i = 0; i < text.length; i += limit) chunks.push(text.slice(i, i + limit));
+	return chunks.length ? chunks : [""];
+}
+function generateCode() {
+	return Array.from({ length: 6 }, () => "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"[Math.floor(Math.random() * 32)]).join("");
+}
+var SlackAccount = class extends events.EventEmitter {
+	cfg;
+	accountId;
+	botUserId = "";
+	teamName = "";
+	running = false;
+	wsReconnectDelay = 1e3;
+	constructor(accountId, cfg) {
+		super();
+		this.accountId = accountId;
+		this.cfg = {
+			mode: "socket",
+			userTokenReadOnly: true,
+			textChunkLimit: DEFAULT_CHUNK,
+			chunkMode: "length",
+			streaming: "partial",
+			nativeStreaming: true,
+			dmPolicy: "pairing",
+			allowFrom: [],
+			groupPolicy: "allowlist",
+			channels: {},
+			replyToMode: "off",
+			thread: {
+				historyScope: "thread",
+				inheritParent: false,
+				initialHistoryLimit: 20
+			},
+			actions: {
+				messages: true,
+				reactions: true,
+				pins: true,
+				memberInfo: true,
+				emojiList: true
+			},
+			...cfg
+		};
+	}
+	async authenticate() {
+		const token = this.cfg.botToken;
+		const auth = await slackApi(token, "auth.test");
+		this.botUserId = auth.user_id;
+		this.teamName = auth.team;
+		console.log(chalk.default.green(`  💼 Slack [${this.accountId}]: @${auth.user} in ${auth.team}`));
+	}
+	async connect() {
+		await this.loadState();
+		await this.authenticate();
+		this.running = true;
+		this.emit("connected", {
+			userId: this.botUserId,
+			team: this.teamName,
+			accountId: this.accountId
+		});
+		const mode = this.cfg.mode ?? "socket";
+		if (mode === "socket") this.connectSocketMode();
+	}
+	disconnect() {
+		this.running = false;
+	}
+	async connectSocketMode() {
+		if (!this.cfg.appToken) {
+			console.error(`[slack:${this.accountId}] Socket Mode requires appToken (xapp-...)`);
+			return;
+		}
+		let WebSocketImpl;
+		try {
+			WebSocketImpl = await import("ws");
+		} catch {
+			console.error(`[slack:${this.accountId}] ws package not found — install: npm i ws`);
+			return;
+		}
+		while (this.running) try {
+			const resp = await slackApi(this.cfg.appToken, "apps.connections.open");
+			const wsUrl = resp.url;
+			await new Promise((resolve) => {
+				const WS = WebSocketImpl.default ?? WebSocketImpl;
+				const ws = new WS(wsUrl);
+				ws.on("open", () => {
+					this.wsReconnectDelay = 1e3;
+				});
+				ws.on("message", (raw) => {
+					let envelope;
+					try {
+						envelope = JSON.parse(raw.toString());
+					} catch {
+						return;
+					}
+					if (envelope.envelope_id) ws.send(JSON.stringify({ envelope_id: envelope.envelope_id }));
+					this.handleSocketEnvelope(envelope);
+				});
+				ws.on("close", () => resolve());
+				ws.on("error", () => resolve());
+			});
+			if (!this.running) break;
+			await new Promise((r) => setTimeout(r, this.wsReconnectDelay));
+			this.wsReconnectDelay = Math.min(this.wsReconnectDelay * 2, 3e4);
+		} catch (e) {
+			if (this.running) {
+				console.log(chalk.default.yellow(`  ⚠  Slack [${this.accountId}] socket: ${e.message}`));
+				await new Promise((r) => setTimeout(r, this.wsReconnectDelay));
+				this.wsReconnectDelay = Math.min(this.wsReconnectDelay * 2, 3e4);
+			}
+		}
+	}
+	async handleSocketEnvelope(envelope) {
+		const type = envelope.type || "";
+		switch (type) {
+			case "hello": break;
+			case "disconnect": break;
+			case "events_api": {
+				const payload = envelope.payload || {};
+				if (payload.type === "event_callback") await this.handleEvent(payload.event, payload);
+				break;
+			}
+			case "slash_commands": {
+				const p = envelope.payload || {};
+				if (p.command || p.user_id) await this.handleSlashCommand(p);
+				break;
+			}
+			case "block_actions":
+			case "interactive": {
+				const p = envelope.payload || {};
+				this.emit("interaction", {
+					accountId: this.accountId,
+					type,
+					payload: p
+				});
+				break;
+			}
+		}
+	}
+	async handleWebhook(body, signature, timestamp) {
+		if (!this.verifySignature(body, signature, timestamp)) {
+			console.log(chalk.default.yellow(`  ⚠  Slack [${this.accountId}]: invalid signature`));
+			return null;
+		}
+		let payload;
+		try {
+			payload = JSON.parse(body);
+		} catch {
+			return null;
+		}
+		if (payload.type === "url_verification") return payload.challenge;
+		if (payload.type === "event_callback") await this.handleEvent(payload.event, payload);
+		return null;
+	}
+	verifySignature(body, signature, timestamp) {
+		if (!this.cfg.signingSecret) return false;
+		const ts = parseInt(timestamp);
+		if (Math.abs(Date.now() / 1e3 - ts) > 300) return false;
+		const baseString = `v0:${timestamp}:${body}`;
+		const hash = "v0=" + crypto.default.createHmac("sha256", this.cfg.signingSecret).update(baseString).digest("hex");
+		try {
+			return crypto.default.timingSafeEqual(Buffer.from(hash), Buffer.from(signature));
+		} catch {
+			return false;
+		}
+	}
+	async handleEvent(event, _outer) {
+		if (!event) return;
+		if (event.bot_id || event.user === this.botUserId) return;
+		const evType = event.type || "";
+		if (["reaction_added", "reaction_removed"].includes(evType)) {
+			this.emit("system_event", {
+				accountId: this.accountId,
+				type: evType,
+				event
+			});
+			return;
+		}
+		if ([
+			"member_joined_channel",
+			"member_left_channel",
+			"channel_rename",
+			"pin_added",
+			"pin_removed"
+		].includes(evType)) {
+			this.emit("system_event", {
+				accountId: this.accountId,
+				type: evType,
+				event
+			});
+			return;
+		}
+		if (evType !== "message" && evType !== "app_mention") return;
+		if (!event.text || !event.user || !event.channel) return;
+		if (event.subtype && event.subtype !== "file_share") return;
+		const channelType = event.channel_type || "";
+		const isDM = channelType === "im";
+		const isGroup = channelType === "mpim";
+		const isChannel = !isDM && !isGroup;
+		const isAppMention = evType === "app_mention";
+		const threadTs = event.thread_ts;
+		const ts = event.ts || "";
+		const text = event.text.replace(/<@[A-Z0-9]+>/g, "").trim();
+		if (isDM) {
+			const dmEnabled = this.cfg.dm?.enabled !== false;
+			if (!dmEnabled) return;
+			const allowed = await this.checkDMPolicy(event.user, event.channel, text, ts);
+			if (!allowed) return;
+		} else if (isGroup) {
+			const groupEnabled = this.cfg.dm?.groupEnabled === true;
+			if (!groupEnabled) return;
+			const groupChannels = this.cfg.dm?.groupChannels;
+			if (groupChannels?.length && !groupChannels.includes(event.channel)) return;
+		} else if (!this.checkChannelPolicy(event.channel, event.user, text, isAppMention)) return;
+		this.addReaction(this.resolveAckReaction(), event.channel, ts);
+		const chatType = isDM ? "direct" : isGroup ? "group" : "channel";
+		const replyToMode = this.resolveReplyToMode(chatType);
+		this.emit("message", {
+			channelId: "slack",
+			accountId: this.accountId,
+			chatId: event.channel,
+			from: event.user,
+			text,
+			ts,
+			threadTs,
+			isDM,
+			isGroup,
+			isChannel,
+			chatType,
+			replyToMode
+		});
+	}
+	async handleSlashCommand(payload) {
+		const text = [payload.command, payload.text].filter(Boolean).join(" ");
+		const userId = payload.user_id || "";
+		const channelId = payload.channel_id || "";
+		if (!userId || !channelId) return;
+		this.emit("message", {
+			channelId: "slack",
+			accountId: this.accountId,
+			chatId: channelId,
+			from: userId,
+			text,
+			isDM: false,
+			isSlashCommand: true,
+			ephemeral: this.cfg.slashCommand?.ephemeral !== false
+		});
+	}
+	async checkDMPolicy(userId, channelId, text, ts) {
+		const policy = this.cfg.dm?.policy ?? this.cfg.dmPolicy ?? "pairing";
+		const allowFrom = this.cfg.allowFrom ?? this.cfg.dm?.allowFrom ?? [];
+		switch (policy) {
+			case "disabled": return false;
+			case "open": return true;
+			case "allowlist":
+				if (allowFrom.includes(userId) || allowFrom.includes("*")) return true;
+				await this.sendMessage(channelId, "HyperClaw: Not on allowlist.");
+				return false;
+			case "pairing": {
+				if (this.cfg.approvedPairings.includes(userId)) return true;
+				const upper = text.trim().toUpperCase().match(/[A-Z0-9]{6}/)?.[0];
+				if (upper && this.cfg.pendingPairings[upper]) {
+					this.cfg.approvedPairings.push(userId);
+					delete this.cfg.pendingPairings[upper];
+					await this.saveState();
+					await this.sendMessage(channelId, "Paired! You can now send messages.");
+					this.emit("pairing:approved", {
+						userId,
+						channelId: "slack",
+						accountId: this.accountId
+					});
+					return true;
+				}
+				const code = generateCode();
+				this.cfg.pendingPairings[code] = userId;
+				await this.saveState();
+				await this.sendMessage(channelId, `*HyperClaw Pairing*\n\nCode: \`${code}\`\nApprove: \`hyperclaw pairing approve slack ${code}\``);
+				return false;
+			}
+		}
+		return false;
+	}
+	checkChannelPolicy(channelId, userId, text, isAppMention) {
+		const policy = this.cfg.groupPolicy ?? "allowlist";
+		if (policy === "disabled") return false;
+		const chCfg = this.cfg.channels?.[channelId] || {};
+		if (policy === "open") {
+			if (chCfg.allowFrom?.length && !chCfg.allowFrom.includes(userId)) return false;
+			if (chCfg.users?.length && !chCfg.users.includes(userId)) return false;
+			return true;
+		}
+		if (!this.cfg.channels?.[channelId]) return isAppMention;
+		if (chCfg.allowFrom?.length && !chCfg.allowFrom.includes(userId)) return false;
+		if (chCfg.users?.length && !chCfg.users.includes(userId)) return false;
+		if (chCfg.requireMention !== false && !isAppMention) return false;
+		return true;
+	}
+	resolveAckReaction() {
+		return this.cfg.ackReaction ?? "";
+	}
+	resolveTypingReaction() {
+		return this.cfg.typingReaction ?? "";
+	}
+	resolveReplyToMode(chatType) {
+		const byType = this.cfg.replyToModeByChatType;
+		if (byType) {
+			if (chatType === "direct" && byType.direct) return byType.direct;
+			if (chatType === "group" && byType.group) return byType.group;
+			if (chatType === "channel" && byType.channel) return byType.channel;
+		}
+		return this.cfg.replyToMode ?? "off";
+	}
+	async addReaction(emoji, channel, timestamp) {
+		if (!emoji || !channel || !timestamp) return;
+		const name = emoji.replace(/:/g, "");
+		await slackApi(this.cfg.botToken, "reactions.add", {
+			channel,
+			timestamp,
+			name
+		}).catch(() => {});
+	}
+	async removeReaction(emoji, channel, timestamp) {
+		if (!emoji || !channel || !timestamp) return;
+		const name = emoji.replace(/:/g, "");
+		await slackApi(this.cfg.botToken, "reactions.remove", {
+			channel,
+			timestamp,
+			name
+		}).catch(() => {});
+	}
+	async sendMessage(channel, text, threadTs, opts = {}) {
+		const limit = this.cfg.textChunkLimit ?? DEFAULT_CHUNK;
+		const mode = this.cfg.chunkMode ?? "length";
+		const chunks = chunkText(text, limit, mode);
+		const replyThread = threadTs && this.resolveReplyToMode("channel") !== "off";
+		for (const chunk of chunks) {
+			const payload = {
+				channel,
+				text: chunk,
+				mrkdwn: true,
+				...replyThread ? { thread_ts: threadTs } : {}
+			};
+			if (opts.ephemeral && opts.userId) await slackApi(this.cfg.botToken, "chat.postEphemeral", {
+				...payload,
+				user: opts.userId
+			});
+			else await slackApi(this.cfg.botToken, "chat.postMessage", payload);
+		}
+	}
+	async sendTyping(channelId) {}
+	async startStream(channel, threadTs) {
+		if (this.cfg.streaming === "off" || !this.cfg.nativeStreaming) return null;
+		try {
+			const r = await slackApi(this.cfg.botToken, "chat.startStream", {
+				channel,
+				...threadTs ? { thread_ts: threadTs } : {}
+			});
+			return r.stream_ts || null;
+		} catch {
+			return null;
+		}
+	}
+	async appendStream(streamTs, text) {
+		await slackApi(this.cfg.botToken, "chat.appendStream", {
+			stream_ts: streamTs,
+			text
+		}).catch(() => {});
+	}
+	async stopStream(streamTs, text) {
+		await slackApi(this.cfg.botToken, "chat.stopStream", {
+			stream_ts: streamTs,
+			text
+		}).catch(() => {});
+	}
+	async setAssistantStatus(channelId, threadTs, status) {
+		await slackApi(this.cfg.botToken, "assistant.threads.setStatus", {
+			channel_id: channelId,
+			thread_ts: threadTs,
+			status
+		}).catch(() => {});
+	}
+	approvePairing(code) {
+		const upper = code.toUpperCase();
+		if (!this.cfg.pendingPairings[upper]) return false;
+		this.cfg.approvedPairings.push(this.cfg.pendingPairings[upper]);
+		delete this.cfg.pendingPairings[upper];
+		this.saveState();
+		return true;
+	}
+	async openDM(userId) {
+		const r = await slackApi(this.cfg.botToken, "conversations.open", { users: userId });
+		return r.channel.id;
+	}
+	async sendDM(userId, text) {
+		const channelId = await this.openDM(userId);
+		await this.sendMessage(channelId, text);
+	}
+	stateFile() {
+		return path.default.join(STATE_BASE, `slack-state-${this.accountId}.json`);
+	}
+	async loadState() {
+		try {
+			const s = await fs_extra.default.readJson(this.stateFile());
+			if (s.p) this.cfg.pendingPairings = s.p;
+			if (s.a) this.cfg.approvedPairings = s.a;
+		} catch {}
+	}
+	async saveState() {
+		await fs_extra.default.ensureDir(STATE_BASE);
+		await fs_extra.default.writeJson(this.stateFile(), {
+			p: this.cfg.pendingPairings,
+			a: this.cfg.approvedPairings
+		}, { spaces: 2 });
+	}
+	isRunning() {
+		return this.running;
+	}
+};
+var SlackConnector = class extends events.EventEmitter {
+	config;
+	accounts = [];
+	constructor(config) {
+		super();
+		this.config = config;
+	}
+	async connect() {
+		const sharedState = {
+			approvedPairings: this.config.approvedPairings ?? [],
+			pendingPairings: this.config.pendingPairings ?? {}
+		};
+		const accountEntries = Object.entries(this.config.accounts || {});
+		if (accountEntries.length === 0) {
+			const acct = new SlackAccount("default", {
+				...this.config,
+				...sharedState
+			});
+			this.wire(acct);
+			await acct.connect();
+			this.accounts.push(acct);
+		} else for (const [id, acctCfg] of accountEntries) {
+			const merged = {
+				...this.config,
+				...acctCfg,
+				botToken: acctCfg.botToken || this.config.botToken,
+				...sharedState
+			};
+			if (!merged.botToken) {
+				console.error(`[slack] Account "${id}" has no botToken — skipping`);
+				continue;
+			}
+			const acct = new SlackAccount(id, merged);
+			this.wire(acct);
+			try {
+				await acct.connect();
+				this.accounts.push(acct);
+			} catch (e) {
+				console.error(`[slack] Account "${id}" failed: ${e.message}`);
+			}
+		}
+	}
+	wire(acct) {
+		acct.on("message", (msg) => this.emit("message", msg));
+		acct.on("connected", (info) => this.emit("connected", info));
+		acct.on("pairing:approved", (info) => this.emit("pairing:approved", info));
+		acct.on("system_event", (ev) => this.emit("system_event", ev));
+		acct.on("interaction", (ev) => this.emit("interaction", ev));
+	}
+	async sendMessage(channel, text, threadTs) {
+		const acct = this.accounts[0];
+		if (!acct) throw new Error("Slack: no connected account");
+		await acct.sendMessage(channel, text, threadTs);
+	}
+	async sendTyping(channelId) {}
+	async handleWebhook(body, signature, timestamp) {
+		for (const acct of this.accounts) {
+			const r = await acct.handleWebhook(body, signature, timestamp);
+			if (r != null) return r;
+		}
+		return null;
+	}
+	approvePairing(code) {
+		return this.accounts.some((a) => a.approvePairing(code));
+	}
+	disconnect() {
+		for (const a of this.accounts) a.disconnect();
+		this.accounts = [];
+	}
+	isRunning() {
+		return this.accounts.some((a) => a.isRunning());
+	}
+};
+
+//#endregion
+exports.SlackConnector = SlackConnector;