hyperclaw 5.0.1 → 5.0.2

package/dist/connector-BpDqLgnW.js

@@ -0,0 +1,419 @@
+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 ws = require_chunk.__toESM(require("ws"));
+const https = require_chunk.__toESM(require("https"));
+const events = require_chunk.__toESM(require("events"));
+
+//#region extensions/discord/src/connector.ts
+const STATE_FILE = path.default.join(os.default.homedir(), ".hyperclaw", "discord-state.json");
+const OPC = {
+	DISPATCH: 0,
+	HEARTBEAT: 1,
+	IDENTIFY: 2,
+	RESUME: 6,
+	RECONNECT: 7,
+	INVALID_SESSION: 9,
+	HELLO: 10,
+	HEARTBEAT_ACK: 11
+};
+const INTENTS = {
+	GUILDS: 1,
+	GUILD_MESSAGES: 512,
+	GUILD_MESSAGE_CONTENT: 32768,
+	DIRECT_MESSAGES: 4096,
+	DIRECT_MESSAGE_CONTENT: 16384
+};
+function discordRest(token, method, endpoint, body) {
+	return new Promise((resolve, reject) => {
+		const payload = body ? JSON.stringify(body) : null;
+		const req = https.default.request({
+			hostname: "discord.com",
+			port: 443,
+			path: `/api/v10${endpoint}`,
+			method,
+			headers: {
+				"Authorization": `Bot ${token}`,
+				"User-Agent": "HyperClaw/5.0.0 (https://hyperclaw.ai)",
+				...payload ? {
+					"Content-Type": "application/json",
+					"Content-Length": Buffer.byteLength(payload)
+				} : {}
+			}
+		}, (res) => {
+			let data = "";
+			res.on("data", (c) => data += c);
+			res.on("end", () => {
+				if (res.statusCode === 204) return resolve(null);
+				try {
+					const r = JSON.parse(data);
+					if (res.statusCode && res.statusCode >= 400) reject(new Error(`Discord API ${res.statusCode}: ${r.message || data}`));
+					else resolve(r);
+				} catch {
+					reject(new Error(`Invalid JSON (${res.statusCode})`));
+				}
+			});
+		});
+		req.on("error", reject);
+		if (payload) req.write(payload);
+		req.end();
+	});
+}
+var DiscordConnector = class extends events.EventEmitter {
+	token;
+	config;
+	ws = null;
+	heartbeatInterval = null;
+	lastSequence = null;
+	sessionId = null;
+	resumeGatewayUrl = null;
+	running = false;
+	botUser = null;
+	constructor(token, config) {
+		super();
+		this.token = token;
+		this.config = {
+			token,
+			dmPolicy: "allowlist",
+			allowFrom: [],
+			approvedPairings: [],
+			pendingPairings: {},
+			listenGuildIds: [],
+			commandPrefix: "!",
+			...config
+		};
+	}
+	async connect() {
+		const gateway = await discordRest(this.token, "GET", "/gateway/bot");
+		const wsUrl = (gateway.url || "wss://gateway.discord.gg") + "/?v=10&encoding=json";
+		this.botUser = await discordRest(this.token, "GET", "/users/@me");
+		console.log(chalk.default.green(`  🦅 Discord: @${this.botUser?.username} connected`));
+		await this.loadState();
+		this.running = true;
+		await this.openWebSocket(wsUrl);
+	}
+	async disconnect() {
+		this.running = false;
+		if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
+		this.ws?.close(1e3);
+		await this.saveState();
+	}
+	async openWebSocket(url) {
+		this.ws = new ws.WebSocket(url, { headers: { "User-Agent": "HyperClaw/5.0.0" } });
+		this.ws.on("message", async (data) => {
+			const payload = JSON.parse(data.toString());
+			await this.handlePayload(payload);
+		});
+		this.ws.on("close", (code) => {
+			if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
+			if (!this.running) return;
+			const resumable = ![
+				1e3,
+				4004,
+				4010,
+				4011,
+				4012,
+				4013,
+				4014
+			].includes(code);
+			console.log(chalk.default.yellow(`  ⚠  Discord WS closed (${code}) — ${resumable ? "resuming" : "reconnecting"} in 5s`));
+			setTimeout(() => {
+				if (this.running) {
+					const url$1 = resumable && this.resumeGatewayUrl ? this.resumeGatewayUrl + "/?v=10&encoding=json" : "wss://gateway.discord.gg/?v=10&encoding=json";
+					this.openWebSocket(url$1);
+				}
+			}, 5e3);
+		});
+		this.ws.on("error", (e) => console.log(chalk.default.yellow(`  ⚠  Discord WS error: ${e.message}`)));
+	}
+	async handlePayload(payload) {
+		const { op, d, s, t } = payload;
+		if (s !== null && s !== void 0) this.lastSequence = s;
+		switch (op) {
+			case OPC.HELLO:
+				this.startHeartbeat(d.heartbeat_interval);
+				if (this.sessionId && this.lastSequence) this.resume();
+				else this.identify();
+				break;
+			case OPC.HEARTBEAT_ACK: break;
+			case OPC.HEARTBEAT:
+				this.sendWs({
+					op: OPC.HEARTBEAT,
+					d: this.lastSequence
+				});
+				break;
+			case OPC.RECONNECT:
+				this.ws?.close(4e3);
+				break;
+			case OPC.INVALID_SESSION:
+				if (d) setTimeout(() => this.resume(), 2e3);
+				else {
+					this.sessionId = null;
+					this.lastSequence = null;
+					setTimeout(() => this.identify(), 2e3);
+				}
+				break;
+			case OPC.DISPATCH:
+				await this.handleEvent(t, d);
+				break;
+		}
+	}
+	identify() {
+		const intents = INTENTS.GUILDS | INTENTS.GUILD_MESSAGES | INTENTS.GUILD_MESSAGE_CONTENT | INTENTS.DIRECT_MESSAGES;
+		this.sendWs({
+			op: OPC.IDENTIFY,
+			d: {
+				token: this.token,
+				intents,
+				properties: {
+					os: process.platform,
+					browser: "HyperClaw",
+					device: "HyperClaw"
+				}
+			}
+		});
+	}
+	resume() {
+		this.sendWs({
+			op: OPC.RESUME,
+			d: {
+				token: this.token,
+				session_id: this.sessionId,
+				seq: this.lastSequence
+			}
+		});
+	}
+	startHeartbeat(interval) {
+		if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
+		this.heartbeatInterval = setInterval(() => {
+			this.sendWs({
+				op: OPC.HEARTBEAT,
+				d: this.lastSequence
+			});
+		}, interval);
+	}
+	sendWs(payload) {
+		if (this.ws?.readyState === ws.WebSocket.OPEN) this.ws.send(JSON.stringify(payload));
+	}
+	async handleEvent(type, data) {
+		switch (type) {
+			case "READY":
+				this.sessionId = data.session_id;
+				this.resumeGatewayUrl = data.resume_gateway_url;
+				this.botUser = data.user;
+				await this.saveState();
+				if (this.config.slashCommands !== false) this.registerSlashCommands().catch((e) => console.log(chalk.default.yellow(`  Discord slash commands: ${e.message}`)));
+				this.emit("ready", data.user);
+				break;
+			case "RESUMED":
+				console.log(chalk.default.gray("  Discord session resumed"));
+				break;
+			case "INTERACTION_CREATE":
+				await this.handleInteraction(data);
+				break;
+			case "MESSAGE_CREATE":
+				await this.handleMessage(data);
+				break;
+		}
+	}
+	async handleMessage(msg) {
+		if (msg.author.id === this.botUser?.id) return;
+		if (msg.author.bot) return;
+		const isDM = !msg.channel_id.startsWith("0") && await this.isDirectMessage(msg.channel_id);
+		const userId = msg.author.id;
+		if (isDM) {
+			const allowed = await this.checkDMPolicy(userId, msg.channel_id, msg.content);
+			if (!allowed) return;
+		} else {
+			const guildAllowed = await this.checkGuildPolicy(msg);
+			if (!guildAllowed) return;
+		}
+		this.emit("message", {
+			id: msg.id,
+			channelId: "discord",
+			from: userId,
+			fromUsername: msg.author.global_name || msg.author.username,
+			chatId: msg.channel_id,
+			text: msg.content,
+			timestamp: msg.timestamp,
+			isDM
+		});
+	}
+	dmChannelCache = /* @__PURE__ */ new Set();
+	async isDirectMessage(channelId) {
+		if (this.dmChannelCache.has(channelId)) return true;
+		try {
+			const channel = await discordRest(this.token, "GET", `/channels/${channelId}`);
+			if (channel.type === 1) {
+				this.dmChannelCache.add(channelId);
+				return true;
+			}
+		} catch {}
+		return false;
+	}
+	async checkGuildPolicy(msg) {
+		const channelId = msg.channel_id;
+		let guildId;
+		try {
+			const ch = await discordRest(this.token, "GET", `/channels/${channelId}`);
+			guildId = ch.guild_id;
+		} catch {
+			return false;
+		}
+		if (!guildId) return false;
+		if (this.config.listenGuildIds.length > 0 && !this.config.listenGuildIds.includes(guildId)) return false;
+		if (this.config.requireMentionInGuild !== false) {
+			const content = msg.content || "";
+			const mentioned = msg.mentions?.some((m) => m.id === this.botUser?.id) ?? false;
+			const botMention = this.botUser ? `<@${this.botUser.id}>` : "";
+			if (!mentioned && !content.includes(botMention) && !msg.referenced_message?.author?.bot) return false;
+		}
+		return true;
+	}
+	async checkDMPolicy(userId, channelId, text) {
+		if (this.config.dmPolicy === "none") return false;
+		if (this.config.dmPolicy === "open") return true;
+		if (this.config.dmPolicy === "allowlist") {
+			if (this.config.allowFrom.includes(userId)) return true;
+			await this.sendMessage(channelId, "🦅 **HyperClaw**\n\nYou are not on the allowlist.");
+			return false;
+		}
+		if (this.config.dmPolicy === "pairing") {
+			const bridge = this.config.pairingBridge;
+			if (bridge) {
+				if (await bridge.isApproved(userId)) return true;
+				const upper$1 = text.trim().toUpperCase().replace(/\s/g, "");
+				if (upper$1.length >= 6 && upper$1.length <= 10) {
+					const verified = await bridge.verify(upper$1, userId);
+					if (verified) {
+						await this.sendMessage(channelId, "🦅 **Paired!** You can now send messages.");
+						this.emit("pairing:approved", {
+							userId,
+							channelId: "discord"
+						});
+						return true;
+					}
+				}
+				const code$1 = await bridge.createRequest(userId);
+				if (code$1) await this.sendMessage(channelId, `🦅 **HyperClaw Pairing**\n\nSend the owner this code:\n\`${code$1}\`\n\nApprove with:\n\`hyperclaw pairing approve discord ${code$1}\``);
+				else await this.sendMessage(channelId, "🦅 **HyperClaw Pairing**\n\nYou already have a pending request. Check with the owner to approve.");
+				return false;
+			}
+			if (this.config.approvedPairings.includes(userId)) return true;
+			const upper = text.trim().toUpperCase();
+			if (this.config.pendingPairings[upper]) {
+				this.config.approvedPairings.push(userId);
+				delete this.config.pendingPairings[upper];
+				await this.saveState();
+				await this.sendMessage(channelId, "🦅 **Paired!** You can now send messages.");
+				this.emit("pairing:approved", {
+					userId,
+					channelId: "discord"
+				});
+				return true;
+			}
+			const code = this.generateCode();
+			this.config.pendingPairings[code] = userId;
+			await this.saveState();
+			await this.sendMessage(channelId, `🦅 **HyperClaw Pairing**\n\nSend the owner this code:\n\`${code}\`\n\nApprove with:\n\`hyperclaw pairing approve discord ${code}\``);
+			return false;
+		}
+		return false;
+	}
+	async registerSlashCommands() {
+		const app = await discordRest(this.token, "GET", "/oauth2/applications/@me");
+		const appId = app.id;
+		if (!appId) return;
+		const commands = [{
+			name: "help",
+			description: "Show HyperClaw help and commands"
+		}, {
+			name: "status",
+			description: "Show gateway status"
+		}];
+		await discordRest(this.token, "PUT", `/applications/${appId}/commands`, commands);
+	}
+	async handleInteraction(interaction) {
+		const { id, token, type, data } = interaction;
+		if (type !== 2 || !data?.name) return;
+		const name = data.name;
+		let content = "";
+		if (name === "help") content = "🦅 **HyperClaw** — AI agent on Discord.\n\n**Commands:** `/help`, `/status`\n**Chat:** Just send a message (DM or @mention in servers).\n**Pairing:** DM the bot to get a pairing code, then run `hyperclaw pairing approve discord <CODE>` on the host.";
+		else if (name === "status") content = "🦅 **HyperClaw** — gateway connected. Send a message to chat with the agent.";
+		else return;
+		const payload = {
+			type: 4,
+			data: {
+				content,
+				flags: 64
+			}
+		};
+		await discordRest(this.token, "POST", `/interactions/${id}/${token}/callback`, payload);
+	}
+	async sendMessage(channelId, content) {
+		const chunks = content.match(/.{1,2000}/gs) || [content];
+		let last = null;
+		for (const chunk of chunks) last = await discordRest(this.token, "POST", `/channels/${channelId}/messages`, { content: chunk });
+		return last;
+	}
+	async sendTyping(channelId) {
+		await discordRest(this.token, "POST", `/channels/${channelId}/typing`).catch(() => {});
+	}
+	async createDMChannel(userId) {
+		const ch = await discordRest(this.token, "POST", "/users/@me/channels", { recipient_id: userId });
+		return ch.id;
+	}
+	async sendDM(userId, content) {
+		const channelId = await this.createDMChannel(userId);
+		await this.sendMessage(channelId, content);
+	}
+	generateCode() {
+		const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+		return Array.from({ length: 6 }, () => chars[Math.floor(Math.random() * chars.length)]).join("");
+	}
+	approvePairing(code) {
+		const upper = code.toUpperCase();
+		if (!this.config.pendingPairings[upper]) return false;
+		this.config.approvedPairings.push(this.config.pendingPairings[upper]);
+		delete this.config.pendingPairings[upper];
+		this.saveState();
+		return true;
+	}
+	addToAllowlist(userId) {
+		if (!this.config.allowFrom.includes(userId)) {
+			this.config.allowFrom.push(userId);
+			this.saveState();
+		}
+	}
+	async loadState() {
+		try {
+			const s = await fs_extra.default.readJson(STATE_FILE);
+			this.sessionId = s.sessionId || null;
+			this.lastSequence = s.lastSequence || null;
+			this.resumeGatewayUrl = s.resumeGatewayUrl || null;
+			if (s.pendingPairings) this.config.pendingPairings = s.pendingPairings;
+			if (s.approvedPairings) this.config.approvedPairings = s.approvedPairings;
+		} catch {}
+	}
+	async saveState() {
+		await fs_extra.default.ensureDir(path.default.dirname(STATE_FILE));
+		await fs_extra.default.writeJson(STATE_FILE, {
+			sessionId: this.sessionId,
+			lastSequence: this.lastSequence,
+			resumeGatewayUrl: this.resumeGatewayUrl,
+			pendingPairings: this.config.pendingPairings,
+			approvedPairings: this.config.approvedPairings
+		}, { spaces: 2 });
+	}
+	isRunning() {
+		return this.running;
+	}
+	getBotUser() {
+		return this.botUser;
+	}
+};
+
+//#endregion
+exports.DiscordConnector = DiscordConnector;

