hyperclaw 4.0.1 → 4.0.2

package/dist/inference-ix607p7k.js

@@ -0,0 +1,6 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_inference = require('./inference-CTWJeX9Q.js');
+
+require_inference.init_inference();
+exports.InferenceEngine = require_inference.InferenceEngine;
+exports.getBuiltinTools = require_inference.getBuiltinTools;

package/dist/knowledge-graph-DqA-Fztl.js

@@ -0,0 +1,131 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const os = require_chunk.__toESM(require("os"));
+
+//#region src/services/knowledge-graph.ts
+async function load() {
+	try {
+		const data = await fs_extra.default.readJson(KG_FILE);
+		return {
+			...DEFAULT_GRAPH,
+			...data
+		};
+	} catch {
+		return { ...DEFAULT_GRAPH };
+	}
+}
+async function save(graph) {
+	await fs_extra.default.ensureDir(path.default.dirname(KG_FILE));
+	await fs_extra.default.writeJson(KG_FILE, graph, { spaces: 2 });
+}
+function slug(label, type) {
+	const base = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 40);
+	return `${type}_${base}_${Date.now().toString(36)}`;
+}
+/** Add entity. */
+async function addEntity(type, label, props = {}) {
+	const graph = await load();
+	const id = slug(label, type);
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const entity = {
+		id,
+		type,
+		label,
+		props,
+		createdAt: now,
+		updatedAt: now
+	};
+	const idx = graph.entities.findIndex((e) => e.id === id);
+	if (idx >= 0) graph.entities[idx] = {
+		...entity,
+		createdAt: graph.entities[idx].createdAt
+	};
+	else graph.entities.push(entity);
+	await save(graph);
+	return id;
+}
+/** Add relation. */
+async function addRelation(fromId, toId, type, props) {
+	const graph = await load();
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const rel = {
+		from: fromId,
+		to: toId,
+		type,
+		props,
+		createdAt: now
+	};
+	const exists = graph.relations.some((r) => r.from === fromId && r.to === toId && r.type === type);
+	if (!exists) graph.relations.push(rel);
+	await save(graph);
+}
+/** Add fact (convenience). */
+async function addFact(fact, tags) {
+	return addEntity("fact", fact.slice(0, 200), {
+		fullText: fact,
+		tags: tags?.join(",") ?? ""
+	});
+}
+/** Add preference. */
+async function addPreference(topic, value) {
+	const topicId = await addEntity("topic", topic);
+	const prefId = await addEntity("preference", `${topic}: ${value}`, {
+		topic,
+		value
+	});
+	await addRelation(prefId, topicId, "belongs_to");
+	return prefId;
+}
+/** Add project. */
+async function addProject(name, description) {
+	return addEntity("project", name, { description: description ?? "" });
+}
+/** Query memory for context (semantic-ish: type + label/props match). */
+async function queryMemory(query) {
+	const graph = await load();
+	const { types = [], tags = [], limit = 20 } = query;
+	let entities = graph.entities;
+	if (types.length > 0) entities = entities.filter((e) => types.includes(e.type));
+	if (tags.length > 0) entities = entities.filter((e) => {
+		const t = String(e.props.tags || "").split(",");
+		return tags.some((tag) => t.some((x) => x.toLowerCase().includes(tag.toLowerCase())));
+	});
+	entities = entities.sort((a, b) => new Date(b.updatedAt || b.createdAt).getTime() - new Date(a.updatedAt || a.createdAt).getTime()).slice(0, limit);
+	if (entities.length === 0) return "";
+	const lines = entities.map((e) => {
+		const d = e.updatedAt || e.createdAt;
+		return `- [${e.type}] ${e.label} (${d.slice(0, 10)})`;
+	});
+	return lines.join("\n");
+}
+/** Get full context string for injection into prompts. */
+async function getContextSummary(limit = 30) {
+	const facts = await queryMemory({
+		types: [
+			"fact",
+			"preference",
+			"project"
+		],
+		limit
+	});
+	if (!facts) return "";
+	return `## Knowledge Graph Context\n${facts}`;
+}
+var KG_FILE, DEFAULT_GRAPH;
+var init_knowledge_graph = require_chunk.__esm({ "src/services/knowledge-graph.ts"() {
+	KG_FILE = path.default.join(os.default.homedir(), ".hyperclaw", "knowledge-graph.json");
+	DEFAULT_GRAPH = {
+		entities: [],
+		relations: [],
+		version: 1
+	};
+} });
+
+//#endregion
+init_knowledge_graph();
+exports.addFact = addFact;
+exports.addPreference = addPreference;
+exports.addProject = addProject;
+exports.getContextSummary = getContextSummary;
+exports.queryMemory = queryMemory;

package/dist/loader-CISCqBto.js

