hyperclaw 4.0.0 → 4.0.2

package/dist/connector-By5wWGTR.js

@@ -0,0 +1,343 @@
+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/4.0.2 (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/4.0.2" } });
+		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();
+				this.emit("ready", data.user);
+				break;
+			case "RESUMED":
+				console.log(chalk.default.gray("  Discord session resumed"));
+				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;
+		}
+		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 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") {
+			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 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-C1BaFFgN.js

@@ -0,0 +1,213 @@
+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/feishu/src/connector.ts
+const STATE_FILE = path.default.join(os.default.homedir(), ".hyperclaw", "feishu-state.json");
+let feishuToken = null;
+async function getAccessToken(appId, appSecret) {
+	if (feishuToken && feishuToken.expiresAt > Date.now() + 6e4) return feishuToken.token;
+	return new Promise((resolve, reject) => {
+		const payload = JSON.stringify({
+			app_id: appId,
+			app_secret: appSecret
+		});
+		const req = https.default.request({
+			hostname: "open.feishu.cn",
+			port: 443,
+			path: "/open-apis/auth/v3/tenant_access_token/internal",
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				"Content-Length": Buffer.byteLength(payload)
+			}
+		}, (res) => {
+			let data = "";
+			res.on("data", (c) => data += c);
+			res.on("end", () => {
+				try {
+					const r = JSON.parse(data);
+					feishuToken = {
+						token: r.tenant_access_token,
+						expiresAt: Date.now() + r.expire * 1e3
+					};
+					resolve(r.tenant_access_token);
+				} catch {
+					reject(new Error("Token error"));
+				}
+			});
+		});
+		req.on("error", reject);
+		req.write(payload);
+		req.end();
+	});
+}
+function feishuReq(token, method, endpoint, body) {
+	return new Promise((resolve, reject) => {
+		const payload = body ? JSON.stringify(body) : null;
+		const req = https.default.request({
+			hostname: "open.feishu.cn",
+			port: 443,
+			path: `/open-apis${endpoint}`,
+			method,
+			headers: {
+				"Authorization": `Bearer ${token}`,
+				...payload ? {
+					"Content-Type": "application/json",
+					"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.code !== 0) reject(new Error(r.msg));
+					else resolve(r);
+				} catch {
+					reject(new Error("Invalid JSON"));
+				}
+			});
+		});
+		req.on("error", reject);
+		if (payload) req.write(payload);
+		req.end();
+	});
+}
+var FeishuConnector = class extends events.EventEmitter {
+	config;
+	running = false;
+	botOpenId = "";
+	constructor(config) {
+		super();
+		this.config = {
+			dmPolicy: "allowlist",
+			allowFrom: [],
+			approvedPairings: [],
+			pendingPairings: {},
+			...config
+		};
+	}
+	async connect() {
+		const token = await getAccessToken(this.config.appId, this.config.appSecret);
+		const botInfo = await feishuReq(token, "GET", "/bot/v3/info");
+		this.botOpenId = botInfo.bot?.open_id || "";
+		await this.loadState();
+		this.running = true;
+		console.log(chalk.default.green(`  🦅 Feishu: ${botInfo.bot?.app_name || this.config.appId} connected`));
+		this.emit("connected", { openId: this.botOpenId });
+	}
+	disconnect() {
+		this.running = false;
+	}
+	handleChallenge(body) {
+		try {
+			const r = JSON.parse(body);
+			if (r.type === "url_verification") return JSON.stringify({ challenge: r.challenge });
+		} catch {}
+		return null;
+	}
+	async handleWebhook(body) {
+		let payload;
+		try {
+			payload = JSON.parse(body);
+		} catch {
+			return;
+		}
+		const event = payload.event;
+		if (!event || payload.header?.event_type !== "im.message.receive_v1") return;
+		const senderId = event.sender?.sender_id?.open_id;
+		const msgType = event.message?.message_type;
+		if (msgType !== "text" || !senderId) return;
+		let text = "";
+		try {
+			text = JSON.parse(event.message.content).text;
+		} catch {
+			return;
+		}
+		if (!text) return;
+		const chatId = event.message?.chat_id || senderId;
+		const allowed = await this.checkDMPolicy(senderId, text, chatId);
+		if (!allowed) return;
+		this.emit("message", {
+			id: event.message?.message_id,
+			channelId: "feishu",
+			from: senderId,
+			chatId,
+			text,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			isDM: true
+		});
+	}
+	async checkDMPolicy(from, text, chatId) {
+		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.sendMessage(chatId, "🦅 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.sendMessage(chatId, "🦅 Paired!");
+				this.emit("pairing:approved", {
+					userId: from,
+					channelId: "feishu"
+				});
+				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.sendMessage(chatId, `🦅 Pairing code: ${code}\nApprove: hyperclaw pairing approve feishu ${code}`);
+			return false;
+		}
+		return false;
+	}
+	async sendMessage(chatId, text) {
+		const token = await getAccessToken(this.config.appId, this.config.appSecret);
+		await feishuReq(token, "POST", "/im/v1/messages?receive_id_type=chat_id", {
+			receive_id: chatId,
+			msg_type: "text",
+			content: JSON.stringify({ text: text.slice(0, 4e3) })
+		});
+	}
+	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.FeishuConnector = FeishuConnector;