package/dist/connector-BpW88ut2.js

@@ -0,0 +1,189 @@
+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 https = require_chunk.__toESM(require("https"));
+const events = require_chunk.__toESM(require("events"));
+
+//#region extensions/msteams/src/connector.ts
+const STATE_FILE = path.default.join(os.default.homedir(), ".hyperclaw", "msteams-state.json");
+let cachedToken = null;
+async function getBotToken(appId, appPassword) {
+	if (cachedToken && cachedToken.expiresAt > Date.now() + 6e4) return cachedToken.token;
+	return new Promise((resolve, reject) => {
+		const body = `grant_type=client_credentials&client_id=${encodeURIComponent(appId)}&client_secret=${encodeURIComponent(appPassword)}&scope=https%3A%2F%2Fapi.botframework.com%2F.default`;
+		const req = https.default.request({
+			hostname: "login.microsoftonline.com",
+			port: 443,
+			path: "/botframework.com/oauth2/v2.0/token",
+			method: "POST",
+			headers: {
+				"Content-Type": "application/x-www-form-urlencoded",
+				"Content-Length": Buffer.byteLength(body)
+			}
+		}, (res) => {
+			let data = "";
+			res.on("data", (c) => data += c);
+			res.on("end", () => {
+				try {
+					const r = JSON.parse(data);
+					cachedToken = {
+						token: r.access_token,
+						expiresAt: Date.now() + r.expires_in * 1e3
+					};
+					resolve(r.access_token);
+				} catch {
+					reject(new Error("Token parse error"));
+				}
+			});
+		});
+		req.on("error", reject);
+		req.write(body);
+		req.end();
+	});
+}
+async function sendActivity(token, serviceUrl, conversationId, activity) {
+	const url = new URL(`${serviceUrl}v3/conversations/${conversationId}/activities`);
+	return new Promise((resolve, reject) => {
+		const payload = JSON.stringify(activity);
+		const req = https.default.request({
+			hostname: url.hostname,
+			port: 443,
+			path: url.pathname,
+			method: "POST",
+			headers: {
+				"Authorization": `Bearer ${token}`,
+				"Content-Type": "application/json",
+				"Content-Length": Buffer.byteLength(payload)
+			}
+		}, (res) => {
+			res.on("data", () => {});
+			res.on("end", resolve);
+		});
+		req.on("error", reject);
+		req.write(payload);
+		req.end();
+	});
+}
+var MSTeamsConnector = class extends events.EventEmitter {
+	config;
+	running = false;
+	constructor(config) {
+		super();
+		this.config = {
+			dmPolicy: "allowlist",
+			allowFrom: [],
+			approvedPairings: [],
+			pendingPairings: {},
+			...config
+		};
+	}
+	async connect() {
+		await getBotToken(this.config.appId, this.config.appPassword);
+		await this.loadState();
+		this.running = true;
+		console.log(chalk.default.green(`  🦅 MS Teams: Bot ${this.config.appId} connected`));
+		this.emit("connected", { appId: this.config.appId });
+	}
+	disconnect() {
+		this.running = false;
+	}
+	async handleWebhook(body) {
+		let activity;
+		try {
+			activity = JSON.parse(body);
+		} catch {
+			return;
+		}
+		if (activity.type !== "message") return;
+		const from = activity.from?.aadObjectId || activity.from?.id;
+		const text = activity.text?.replace(/<at>[^<]+<\/at>/g, "").trim();
+		const serviceUrl = activity.serviceUrl;
+		const conversationId = activity.conversation?.id;
+		if (!from || !text || !serviceUrl || !conversationId) return;
+		const allowed = await this.checkDMPolicy(from, text, serviceUrl, conversationId, activity);
+		if (!allowed) return;
+		this.emit("message", {
+			id: activity.id,
+			channelId: "msteams",
+			from,
+			chatId: conversationId,
+			fromName: activity.from?.name,
+			text,
+			timestamp: activity.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+			isDM: activity.conversation?.conversationType === "personal",
+			serviceUrl,
+			activity
+		});
+	}
+	async checkDMPolicy(from, text, serviceUrl, convId, activity) {
+		if (this.config.dmPolicy === "none") return false;
+		if (this.config.dmPolicy === "open") return true;
+		if (this.config.dmPolicy === "allowlist") {
+			if (this.config.allowFrom.includes(from)) return true;
+			await this.reply(serviceUrl, convId, activity, "🦅 HyperClaw: Not on allowlist.");
+			return false;
+		}
+		if (this.config.dmPolicy === "pairing") {
+			if (this.config.approvedPairings.includes(from)) return true;
+			const upper = text.trim().toUpperCase();
+			if (this.config.pendingPairings[upper]) {
+				this.config.approvedPairings.push(from);
+				delete this.config.pendingPairings[upper];
+				await this.saveState();
+				await this.reply(serviceUrl, convId, activity, "🦅 Paired!");
+				this.emit("pairing:approved", {
+					userId: from,
+					channelId: "msteams"
+				});
+				return true;
+			}
+			const code = Array.from({ length: 6 }, () => "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"[Math.floor(Math.random() * 32)]).join("");
+			this.config.pendingPairings[code] = from;
+			await this.saveState();
+			await this.reply(serviceUrl, convId, activity, `🦅 Pairing code: ${code}\nApprove: hyperclaw pairing approve msteams ${code}`);
+			return false;
+		}
+		return false;
+	}
+	async reply(serviceUrl, conversationId, originalActivity, text) {
+		const token = await getBotToken(this.config.appId, this.config.appPassword);
+		await sendActivity(token, serviceUrl, conversationId, {
+			type: "message",
+			text: text.slice(0, 4e3),
+			replyToId: originalActivity.id,
+			from: { id: this.config.appId },
+			conversation: originalActivity.conversation,
+			recipient: originalActivity.from
+		});
+	}
+	approvePairing(code) {
+		const upper = code.toUpperCase();
+		if (!this.config.pendingPairings[upper]) return false;
+		this.config.approvedPairings.push(this.config.pendingPairings[upper]);
+		delete this.config.pendingPairings[upper];
+		this.saveState();
+		return true;
+	}
+	async loadState() {
+		try {
+			const s = await fs_extra.default.readJson(STATE_FILE);
+			if (s.p) this.config.pendingPairings = s.p;
+			if (s.a) this.config.approvedPairings = s.a;
+		} catch {}
+	}
+	async saveState() {
+		await fs_extra.default.ensureDir(path.default.dirname(STATE_FILE));
+		await fs_extra.default.writeJson(STATE_FILE, {
+			p: this.config.pendingPairings,
+			a: this.config.approvedPairings
+		}, { spaces: 2 });
+	}
+	isRunning() {
+		return this.running;
+	}
+};
+
+//#endregion
+exports.MSTeamsConnector = MSTeamsConnector;