hyperclaw 5.3.45 → 5.4.1

package/dist/loader-hXv2mZjK.js

@@ -0,0 +1,410 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_paths = require('./paths-AIyBxIzm.js');
+const require_paths$1 = require('./paths-DPovhojT.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+
+//#region src/hooks/loader.ts
+require_paths$1.init_paths();
+const BUILTIN_HOOKS = [
+	{
+		id: "session-memory",
+		name: "Session Memory",
+		description: "Writes a summary of each session to MEMORY.md on close.",
+		trigger: "session:end",
+		eligible: true,
+		enabled: true,
+		builtin: true,
+		tags: ["memory", "sessions"],
+		version: "1.0.0"
+	},
+	{
+		id: "command-logger",
+		name: "Command Logger",
+		description: "Logs every AI command execution to the daily log file.",
+		trigger: "message:sent",
+		eligible: true,
+		enabled: false,
+		builtin: true,
+		tags: ["logging", "debug"],
+		version: "1.0.0"
+	},
+	{
+		id: "gateway-health",
+		name: "Gateway Health Monitor",
+		description: "Pings the gateway every 5 minutes and logs latency.",
+		trigger: "cron",
+		eligible: true,
+		enabled: true,
+		builtin: true,
+		tags: ["health", "monitoring"],
+		version: "1.1.0"
+	},
+	{
+		id: "auto-backup",
+		name: "Auto Backup",
+		description: "Backs up AGENTS.md and config to ~/.hyperclaw/backups/ daily.",
+		trigger: "cron",
+		eligible: true,
+		enabled: false,
+		builtin: true,
+		tags: ["backup", "config"],
+		version: "1.0.0"
+	},
+	{
+		id: "dm-guard",
+		name: "DM Guard",
+		description: "Enforces DM policy and logs policy violations.",
+		trigger: "message:received",
+		eligible: true,
+		enabled: true,
+		builtin: true,
+		tags: ["security", "dm-policy"],
+		version: "2.0.0"
+	},
+	{
+		id: "voice-wake",
+		name: "Voice Wake Detector",
+		description: "Listens for wake word and starts voice session (macOS/iOS only).",
+		trigger: "gateway:start",
+		eligible: process.platform === "darwin",
+		enabled: false,
+		builtin: true,
+		tags: ["voice", "macos"],
+		version: "1.0.0"
+	},
+	{
+		id: "morning-briefing",
+		name: "Morning Briefing (Heartbeat)",
+		description: "Proactive daily briefing: agent generates summary from MEMORY, reminders, knowledge graph. Writes to HEARTBEAT.md.",
+		trigger: "cron",
+		eligible: true,
+		enabled: false,
+		builtin: true,
+		tags: [
+			"heartbeat",
+			"briefing",
+			"automation"
+		],
+		version: "1.0.0"
+	},
+	{
+		id: "website-watch",
+		name: "Website Change Monitor",
+		description: "Every 15 min, checks watched URLs for changes. Use watch_website_add tool to add URLs.",
+		trigger: "cron",
+		eligible: true,
+		enabled: true,
+		builtin: true,
+		tags: ["automation", "monitoring"],
+		version: "1.0.0"
+	},
+	{
+		id: "voice-note-transcription",
+		name: "Voice Note Transcription",
+		description: "Transcribes incoming voice messages via Whisper (OPENAI_API_KEY). Used by channels when audioPath is set.",
+		trigger: "message:received",
+		eligible: true,
+		enabled: true,
+		builtin: true,
+		tags: [
+			"voice",
+			"transcription",
+			"messaging"
+		],
+		version: "1.0.0"
+	}
+];
+var HookLoader = class {
+	stateFile;
+	state = {};
+	constructor() {
+		this.stateFile = path.default.join(require_paths.getHyperClawDir(), "hooks-state.json");
+		this.loadState();
+	}
+	loadState() {
+		try {
+			this.state = fs_extra.default.readJsonSync(this.stateFile);
+		} catch {
+			this.state = {};
+		}
+	}
+	saveState() {
+		fs_extra.default.ensureDirSync(path.default.dirname(this.stateFile));
+		fs_extra.default.writeJsonSync(this.stateFile, this.state, { spaces: 2 });
+	}
+	isEnabled(hook) {
+		if (this.state[hook.id] !== void 0) return this.state[hook.id].enabled;
+		return hook.enabled;
+	}
+	getHooks(eligibleOnly = false) {
+		const hooks = eligibleOnly ? BUILTIN_HOOKS.filter((h) => h.eligible) : BUILTIN_HOOKS;
+		return hooks.map((h) => ({
+			...h,
+			enabled: this.isEnabled(h),
+			eligible: h.eligible
+		}));
+	}
+	list(eligibleOnly = false) {
+		const hooks = this.getHooks(eligibleOnly);
+		console.log(chalk.default.bold.cyan("\n  ⚡ HYPERCLAW HOOKS\n"));
+		for (const hook of hooks) {
+			const dot = hook.enabled ? chalk.default.green("●") : chalk.default.gray("○");
+			const eligBadge = hook.eligible ? "" : chalk.default.red(" [ineligible]");
+			const builtinBadge = hook.builtin ? chalk.default.gray(" [builtin]") : "";
+			console.log(`  ${dot} ${chalk.default.white(hook.id)}${eligBadge}${builtinBadge}`);
+			console.log(`     ${chalk.default.gray(hook.description)}`);
+			console.log(`     ${chalk.default.gray(`trigger: ${hook.trigger}  v${hook.version}  tags: ${hook.tags.join(", ")}`)}`);
+			console.log();
+		}
+	}
+	info(id) {
+		const hook = BUILTIN_HOOKS.find((h) => h.id === id);
+		if (!hook) {
+			console.log(chalk.default.red(`  ✖  Hook not found: ${id}`));
+			return;
+		}
+		const enabled = this.isEnabled(hook);
+		console.log(chalk.default.bold.cyan(`\n  Hook: ${hook.name}\n`));
+		console.log(`  ID:          ${hook.id}`);
+		console.log(`  Status:      ${enabled ? chalk.default.green("enabled") : chalk.default.gray("disabled")}`);
+		console.log(`  Eligible:    ${hook.eligible ? chalk.default.green("yes") : chalk.default.red("no — OS not supported")}`);
+		console.log(`  Trigger:     ${hook.trigger}`);
+		console.log(`  Description: ${hook.description}`);
+		console.log(`  Tags:        ${hook.tags.join(", ")}`);
+		console.log(`  Version:     ${hook.version}`);
+		console.log();
+	}
+	enable(id) {
+		const hook = BUILTIN_HOOKS.find((h) => h.id === id);
+		if (!hook) {
+			console.log(chalk.default.red(`  ✖  Hook not found: ${id}`));
+			return;
+		}
+		if (!hook.eligible) {
+			console.log(chalk.default.red(`  ✖  Hook not eligible on this OS: ${id}`));
+			return;
+		}
+		this.state[id] = { enabled: true };
+		this.saveState();
+		console.log(chalk.default.green(`  ✔  Hook enabled: ${id}`));
+	}
+	disable(id) {
+		const hook = BUILTIN_HOOKS.find((h) => h.id === id);
+		if (!hook) {
+			console.log(chalk.default.red(`  ✖  Hook not found: ${id}`));
+			return;
+		}
+		this.state[id] = { enabled: false };
+		this.saveState();
+		console.log(chalk.default.green(`  ✔  Hook disabled: ${id}`));
+	}
+	async install(pack) {
+		const s = require("ora")(`Installing hook pack: ${pack}...`).start();
+		await new Promise((r) => setTimeout(r, 1500));
+		s.succeed(`Hook pack installed: ${pack}`);
+		console.log(chalk.default.gray(`  Run: hyperclaw hooks list to see new hooks`));
+	}
+	/** Execute enabled hooks for a trigger. Fire-and-forget. */
+	async execute(trigger, payload) {
+		const toRun = BUILTIN_HOOKS.filter((h) => h.trigger === trigger && h.eligible && this.isEnabled(h));
+		for (const hook of toRun) this.runHandler(hook, payload).catch((err) => console.error(`[hooks] ${hook.id} error:`, err?.message || err));
+	}
+	/** Execute a single cron hook by ID. Used by CronRunner. */
+	async executeCronHook(hookId) {
+		const hook = BUILTIN_HOOKS.find((h) => h.id === hookId && h.trigger === "cron" && h.eligible && this.isEnabled(h));
+		if (hook) await this.runHandler(hook, {}).catch((err) => console.error(`[hooks] ${hook.id} error:`, err?.message || err));
+	}
+	/** Start cron schedules: gateway-health (5 min), auto-backup (3am), website-watch (15 min), morning-briefing (8am), + user cron-tasks. */
+	startCronScheduler() {
+		const cron = require("node-cron");
+		const stops = [];
+		const t1 = cron.schedule("*/5 * * * *", () => {
+			this.executeCronHook("gateway-health").catch(() => {});
+		});
+		const t2 = cron.schedule("0 3 * * *", () => {
+			this.executeCronHook("auto-backup").catch(() => {});
+		});
+		const t3 = cron.schedule("*/15 * * * *", () => {
+			this.executeCronHook("website-watch").catch(() => {});
+		});
+		const t4 = cron.schedule("0 8 * * *", () => {
+			this.executeCronHook("morning-briefing").catch(() => {});
+		});
+		stops.push(() => {
+			t1.stop();
+			t2.stop();
+			t3.stop();
+			t4.stop();
+		});
+		(async () => {
+			try {
+				const { loadCronTasks, runCronTask } = await Promise.resolve().then(() => require("./cron-tasks-BFsaCKxE.js"));
+				const tasks = await loadCronTasks();
+				let port = 18789;
+				try {
+					const { getConfigPath } = await Promise.resolve().then(() => require("./paths-D-QecARF.js"));
+					const cfg = await fs_extra.default.readJson(getConfigPath());
+					port = cfg?.gateway?.port ?? 18789;
+				} catch {}
+				for (const task of tasks) {
+					if (!task.enabled) continue;
+					try {
+						const t = cron.schedule(task.schedule, () => runCronTask(task, port).catch(() => {}));
+						stops.push(() => t.stop());
+					} catch {}
+				}
+			} catch {}
+		})();
+		return () => {
+			stops.forEach((s) => s());
+		};
+	}
+	async runHandler(hook, payload) {
+		const handlers = {
+			"session-memory": async () => {
+				const sessionId = payload?.sessionId;
+				const turnCount = payload?.turnCount ?? 0;
+				const newFacts = payload?.newFacts;
+				if (turnCount > 0 && sessionId) {
+					const entry = `\n- ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}: Session ${sessionId} closed after ${turnCount} turns\n`;
+					const { getHyperClawDir: getHyperClawDir$1 } = await Promise.resolve().then(() => require("./paths-D-QecARF.js"));
+					await fs_extra.default.appendFile(path.default.join(getHyperClawDir$1(), "MEMORY.md"), entry);
+				}
+				try {
+					const { onSessionEnd } = await Promise.resolve().then(() => require("./memory-integration-DMXDbMIL.js"));
+					await onSessionEnd({
+						sessionId,
+						turnCount,
+						newFacts
+					});
+				} catch {}
+			},
+			"command-logger": async () => {
+				const { getHyperClawDir: getHyperClawDir$1 } = await Promise.resolve().then(() => require("./paths-D-QecARF.js"));
+				const logDir = path.default.join(getHyperClawDir$1(), "logs");
+				const logFile = path.default.join(logDir, `commands-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.log`);
+				await fs_extra.default.ensureDir(logDir);
+				const msg = String(payload?.message ?? "").slice(0, 100);
+				const resp = String(payload?.response ?? "").slice(0, 200);
+				const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] msg=${msg} | resp=${resp}\n`;
+				await fs_extra.default.appendFile(logFile, line);
+			},
+			"dm-guard": async () => {
+				if (payload?.channel) {
+					const { getHyperClawDir: getHyperClawDir$1 } = await Promise.resolve().then(() => require("./paths-D-QecARF.js"));
+					const auditDir = path.default.join(getHyperClawDir$1(), "logs");
+					await fs_extra.default.ensureDir(auditDir);
+					const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] message:received channel=${payload.channel}\n`;
+					await fs_extra.default.appendFile(path.default.join(auditDir, "dm-guard.log"), line);
+				}
+			},
+			"gateway-health": async () => {
+				const { getHyperClawDir: getHyperClawDir$1, getConfigPath } = await Promise.resolve().then(() => require("./paths-D-QecARF.js"));
+				const hcDir = getHyperClawDir$1();
+				let port = 18789;
+				try {
+					const cfg = await fs_extra.default.readJson(getConfigPath());
+					if (cfg?.gateway?.port) port = cfg.gateway.port;
+				} catch {}
+				const logDir = path.default.join(hcDir, "logs");
+				const logFile = path.default.join(logDir, "gateway-health.log");
+				const start = Date.now();
+				try {
+					const http = await import("http");
+					await new Promise((resolve, reject) => {
+						const req = http.get(`http://127.0.0.1:${port}/api/status`, (res) => {
+							let data = "";
+							res.on("data", (c) => data += c);
+							res.on("end", () => {
+								resolve();
+							});
+						});
+						req.on("error", reject);
+						req.setTimeout(5e3, () => {
+							req.destroy();
+							reject(new Error("Timeout"));
+						});
+					});
+					const latency = Date.now() - start;
+					await fs_extra.default.ensureDir(logDir);
+					await fs_extra.default.appendFile(logFile, `[${(/* @__PURE__ */ new Date()).toISOString()}] OK latency=${latency}ms\n`);
+				} catch (e) {
+					await fs_extra.default.ensureDir(logDir);
+					await fs_extra.default.appendFile(logFile, `[${(/* @__PURE__ */ new Date()).toISOString()}] FAIL ${e.message}\n`);
+				}
+			},
+			"auto-backup": async () => {
+				const { getHyperClawDir: getHyperClawDir$1, getConfigPath } = await Promise.resolve().then(() => require("./paths-D-QecARF.js"));
+				const hcDir = getHyperClawDir$1();
+				const backupDir = path.default.join(hcDir, "backups");
+				await fs_extra.default.ensureDir(backupDir);
+				const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+				for (const f of [
+					"hyperclaw.json",
+					"AGENTS.md",
+					"MEMORY.md",
+					"SOUL.md"
+				]) {
+					const src = path.default.join(hcDir, f);
+					if (await fs_extra.default.pathExists(src)) await fs_extra.default.copy(src, path.default.join(backupDir, `${f}.${ts}.bak`));
+				}
+			},
+			"voice-wake": async () => {},
+			"morning-briefing": async () => {
+				try {
+					const { runMorningBriefing, persistBriefing } = await Promise.resolve().then(() => require("./heartbeat-engine-5iOlL7Dj.js"));
+					const text = await runMorningBriefing();
+					await persistBriefing(text);
+				} catch (e) {
+					const { getHyperClawDir: getHyperClawDir$1 } = await Promise.resolve().then(() => require("./paths-D-QecARF.js"));
+					const logDir = path.default.join(getHyperClawDir$1(), "logs");
+					await fs_extra.default.ensureDir(logDir);
+					await fs_extra.default.appendFile(path.default.join(logDir, "heartbeat-errors.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] ${e.message}\n`);
+				}
+			},
+			"website-watch": async () => {
+				const path$2 = await import("path");
+				const os = await import("os");
+				const fs$1 = await import("fs-extra");
+				const { getHyperClawDir: getHyperClawDir$1 } = await Promise.resolve().then(() => require("./paths-D-QecARF.js"));
+				const watchFile = path$2.join(getHyperClawDir$1(), "website-watches.json");
+				if (!await fs$1.pathExists(watchFile)) return;
+				const watches = await fs$1.readJson(watchFile).catch(() => ({}));
+				const crypto = await import("crypto");
+				const https = await import("https");
+				const http = await import("http");
+				const fetch = (u) => new Promise((res, rej) => {
+					const c = u.startsWith("https") ? https : http;
+					const req = c.get(u, { timeout: 1e4 }, (r) => {
+						let d = "";
+						r.on("data", (x) => d += x);
+						r.on("end", () => res(d));
+					});
+					req.on("error", rej);
+				});
+				const hash = (s) => crypto.createHash("sha256").update(s.replace(/\s+/g, " ").slice(0, 5e4)).digest("hex").slice(0, 16);
+				for (const url of Object.keys(watches)) try {
+					const content = await fetch(url);
+					const h = hash(content);
+					if (h !== watches[url].lastHash) {
+						watches[url].lastHash = h;
+						watches[url].lastCheck = (/* @__PURE__ */ new Date()).toISOString();
+					}
+				} catch {}
+				await fs$1.writeJson(watchFile, watches, { spaces: 2 });
+			}
+		};
+		const fn = handlers[hook.id];
+		if (fn) await fn();
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'HookLoader', {
+  enumerable: true,
+  get: function () {
+    return HookLoader;
+  }
+});