@@ -0,0 +1,400 @@
+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"));
+
+//#region src/hooks/loader.ts
+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(os.default.homedir(), ".hyperclaw", "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-BvDFNyiE.js"));
+				const tasks = await loadCronTasks();
+				let port = 18789;
+				try {
+					const cfg = await fs_extra.default.readJson(path.default.join(os.default.homedir(), ".hyperclaw", "hyperclaw.json"));
+					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`;
+					await fs_extra.default.appendFile(path.default.join(os.default.homedir(), ".hyperclaw", "MEMORY.md"), entry);
+				}
+				try {
+					const { onSessionEnd } = await Promise.resolve().then(() => require("./memory-integration-DZExqWr4.js"));
+					await onSessionEnd({
+						sessionId,
+						turnCount,
+						newFacts
+					});
+				} catch {}
+			},
+			"command-logger": async () => {
+				const logDir = path.default.join(os.default.homedir(), ".hyperclaw", "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 auditDir = path.default.join(os.default.homedir(), ".hyperclaw", "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 hcDir = path.default.join(os.default.homedir(), ".hyperclaw");
+				let port = 18789;
+				try {
+					const cfg = await fs_extra.default.readJson(path.default.join(hcDir, "hyperclaw.json"));
+					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 hcDir = path.default.join(os.default.homedir(), ".hyperclaw");
+				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-CRqfPcFM.js"));
+					const text = await runMorningBriefing();
+					await persistBriefing(text);
+				} catch (e) {
+					const logDir = path.default.join(os.default.homedir(), ".hyperclaw", "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$2 = await import("os");
+				const fs$1 = await import("fs-extra");
+				const watchFile = path$2.join(os$2.homedir(), ".hyperclaw", "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;
+  }
+});

package/dist/loader-CYMQ8VOS.js

@@ -0,0 +1,4 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_loader = require('./loader-CISCqBto.js');
+
+exports.HookLoader = require_loader.HookLoader;

package/dist/logger-8tEtAd3y.js

@@ -0,0 +1,83 @@
+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"));
+
+//#region src/logging/logger.ts
+const LEVEL_COLOR = {
+	debug: chalk.default.gray,
+	info: chalk.default.cyan,
+	warn: chalk.default.yellow,
+	error: chalk.default.red,
+	silent: chalk.default.gray
+};
+const LOG_DIR = path.default.join(os.default.homedir(), ".hyperclaw", "logs");
+const LOG_FILE = path.default.join(LOG_DIR, "hyperclaw.log");
+const MAX_LOG_BYTES = 5 * 1024 * 1024;
+function formatConsole(entry) {
+	const ts = chalk.default.gray(entry.ts.slice(11, 23));
+	const level = LEVEL_COLOR[entry.level](entry.level.toUpperCase().padEnd(5));
+	const mod = chalk.default.blue(`[${entry.module}]`);
+	const data = entry.data ? chalk.default.gray(" " + JSON.stringify(entry.data)) : "";
+	return `  ${ts} ${level} ${mod} ${entry.message}${data}`;
+}
+async function tailLog(lines = 50) {
+	if (!await fs_extra.default.pathExists(LOG_FILE)) {
+		console.log(chalk.default.gray("\n  No log file yet. Start the daemon first.\n"));
+		return;
+	}
+	const content = await fs_extra.default.readFile(LOG_FILE, "utf8");
+	const all = content.trim().split("\n").filter(Boolean);
+	const tail = all.slice(-lines);
+	console.log(chalk.default.bold.cyan(`\n  📋 LAST ${tail.length} LOG ENTRIES\n`));
+	for (const line of tail) try {
+		const entry = JSON.parse(line);
+		console.log(formatConsole(entry));
+	} catch {
+		console.log(chalk.default.gray("  " + line));
+	}
+	console.log();
+}
+async function streamLog() {
+	console.log(chalk.default.bold.cyan("\n  📡 STREAMING LOGS (Ctrl+C to stop)\n"));
+	await fs_extra.default.ensureDir(LOG_DIR);
+	await fs_extra.default.ensureFile(LOG_FILE);
+	const { createReadStream } = await import("fs");
+	const { Tail } = await import("tail").catch(() => ({ Tail: null }));
+	if (Tail) {
+		const tail = new Tail(LOG_FILE);
+		tail.on("line", (line) => {
+			try {
+				const entry = JSON.parse(line);
+				console.log(formatConsole(entry));
+			} catch {
+				console.log(chalk.default.gray("  " + line));
+			}
+		});
+	} else {
+		const { spawn } = await import("child_process");
+		const proc = spawn("tail", ["-f", LOG_FILE], { stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		] });
+		proc.stdout?.on("data", (chunk) => {
+			const lines = chunk.toString().split("\n");
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				try {
+					const entry = JSON.parse(line);
+					console.log(formatConsole(entry));
+				} catch {
+					console.log(chalk.default.gray("  " + line));
+				}
+			}
+		});
+		await new Promise(() => {});
+	}
+}
+
+//#endregion
+exports.streamLog = streamLog;
+exports.tailLog = tailLog;

package/dist/manager-CPjeRe-6.js

@@ -0,0 +1,4 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_manager = require('./manager-Cwzj7w5R.js');
+
+exports.GatewayManager = require_manager.GatewayManager;