hyperclaw 5.4.0 → 5.4.2

package/dist/hyperclawbot-DR6BgI_d.js

@@ -0,0 +1,516 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_paths = require('./paths-AIyBxIzm.js');
+const require_paths$1 = require('./paths-DPovhojT.js');
+require('./browser-tools-BMgBB2fK.js');
+require('./src-lltU5gkh.js');
+require('./engine-C7LyH310.js');
+require('./extraction-tools-Bh5F0ENP.js');
+require('./inference-DCSz6Sb1.js');
+require('./memory-auto-BVCJeTwd.js');
+require('./orchestrator-CA4eKeGn.js');
+require('./pc-access-D4g0fjQb.js');
+require('./session-store-sUpA509O.js');
+require('./sessions-tools-ClrKqLII.js');
+require('./skill-loader-CM4KWQ7_.js');
+require('./skill-runtime-CB9tnc-P.js');
+require('./vision-tools-kYb3effk.js');
+require('./website-watch-tools-D92dkYZa.js');
+const require_src$1 = require('./src-tF0sBtr3.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 axios = require_chunk.__toESM(require("axios"));
+
+//#region src/bot/hyperclawbot.ts
+require_paths$1.init_paths();
+const getBotConfigFile = () => path.default.join(require_paths.getHyperClawDir(), "hyperclawbot.json");
+const getBotPidFile = () => path.default.join(require_paths.getHyperClawDir(), "hyperclawbot.pid");
+const MAX_TELEGRAM_VOICE_BYTES = 25 * 1024 * 1024;
+async function getGatewayStatus(gatewayUrl, token) {
+	try {
+		const headers = token ? { Authorization: `Bearer ${token}` } : {};
+		const res = await axios.default.get(`${gatewayUrl}/api/status`, {
+			headers,
+			timeout: 3e3
+		});
+		const d = res.data;
+		return `⚡ *Gateway Status*\n\n🟢 Running on port ${d.port}\n🦅 Agent: ${d.agentName || "unknown"}\n📱 Channels: ${(d.channels || []).join(", ") || "none"}\n👥 Sessions: ${d.sessions || 0}\n⏱ Uptime: ${d.uptime || "?"}\n🧠 Model: ${d.model || "unknown"}`;
+	} catch {
+		return "🔴 *Gateway Offline*\n\nStart with: `hyperclaw daemon start`";
+	}
+}
+async function getLogSummary(n = 20) {
+	const logFile = path.default.join(require_paths.getHyperClawDir(), "logs", "hyperclaw.log");
+	if (!await fs_extra.default.pathExists(logFile)) return "📋 No logs yet.";
+	const content = await fs_extra.default.readFile(logFile, "utf8");
+	const lines = content.trim().split("\n").slice(-n);
+	const formatted = lines.map((line) => {
+		try {
+			const e = JSON.parse(line);
+			const level = e.level?.toUpperCase() || "INFO";
+			const icon = {
+				ERROR: "🔴",
+				WARN: "🟡",
+				INFO: "🔵",
+				DEBUG: "⚪"
+			}[level] || "⚪";
+			return `${icon} ${e.ts?.slice(11, 19) || ""} [${e.module || "?"}] ${e.message || ""}`;
+		} catch {
+			return line;
+		}
+	});
+	return `📋 *Last ${n} log entries*\n\n\`\`\`\n${formatted.join("\n").slice(0, 3500)}\n\`\`\``;
+}
+async function approveCode(channelId, code) {
+	try {
+		const { PairingStore } = await Promise.resolve().then(() => require("./pairing-2vAiDBjN.js"));
+		const store = new PairingStore(channelId);
+		await store.cliApprove(code);
+		return `✅ Approved pairing code *${code}* on *${channelId}*`;
+	} catch (e) {
+		return `❌ Failed: ${e.message}`;
+	}
+}
+async function listChannels() {
+	try {
+		const cfg = await fs_extra.default.readJson(require_paths.getConfigPath());
+		const channels = Object.entries(cfg.channelConfigs || {}).map(([id]) => `• ${id}`).join("\n");
+		return `📱 *Active Channels*\n\n${channels || "(none configured)"}`;
+	} catch {
+		return "❌ Could not read config";
+	}
+}
+async function listHooks() {
+	try {
+		const { HookLoader } = await Promise.resolve().then(() => require("./loader-JktrmJOG.js"));
+		const loader = new HookLoader();
+		loader.loadState();
+		const hooks = loader.getHooks().map((h) => `${h.enabled && h.eligible ? "✅" : "⬜"} ${h.id} — ${h.trigger}`).join("\n");
+		return `🪝 *Hooks*\n\n${hooks}`;
+	} catch {
+		return "❌ Could not load hooks";
+	}
+}
+async function sendToAgent(message, gatewayUrl, gatewayToken, surface = "telegram") {
+	try {
+		const headers = gatewayToken ? { Authorization: `Bearer ${gatewayToken}` } : {};
+		const res = await axios.default.post(`${gatewayUrl}/api/chat`, {
+			message,
+			thinking: "none"
+		}, {
+			headers,
+			timeout: 3e4
+		});
+		const { formatAgentResponse } = (require_src$1.init_src(), require_chunk.__toCommonJS(require_src$1.src_exports));
+		return formatAgentResponse(res.data.response ?? "", surface);
+	} catch {
+		return "❌ Gateway unreachable — start with: `hyperclaw daemon start`";
+	}
+}
+function parseCommand(text) {
+	const parts = text.trim().split(/\s+/);
+	const cmd = parts[0].replace("/", "").toLowerCase();
+	return {
+		cmd,
+		args: parts.slice(1)
+	};
+}
+function getHelp(platform) {
+	const { getAgentHelp } = (require_src$1.init_src(), require_chunk.__toCommonJS(require_src$1.src_exports));
+	return getAgentHelp(platform === "discord" ? "discord" : "telegram");
+}
+var TelegramHyperClawBot = class {
+	config;
+	offset = 0;
+	running = false;
+	apiBase;
+	botUsername = "";
+	constructor(config) {
+		this.config = config;
+		this.apiBase = `https://api.telegram.org/bot${config.token}`;
+	}
+	async api(method, body) {
+		const res = await axios.default.post(`${this.apiBase}/${method}`, body, { timeout: 1e4 });
+		return res.data;
+	}
+	isAllowed(userId) {
+		if (this.config.allowedUsers.length === 0) return true;
+		return this.config.allowedUsers.includes(String(userId));
+	}
+	async sendMessage(chatId, text) {
+		await this.api("sendMessage", {
+			chat_id: chatId,
+			text: text.slice(0, 4096),
+			parse_mode: "Markdown"
+		});
+	}
+	async downloadAndTranscribeVoice(fileId) {
+		const fileRes = await this.api("getFile", { file_id: fileId });
+		const filePath = fileRes.result?.file_path;
+		if (!filePath) throw new Error("Could not get file path");
+		const url = `https://api.telegram.org/file/bot${this.config.token}/${filePath}`;
+		const res = await axios.default.get(url, {
+			responseType: "arraybuffer",
+			timeout: 15e3,
+			maxContentLength: MAX_TELEGRAM_VOICE_BYTES,
+			maxBodyLength: MAX_TELEGRAM_VOICE_BYTES
+		});
+		const buffer = Buffer.from(res.data);
+		if (buffer.length === 0) throw new Error("Downloaded voice note is empty");
+		if (buffer.length > MAX_TELEGRAM_VOICE_BYTES) throw new Error(`Voice note exceeds ${MAX_TELEGRAM_VOICE_BYTES} bytes`);
+		const { transcribeVoiceNote } = await Promise.resolve().then(() => require("./voice-transcription-B1D1rpca.js"));
+		return transcribeVoiceNote(buffer);
+	}
+	shouldRespondInGroup(msg) {
+		const chatType = msg.chat.type || "";
+		if (chatType !== "group" && chatType !== "supergroup") return true;
+		if ((this.config.activationMode ?? "mention") === "always") return true;
+		if (msg.reply_to_message?.from?.is_bot) return true;
+		const mention = msg.entities?.find((e) => e.type === "mention" || e.type === "text_mention");
+		if (mention && msg.text) {
+			const mentioned = msg.text.slice(mention.offset, mention.offset + mention.length);
+			if (this.botUsername && mentioned.toLowerCase().includes(this.botUsername.toLowerCase())) return true;
+		}
+		return false;
+	}
+	async handleUpdate(update) {
+		const msg = update.message;
+		if (!msg) return;
+		const userId = msg.from?.id;
+		if (!userId || !this.isAllowed(userId)) {
+			await this.sendMessage(msg.chat.id, "🚫 Unauthorized");
+			return;
+		}
+		if (!this.shouldRespondInGroup(msg)) return;
+		let text = msg.text || "";
+		let isFromVoice = false;
+		if (!text && msg.voice) try {
+			await this.sendMessage(msg.chat.id, "🎤 Transcribing...");
+			text = await this.downloadAndTranscribeVoice(msg.voice.file_id);
+			if (!text || text.startsWith("[")) {
+				await this.sendMessage(msg.chat.id, text || "❌ Transcription failed");
+				return;
+			}
+			isFromVoice = true;
+		} catch (e) {
+			await this.sendMessage(msg.chat.id, `❌ Transcription failed: ${e.message}`);
+			return;
+		}
+		if (!text.trim()) return;
+		const { cmd, args } = isFromVoice && !text.startsWith("/") ? {
+			cmd: "agent",
+			args: text.trim().split(/\s+/)
+		} : parseCommand(text);
+		const { gatewayUrl, gatewayToken } = this.config;
+		let response = "";
+		switch (cmd) {
+			case "start":
+			case "help":
+				response = getHelp(this.config.platform);
+				break;
+			case "status":
+				response = await getGatewayStatus(gatewayUrl, gatewayToken);
+				break;
+			case "logs":
+				response = await getLogSummary(parseInt(args[0]) || 20);
+				break;
+			case "approve":
+				if (args.length < 2) {
+					response = "❌ Usage: /approve <channel> <code>";
+					break;
+				}
+				response = await approveCode(args[0], args[1]);
+				break;
+			case "channels":
+				response = await listChannels();
+				break;
+			case "hook":
+				if (args[0] === "list" || !args[0]) {
+					response = await listHooks();
+					break;
+				}
+				if ((args[0] === "on" || args[0] === "off") && args[1]) {
+					const { HookLoader } = await Promise.resolve().then(() => require("./loader-JktrmJOG.js"));
+					const loader = new HookLoader();
+					loader.loadState();
+					if (args[0] === "on") await loader.enable(args[1]);
+					else await loader.disable(args[1]);
+					response = `${args[0] === "on" ? "✅" : "⬜"} Hook ${args[0] === "on" ? "enabled" : "disabled"}: ${args[1]}`;
+					break;
+				}
+				response = "❌ Usage: /hook list | /hook on <id> | /hook off <id>";
+				break;
+			case "restart":
+				response = "🔄 Restarting gateway...";
+				await this.sendMessage(msg.chat.id, response);
+				try {
+					const r = await axios.default.post(`${gatewayUrl}/api/remote/restart`, {}, {
+						headers: gatewayToken ? { Authorization: `Bearer ${gatewayToken}` } : {},
+						timeout: 5e3
+					});
+					response = (r.data?.restarted ? "✅ Gateway restarted" : r.data?.message) || "✅ Request accepted";
+				} catch {
+					response = "⚠️ Could not reach gateway to restart";
+				}
+				break;
+			case "agent":
+				if (!args.length) {
+					response = "❌ Usage: /agent <message>";
+					break;
+				}
+				response = await sendToAgent(args.join(" "), gatewayUrl, gatewayToken, "telegram");
+				break;
+			case "secrets":
+				response = "🔍 Run locally: `hyperclaw secrets audit`";
+				break;
+			case "security":
+				response = "🔐 Run locally: `hyperclaw security audit --deep`";
+				break;
+			case "activation": {
+				const mode = args[0]?.toLowerCase();
+				if (mode === "mention" || mode === "always") {
+					this.config.activationMode = mode;
+					await saveBotConfig(this.config);
+					response = `✅ Activation mode set to *${mode}*\n\n` + (mode === "always" ? "🔊 Bot will respond to _all_ messages in groups." : "🔇 Bot will only respond to @mentions and replies in groups.");
+				} else {
+					const current = this.config.activationMode ?? "mention";
+					response = `🎛 *Activation Mode*\n\nCurrent: *${current}*\n\n• /activation mention — respond only to @mentions and replies _(default)_\n• /activation always — respond to all messages in groups`;
+				}
+				break;
+			}
+			default: response = `❓ Unknown command: /${cmd}\n\nTry /help`;
+		}
+		await this.sendMessage(msg.chat.id, response);
+	}
+	async start() {
+		this.running = true;
+		try {
+			const me = await this.api("getMe");
+			this.botUsername = me.result?.username || "";
+		} catch {}
+		console.log(chalk.default.green("\n  ✔  HyperClaw Bot (Telegram) started"));
+		console.log(chalk.default.gray(`  Polling updates...\n  Send /status to your bot to test.\n`));
+		while (this.running) try {
+			const result = await this.api("getUpdates", {
+				offset: this.offset,
+				timeout: 30,
+				allowed_updates: ["message"]
+			});
+			for (const update of result.result || []) {
+				this.offset = update.update_id + 1;
+				await this.handleUpdate(update).catch((e) => console.log(chalk.default.yellow(`  ⚠  HyperClaw Bot error: ${e.message}`)));
+			}
+		} catch {
+			await new Promise((r) => setTimeout(r, 3e3));
+		}
+	}
+	stop() {
+		this.running = false;
+	}
+};
+var DiscordHyperClawBot = class {
+	config;
+	client;
+	running = false;
+	constructor(config) {
+		this.config = config;
+		this.client = null;
+	}
+	isAllowed(userId) {
+		if (this.config.allowedUsers.length === 0) return true;
+		return this.config.allowedUsers.includes(userId);
+	}
+	async handleCommand(cmd, args, reply) {
+		const { gatewayUrl, gatewayToken } = this.config;
+		let response = "";
+		switch (cmd) {
+			case "start":
+			case "help":
+				response = getHelp("discord");
+				break;
+			case "status":
+				response = (await getGatewayStatus(gatewayUrl, gatewayToken)).replace(/\*/g, "**");
+				break;
+			case "logs":
+				response = (await getLogSummary(parseInt(args[0]) || 20)).replace(/\*/g, "**");
+				break;
+			case "approve":
+				if (args.length < 2) {
+					response = "❌ Usage: /approve <channel> <code>";
+					break;
+				}
+				response = await approveCode(args[0], args[1]);
+				break;
+			case "channels":
+				response = (await listChannels()).replace(/\*/g, "**");
+				break;
+			case "hook":
+				if (args[0] === "list" || !args[0]) {
+					response = (await listHooks()).replace(/\*/g, "**");
+					break;
+				}
+				if ((args[0] === "on" || args[0] === "off") && args[1]) {
+					const { HookLoader } = await Promise.resolve().then(() => require("./loader-JktrmJOG.js"));
+					const loader = new HookLoader();
+					loader.loadState();
+					if (args[0] === "on") await loader.enable(args[1]);
+					else await loader.disable(args[1]);
+					response = `${args[0] === "on" ? "✅" : "⬜"} Hook ${args[0] === "on" ? "enabled" : "disabled"}: ${args[1]}`;
+					break;
+				}
+				response = "❌ Usage: /hook list | /hook on <id> | /hook off <id>";
+				break;
+			case "restart":
+				await reply("🔄 Restarting gateway...");
+				try {
+					const r = await axios.default.post(`${gatewayUrl}/api/remote/restart`, {}, {
+						headers: gatewayToken ? { Authorization: `Bearer ${gatewayToken}` } : {},
+						timeout: 5e3
+					});
+					response = (r.data?.restarted ? "✅ Gateway restarted" : r.data?.message) || "✅ Request accepted";
+				} catch {
+					response = "⚠️ Could not reach gateway to restart";
+				}
+				break;
+			case "agent":
+				if (!args.length) {
+					response = "❌ Usage: /agent <message>";
+					break;
+				}
+				response = await sendToAgent(args.join(" "), gatewayUrl, gatewayToken, "discord");
+				break;
+			case "secrets":
+				response = "🔍 Run locally: `hyperclaw secrets audit`";
+				break;
+			case "security":
+				response = "🔐 Run locally: `hyperclaw security audit --deep`";
+				break;
+			case "activation": {
+				const mode = args[0]?.toLowerCase();
+				if (mode === "mention" || mode === "always") {
+					this.config.activationMode = mode;
+					await saveBotConfig(this.config);
+					response = `✅ Activation mode set to **${mode}**\n` + (mode === "always" ? "🔊 Bot will respond to _all_ messages in groups." : "🔇 Bot will only respond to @mentions and replies in groups.");
+				} else {
+					const current = this.config.activationMode ?? "mention";
+					response = `🎛 **Activation Mode**\nCurrent: **${current}**\n\n• /activation mention — @mentions and replies only _(default)_\n• /activation always — all messages in groups`;
+				}
+				break;
+			}
+			default: response = `❓ Unknown command: /${cmd}\n\nTry /help`;
+		}
+		await reply(response.slice(0, 2e3));
+	}
+	async start() {
+		try {
+			const { Client, GatewayIntentBits } = await import("discord.js");
+			this.client = new Client({ intents: [
+				GatewayIntentBits.Guilds,
+				GatewayIntentBits.GuildMessages,
+				GatewayIntentBits.DirectMessages,
+				GatewayIntentBits.MessageContent
+			] });
+			this.running = true;
+			this.client.on("ready", () => {
+				console.log(chalk.default.green(`\n  ✔  HyperClaw Bot (Discord) started as ${this.client.user?.tag}`));
+				console.log(chalk.default.gray(`  Send /status to your bot to test.\n`));
+			});
+			this.client.on("messageCreate", async (msg) => {
+				if (msg.author?.bot) return;
+				const userId = msg.author?.id;
+				if (!userId || !this.isAllowed(userId)) {
+					await msg.reply("🚫 Unauthorized").catch(() => {});
+					return;
+				}
+				const text = (msg.content || "").trim();
+				if (!text || !text.startsWith("/")) return;
+				const { cmd, args } = parseCommand(text);
+				const reply = async (t) => {
+					try {
+						await msg.reply({ content: t.slice(0, 2e3) });
+					} catch (e) {
+						console.log(chalk.default.yellow(`  ⚠  Discord reply error: ${e.message}`));
+					}
+				};
+				await this.handleCommand(cmd, args, reply).catch((e) => console.log(chalk.default.yellow(`  ⚠  HyperClaw Bot error: ${e.message}`)));
+			});
+			await this.client.login(this.config.token);
+		} catch (e) {
+			if (e.code === "MODULE_NOT_FOUND" || e.message?.includes("discord.js")) {
+				console.log(chalk.default.red("\n  ✖  discord.js not installed. Run: npm install discord.js\n"));
+				process.exit(1);
+			}
+			throw e;
+		}
+	}
+	stop() {
+		this.running = false;
+		if (this.client) {
+			this.client.destroy().catch(() => {});
+			this.client = null;
+		}
+	}
+};
+async function loadBotConfig() {
+	try {
+		const cfg = await fs_extra.default.readJson(getBotConfigFile());
+		return cfg;
+	} catch {
+		try {
+			for (const p of [path.default.join(require_paths.getHyperClawDir(), "hyperclaw-bot.json"), path.default.join(require_paths.getHyperClawDir(), "bot-config.json")]) if (await fs_extra.default.pathExists(p)) return await fs_extra.default.readJson(p);
+		} catch {}
+		return null;
+	}
+}
+async function saveBotConfig(config) {
+	const botCfg = getBotConfigFile();
+	await fs_extra.default.ensureDir(path.default.dirname(botCfg));
+	await fs_extra.default.writeJson(botCfg, config, { spaces: 2 });
+	await fs_extra.default.chmod(botCfg, 384);
+}
+async function stopBotProcess() {
+	try {
+		const pidFile = getBotPidFile();
+		if (!await fs_extra.default.pathExists(pidFile)) return false;
+		const pid = parseInt(await fs_extra.default.readFile(pidFile, "utf8"), 10);
+		if (isNaN(pid)) return false;
+		try {
+			process.kill(pid, "SIGTERM");
+		} catch {}
+		await fs_extra.default.remove(getBotPidFile());
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function writeBotPid(pid) {
+	const pidFile = getBotPidFile();
+	await fs_extra.default.ensureDir(path.default.dirname(pidFile));
+	await fs_extra.default.writeFile(pidFile, String(pid), "utf8");
+}
+async function showBotStatus() {
+	const cfg = await loadBotConfig();
+	console.log(chalk.default.bold.cyan("\n  🦅 HYPERCLAW BOT\n"));
+	if (!cfg || !cfg.enabled) {
+		console.log(chalk.default.gray("  HyperClaw Bot is not configured.\n"));
+		console.log(chalk.default.gray("  Setup: hyperclaw bot setup\n"));
+		return;
+	}
+	console.log(`  ${chalk.default.green("●")} ${chalk.default.white(cfg.platform === "telegram" ? "Telegram" : "Discord")} bot`);
+	console.log(`  ${chalk.default.gray("Token:")}        ${cfg.token.slice(0, 8)}...`);
+	console.log(`  ${chalk.default.gray("Gateway:")}      ${cfg.gatewayUrl}`);
+	console.log(`  ${chalk.default.gray("Allowed users:")} ${cfg.allowedUsers.length === 0 ? "(anyone)" : cfg.allowedUsers.join(", ")}`);
+	console.log(`  ${chalk.default.gray("Status:")}       ${cfg.enabled ? chalk.default.green("enabled") : chalk.default.gray("disabled")}`);
+	console.log();
+	console.log(chalk.default.gray("  Commands: hyperclaw bot start | stop | setup"));
+	console.log();
+}
+
+//#endregion
+exports.DiscordHyperClawBot = DiscordHyperClawBot;
+exports.TelegramHyperClawBot = TelegramHyperClawBot;
+exports.loadBotConfig = loadBotConfig;
+exports.saveBotConfig = saveBotConfig;
+exports.showBotStatus = showBotStatus;
+exports.stopBotProcess = stopBotProcess;
+exports.writeBotPid = writeBotPid;