hyperclaw 4.0.2 → 5.0.1

package/dist/loader-CnEdOyjT.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-Bli7Kzd2.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-cSYkZyEo.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-BYT5ayQH.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-DI2qDRPC.js

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

package/dist/logger-Cp8wC7F8.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/logger-ybOp7VOC.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-03ipO9R0.js

@@ -0,0 +1,105 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const crypto = require_chunk.__toESM(require("crypto"));
+const child_process = require_chunk.__toESM(require("child_process"));
+const util = require_chunk.__toESM(require("util"));
+const net = require_chunk.__toESM(require("net"));
+
+//#region packages/gateway/src/manager.ts
+const execAsync = (0, util.promisify)(child_process.exec);
+var GatewayManager = class {
+	generateToken() {
+		return crypto.default.randomBytes(32).toString("hex");
+	}
+	async isRunning(port) {
+		return new Promise((resolve) => {
+			const socket = new net.default.Socket();
+			socket.setTimeout(500);
+			socket.on("connect", () => {
+				socket.destroy();
+				resolve(true);
+			});
+			socket.on("error", () => resolve(false));
+			socket.on("timeout", () => resolve(false));
+			try {
+				socket.connect(port, "127.0.0.1");
+			} catch {
+				resolve(false);
+			}
+		});
+	}
+	async detectTailscale() {
+		try {
+			const { stdout } = await execAsync("tailscale ip -4 2>/dev/null");
+			return stdout.trim() || null;
+		} catch {
+			return null;
+		}
+	}
+	async detectRuntime() {
+		for (const runtime of [
+			"bun",
+			"deno",
+			"node"
+		]) try {
+			await execAsync(`which ${runtime}`);
+			return runtime;
+		} catch {}
+		return "node";
+	}
+	bindLabel(bind, custom) {
+		const map = {
+			"127.0.0.1": "Loopback only (this machine)",
+			"0.0.0.0": "All interfaces (LAN accessible)",
+			"tailscale": "Tailscale IP (VPN peers only)",
+			"custom": `Custom: ${custom || "?"}`
+		};
+		return map[bind];
+	}
+	exposureLabel(e) {
+		const map = {
+			"off": "Off — no Tailscale exposure",
+			"serve": "Serve — accessible to your Tailscale devices",
+			"funnel": "Funnel — publicly accessible via Tailscale URL"
+		};
+		return map[e];
+	}
+	async applyTailscaleExposure(exposure, port) {
+		if (exposure === "off") return;
+		try {
+			if (exposure === "serve") await execAsync(`tailscale serve ${port}`);
+			else if (exposure === "funnel") await execAsync(`tailscale funnel ${port}`);
+		} catch {
+			console.log(chalk.default.yellow("⚠️  Tailscale exposure failed — check tailscale is running"));
+		}
+	}
+	getWsUrl(config) {
+		const host = config.bind === "127.0.0.1" ? "127.0.0.1" : config.bind === "custom" ? config.customBind || "localhost" : "localhost";
+		return `ws://${host}:${config.port}`;
+	}
+	getHttpUrl(config) {
+		return `http://localhost:${config.port}`;
+	}
+	async showStatus(config) {
+		const running = await this.isRunning(config.port);
+		const statusIcon = running ? chalk.default.green("● RUNNING") : chalk.default.red("○ STOPPED");
+		const ws = this.getWsUrl(config);
+		console.log(chalk.default.cyan("\n╔══════════════════════════════════════╗"));
+		console.log(chalk.default.cyan("║      🌐 GATEWAY STATUS               ║"));
+		console.log(chalk.default.cyan("╠══════════════════════════════════════╣"));
+		console.log(chalk.default.cyan(`║ Status:  ${statusIcon.padEnd(29)}║`));
+		console.log(chalk.default.cyan(`║ Address: ${chalk.default.white(ws).padEnd(29)}║`));
+		console.log(chalk.default.cyan(`║ Auth:    ${chalk.default.yellow("token (masked)").padEnd(29)}║`));
+		console.log(chalk.default.cyan(`║ Bind:    ${chalk.default.gray(config.bind).padEnd(29)}║`));
+		console.log(chalk.default.cyan(`║ Tailscale: ${chalk.default.gray(config.tailscaleExposure).padEnd(27)}║`));
+		console.log(chalk.default.cyan("╚══════════════════════════════════════╝\n"));
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'GatewayManager', {
+  enumerable: true,
+  get: function () {
+    return GatewayManager;
+  }
+});