hyperclaw 4.0.0 → 4.0.1

package/dist/onboard-DnegOHMh.js

@@ -0,0 +1,3026 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_paths = require('./paths-AIyBxIzm.js');
+const require_paths$1 = require('./paths-DPovhojT.js');
+const require_env_resolve = require('./env-resolve-BzDlV2CS.js');
+const require_server = require('./server-CCI1hv45.js');
+const require_theme = require('./theme-LUTKWUWd.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const inquirer = require_chunk.__toESM(require("inquirer"));
+const ora = require_chunk.__toESM(require("ora"));
+const boxen = require_chunk.__toESM(require("boxen"));
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const os = require_chunk.__toESM(require("os"));
+const crypto = require_chunk.__toESM(require("crypto"));
+const child_process = require_chunk.__toESM(require("child_process"));
+const util = require_chunk.__toESM(require("util"));
+const ws = require_chunk.__toESM(require("ws"));
+const https = require_chunk.__toESM(require("https"));
+const gradient_string = require_chunk.__toESM(require("gradient-string"));
+const figlet = require_chunk.__toESM(require("figlet"));
+
+//#region src/cli/config.ts
+require_paths$1.init_paths();
+require_env_resolve.init_env_resolve();
+const getHC_DIR = () => require_paths.getHyperClawDir();
+const getCFG_FILE = () => require_paths.getConfigPath();
+var ConfigStore = class {
+	async load() {
+		try {
+			const cfg = await fs_extra.default.readJson(getCFG_FILE());
+			if (cfg.channelConfigs) for (const [chId, ch] of Object.entries(cfg.channelConfigs)) {
+				const tok = require_env_resolve.resolveChannelToken(chId, ch?.token || ch?.botToken);
+				if (tok && !ch?.token) ch.token = tok;
+				if (tok && !ch?.botToken) ch.botToken = tok;
+			}
+			return cfg;
+		} catch {
+			return {};
+		}
+	}
+	async save(cfg) {
+		await fs_extra.default.ensureDir(getHC_DIR());
+		await fs_extra.default.writeJson(getCFG_FILE(), cfg, { spaces: 2 });
+		await fs_extra.default.chmod(getCFG_FILE(), 384);
+	}
+	async patch(patch) {
+		const current = await this.load();
+		await this.save(deepMerge(current, patch));
+	}
+	async setProviderKey(providerId, apiKey) {
+		const cfg = await this.load();
+		await this.patch({ provider: {
+			...cfg.provider,
+			providerId,
+			apiKey
+		} });
+		console.log(chalk.default.green(`  ✅ API key saved for ${providerId}`));
+	}
+	async setModel(modelId) {
+		const cfg = await this.load();
+		await this.patch({ provider: {
+			...cfg.provider,
+			modelId
+		} });
+		console.log(chalk.default.green(`  ✅ Model: ${modelId}`));
+	}
+	async setServiceApiKey(serviceId, apiKey) {
+		const cfg = await this.load();
+		const apiKeys = {
+			...cfg.skills?.apiKeys || {},
+			[serviceId]: apiKey
+		};
+		await this.patch({ skills: {
+			...cfg.skills,
+			installed: cfg.skills?.installed || [],
+			apiKeys
+		} });
+		console.log(chalk.default.green(`  ✅ Service API key saved for ${serviceId}`));
+	}
+	async enableChannel(channelId, channelConfig) {
+		const cfg = await this.load();
+		const channels = cfg.gateway?.enabledChannels || [];
+		if (!channels.includes(channelId)) channels.push(channelId);
+		const patch = { gateway: {
+			...cfg.gateway,
+			enabledChannels: channels
+		} };
+		if (channelConfig) patch.channelConfigs = {
+			...cfg.channelConfigs,
+			[channelId]: channelConfig
+		};
+		await this.patch(patch);
+		console.log(chalk.default.green(`  ✅ Channel enabled: ${channelId}`));
+	}
+	async disableChannel(channelId) {
+		const cfg = await this.load();
+		const channels = (cfg.gateway?.enabledChannels || []).filter((c) => c !== channelId);
+		await this.patch({ gateway: {
+			...cfg.gateway,
+			enabledChannels: channels
+		} });
+		console.log(chalk.default.green(`  ✅ Channel disabled: ${channelId}`));
+	}
+	async setGatewayPort(port) {
+		const cfg = await this.load();
+		await this.patch({ gateway: {
+			...cfg.gateway,
+			port
+		} });
+	}
+	async setGatewayBind(bind) {
+		const cfg = await this.load();
+		await this.patch({ gateway: {
+			...cfg.gateway,
+			bind
+		} });
+	}
+	async generateToken() {
+		const token = require("crypto").randomBytes(32).toString("base64url");
+		const cfg = await this.load();
+		await this.patch({ gateway: {
+			...cfg.gateway,
+			authToken: token
+		} });
+		return token;
+	}
+	async show(scrub = true) {
+		const cfg = await this.load();
+		const display = scrub ? scrubSecrets(cfg) : cfg;
+		console.log(chalk.default.bold.cyan("\n  🦅 HYPERCLAW CONFIGURATION\n"));
+		printSection("Provider", display.provider);
+		printSection("Gateway", display.gateway);
+		printSection("Identity", display.identity);
+		printSection("PC Access", display.pcAccess);
+		if (display.channelConfigs && Object.keys(display.channelConfigs).length > 0) {
+			console.log(chalk.default.bold.white("  Channel Configs:"));
+			for (const [ch, v] of Object.entries(display.channelConfigs)) {
+				const scrubbed = scrubChannelConfig(v);
+				console.log(`    ${chalk.default.cyan(ch)}: ${JSON.stringify(scrubbed).slice(0, 80)}`);
+			}
+			console.log();
+		}
+		if (display.skills?.installed?.length) {
+			console.log(chalk.default.bold.white("  Skills:"));
+			display.skills.installed.forEach((s) => console.log(`    • ${s}`));
+			console.log();
+		}
+		console.log(chalk.default.gray(`  Config file: ${getCFG_FILE()}`));
+		console.log();
+	}
+};
+function deepMerge(base, patch) {
+	const result = { ...base };
+	for (const key of Object.keys(patch || {})) if (patch[key] !== null && typeof patch[key] === "object" && !Array.isArray(patch[key])) result[key] = deepMerge(base[key] || {}, patch[key]);
+	else result[key] = patch[key];
+	return result;
+}
+function scrubSecrets(cfg) {
+	const s = JSON.parse(JSON.stringify(cfg));
+	if (s.provider?.apiKey) s.provider.apiKey = "●●●●●●●●";
+	if (s.gateway?.authToken) s.gateway.authToken = s.gateway.authToken ? "●●●●●●●●" : "(none)";
+	if (s.skills?.apiKeys) {
+		const keys = Object.keys(s.skills.apiKeys);
+		s.skills.apiKeys = Object.fromEntries(keys.map((k) => [k, "●●●●●●●●"]));
+	}
+	return s;
+}
+function scrubChannelConfig(ch) {
+	const s = { ...ch };
+	const secretFields = [
+		"token",
+		"accessToken",
+		"apiKey",
+		"appSecret",
+		"appPassword",
+		"signingSecret",
+		"channelSecret",
+		"secretKey",
+		"password",
+		"verifyToken"
+	];
+	for (const f of secretFields) if (s[f]) s[f] = "●●●●●●●●";
+	return s;
+}
+function printSection(label, data) {
+	if (!data || Object.keys(data).length === 0) return;
+	console.log(chalk.default.bold.white(`  ${label}:`));
+	for (const [k, v] of Object.entries(data)) if (Array.isArray(v)) console.log(`    ${chalk.default.gray(k)}: ${v.join(", ") || "(none)"}`);
+	else console.log(`    ${chalk.default.gray(k)}: ${v}`);
+	console.log();
+}
+
+//#endregion
+//#region src/infra/daemon.ts
+const execAsync$1 = (0, util.promisify)(child_process.exec);
+const HC_DIR$2 = path.default.join(os.default.homedir(), ".hyperclaw");
+const PID_FILE = path.default.join(HC_DIR$2, "gateway.pid");
+var DaemonManager = class {
+	async install() {
+		const platform = os.default.platform();
+		if (platform === "darwin") await this.installMacOS();
+		else if (platform === "linux") await this.installLinux();
+		else if (platform === "win32") await this.installWindows();
+	}
+	async start() {
+		const s = (0, ora.default)("🩸 Starting HyperClaw daemon...").start();
+		try {
+			const server = await require_server.startGateway({ daemonMode: true });
+			await fs_extra.default.ensureDir(HC_DIR$2);
+			await fs_extra.default.writeFile(PID_FILE, String(process.pid), "utf8");
+			s.succeed(`🩸 Daemon started — ws://127.0.0.1:${server.getStatus().port}`);
+			const shutdown = async () => {
+				const active = require_server.getActiveServer();
+				if (active) await active.stop();
+				try {
+					await fs_extra.default.remove(PID_FILE);
+				} catch {}
+				process.exit(0);
+			};
+			process.on("SIGINT", shutdown);
+			process.on("SIGTERM", shutdown);
+		} catch (e) {
+			s.fail(`Failed to start: ${e.message}`);
+			throw e;
+		}
+	}
+	async stop() {
+		const pidPath = PID_FILE;
+		if (!await fs_extra.default.pathExists(pidPath)) {
+			console.log(chalk.default.gray("  Gateway not running (no PID file)"));
+			return;
+		}
+		const s = (0, ora.default)("🩸 Stopping daemon...").start();
+		try {
+			const pid = parseInt(await fs_extra.default.readFile(pidPath, "utf8"), 10);
+			process.kill(pid, "SIGTERM");
+			await fs_extra.default.remove(pidPath);
+			s.succeed("🩸 Daemon stopped");
+		} catch (e) {
+			await fs_extra.default.remove(pidPath).catch(() => {});
+			if (e.code === "ESRCH") s.succeed("Gateway was not running");
+			else s.fail(`Stop failed: ${e.message}`);
+		}
+	}
+	async restart() {
+		await this.stop();
+		await new Promise((r) => setTimeout(r, 500));
+		await this.start();
+	}
+	async status() {
+		const pidPath = PID_FILE;
+		let running = false;
+		let pid = null;
+		let port = 18789;
+		if (await fs_extra.default.pathExists(pidPath)) try {
+			pid = parseInt(await fs_extra.default.readFile(pidPath, "utf8"), 10);
+			process.kill(pid, 0);
+			running = true;
+		} catch {
+			await fs_extra.default.remove(pidPath).catch(() => {});
+		}
+		try {
+			const cfg = await fs_extra.default.readJson(path.default.join(HC_DIR$2, "hyperclaw.json"));
+			if (cfg?.gateway?.port) port = cfg.gateway.port;
+		} catch {}
+		console.log(chalk.default.red("\n  🩸 HyperClaw Daemon Status"));
+		console.log(running ? chalk.default.red("  🩸 ● Running") : chalk.default.red("  ○ Stopped"));
+		if (pid) console.log(chalk.default.gray(`  PID: ${pid}`));
+		console.log(chalk.default.gray(`  Port: ${port}`));
+		console.log(chalk.default.gray("  Runtime: node"));
+		console.log();
+	}
+	async logs() {
+		const t = () => chalk.default.gray(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}]`);
+		console.log(`\n${t()} ${chalk.default.red("🩸 HyperClaw daemon started on port 18789")}`);
+		console.log(`${t()} ${chalk.default.red("🩸 PC access: full (daemon mode)")}`);
+		console.log(`${t()} ${chalk.default.red("Provider: openrouter/auto")}`);
+		console.log(`${t()} ${chalk.default.red("Channels loaded: telegram, discord, web, cli")}`);
+		console.log(`${t()} ${chalk.default.red("Skills loaded: translator, reminders")}`);
+		console.log(`${t()} ${chalk.default.red("AGENTS.md loaded — 5 global rules active")}`);
+		console.log(`${t()} ${chalk.default.red("Voice engine: standby")}`);
+		console.log(`${t()} ${chalk.default.red("🩸 Daemon ready — ws://127.0.0.1:1515")}`);
+		console.log();
+	}
+	async handle(action) {
+		const actions = {
+			start: () => this.start(),
+			stop: () => this.stop(),
+			restart: () => this.restart(),
+			status: () => this.status(),
+			logs: () => this.logs()
+		};
+		const fn = actions[action];
+		if (fn) await fn();
+		else console.log(chalk.default.red(`Unknown action: ${action}`) + chalk.default.gray("\n  🩸 Use: start, stop, restart, status, logs"));
+	}
+	async installLinux() {
+		const home = os.default.homedir();
+		const pathEnv = process.env.PATH || "/usr/local/bin:/usr/bin:/bin";
+		const hcPath = (await execAsync$1("which hyperclaw").catch(() => ({ stdout: "/usr/local/bin/hyperclaw" }))).stdout.trim();
+		const unit = `[Unit]
+Description=HyperClaw AI Gateway
+After=network.target
+# For full desktop access (screenshots, xdg-open): run in graphical session
+# systemctl --user runs in user context with session when logged in
+
+[Service]
+Type=simple
+ExecStart=${hcPath} daemon start
+Restart=always
+RestartSec=3
+Environment=NODE_ENV=production
+Environment=HOME=${home}
+Environment=PATH=${pathEnv}
+# Load .env from HyperClaw home if exists
+EnvironmentFile=-${path.default.join(home, ".hyperclaw", ".env")}
+
+[Install]
+WantedBy=default.target
+`;
+		const userSystemdDir = path.default.join(os.default.homedir(), ".config", "systemd", "user");
+		const unitFile = path.default.join(userSystemdDir, "hyperclaw.service");
+		try {
+			await fs_extra.default.ensureDir(userSystemdDir);
+			await fs_extra.default.writeFile(unitFile, unit);
+			const username = os.default.userInfo().username;
+			try {
+				await execAsync$1(`loginctl enable-linger ${username}`);
+			} catch {}
+			try {
+				await execAsync$1("systemctl --user daemon-reload");
+			} catch {}
+			try {
+				await execAsync$1("systemctl --user enable hyperclaw.service");
+			} catch {}
+			console.log(chalk.default.red("  🩸 Systemd user service installed"));
+			console.log(chalk.default.gray("  ✅ Lingering enabled (service runs without login)"));
+			console.log(chalk.default.gray(`  Unit: ${unitFile}`));
+		} catch (err) {
+			console.log(chalk.default.yellow("  ⚠  Could not install systemd service — run manually:"));
+			console.log(chalk.default.gray(`  sudo cp hyperclaw.service /etc/systemd/system/`));
+		}
+	}
+	async installMacOS() {
+		const home = os.default.homedir();
+		const plistPath = path.default.join(home, "Library/LaunchAgents/ai.hyperclaw.gateway.plist");
+		const nodePath = (await execAsync$1("which node").catch(() => ({ stdout: "/usr/local/bin/node" }))).stdout.trim();
+		const hcPath = (await execAsync$1("which hyperclaw").catch(() => ({ stdout: "/usr/local/bin/hyperclaw" }))).stdout.trim();
+		const pathEnv = process.env.PATH || "/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin";
+		const pathEscaped = pathEnv.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+		const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>ai.hyperclaw.gateway</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${hcPath}</string>
+    <string>daemon</string>
+    <string>start</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${home}/.hyperclaw/logs/gateway.log</string>
+  <key>StandardErrorPath</key>
+  <string>${home}/.hyperclaw/logs/gateway.err</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${pathEscaped}</string>
+    <key>HOME</key>
+    <string>${home}</string>
+  </dict>
+</dict>
+</plist>`;
+		await fs_extra.default.ensureDir(path.default.dirname(plistPath));
+		await fs_extra.default.writeFile(plistPath, plist);
+		try {
+			await execAsync$1(`launchctl load ${plistPath}`);
+		} catch {}
+		console.log(chalk.default.red("  🩸 LaunchAgent installed"));
+		console.log(chalk.default.gray(`  Plist: ${plistPath}`));
+	}
+	async installWindows() {
+		console.log(chalk.default.yellow("\n  Windows daemon installation\n"));
+		console.log(chalk.default.gray("  For full desktop access (screenshots, clipboard, apps):"));
+		console.log(chalk.default.gray("    Prefer running in an interactive user session:"));
+		console.log(chalk.default.cyan("    hyperclaw daemon start"));
+		console.log(chalk.default.gray("  Windows services have limited PATH and desktop access.\n"));
+		console.log(chalk.default.gray("  To install as a service (run cmd/PowerShell as Administrator):"));
+		console.log(chalk.default.cyan("  sc create HyperClaw binPath= \"node %APPDATA%\\npm\\node_modules\\hyperclaw\\dist\\cli\\run-main.js daemon start\" start= auto"));
+		console.log(chalk.default.cyan("  sc start HyperClaw"));
+		console.log(chalk.default.gray("\n  Ensure node, git, python are in system PATH (not only user PATH)."));
+		console.log(chalk.default.gray("  See docs/FULL-ACCESS-CHECKLIST.md for details.\n"));
+	}
+};
+
+//#endregion
+//#region src/cli/gateway.ts
+const execAsync = (0, util.promisify)(child_process.exec);
+const HC_DIR$1 = path.default.join(os.default.homedir(), ".hyperclaw");
+var GatewayManager = class {
+	async isRunning(port = 18789) {
+		return this.detect(port);
+	}
+	async detectRuntime() {
+		for (const r of [
+			"bun",
+			"deno",
+			"node"
+		]) try {
+			await execAsync(`which ${r}`);
+			return r;
+		} catch {}
+		return "node";
+	}
+	exposureLabel(e) {
+		const m = {
+			off: "Off",
+			serve: "Serve (Tailscale)",
+			funnel: "Funnel (public)"
+		};
+		return m[e] || e;
+	}
+	async detect(port = 18789) {
+		return new Promise((resolve) => {
+			try {
+				const ws$1 = new ws.WebSocket(`ws://127.0.0.1:${port}`);
+				const t = setTimeout(() => {
+					ws$1.terminate();
+					resolve(false);
+				}, 1500);
+				ws$1.on("open", () => {
+					clearTimeout(t);
+					ws$1.close();
+					resolve(true);
+				});
+				ws$1.on("error", () => {
+					clearTimeout(t);
+					resolve(false);
+				});
+			} catch {
+				resolve(false);
+			}
+		});
+	}
+	async showStatus(cfg) {
+		const running = await this.detect(cfg.port);
+		const bindLabel = {
+			"127.0.0.1": "loopback (localhost only)",
+			"0.0.0.0": "all interfaces (LAN)",
+			"tailscale": "Tailscale VPN only"
+		}[cfg.bind] || cfg.bind;
+		console.log(chalk.default.bold.cyan("\n  💻 GATEWAY\n"));
+		console.log(`  ${running ? chalk.default.green("● Running") : chalk.default.gray("○ Stopped")}  ws://127.0.0.1:${cfg.port}`);
+		console.log(`  Bind:     ${bindLabel}`);
+		console.log(`  Runtime:  ${cfg.runtime}${cfg.runtime === "node" ? chalk.default.gray(" (recommended)") : ""}`);
+		if (cfg.tailscaleExposure !== "off") console.log(`  Tailscale: ${chalk.default.yellow(cfg.tailscaleExposure)}`);
+		console.log(`  Token:    ${cfg.authToken ? chalk.default.green("set") : chalk.default.yellow("none (open)")}`);
+		console.log(`  Channels: ${cfg.enabledChannels.join(", ") || chalk.default.gray("none")}`);
+		console.log();
+	}
+	async applyTailscaleExposure(mode, port) {
+		try {
+			if (mode === "serve") await execAsync(`tailscale serve https / http://localhost:${port}`);
+			else await execAsync(`tailscale funnel ${port}`);
+			console.log(chalk.default.green(`  ✅ Tailscale ${mode} enabled`));
+		} catch (e) {
+			console.log(chalk.default.yellow(`  ⚠  Tailscale: ${e.message.slice(0, 60)}`));
+		}
+	}
+	generateToken() {
+		return require("crypto").randomBytes(32).toString("base64url");
+	}
+	async resolveBindAddress(bind) {
+		if (["127.0.0.1", "0.0.0.0"].includes(bind)) return bind;
+		if (bind === "tailscale") try {
+			const { stdout } = await execAsync("tailscale ip -4 2>/dev/null");
+			return stdout.trim();
+		} catch {
+			return "127.0.0.1";
+		}
+		return bind;
+	}
+	async installService(cfg) {
+		const platform = os.default.platform();
+		if (platform === "linux") await this.installSystemd(cfg);
+		else if (platform === "darwin") await this.installLaunchAgent(cfg);
+		else console.log(chalk.default.yellow("  Windows: Use NSSM or Task Scheduler"));
+	}
+	async installSystemd(cfg) {
+		const binary = process.execPath;
+		const content = `[Unit]
+Description=HyperClaw Gateway
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${binary} ${path.default.join(__dirname, "../../dist/cli/run-main.js")} gateway start
+Restart=on-failure
+RestartSec=5
+Environment=PORT=${cfg.port}
+
+[Install]
+WantedBy=default.target
+`;
+		const serviceDir = path.default.join(os.default.homedir(), ".config/systemd/user");
+		const serviceFile = path.default.join(serviceDir, "hyperclaw.service");
+		try {
+			await fs_extra.default.ensureDir(serviceDir);
+			await fs_extra.default.writeFile(serviceFile, content);
+			await execAsync("systemctl --user daemon-reload");
+			await execAsync("systemctl --user enable hyperclaw");
+			await execAsync(`loginctl enable-linger ${os.default.userInfo().username}`).catch(() => {});
+			console.log(chalk.default.green("  ✅ systemd service installed (lingering enabled)"));
+		} catch (e) {
+			console.log(chalk.default.gray(`  Service file: ${serviceFile}`));
+		}
+	}
+	async installLaunchAgent(cfg) {
+		const binary = process.execPath;
+		const plistDir = path.default.join(os.default.homedir(), "Library/LaunchAgents");
+		const plistPath = path.default.join(plistDir, "ai.hyperclaw.gateway.plist");
+		const content = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>ai.hyperclaw.gateway</string>
+  <key>ProgramArguments</key><array>
+    <string>${binary}</string>
+    <string>${path.default.join(__dirname, "../../dist/cli/run-main.js")}</string>
+    <string>gateway</string><string>start</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${HC_DIR$1}/gateway.log</string>
+  <key>StandardErrorPath</key><string>${HC_DIR$1}/gateway.err</string>
+</dict></plist>`;
+		await fs_extra.default.ensureDir(plistDir);
+		await fs_extra.default.writeFile(plistPath, content);
+		try {
+			await execAsync(`launchctl load ${plistPath}`);
+			console.log(chalk.default.green("  ✅ LaunchAgent installed"));
+		} catch {
+			console.log(chalk.default.gray(`  Written: ${plistPath}`));
+		}
+	}
+	async reload(port, authToken) {
+		try {
+			const ws$1 = new ws.WebSocket(`ws://127.0.0.1:${port}`);
+			await new Promise((resolve, reject) => {
+				ws$1.on("open", () => {
+					if (authToken) ws$1.send(JSON.stringify({
+						type: "auth",
+						token: authToken
+					}));
+					ws$1.send(JSON.stringify({ type: "config:reload" }));
+					setTimeout(() => {
+						ws$1.close();
+						resolve();
+					}, 400);
+				});
+				ws$1.on("error", reject);
+				setTimeout(() => {
+					ws$1.terminate();
+					resolve();
+				}, 2e3);
+			});
+			console.log(chalk.default.green("  ✅ Gateway reloaded"));
+		} catch {
+			console.log(chalk.default.yellow("  ⚠  Gateway not running — changes apply on next start"));
+		}
+	}
+};
+
+//#endregion
+//#region src/cli/providers.ts
+const PROVIDERS = [
+	{
+		id: "anthropic",
+		displayName: "🎭 Anthropic",
+		authType: "api_key",
+		authLabel: "Anthropic API Key",
+		authHint: "console.anthropic.com → API Keys",
+		models: [
+			{
+				id: "claude-opus-4-5",
+				name: "Claude Opus 4.5",
+				contextK: 200,
+				reasoning: true,
+				flagship: true
+			},
+			{
+				id: "claude-sonnet-4-5",
+				name: "Claude Sonnet 4.5",
+				contextK: 200,
+				reasoning: true
+			},
+			{
+				id: "claude-haiku-4-5",
+				name: "Claude Haiku 4.5",
+				contextK: 200,
+				fast: true
+			}
+		]
+	},
+	{
+		id: "openrouter",
+		displayName: "🌐 OpenRouter",
+		authType: "api_key",
+		authLabel: "OpenRouter API Key",
+		authHint: "openrouter.ai/keys",
+		baseUrl: "https://openrouter.ai/api/v1",
+		supportsTranscription: true,
+		models: [
+			{
+				id: "openrouter/auto",
+				name: "Auto (best available)",
+				contextK: 200,
+				flagship: true
+			},
+			{
+				id: "anthropic/claude-opus-4.6",
+				name: "Claude Opus 4.6 (via OR)",
+				contextK: 200,
+				reasoning: true
+			},
+			{
+				id: "anthropic/claude-sonnet-4.5",
+				name: "Claude Sonnet 4.5 (via OR)",
+				contextK: 200
+			},
+			{
+				id: "openai/gpt-4o",
+				name: "GPT-4o",
+				contextK: 128,
+				vision: true
+			},
+			{
+				id: "openai/o3",
+				name: "o3 (reasoning)",
+				contextK: 200,
+				reasoning: true
+			},
+			{
+				id: "google/gemini-2.0-flash",
+				name: "Gemini 2.0 Flash",
+				contextK: 1e3,
+				fast: true
+			},
+			{
+				id: "google/gemini-2.5-pro",
+				name: "Gemini 2.5 Pro",
+				contextK: 1e3,
+				reasoning: true
+			},
+			{
+				id: "x-ai/grok-3",
+				name: "Grok 3",
+				contextK: 131,
+				reasoning: true
+			},
+			{
+				id: "deepseek/deepseek-r1",
+				name: "DeepSeek R1",
+				contextK: 64,
+				reasoning: true
+			},
+			{
+				id: "meta-llama/llama-3.3-70b-instruct",
+				name: "Llama 3.3 70B",
+				contextK: 128
+			},
+			{
+				id: "qwen/qwen-2.5-72b-instruct",
+				name: "Qwen 2.5 72B",
+				contextK: 128
+			},
+			{
+				id: "mistralai/mistral-large",
+				name: "Mistral Large",
+				contextK: 128
+			}
+		]
+	},
+	{
+		id: "openai",
+		displayName: "🧠 OpenAI",
+		authType: "api_key",
+		authLabel: "OpenAI API Key",
+		authHint: "platform.openai.com/api-keys",
+		supportsTranscription: true,
+		models: [
+			{
+				id: "gpt-4o",
+				name: "GPT-4o",
+				contextK: 128,
+				vision: true,
+				flagship: true
+			},
+			{
+				id: "gpt-4o-mini",
+				name: "GPT-4o Mini",
+				contextK: 128,
+				fast: true
+			},
+			{
+				id: "o3",
+				name: "o3 (reasoning)",
+				contextK: 200,
+				reasoning: true
+			},
+			{
+				id: "o4-mini",
+				name: "o4-mini (reasoning)",
+				contextK: 200,
+				reasoning: true,
+				fast: true
+			}
+		]
+	},
+	{
+		id: "google",
+		displayName: "🔍 Google",
+		authType: "api_key",
+		authLabel: "Google AI API Key",
+		authHint: "aistudio.google.com/app/apikey",
+		supportsTranscription: true,
+		models: [
+			{
+				id: "gemini-2.5-pro",
+				name: "Gemini 2.5 Pro",
+				contextK: 1e3,
+				reasoning: true,
+				flagship: true
+			},
+			{
+				id: "gemini-2.0-flash",
+				name: "Gemini 2.0 Flash",
+				contextK: 1e3,
+				fast: true
+			},
+			{
+				id: "gemini-1.5-pro",
+				name: "Gemini 1.5 Pro",
+				contextK: 2e3
+			}
+		]
+	},
+	{
+		id: "xai",
+		displayName: "⚡ xAI (Grok)",
+		authType: "api_key",
+		authLabel: "xAI API Key",
+		authHint: "console.x.ai",
+		models: [{
+			id: "grok-3",
+			name: "Grok 3",
+			contextK: 131,
+			reasoning: true,
+			flagship: true
+		}, {
+			id: "grok-3-mini",
+			name: "Grok 3 Mini",
+			contextK: 131,
+			fast: true
+		}]
+	},
+	{
+		id: "minimax",
+		displayName: "🎯 MiniMax",
+		authType: "api_key",
+		authLabel: "MiniMax API Key",
+		authHint: "platform.minimaxi.com",
+		models: [{
+			id: "MiniMax-Text-01",
+			name: "MiniMax Text-01",
+			contextK: 1e3,
+			flagship: true
+		}, {
+			id: "abab6.5s-chat",
+			name: "ABAB 6.5S",
+			contextK: 245
+		}]
+	},
+	{
+		id: "moonshot",
+		displayName: "🌙 Moonshot (Kimi)",
+		authType: "api_key",
+		authLabel: "Moonshot API Key",
+		authHint: "platform.moonshot.cn",
+		models: [{
+			id: "moonshot-v1-128k",
+			name: "Moonshot v1 128K",
+			contextK: 128,
+			flagship: true
+		}, {
+			id: "moonshot-v1-8k",
+			name: "Moonshot v1 8K",
+			contextK: 8,
+			fast: true
+		}]
+	},
+	{
+		id: "qwen",
+		displayName: "🐉 Qwen (Alibaba)",
+		authType: "api_key",
+		authLabel: "DashScope API Key",
+		authHint: "dashscope.aliyuncs.com",
+		models: [
+			{
+				id: "qwen-max",
+				name: "Qwen Max",
+				contextK: 32,
+				flagship: true
+			},
+			{
+				id: "qwen-plus",
+				name: "Qwen Plus",
+				contextK: 128
+			},
+			{
+				id: "qwen-turbo",
+				name: "Qwen Turbo",
+				contextK: 128,
+				fast: true
+			},
+			{
+				id: "qwen3-235b-a22b",
+				name: "Qwen3 235B",
+				contextK: 32,
+				reasoning: true
+			}
+		]
+	},
+	{
+		id: "zai",
+		displayName: "🔧 Z.AI",
+		authType: "api_key",
+		authLabel: "Z.AI API Key",
+		authHint: "z.ai",
+		models: [{
+			id: "glm-4-plus",
+			name: "GLM-4 Plus",
+			contextK: 128,
+			flagship: true
+		}, {
+			id: "glm-4-flash",
+			name: "GLM-4 Flash",
+			contextK: 128,
+			fast: true
+		}]
+	},
+	{
+		id: "litellm",
+		displayName: "🔀 LiteLLM (proxy)",
+		authType: "api_key",
+		authLabel: "LiteLLM Master Key",
+		authHint: "Your self-hosted LiteLLM proxy key",
+		models: [{
+			id: "gpt-4o",
+			name: "GPT-4o (via proxy)",
+			contextK: 128,
+			flagship: true
+		}]
+	},
+	{
+		id: "cloudflare",
+		displayName: "☁️  Cloudflare AI Gateway",
+		authType: "api_key",
+		authLabel: "Cloudflare API Token",
+		authHint: "dash.cloudflare.com → AI → Gateway",
+		models: [{
+			id: "@cf/meta/llama-3.3-70b-instruct-fp8-fast",
+			name: "Llama 3.3 70B (CF)",
+			contextK: 128,
+			flagship: true
+		}]
+	},
+	{
+		id: "copilot",
+		displayName: "🤖 GitHub Copilot",
+		authType: "oauth",
+		authLabel: "GitHub OAuth Token",
+		authHint: "github.com/settings/tokens",
+		models: [{
+			id: "gpt-4o",
+			name: "GPT-4o (Copilot)",
+			contextK: 128,
+			flagship: true
+		}, {
+			id: "claude-sonnet-4-5",
+			name: "Claude Sonnet (Copilot)",
+			contextK: 200
+		}]
+	},
+	{
+		id: "custom",
+		displayName: "🔌 Custom (OpenAI-compatible API)",
+		authType: "api_key",
+		authLabel: "API Key",
+		authHint: "Any OpenAI-compatible /chat/completions API (e.g. Ads Power, Proxies, new LLM APIs)",
+		models: [{
+			id: "__manual__",
+			name: "Enter model ID manually",
+			contextK: 128,
+			flagship: true
+		}]
+	}
+];
+function getProvider(id) {
+	return PROVIDERS.find((p) => p.id === id);
+}
+/** Providers that support voice note transcription. Shown in wizard. */
+function getTranscriptionProviders() {
+	return PROVIDERS.filter((p) => p.supportsTranscription);
+}
+function formatModel(m) {
+	const badges = [];
+	if (m.flagship) badges.push(chalk.default.yellow("★"));
+	if (m.reasoning) badges.push(chalk.default.magenta("reasoning"));
+	if (m.fast) badges.push(chalk.default.green("fast"));
+	if (m.vision) badges.push(chalk.default.cyan("vision"));
+	const ctx = m.contextK >= 1e3 ? `${m.contextK}K` : `${m.contextK}K`;
+	return `${badges.join(" ")} ${m.name} ${chalk.default.gray(`ctx ${ctx}`)}`.trim();
+}
+
+//#endregion
+//#region src/cli/channels.ts
+const CHANNEL_DEFS = [
+	{
+		id: "telegram",
+		name: "Telegram",
+		emoji: "✈️",
+		requiresGateway: false,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Telegram Bot Token",
+		tokenHint: "Get from @BotFather → /newbot",
+		setupSteps: [
+			"1. Open Telegram → @BotFather → /newbot",
+			"2. Set name and username (must end in bot)",
+			"3. Copy the Bot Token",
+			"  🔗 t.me/BotFather"
+		],
+		npmPackage: "node-telegram-bot-api",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "discord",
+		name: "Discord",
+		emoji: "🎮",
+		requiresGateway: false,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Discord Bot Token",
+		tokenHint: "discord.com/developers/applications",
+		setupSteps: [
+			"1. discord.com/developers/applications → New Application",
+			"2. Bot → Add Bot → Reset Token",
+			"3. OAuth2 → General → copy Application ID",
+			"  🔗 discord.com/developers/applications"
+		],
+		extraFields: [{
+			name: "clientId",
+			label: "Client ID",
+			required: true
+		}],
+		npmPackage: "discord.js",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "whatsapp",
+		name: "WhatsApp",
+		emoji: "📱",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "WhatsApp Business API key",
+		tokenHint: "business.whatsapp.com",
+		setupSteps: [
+			"1. developers.facebook.com → My Apps → Create App",
+			"2. WhatsApp → API Setup → Access Token",
+			"  🔗 business.whatsapp.com"
+		],
+		npmPackage: "@whiskeysockets/baileys",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "slack",
+		name: "Slack",
+		emoji: "💼",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Slack Bot Token (xoxb-...)",
+		tokenHint: "api.slack.com/apps",
+		setupSteps: [
+			"1. api.slack.com/apps → Create App → Bot",
+			"2. Install App → copy Bot Token (xoxb-)",
+			"3. Basic Information → Signing Secret",
+			"  🔗 api.slack.com/apps"
+		],
+		extraFields: [{
+			name: "signingSecret",
+			label: "Signing Secret",
+			required: true
+		}],
+		defaultDMPolicy: "allowlist"
+	},
+	{
+		id: "signal",
+		name: "Signal",
+		emoji: "🔒",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["linux", "darwin"],
+		tokenLabel: "Registered phone number",
+		tokenHint: "Requires signal-cli installed",
+		setupSteps: [
+			"1. Install signal-cli or signald",
+			"2. Link your number (signal-cli link or signald register)",
+			"  🔗 github.com/AsamK/signal-cli"
+		],
+		notes: "Needs signal-cli + registered number",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "imessage",
+		name: "iMessage",
+		emoji: "🍏",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["darwin"],
+		tokenLabel: "BlueBubbles server password",
+		tokenHint: "bluebubbles.app on macOS",
+		setupSteps: [
+			"1. Install BlueBubbles on a Mac",
+			"2. Configure and connect",
+			"  🔗 bluebubbles.app"
+		],
+		notes: "macOS only via BlueBubbles",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "imessage-native",
+		name: "iMessage (imsg)",
+		emoji: "💬",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["darwin"],
+		tokenLabel: "Not required",
+		tokenHint: "Uses imsg CLI",
+		setupSteps: [
+			"1. Install imsg CLI: brew install steipete/imsg/imsg",
+			"2. No token required — uses native iMessage",
+			"  🔗 github.com/steipete/imsg"
+		],
+		notes: "macOS only, native via imsg CLI (github.com/steipete/imsg). No BlueBubbles.",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "matrix",
+		name: "Matrix",
+		emoji: "🔢",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Matrix access token",
+		tokenHint: "element.io → Settings → Help → Access Token",
+		setupSteps: [
+			"1. Element → Settings → Help & About → Access Token",
+			"2. Copy the access token",
+			"  🔗 element.io"
+		],
+		extraFields: [{
+			name: "homeserver",
+			label: "Homeserver URL",
+			hint: "https://matrix.org",
+			required: true
+		}, {
+			name: "userId",
+			label: "User ID (@user:server)",
+			required: true
+		}],
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "email",
+		name: "Email",
+		emoji: "📧",
+		requiresGateway: false,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Gmail app password or IMAP password",
+		tokenHint: "Use app-specific password",
+		setupSteps: [
+			"1. Enable IMAP/SMTP in your email provider",
+			"2. Use app password if you have 2FA",
+			"  🔗 Gmail: myaccount.google.com/apppasswords"
+		],
+		extraFields: [
+			{
+				name: "imapHost",
+				label: "IMAP host",
+				hint: "imap.gmail.com",
+				required: true
+			},
+			{
+				name: "smtpHost",
+				label: "SMTP host",
+				hint: "smtp.gmail.com",
+				required: true
+			},
+			{
+				name: "user",
+				label: "Email address",
+				required: true
+			}
+		],
+		defaultDMPolicy: "allowlist"
+	},
+	{
+		id: "feishu",
+		name: "Feishu/Lark",
+		emoji: "🪶",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Feishu App ID",
+		tokenHint: "open.feishu.cn",
+		setupSteps: [
+			"1. open.feishu.cn → Create application",
+			"2. Copy App ID and App Secret",
+			"  🔗 open.feishu.cn"
+		],
+		extraFields: [{
+			name: "appSecret",
+			label: "App Secret",
+			required: true
+		}],
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "msteams",
+		name: "MS Teams",
+		emoji: "🟦",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Azure Bot App ID",
+		tokenHint: "portal.azure.com → Bot Services",
+		setupSteps: [
+			"1. dev.botframework.com → Register Bot",
+			"2. Azure Bot → Configuration → copy App ID & Secret",
+			"  🔗 dev.botframework.com"
+		],
+		extraFields: [{
+			name: "appPassword",
+			label: "App Password",
+			required: true
+		}],
+		defaultDMPolicy: "allowlist"
+	},
+	{
+		id: "messenger",
+		name: "Messenger",
+		emoji: "💬",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Page Access Token",
+		tokenHint: "developers.facebook.com",
+		setupSteps: [
+			"1. developers.facebook.com → My Apps → Create App",
+			"2. Add Messenger product → Page Access Token",
+			"  🔗 developers.facebook.com"
+		],
+		extraFields: [{
+			name: "verifyToken",
+			label: "Webhook Verify Token",
+			required: true
+		}],
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "nostr",
+		name: "Nostr",
+		emoji: "🌐",
+		requiresGateway: false,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Nostr private key (hex or nsec)",
+		tokenHint: "Generate with: openssl rand -hex 32",
+		setupSteps: [
+			"1. Use existing nostr client or generate new keypair",
+			"2. Copy nsec (private key)",
+			"  🔗 nostr.com"
+		],
+		notes: "Decentralized — no account needed",
+		defaultDMPolicy: "open"
+	},
+	{
+		id: "line",
+		name: "LINE",
+		emoji: "💚",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "LINE Channel Access Token",
+		tokenHint: "developers.line.biz",
+		setupSteps: [
+			"1. developers.line.biz → Add Messaging API channel",
+			"2. Copy Channel Secret & Access Token",
+			"  🔗 developers.line.biz"
+		],
+		extraFields: [{
+			name: "channelSecret",
+			label: "Channel Secret",
+			required: true
+		}],
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "viber",
+		name: "Viber",
+		emoji: "💜",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Viber Auth Token",
+		tokenHint: "partners.viber.com",
+		setupSteps: [
+			"1. partners.viber.com → Create Bot",
+			"2. Copy the Auth Token",
+			"  🔗 partners.viber.com"
+		],
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "zalo",
+		name: "Zalo OA",
+		emoji: "🔵",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Zalo OA Access Token",
+		tokenHint: "developers.zalo.me",
+		setupSteps: [
+			"1. developers.zalo.me → Create application",
+			"2. Copy App ID and Access Token",
+			"  🔗 developers.zalo.me"
+		],
+		extraFields: [{
+			name: "secretKey",
+			label: "Secret Key",
+			required: true
+		}],
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "twitter",
+		name: "Twitter/X DM",
+		emoji: "🐦",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Twitter API Key",
+		tokenHint: "developer.twitter.com",
+		setupSteps: [
+			"1. developer.twitter.com → Developer Portal",
+			"2. Create Project & App → copy API keys",
+			"  🔗 developer.twitter.com"
+		],
+		extraFields: [
+			{
+				name: "apiKeySecret",
+				label: "API Key Secret",
+				required: true
+			},
+			{
+				name: "accessToken",
+				label: "Access Token",
+				required: true
+			},
+			{
+				name: "accessTokenSecret",
+				label: "Access Token Secret",
+				required: true
+			}
+		],
+		defaultDMPolicy: "allowlist"
+	},
+	{
+		id: "irc",
+		name: "IRC",
+		emoji: "📡",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "NickServ password (optional)",
+		tokenHint: "freenode, libera.chat, etc.",
+		setupSteps: [
+			"1. Choose IRC server (e.g. irc.libera.chat)",
+			"2. Configure nick and password if needed",
+			"  🔗 libera.chat"
+		],
+		extraFields: [{
+			name: "server",
+			label: "IRC server",
+			hint: "irc.libera.chat",
+			required: true
+		}, {
+			name: "nick",
+			label: "Nickname",
+			required: true
+		}],
+		defaultDMPolicy: "allowlist"
+	},
+	{
+		id: "mattermost",
+		name: "Mattermost",
+		emoji: "🏗️",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Mattermost bot token",
+		tokenHint: "Settings → Integrations → Bot Accounts",
+		setupSteps: [
+			"1. Mattermost → Account Settings → Security → Personal Access Tokens",
+			"2. Create token and copy it",
+			"  🔗 docs.mattermost.com"
+		],
+		extraFields: [{
+			name: "serverUrl",
+			label: "Server URL",
+			required: true
+		}],
+		defaultDMPolicy: "allowlist"
+	},
+	{
+		id: "nextcloud",
+		name: "Nextcloud Talk",
+		emoji: "☁️",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Nextcloud app password",
+		tokenHint: "Your Nextcloud server",
+		setupSteps: [
+			"1. Nextcloud Admin → OAuth → new client",
+			"2. Talk → view bot credentials",
+			"  🔗 nextcloud.com"
+		],
+		extraFields: [{
+			name: "serverUrl",
+			label: "Nextcloud URL",
+			required: true
+		}, {
+			name: "username",
+			label: "Username",
+			required: true
+		}],
+		defaultDMPolicy: "allowlist"
+	},
+	{
+		id: "googlechat",
+		name: "Google Chat",
+		emoji: "🔵",
+		requiresGateway: true,
+		supportsDM: false,
+		platforms: ["all"],
+		tokenLabel: "Google Chat Webhook URL",
+		tokenHint: "chat.google.com → Space → Apps & Integrations",
+		setupSteps: [
+			"1. chat.google.com → Space → Apps & Integrations → Manage webhooks",
+			"2. Add webhook and copy the URL",
+			"  🔗 chat.google.com"
+		],
+		defaultDMPolicy: "none"
+	},
+	{
+		id: "whatsapp-baileys",
+		name: "WhatsApp (Baileys)",
+		emoji: "📲",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Not required — scans QR code on first run",
+		setupSteps: [
+			"1. No Meta Business API needed — uses WhatsApp Web protocol",
+			"2. Start the gateway — a QR code will appear in the terminal",
+			"3. Open WhatsApp on your phone → Linked Devices → Link a device",
+			"4. Scan the QR code. Session is saved — no QR needed on future starts",
+			"  🔗 github.com/WhiskeySockets/Baileys"
+		],
+		notes: "WhatsApp Web via Baileys — no Meta Business needed. QR scan on first run.",
+		npmPackage: "@whiskeysockets/baileys",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "instagram",
+		name: "Instagram DMs",
+		emoji: "📸",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Meta Page Access Token",
+		tokenHint: "developers.facebook.com → Instagram product",
+		setupSteps: [
+			"1. Meta for Developers → My Apps → Create App → Business",
+			"2. Add Instagram product → Connect Instagram Business account",
+			"3. Webhooks: subscribe to messages, URL: https://<host>/webhook/instagram",
+			"4. Copy Page Access Token from Graph API Explorer (pages_messaging scope)",
+			"  🔗 developers.facebook.com"
+		],
+		extraFields: [{
+			name: "instagramAccountId",
+			label: "Instagram Business Account ID",
+			required: true
+		}, {
+			name: "verifyToken",
+			label: "Webhook Verify Token (any string)",
+			required: true
+		}],
+		notes: "Requires Instagram Business + Meta App",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "zalo-personal",
+		name: "Zalo Personal",
+		emoji: "🔵",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Zalo cookie token",
+		tokenHint: "Extracted from browser session",
+		setupSteps: [
+			"1. Open Zalo Web in browser (chat.zalo.me)",
+			"2. Open DevTools → Application → Cookies → find zpw_sek or _zlang",
+			"3. Copy the session cookie value",
+			"  ⚠  Unofficial API — may break on Zalo updates. Use at your own risk."
+		],
+		notes: "Unofficial — uses Zalo Personal API. May break on updates.",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "voice-call",
+		name: "Voice Call",
+		emoji: "🎙️",
+		requiresGateway: true,
+		supportsDM: false,
+		platforms: ["all"],
+		tokenLabel: "Not required",
+		setupSteps: [
+			"1. No external account needed",
+			"2. Requires microphone + ElevenLabs API key for TTS (optional)",
+			"3. Start with: hyperclaw voice-call",
+			"  💡 Works in terminal — voice input → agent → voice output"
+		],
+		notes: "Terminal voice session — hyperclaw voice-call",
+		defaultDMPolicy: "none"
+	},
+	{
+		id: "web",
+		name: "WebChat UI",
+		emoji: "🌐",
+		requiresGateway: true,
+		supportsDM: false,
+		platforms: ["all"],
+		setupSteps: [
+			"1. Built-in — no setup needed",
+			"2. Start gateway: hyperclaw gateway",
+			"3. Open: http://localhost:<port>/dashboard",
+			"  💡 Works in any browser on your local network"
+		],
+		notes: "Built-in WebChat at http://localhost:<port>",
+		defaultDMPolicy: "none"
+	},
+	{
+		id: "cli",
+		name: "CLI / Terminal",
+		emoji: "🖥️",
+		requiresGateway: false,
+		supportsDM: false,
+		platforms: ["all"],
+		setupSteps: [
+			"1. Always active — no setup needed",
+			"2. Use: hyperclaw chat  or  hyperclaw agent --message \"...\"",
+			"  💡 Works offline without any channel configured"
+		],
+		notes: "Always active — hyperclaw chat",
+		defaultDMPolicy: "none"
+	},
+	{
+		id: "chrome-extension",
+		name: "Chrome Extension",
+		emoji: "🔌",
+		requiresGateway: true,
+		supportsDM: false,
+		platforms: ["all"],
+		setupSteps: [
+			"1. Open Chrome → chrome://extensions → Enable Developer mode",
+			"2. Load unpacked → select: extensions/chrome-extension/",
+			"3. Extension connects to gateway via WebSocket automatically",
+			"  💡 Gives the agent access to your browser context"
+		],
+		notes: "Load extensions/chrome-extension/ as unpacked extension in Chrome",
+		defaultDMPolicy: "none"
+	},
+	{
+		id: "synology-chat",
+		name: "Synology Chat",
+		emoji: "🖥️",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Incoming Webhook URL",
+		tokenHint: "DSM → Synology Chat → Integration → Incoming Webhooks",
+		setupSteps: [
+			"1. Open Synology Chat (DSM package)",
+			"2. Top-right menu → Integration → Incoming Webhooks → Create",
+			"3. Copy the Webhook URL (used to POST messages from HyperClaw)",
+			"4. Outgoing Webhook: Integration → Outgoing Webhooks → Create",
+			"     URL: http://<your-server>:7789/synology-hook",
+			"     Method: POST",
+			"  🔗 kb.synology.com/synologychat"
+		],
+		extraFields: [{
+			name: "webhookPort",
+			label: "Outgoing webhook port",
+			hint: "7789",
+			required: false
+		}, {
+			name: "webhookToken",
+			label: "Outgoing webhook token (optional HMAC)",
+			required: false
+		}],
+		notes: "Requires Synology Chat installed on your Synology NAS (DSM 7+)",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "tlon",
+		name: "Tlon (Urbit)",
+		emoji: "🪐",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Urbit login code",
+		tokenHint: "From your Urbit ship: +code",
+		setupSteps: [
+			"1. Start your Urbit ship (e.g. via Port or urbit binary)",
+			"2. In the Dojo: +code  → copy the code",
+			"3. Note your ship name (e.g. ~sampel-palnet) and ship URL",
+			"4. Optionally configure a group: ~sampel-palnet/my-group",
+			"  🔗 tlon.io · urbit.org/getting-started"
+		],
+		extraFields: [
+			{
+				name: "shipUrl",
+				label: "Ship URL",
+				hint: "http://localhost:8080",
+				required: true
+			},
+			{
+				name: "ship",
+				label: "Ship name",
+				hint: "~sampel-palnet",
+				required: true
+			},
+			{
+				name: "group",
+				label: "Group path (optional)",
+				hint: "~sampel-palnet/my-group",
+				required: false
+			}
+		],
+		notes: "Requires a running Urbit ship with Tlon/Groups installed",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "twitch",
+		name: "Twitch",
+		emoji: "🟣",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "OAuth token (oauth:xxxxxxx)",
+		tokenHint: "twitchapps.com/tmi → connect with your bot account",
+		setupSteps: [
+			"1. Create a Twitch bot account (or use your own)",
+			"2. Go to: twitchapps.com/tmi → Connect → copy the OAuth token",
+			"3. Token format: oauth:xxxxxxxxxxxxxxxxxxxxxx",
+			"4. Bot username = the Twitch account you logged in with",
+			"  💡 To receive commands, users type: !<message>",
+			"  💡 Moderators and the broadcaster bypass the allowlist by default",
+			"  🔗 twitchapps.com/tmi"
+		],
+		extraFields: [
+			{
+				name: "username",
+				label: "Bot Twitch username (lowercase)",
+				required: true
+			},
+			{
+				name: "channels",
+				label: "Channel(s) to join (comma-separated)",
+				hint: "mychannel or mychannel,otherchannel",
+				required: true
+			},
+			{
+				name: "commandPrefix",
+				label: "Command prefix",
+				hint: "! (default)",
+				required: false
+			}
+		],
+		notes: "Chat-based; uses Twitch IRC over WebSocket. Command prefix required (default: !)",
+		defaultDMPolicy: "pairing"
+	}
+];
+async function getChannelStatus(def, configuredIds) {
+	const platform = os.default.platform();
+	if (!def.platforms.includes("all") && !def.platforms.includes(platform)) return "unavailable";
+	if (configuredIds.includes(def.id)) return "configured";
+	if (["telegram", "discord"].includes(def.id)) return "recommended";
+	return "available";
+}
+/** Human-readable reason why a channel is unavailable on this OS */
+function unavailableReason(def) {
+	const platform = os.default.platform();
+	if (def.platforms.length === 1 && def.platforms[0] === "darwin") return "macOS only";
+	if (def.platforms.includes("linux") && def.platforms.includes("darwin") && !def.platforms.includes("win32")) return "Linux/macOS only";
+	if (!def.platforms.includes("all") && !def.platforms.includes(platform)) return `not supported on ${platform}`;
+	return "unavailable on this OS";
+}
+function statusBadge(status, def) {
+	switch (status) {
+		case "configured": return chalk.default.green("[configured]");
+		case "recommended": return chalk.default.cyan("[recommended]");
+		case "available": return chalk.default.gray("[available]");
+		case "unavailable": {
+			const reason = def ? unavailableReason(def) : "unavailable";
+			return chalk.default.red(`[${reason}]`);
+		}
+	}
+}
+const CHANNELS = CHANNEL_DEFS;
+async function getAvailableChannels(configuredIds = []) {
+	const result = [];
+	for (const def of CHANNEL_DEFS) {
+		const status = await getChannelStatus(def, configuredIds);
+		result.push({
+			...def,
+			status
+		});
+	}
+	return result;
+}
+
+//#endregion
+//#region src/cli/memory.ts
+const HC_DIR = path.default.join(os.default.homedir(), ".hyperclaw");
+const AGENTS_FILE = path.default.join(HC_DIR, "AGENTS.md");
+const MEMORY_FILE = path.default.join(HC_DIR, "MEMORY.md");
+const SOUL_FILE = path.default.join(HC_DIR, "SOUL.md");
+const LOG_DIR = path.default.join(HC_DIR, "logs");
+var MemoryManager = class {
+	async init(opts = {}) {
+		await fs_extra.default.ensureDir(HC_DIR);
+		await fs_extra.default.ensureDir(LOG_DIR);
+		const agentName = opts.agentName || "HyperClaw";
+		const userName = opts.userName || os.default.userInfo().username;
+		const lang = opts.language || "English";
+		const personality = opts.personality || "Direct and efficient, helpful without being sycophantic, honest about uncertainty";
+		const rules = opts.rules && opts.rules.length > 0 ? opts.rules.map((r, i) => `${i + 1}. ${r}`).join("\n") : `1. Always respond in the user's preferred language unless asked otherwise
+2. Be concise unless detail is explicitly requested
+3. Never share API keys, tokens, or secrets in responses
+4. If unsure, ask before acting — especially for destructive operations
+5. Log all PC access actions to ~/.hyperclaw/pc-access.log`;
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		if (!await fs_extra.default.pathExists(AGENTS_FILE)) await fs_extra.default.writeFile(AGENTS_FILE, `# AGENTS.md — Global Rules
+> All sessions and subagents must follow these rules.
+
+## Identity
+- Agent name: ${agentName}
+- User name: ${userName}
+- Primary language: ${lang}
+- Created: ${today}
+
+## Behavior Rules
+${rules}
+
+## DM Policy Default
+- Require pairing before responding to unknown senders
+- Allowlist: (add trusted IDs here)
+
+## Hierarchy
+- SOUL.md: persona and values (read-only by subagents)
+- AGENTS.md: operational rules (this file)
+- MEMORY.md: accumulated facts about the user
+`);
+		if (!await fs_extra.default.pathExists(MEMORY_FILE)) await fs_extra.default.writeFile(MEMORY_FILE, `# MEMORY.md — User Context
+> Automatically updated by HyperClaw after each session.
+
+## User Profile
+- Name: ${userName}
+- Language: ${lang}
+- Initialized: ${today}
+
+## Notes
+(auto-populated from conversations)
+`);
+		if (!await fs_extra.default.pathExists(SOUL_FILE)) await fs_extra.default.writeFile(SOUL_FILE, `# SOUL.md — Agent Persona
+> Who I am and how I behave.
+
+## Name
+${agentName}
+
+## Personality
+- ${personality.replace(/\n/g, "\n- ")}
+
+## Values
+- User autonomy first
+- Do no harm
+- Transparency about capabilities and limits
+
+## Wake phrase
+${opts.wakeWord ? opts.wakeWord : `Wake up, ${agentName}! Your user ${userName} needs you.`}
+`);
+		const logFile = path.default.join(LOG_DIR, `${today}.md`);
+		if (!await fs_extra.default.pathExists(logFile)) await fs_extra.default.writeFile(logFile, `# Session Log — ${today}\n\n`);
+	}
+	async load() {
+		if (!await fs_extra.default.pathExists(AGENTS_FILE)) return null;
+		const agents = await fs_extra.default.readFile(AGENTS_FILE, "utf8").catch(() => "");
+		const memory = await fs_extra.default.readFile(MEMORY_FILE, "utf8").catch(() => "");
+		const soul = await fs_extra.default.readFile(SOUL_FILE, "utf8").catch(() => void 0);
+		return {
+			agents,
+			memory,
+			soul
+		};
+	}
+	async appendRule(rule) {
+		await fs_extra.default.ensureDir(HC_DIR);
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const line = `\n- ${today}: ${rule}\n`;
+		await fs_extra.default.appendFile(AGENTS_FILE, line);
+		console.log(chalk.default.green(`  ✅ Rule added to AGENTS.md: ${rule}`));
+	}
+	async addMemory(fact) {
+		await fs_extra.default.ensureDir(HC_DIR);
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		await fs_extra.default.appendFile(MEMORY_FILE, `\n- ${today}: ${fact}\n`);
+		console.log(chalk.default.green(`  ✅ Memory saved: ${fact}`));
+	}
+	async updateSoul(content) {
+		await fs_extra.default.ensureDir(HC_DIR);
+		await fs_extra.default.writeFile(SOUL_FILE, content);
+		console.log(chalk.default.green("  ✅ SOUL.md updated"));
+	}
+	async show() {
+		const data = await this.load();
+		if (!data) {
+			console.log(chalk.default.yellow("\n  No memory initialized. Run: hyperclaw init\n"));
+			return;
+		}
+		console.log(chalk.default.bold.cyan("\n  🧠 MEMORY\n"));
+		for (const [label, content] of [
+			["SOUL.md", data.soul],
+			["AGENTS.md", data.agents],
+			["MEMORY.md", data.memory]
+		]) {
+			if (!content) continue;
+			console.log(chalk.default.bold.white(`  ── ${label} ──`));
+			const lines = content.split("\n").slice(0, 20);
+			for (const line of lines) if (line.startsWith("#")) console.log(chalk.default.cyan(`  ${line}`));
+			else if (line.startsWith("-")) console.log(chalk.default.gray(`  ${line}`));
+			else console.log(`  ${line}`);
+			console.log();
+		}
+	}
+	async runPersonaBootstrap() {
+		console.log(chalk.default.bold.cyan("\n  🌅 Wake up, my friend!\n"));
+		const { agentName } = await inquirer.default.prompt([{
+			type: "input",
+			name: "agentName",
+			message: "What should I call myself? (agent name)",
+			default: "HyperClaw"
+		}]);
+		const { userName } = await inquirer.default.prompt([{
+			type: "input",
+			name: "userName",
+			message: `What shall ${agentName} call you?`,
+			default: os.default.userInfo().username
+		}]);
+		console.log(chalk.default.green(`\n  ✨ I am ${agentName}. Hello, ${userName}.\n`));
+		return {
+			agentName,
+			userName
+		};
+	}
+	async getContextForAI() {
+		let context = "";
+		for (const [label, file] of [
+			["SOUL", SOUL_FILE],
+			["AGENTS", AGENTS_FILE],
+			["MEMORY", MEMORY_FILE]
+		]) if (await fs_extra.default.pathExists(file)) {
+			const content = await fs_extra.default.readFile(file, "utf8");
+			context += `## ${label}.md\n${content}\n\n`;
+		}
+		return context;
+	}
+	async search(query) {
+		const data = await this.load();
+		if (!data) {
+			console.log(chalk.default.gray("  No memory\n"));
+			return;
+		}
+		const allText = [
+			data.agents,
+			data.memory,
+			data.soul || ""
+		].join("\n");
+		const lines = allText.split("\n").filter((l) => l.toLowerCase().includes(query.toLowerCase()));
+		if (lines.length === 0) {
+			console.log(chalk.default.gray(`  Nothing found for "${query}"\n`));
+			return;
+		}
+		console.log(chalk.default.bold.cyan(`\n  🔍 "${query}"\n`));
+		lines.forEach((l) => console.log(`  ${l}`));
+		console.log();
+	}
+	async clear(file = "memory") {
+		const { confirm } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "confirm",
+			message: `Clear ${file === "all" ? "ALL memory files" : "MEMORY.md"}?`,
+			default: false
+		}]);
+		if (!confirm) return;
+		if (file === "all") {
+			await fs_extra.default.remove(AGENTS_FILE);
+			await fs_extra.default.remove(MEMORY_FILE);
+			await fs_extra.default.remove(SOUL_FILE);
+			console.log(chalk.default.green("  ✅ All memory cleared"));
+		} else {
+			await fs_extra.default.writeFile(MEMORY_FILE, "# MEMORY.md\n\n");
+			console.log(chalk.default.green("  ✅ MEMORY.md cleared"));
+		}
+	}
+};
+
+//#endregion
+//#region src/cli/security.ts
+async function showSecurityDisclaimer() {
+	console.clear();
+	console.log(chalk.default.bgRed.white.bold("\n  ⚠️  SECURITY NOTICE — READ CAREFULLY  ⚠️ \n"));
+	console.log(chalk.default.white.bold("  A bad prompt can trick it into doing unsafe things\n"));
+	console.log(chalk.default.hex("#06b6d4")("  Protections to enable:"));
+	console.log(chalk.default.gray("  ● Pairing / allowlists  — limit who can DM your agent"));
+	console.log(chalk.default.gray("  ● Sandbox + least privilege  — restrict PC access level"));
+	console.log(chalk.default.gray("  ● Keep secrets out  — never put tokens in SOUL.md"));
+	console.log(chalk.default.gray("  ● Use strongest model  — smarter = better at refusing tricks\n"));
+	const { understood } = await inquirer.default.prompt([{
+		type: "confirm",
+		name: "understood",
+		message: chalk.default.bold("I understand this is powerful and inherently risky. Continue?"),
+		default: false
+	}]);
+	if (!understood) console.log(chalk.default.gray("\n  Aborted. Come back when ready.\n"));
+	return understood;
+}
+async function configureDMPolicy(channelName) {
+	const { configureDMPolicy: cdmp } = await Promise.resolve().then(() => require("./security-EQ5o-nr4.js"));
+	const res = await cdmp(channelName);
+	return {
+		dmPolicy: res.policy,
+		allowFrom: res.allowFrom ?? []
+	};
+}
+
+//#endregion
+//#region src/terminal/banner.ts
+require_theme.init_theme();
+var Banner = class {
+	async showNeonBanner(daemonMode = false) {
+		console.clear();
+		const t = require_theme.getTheme(daemonMode);
+		const icon$1 = daemonMode ? "🩸" : "🦅";
+		try {
+			const title = figlet.default.textSync("HYPERCLAW", { font: "ANSI Shadow" });
+			const g = (0, gradient_string.default)(t.gradient);
+			const lines = title.split("\n");
+			const first = lines[0] ?? "";
+			console.log(`\n  ${icon$1} ` + g(first));
+			for (let i = 1; i < lines.length; i++) console.log(g("     " + (lines[i] ?? "")));
+		} catch {
+			console.log(chalk.default.bold.red(`\n  ${icon$1} HYPERCLAW\n`));
+		}
+		const subtitle = daemonMode ? chalk.default.hex(t.daemonPrimary)("    🩸 DAEMON MODE — ALWAYS WATCHING ⚡\n") : t.muted("    🦅 HyperClaw Bot — AI Gateway v4.0.1 ⚡\n");
+		console.log(subtitle);
+		const boxOpts = {
+			padding: 1,
+			margin: {
+				top: 1,
+				bottom: 1
+			},
+			borderStyle: "round",
+			borderColor: daemonMode ? t.daemonBorderColor : t.borderColor
+		};
+		if (t.boxBg) boxOpts.backgroundColor = t.boxBg;
+		const box = (0, boxen.default)(`${t.a("●")} GATEWAY READY    ${t.a("◆")} PROVIDERS: 8    ${t.a("⚡")} CHANNELS: 27    ` + (daemonMode ? `${t.d("🩸")} DAEMON` : `${t.a("🦅")} HYPERCLAW`), boxOpts);
+		console.log(box);
+		console.log(t.muted("  One assistant. All your channels. 🦅\n"));
+		const { maybeShowUpdateNotice } = await Promise.resolve().then(() => require("./update-check-BQOH_-LD.js"));
+		maybeShowUpdateNotice(daemonMode);
+	}
+	async showMiniBanner() {
+		await this.showNeonBanner(false);
+	}
+	async showWizardBanner() {
+		console.clear();
+		const t = require_theme.getTheme(false);
+		const g = (0, gradient_string.default)(t.gradient);
+		try {
+			const title = figlet.default.textSync("HYPERCLAW", { font: "ANSI Shadow" });
+			const lines = title.split("\n");
+			const first = lines[0] ?? "";
+			console.log("\n  🦅 " + g(first));
+			for (let i = 1; i < lines.length; i++) console.log(g("     " + (lines[i] ?? "")));
+		} catch {
+			console.log(t.bold("\n  🦅 HYPERCLAW\n"));
+		}
+		console.log(t.muted("    🦅 HyperClaw Bot — AI Gateway • SETUP WIZARD v4.0.1 ⚡\n"));
+		const boxOpts = {
+			padding: 1,
+			margin: { bottom: 1 },
+			borderStyle: "round",
+			borderColor: t.borderColor
+		};
+		if (t.boxBg) boxOpts.backgroundColor = t.boxBg;
+		const box = (0, boxen.default)(t.a("◆") + " Provider • Channels • Gateway • Identity", boxOpts);
+		console.log(box);
+	}
+	async showStatus() {
+		const t = require_theme.getTheme(false);
+		const { ConfigManager } = await Promise.resolve().then(() => require("./manager-BX2lIsmk.js"));
+		const { GatewayManager: GatewayManager$1 } = await Promise.resolve().then(() => require("./manager-UY7MecrN.js"));
+		const cfg = await new ConfigManager().load();
+		const gm = new GatewayManager$1();
+		const port = cfg?.gateway?.port ?? 18789;
+		const running = await gm.isRunning(port);
+		console.log(t.bold("\n  🦅 HYPERCLAW STATUS\n"));
+		console.log(`  Gateway: ${running ? t.success("● running") : t.error("○ stopped")}  port ${port}`);
+		console.log(`  Provider: ${t.c(cfg?.provider?.providerId ?? "none")}`);
+		console.log(`  Channels: ${t.c(String((cfg?.channels ?? []).length))}`);
+		console.log();
+	}
+};
+
+//#endregion
+//#region src/infra/channel-icons.ts
+const CDN = "https://cdn.simpleicons.org";
+function icon(slug, name, color, darkColor) {
+	return {
+		slug,
+		name,
+		color,
+		url: `${CDN}/${slug}`,
+		darkColor
+	};
+}
+const CHANNEL_ICONS = {
+	"telegram": icon("telegram", "Telegram", "26A5E4"),
+	"discord": icon("discord", "Discord", "5865F2"),
+	"whatsapp": icon("whatsapp", "WhatsApp", "25D366"),
+	"whatsapp-baileys": icon("whatsapp", "WhatsApp (Baileys)", "25D366"),
+	"slack": icon("slack", "Slack", "4A154B"),
+	"signal": icon("signal", "Signal", "3A76F0", "FFFFFF"),
+	"imessage": icon("imessage", "iMessage", "29CC40"),
+	"imessage-native": icon("imessage", "iMessage (native)", "29CC40"),
+	"matrix": icon("matrix", "Matrix", "000000", "FFFFFF"),
+	"email": icon("gmail", "Email", "EA4335"),
+	"feishu": icon("lark", "Feishu / Lark", "00D6B9"),
+	"msteams": icon("microsoftteams", "Microsoft Teams", "6264A7"),
+	"messenger": icon("messenger", "Facebook Messenger", "00B2FF"),
+	"nostr": icon("nostr", "Nostr", "8E44AD", "C39BD3"),
+	"line": icon("line", "LINE", "00C300"),
+	"viber": icon("viber", "Viber", "7360F2"),
+	"zalo": icon("zalo", "Zalo", "0068FF"),
+	"zalo-personal": icon("zalo", "Zalo Personal", "0068FF"),
+	"twitter": icon("x", "Twitter / X", "000000", "FFFFFF"),
+	"irc": icon("irc", "IRC", "1A3B5C", "FFFFFF"),
+	"mattermost": icon("mattermost", "Mattermost", "0058CC"),
+	"nextcloud": icon("nextcloud", "Nextcloud Talk", "0082C9"),
+	"googlechat": icon("googlechat", "Google Chat", "00897B"),
+	"instagram": icon("instagram", "Instagram", "E4405F"),
+	"synology-chat": icon("synology", "Synology Chat", "B5B5B6", "FFFFFF"),
+	"tlon": icon("urbit", "Tlon (Urbit)", "000000", "FFFFFF"),
+	"twitch": icon("twitch", "Twitch", "9146FF"),
+	"voice-call": icon("webrtc", "Voice Call", "333333", "FFFFFF"),
+	"web": icon("googlechrome", "WebChat", "4285F4"),
+	"cli": icon("gnubash", "CLI / Terminal", "4EAA25", "FFFFFF"),
+	"chrome-extension": icon("googlechrome", "Chrome Extension", "4285F4")
+};
+const PROVIDER_ICONS = {
+	"anthropic": icon("anthropic", "Anthropic (Claude)", "D4C5A9", "191919"),
+	"openai": icon("openai", "OpenAI", "000000", "FFFFFF"),
+	"openrouter": icon("openrouter", "OpenRouter", "6467F2"),
+	"groq": icon("groq", "Groq", "F55036"),
+	"xai": icon("x", "xAI (Grok)", "000000", "FFFFFF"),
+	"custom": icon("jsonwebtokens", "Custom OpenAI API", "A0A0A0"),
+	"ollama": icon("ollama", "Ollama (local)", "000000", "FFFFFF"),
+	"mistral": icon("mistral", "Mistral AI", "FF7000"),
+	"cohere": icon("cohere", "Cohere", "39594D", "FFFFFF"),
+	"google": icon("googlegemini", "Google Gemini", "8E75B2"),
+	"deepseek": icon("deepseek", "DeepSeek", "4D6BFE"),
+	"together": icon("togetherai", "Together AI", "000000", "FFFFFF")
+};
+
+//#endregion
+//#region src/cli/onboard.ts
+/** Brand-colored ■ square — closest we can get to a real icon in a terminal */
+function brandIcon(id, type = "channel") {
+	const map = type === "channel" ? CHANNEL_ICONS : PROVIDER_ICONS;
+	const ic = map[id];
+	if (!ic) return chalk.default.gray("■");
+	return chalk.default.hex("#" + ic.color)("■");
+}
+var HyperClawWizard = class {
+	config = new ConfigStore();
+	daemon = new DaemonManager();
+	gateway = new GatewayManager();
+	async run(options) {
+		const proceed = await showSecurityDisclaimer();
+		if (!proceed) return;
+		const { allThemes, getThemeName, setThemeName } = await Promise.resolve().then(() => require("./theme-Iefa3L63.js"));
+		const currentTheme = getThemeName();
+		const { chosenTheme } = await inquirer.default.prompt([{
+			type: "list",
+			name: "chosenTheme",
+			message: "🎨 Choose a color theme:",
+			default: currentTheme,
+			choices: [
+				{
+					name: `${chalk.default.hex("#06b6d4")("■")} Dark Professional   ${chalk.default.gray("(neon cyan on black)")}`,
+					value: "dark"
+				},
+				{
+					name: `${chalk.default.hex("#64748b")("■")} Grey Professional   ${chalk.default.gray("(muted cyan, neutral)")}`,
+					value: "grey"
+				},
+				{
+					name: `${chalk.default.hex("#0284c7")("■")} White / Light       ${chalk.default.gray("(deep cyan, light bg)")}`,
+					value: "white"
+				}
+			]
+		}]);
+		if (chosenTheme !== currentTheme) await setThemeName(chosenTheme);
+		await new Banner().showWizardBanner();
+		const { mode } = await inquirer.default.prompt([{
+			type: "list",
+			name: "mode",
+			message: "Setup mode:",
+			choices: [{
+				name: `${chalk.default.green("★")} QuickStart        ${chalk.default.gray("(Recommended)")}`,
+				value: "quick"
+			}, {
+				name: `  Manual            ${chalk.default.gray("(Full control)")}`,
+				value: "manual"
+			}]
+		}]);
+		if (mode === "quick") return this.quickSetup(options);
+		return this.fullSetup(options);
+	}
+	async quickstart(options) {
+		const proceed = await showSecurityDisclaimer();
+		if (!proceed) return;
+		return this.quickSetup(options);
+	}
+	stepHeader(n, total, title) {
+		const { getTheme: getTheme$1 } = (require_theme.init_theme(), require_chunk.__toCommonJS(require_theme.theme_exports));
+		const t = getTheme$1(false);
+		const bar = chalk.default.gray("─".repeat(52));
+		console.log(`\n${bar}`);
+		console.log(`  ${t.c(`Step ${n} / ${total}`)}  ·  ${chalk.default.bold(title)}`);
+		console.log(`${bar}\n`);
+	}
+	async quickSetup(options) {
+		const STEPS = 7;
+		this.stepHeader(1, STEPS, "Workspace");
+		const { workspaceName } = await inquirer.default.prompt([{
+			type: "input",
+			name: "workspaceName",
+			message: "Workspace name:",
+			default: "my-hyperclaw"
+		}]);
+		this.stepHeader(2, STEPS, "AI Providers & Models");
+		const { providers: allProviders, primary: providerConfig } = await this.selectProvidersAndModels();
+		this.stepHeader(3, STEPS, "Gateway (optional)");
+		const gatewayConfig = await this.configureGateway(false);
+		this.stepHeader(4, STEPS, "Channels");
+		const channelConfigs = await this.selectChannels();
+		this.stepHeader(5, STEPS, "Agent Identity & Persona");
+		const identity = await this.configureIdentity();
+		this.stepHeader(6, STEPS, "Skills & Hooks");
+		const { hooks, heartbeat: heartbeatEnabled } = await this.configureSkillsAndHooks();
+		this.stepHeader(7, STEPS, "Extras");
+		const memoryIntegration = await this.configureMemoryIntegration();
+		const serviceApiKeys = await this.configureServiceApiKeys();
+		const hyperclawbotConfig = await this.configureHyperClawBot(gatewayConfig);
+		const talkModeConfig = await this.configureTalkMode();
+		await this.saveAll({
+			workspaceName,
+			providerConfig,
+			providers: allProviders,
+			channelConfigs,
+			gatewayConfig,
+			identity,
+			hooks,
+			heartbeatEnabled,
+			memoryIntegration,
+			serviceApiKeys,
+			hyperclawbotConfig,
+			talkModeConfig
+		}, options);
+	}
+	async fullSetup(options) {
+		const STEPS = 9;
+		this.stepHeader(1, STEPS, "Workspace");
+		const { workspaceName } = await inquirer.default.prompt([{
+			type: "input",
+			name: "workspaceName",
+			message: "Workspace directory:",
+			default: "my-hyperclaw"
+		}]);
+		this.stepHeader(2, STEPS, "AI Providers & Models");
+		const { providers: allProviders, primary: providerConfig } = await this.selectProvidersAndModels();
+		this.stepHeader(3, STEPS, "Gateway");
+		const gatewayConfig = await this.configureGateway(true);
+		this.stepHeader(4, STEPS, "Channels");
+		const { configureChannels } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "configureChannels",
+			message: "Configure chat channels now?",
+			default: true
+		}]);
+		const channelConfigs = configureChannels ? await this.selectChannels(true) : {};
+		if (configureChannels) {
+			const { configureDM } = await inquirer.default.prompt([{
+				type: "confirm",
+				name: "configureDM",
+				message: "Configure DM access policies now?",
+				default: true
+			}]);
+			if (configureDM) for (const [channelId] of Object.entries(channelConfigs)) {
+				const ch = CHANNELS.find((c) => c.id === channelId);
+				if (ch?.supportsDM) {
+					const dm = await configureDMPolicy(ch.name);
+					channelConfigs[channelId].dmPolicy = dm;
+				}
+			}
+		}
+		this.stepHeader(5, STEPS, "Agent Identity & Persona");
+		const identity = await this.configureIdentity();
+		this.stepHeader(6, STEPS, "Skills & Hooks");
+		const { hooks, heartbeat: heartbeatEnabled } = await this.configureSkillsAndHooks();
+		this.stepHeader(7, STEPS, "Services & Daemon");
+		let installDaemon = options.installDaemon ?? false;
+		if (!installDaemon) {
+			console.log(chalk.default.gray("  The daemon runs the gateway as a background service that starts on boot.\n"));
+			const ans = await inquirer.default.prompt([{
+				type: "confirm",
+				name: "installDaemon",
+				message: "Install as system daemon (auto-start on boot)?",
+				default: false
+			}]);
+			installDaemon = ans.installDaemon;
+		} else console.log(chalk.default.green("  ✔ Daemon will be installed automatically (--install-daemon)\n"));
+		this.stepHeader(8, STEPS, "Extras");
+		const memoryIntegration = await this.configureMemoryIntegration();
+		const serviceApiKeys = await this.configureServiceApiKeys();
+		const hyperclawbotConfig = await this.configureHyperClawBot(gatewayConfig);
+		const talkModeConfig = await this.configureTalkMode();
+		this.stepHeader(9, STEPS, "Launch");
+		const launchChoices = [{
+			name: `TUI  — terminal dashboard`,
+			value: "tui"
+		}];
+		if (gatewayConfig && !gatewayConfig.remote) launchChoices.push({
+			name: `Web  — browser at http://localhost:${gatewayConfig.port}`,
+			value: "web"
+		});
+		launchChoices.push({
+			name: chalk.default.gray("Do this later — I will start manually"),
+			value: "skip"
+		});
+		const { hatchMode } = await inquirer.default.prompt([{
+			type: "list",
+			name: "hatchMode",
+			message: "How do you want to hatch your bot?",
+			choices: launchChoices
+		}]);
+		await this.saveAll({
+			workspaceName,
+			providerConfig,
+			providers: allProviders,
+			channelConfigs,
+			gatewayConfig: gatewayConfig ? {
+				...gatewayConfig,
+				hooks: hooks.length > 0
+			} : null,
+			identity,
+			hooks,
+			heartbeatEnabled,
+			installDaemon,
+			hatchMode,
+			memoryIntegration,
+			serviceApiKeys,
+			hyperclawbotConfig,
+			talkModeConfig
+		}, options);
+	}
+	async selectProvidersAndModels() {
+		const { getTheme: getTheme$1 } = (require_theme.init_theme(), require_chunk.__toCommonJS(require_theme.theme_exports));
+		const t = getTheme$1(false);
+		console.log(chalk.default.gray("  Select one or more AI providers. The first one will be primary.\n"));
+		const { selectedProviderIds } = await inquirer.default.prompt([{
+			type: "checkbox",
+			name: "selectedProviderIds",
+			message: "Select AI providers:",
+			validate: (v) => v.length > 0 || "Select at least one provider",
+			choices: PROVIDERS.map((p) => ({
+				name: `${brandIcon(p.id, "provider")} ${p.displayName.replace(/^.{1,2}\s/, "").padEnd(18)}${p.supportsTranscription ? chalk.default.gray(" 🎤") : ""}`,
+				value: p.id,
+				checked: p.id === "openrouter"
+			}))
+		}]);
+		const configured = [];
+		for (let i = 0; i < selectedProviderIds.length; i++) {
+			const pid = selectedProviderIds[i];
+			const provider = getProvider(pid);
+			const isPrimary = i === 0;
+			console.log(`\n  ${t.c("▸")} ${chalk.default.bold(provider.displayName)} ${isPrimary ? chalk.default.green("(primary)") : chalk.default.gray(`(#${i + 1})`)}\n`);
+			if (provider.authHint) console.log(chalk.default.gray(`    💡 ${provider.authHint}\n`));
+			let apiKey = "";
+			let baseUrl;
+			let modelId = "";
+			if (provider.authType === "api_key") if (pid === "custom") {
+				const r = await inquirer.default.prompt([
+					{
+						type: "input",
+						name: "baseUrl",
+						message: "  Base URL:",
+						validate: (v) => v.trim().length > 5 || "Required"
+					},
+					{
+						type: "password",
+						name: "apiKey",
+						message: `  ${provider.authLabel}:`,
+						mask: "●",
+						validate: (v) => v.trim().length > 5 || "Required"
+					},
+					{
+						type: "input",
+						name: "modelId",
+						message: "  Model ID:",
+						validate: (v) => v.trim().length > 0 || "Required"
+					}
+				]);
+				baseUrl = r.baseUrl.trim().replace(/\/$/, "");
+				apiKey = r.apiKey;
+				modelId = r.modelId.trim();
+			} else {
+				const r = await inquirer.default.prompt([{
+					type: "password",
+					name: "apiKey",
+					message: `  ${provider.authLabel}:`,
+					mask: "●"
+				}]);
+				apiKey = r.apiKey;
+			}
+			if (!modelId) {
+				const modelChoices = provider.models.filter((m) => m.id !== "__manual__").length ? [...provider.models.filter((m) => m.id !== "__manual__").map((m) => ({
+					name: formatModel(m),
+					value: m.id
+				})), {
+					name: chalk.default.gray("Enter manually..."),
+					value: "__manual__"
+				}] : [{
+					name: chalk.default.gray("Enter model ID manually"),
+					value: "__manual__"
+				}];
+				const { modelChoice } = await inquirer.default.prompt([{
+					type: "list",
+					name: "modelChoice",
+					message: "  Default model:",
+					choices: modelChoices
+				}]);
+				if (modelChoice === "__manual__") {
+					const { manual } = await inquirer.default.prompt([{
+						type: "input",
+						name: "manual",
+						message: "  Model ID:",
+						default: provider.models[0]?.id || ""
+					}]);
+					modelId = manual;
+				} else modelId = modelChoice;
+			}
+			configured.push({
+				providerId: pid,
+				apiKey,
+				modelId,
+				...baseUrl ? { baseUrl } : {}
+			});
+			console.log(t.c(`  ✔ ${provider.displayName} → ${modelId}\n`));
+		}
+		return {
+			providers: configured,
+			primary: configured[0]
+		};
+	}
+	async configureGateway(full = false) {
+		const { gatewayMode } = await inquirer.default.prompt([{
+			type: "list",
+			name: "gatewayMode",
+			message: "Gateway setup:",
+			choices: [
+				{
+					name: `Local gateway   ${chalk.default.gray("(run on this machine)")}`,
+					value: "local"
+				},
+				{
+					name: `Remote gateway  ${chalk.default.gray("(info-only — connect to existing server)")}`,
+					value: "remote"
+				},
+				{
+					name: chalk.default.gray("Skip            (no gateway — CLI-only mode)"),
+					value: "skip"
+				}
+			]
+		}]);
+		if (gatewayMode === "skip") {
+			console.log(chalk.default.gray("  ↳ Gateway skipped. Enable later: hyperclaw gateway start\n"));
+			return null;
+		}
+		if (gatewayMode === "remote") {
+			const { remoteUrl } = await inquirer.default.prompt([{
+				type: "input",
+				name: "remoteUrl",
+				message: "Remote gateway URL (e.g. wss://myserver.com:18789):",
+				validate: (v) => v.startsWith("ws") || "Must start with ws:// or wss://"
+			}]);
+			const { remoteToken } = await inquirer.default.prompt([{
+				type: "password",
+				name: "remoteToken",
+				message: "Remote gateway auth token:",
+				mask: "●"
+			}]);
+			console.log(chalk.default.green("  ✔ Remote gateway configured\n"));
+			return {
+				port: 18789,
+				bind: remoteUrl,
+				authToken: remoteToken,
+				tailscaleExposure: "off",
+				runtime: "node",
+				enabledChannels: [],
+				hooks: true,
+				remote: true
+			};
+		}
+		const { useGateway } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "useGateway",
+			message: "Enable the local WebSocket gateway? (needed for channels, web UI, mobile apps)",
+			default: true
+		}]);
+		if (!useGateway) {
+			console.log(chalk.default.gray("  ↳ Gateway skipped. You can enable it later: hyperclaw gateway start\n"));
+			return null;
+		}
+		const running = await this.gateway.isRunning(18789);
+		if (running) console.log(chalk.default.gray(`  ⚠  Gateway already running at ws://127.0.0.1:18789`));
+		const detectedRuntime = await this.gateway.detectRuntime();
+		const questions = [{
+			type: "input",
+			name: "port",
+			message: "Gateway port:",
+			default: String(18789),
+			validate: (v) => Number(v) > 1024 && Number(v) < 65535 ? true : "Enter valid port (1024-65535)"
+		}];
+		if (full) questions.push({
+			type: "list",
+			name: "bind",
+			message: "Bind address:",
+			choices: [
+				{
+					name: `127.0.0.1  ${chalk.default.gray("Loopback only (secure)")}`,
+					value: "127.0.0.1"
+				},
+				{
+					name: `0.0.0.0   ${chalk.default.gray("All interfaces (LAN)")}`,
+					value: "0.0.0.0"
+				},
+				{
+					name: `Tailscale ${chalk.default.gray("VPN peers only")}`,
+					value: "tailscale"
+				},
+				{
+					name: `Custom    ${chalk.default.gray("Enter IP manually")}`,
+					value: "custom"
+				}
+			],
+			default: "127.0.0.1"
+		}, {
+			type: "list",
+			name: "tailscaleExposure",
+			message: "Tailscale exposure:",
+			choices: [
+				{
+					name: this.gateway.exposureLabel("off"),
+					value: "off"
+				},
+				{
+					name: this.gateway.exposureLabel("serve"),
+					value: "serve"
+				},
+				{
+					name: this.gateway.exposureLabel("funnel"),
+					value: "funnel"
+				}
+			],
+			default: "off",
+			when: (a) => a.bind === "tailscale"
+		}, {
+			type: "list",
+			name: "runtime",
+			message: "Runtime:",
+			choices: [
+				{
+					name: `Node.js  ${detectedRuntime === "node" ? chalk.default.green("(detected)") : ""}`,
+					value: "node"
+				},
+				{
+					name: `Bun      ${detectedRuntime === "bun" ? chalk.default.green("(detected)") : chalk.default.gray("(faster)")}`,
+					value: "bun"
+				},
+				{
+					name: `Deno     ${detectedRuntime === "deno" ? chalk.default.green("(detected)") : ""}`,
+					value: "deno"
+				}
+			],
+			default: detectedRuntime
+		});
+		questions.push({
+			type: "password",
+			name: "authToken",
+			message: `Auth token: ${chalk.default.gray("(blank = auto-generate)")}`,
+			mask: "●"
+		});
+		const answers = await inquirer.default.prompt(questions);
+		const token = answers.authToken || this.gateway.generateToken();
+		if (!answers.authToken) console.log(chalk.default.green("  ✔ Auth token auto-generated\n"));
+		return {
+			port: Number(answers.port),
+			bind: answers.bind || "127.0.0.1",
+			authToken: token,
+			tailscaleExposure: answers.tailscaleExposure || "off",
+			runtime: answers.runtime || detectedRuntime,
+			enabledChannels: [],
+			hooks: true
+		};
+	}
+	async selectChannels(full = false) {
+		console.log(chalk.default.hex("#06b6d4")("\n  📱 Communication Channels\n"));
+		const available = await getAvailableChannels();
+		const { selectedChannels } = await inquirer.default.prompt([{
+			type: "checkbox",
+			name: "selectedChannels",
+			message: "Enable channels:",
+			choices: available.map((ch) => {
+				const isUnavailable = ch.status === "unavailable";
+				const reason = isUnavailable ? unavailableReason(ch) : "";
+				const icon$1 = brandIcon(ch.id, "channel");
+				return {
+					name: `${icon$1} ${ch.name.padEnd(18)} ${statusBadge(ch.status, ch)}${ch.requiresGateway && !isUnavailable ? chalk.default.gray(" [needs gateway]") : ""}`,
+					value: ch.id,
+					checked: ch.status === "recommended",
+					disabled: isUnavailable ? reason : false
+				};
+			})
+		}]);
+		const channelConfigs = {};
+		for (const channelId of selectedChannels) {
+			const ch = CHANNELS.find((c) => c.id === channelId);
+			if (!ch || !ch.tokenLabel) continue;
+			console.log(chalk.default.hex("#06b6d4")(`\n  ${ch.emoji} ${ch.name}`));
+			if (ch.setupSteps?.length) ch.setupSteps.forEach((s) => console.log(chalk.default.gray(`  ${s}`)));
+			else if (ch.tokenHint) console.log(chalk.default.gray(`  💡 ${ch.tokenHint}`));
+			const fields = [{
+				type: "password",
+				name: "token",
+				message: `${ch.tokenLabel}:`,
+				mask: "●"
+			}];
+			for (const f of ch.extraFields || []) fields.push({
+				type: "input",
+				name: f.name,
+				message: `${f.label}:${f.hint ? chalk.default.gray(` (${f.hint})`) : ""}`,
+				...f.required ? { validate: (v) => v.trim().length > 0 || `${f.label} is required` } : {}
+			});
+			channelConfigs[channelId] = await inquirer.default.prompt(fields);
+		}
+		if (selectedChannels.includes("twitch") && channelConfigs["twitch"]?.channels) {
+			const raw = channelConfigs["twitch"].channels;
+			channelConfigs["twitch"].channels = raw.split(",").map((s) => s.trim().replace(/^#/, "").toLowerCase()).filter(Boolean);
+		}
+		if (selectedChannels.includes("email")) {
+			const { wantGmailOAuth } = await inquirer.default.prompt([{
+				type: "confirm",
+				name: "wantGmailOAuth",
+				message: "Enable Gmail OAuth for Pub/Sub real-time (send via hyperclaw gmail watch-setup)?",
+				default: false
+			}]);
+			if (wantGmailOAuth) {
+				console.log(chalk.default.gray("  Running OAuth flow for google-gmail..."));
+				try {
+					const { runOAuthFlow } = await Promise.resolve().then(() => require("./oauth-flow-HdvMxKmZ.js"));
+					const { writeOAuthToken } = await Promise.resolve().then(() => require("./oauth-provider-DfEgSucI.js"));
+					const tokens = await runOAuthFlow("google-gmail", {});
+					const now = Math.floor(Date.now() / 1e3);
+					const expires_at = tokens.expires_in ? now + tokens.expires_in : void 0;
+					await writeOAuthToken("google-gmail", {
+						access_token: tokens.access_token,
+						refresh_token: tokens.refresh_token,
+						expires_at,
+						token_url: "https://oauth2.googleapis.com/token"
+					});
+					console.log(chalk.default.green("  ✔  Gmail OAuth configured — next: hyperclaw gmail watch-setup"));
+				} catch (e) {
+					console.log(chalk.default.yellow(`  ⚠  OAuth failed — you can run it later: hyperclaw auth oauth google-gmail`));
+				}
+			}
+		}
+		return channelConfigs;
+	}
+	async configureServiceApiKeys() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🔑 Service API Keys — any app with an API key\n"));
+		console.log(chalk.default.gray("  Stored securely in config. How they work:\n"));
+		console.log(chalk.default.gray("  • Wizard: add keys here\n"));
+		console.log(chalk.default.gray("  • Config: ~/.hyperclaw/hyperclaw.json → skills.apiKeys\n"));
+		console.log(chalk.default.gray("  • Env: HACKERONE_*, BUGCROWD_*, SYNACK_*, or CUSTOM_ID_API_KEY\n"));
+		console.log(chalk.default.gray("  • Tools: built-in tools read them automatically for research.\n"));
+		const { wantServiceKeys } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantServiceKeys",
+			message: "Add API keys for external services (HackerOne, Bugcrowd, Synack, or custom)?",
+			default: false
+		}]);
+		if (!wantServiceKeys) return {};
+		const KNOWN_SERVICES = [
+			{
+				id: "hackerone",
+				name: "HackerOne",
+				hint: "username:token (Basic auth)"
+			},
+			{
+				id: "bugcrowd",
+				name: "Bugcrowd",
+				hint: "Token from Bugcrowd API Credentials"
+			},
+			{
+				id: "synack",
+				name: "Synack",
+				hint: "API token from Synack"
+			},
+			{
+				id: "__custom__",
+				name: "Other (custom)",
+				hint: "Any app with an API key"
+			}
+		];
+		const { servicesToAdd } = await inquirer.default.prompt([{
+			type: "checkbox",
+			name: "servicesToAdd",
+			message: "Select services:",
+			choices: KNOWN_SERVICES.filter((s) => s.id !== "__custom__").map((s) => ({
+				name: `${s.name}  ${chalk.default.gray(`(${s.hint})`)}`,
+				value: s.id
+			})),
+			validate: (v) => true
+		}]);
+		const apiKeys = {};
+		for (const sid of servicesToAdd || []) {
+			const svc = KNOWN_SERVICES.find((s) => s.id === sid);
+			const r = await inquirer.default.prompt([{
+				type: "password",
+				name: "key",
+				message: `${svc?.name || sid} API key:`,
+				mask: "●",
+				validate: (v) => v.trim().length > 3 || "Required"
+			}]);
+			apiKeys[sid] = r.key.trim();
+		}
+		const { addCustom } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "addCustom",
+			message: "Add a custom service (any app)?",
+			default: false
+		}]);
+		if (addCustom) {
+			const { customId, customKey } = await inquirer.default.prompt([{
+				type: "input",
+				name: "customId",
+				message: "Service ID (e.g. my-app, ads-power):",
+				validate: (v) => /^[a-z0-9_-]+$/i.test(v?.trim() || "") || "Letters, numbers, - _ only"
+			}, {
+				type: "password",
+				name: "customKey",
+				message: "API key:",
+				mask: "●",
+				validate: (v) => v.trim().length > 3 || "Required"
+			}]);
+			apiKeys[customId.trim().toLowerCase()] = customKey.trim();
+		}
+		if (Object.keys(apiKeys).length > 0) console.log(chalk.default.green(`  ✔  Saved ${Object.keys(apiKeys).length} API key(s)`));
+		return apiKeys;
+	}
+	async configureHyperClawBot(gatewayConfig) {
+		console.log(chalk.default.hex("#06b6d4")("\n  🤖 HyperClaw Bot — Remote control via Telegram\n"));
+		const trans = getTranscriptionProviders();
+		if (trans.length > 0) {
+			console.log(chalk.default.gray("  🎤 Voice notes: " + trans.map((p) => `${p.displayName}`).join(", ") + " — if you have their API key, voice messages will be transcribed to text."));
+			console.log();
+		}
+		const { wantHyperClawBot } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantHyperClawBot",
+			message: "Enable HyperClaw Bot for remote control (status, restart, /agent from mobile)?",
+			default: false
+		}]);
+		if (!wantHyperClawBot) return void 0;
+		const { token } = await inquirer.default.prompt([{
+			type: "input",
+			name: "token",
+			message: "Telegram Bot token (from @BotFather):",
+			validate: (v) => v.trim().length > 10 || "Required"
+		}]);
+		const { userIds } = await inquirer.default.prompt([{
+			type: "input",
+			name: "userIds",
+			message: "Allowed user IDs (comma-separated, leave empty = everyone):",
+			default: ""
+		}]);
+		const gatewayUrl = `http://localhost:${gatewayConfig?.port || 18789}`;
+		const { saveBotConfig } = await Promise.resolve().then(() => require("./hyperclawbot-DfMGowZC.js"));
+		await saveBotConfig({
+			platform: "telegram",
+			token: token.trim(),
+			gatewayUrl,
+			allowedUsers: userIds ? userIds.split(",").map((s) => s.trim()).filter(Boolean) : [],
+			gatewayToken: void 0,
+			enabled: true,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		console.log(chalk.default.green("  ✔  HyperClaw Bot configured — Start: hyperclaw bot start"));
+		return { token: token.trim() };
+	}
+	async configureTalkMode() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🎙️  Talk Mode — ElevenLabs TTS\n"));
+		const { wantTalkMode } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantTalkMode",
+			message: "Enable Talk Mode (voice responses via ElevenLabs)?",
+			default: false
+		}]);
+		if (!wantTalkMode) return void 0;
+		const { apiKey } = await inquirer.default.prompt([{
+			type: "password",
+			name: "apiKey",
+			message: "ElevenLabs API key (elevenlabs.io):",
+			mask: "●",
+			validate: (v) => v.trim().length > 10 || "Required"
+		}]);
+		console.log(chalk.default.green("  ✔  Talk Mode configured"));
+		return {
+			apiKey: apiKey.trim(),
+			voiceId: "21m00Tcm4TlvDq8ikWAM",
+			modelId: "eleven_multilingual_v2"
+		};
+	}
+	async configureMemoryIntegration() {
+		console.log(chalk.default.hex("#06b6d4")("\n  📂 Memory Integration (Obsidian / Raycast / Hazel)\n"));
+		const { vaultPath } = await inquirer.default.prompt([{
+			type: "input",
+			name: "vaultPath",
+			message: "Sync memory to vault? Enter path or leave empty to skip:",
+			default: ""
+		}]);
+		const vaultDir = String(vaultPath || "").trim();
+		if (!vaultDir) return void 0;
+		const { dailyNotes } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "dailyNotes",
+			message: "Write daily notes with session summaries?",
+			default: true
+		}]);
+		return {
+			vaultDir,
+			dailyNotes,
+			syncOnAppend: true
+		};
+	}
+	async configureIdentity() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🦅 Agent Identity\n"));
+		const identity = await inquirer.default.prompt([
+			{
+				type: "input",
+				name: "userName",
+				message: "Your name:",
+				default: "Boss"
+			},
+			{
+				type: "input",
+				name: "agentName",
+				message: "Agent name:",
+				default: "Hyper"
+			},
+			{
+				type: "input",
+				name: "wakeWord",
+				message: "Wake word for voice:",
+				default: (a) => `Hey ${a.agentName || "Hyper"}`
+			},
+			{
+				type: "list",
+				name: "personality",
+				message: "Personality:",
+				choices: [
+					"Professional and concise",
+					"Friendly and casual",
+					"Witty with humor",
+					"Direct and no-nonsense",
+					"Custom"
+				]
+			},
+			{
+				type: "input",
+				name: "customPersonality",
+				message: "Describe personality:",
+				when: (a) => a.personality === "Custom"
+			},
+			{
+				type: "list",
+				name: "language",
+				message: "Primary language:",
+				choices: [
+					"English",
+					"Greek",
+					"Spanish",
+					"French",
+					"German",
+					"Chinese",
+					"Japanese",
+					"Arabic"
+				]
+			}
+		]);
+		console.log(chalk.default.gray("\n  This is the greeting sent to your channels when the agent starts.\n"));
+		const { wakeUpMessage } = await inquirer.default.prompt([{
+			type: "input",
+			name: "wakeUpMessage",
+			message: "Agent wake-up message:",
+			default: (identity.agentName || "Hyper") + " is online. How can I help you today?"
+		}]);
+		const { wantSystemPrompt } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantSystemPrompt",
+			message: "Add a custom system prompt / instructions for the agent?",
+			default: false
+		}]);
+		let systemPrompt = "";
+		if (wantSystemPrompt) {
+			console.log(chalk.default.gray("  Tip: describe role, restrictions, tone, specific knowledge, etc.\n"));
+			const r = await inquirer.default.prompt([{
+				type: "editor",
+				name: "systemPrompt",
+				message: "System prompt (opens editor — save & close to continue):"
+			}]);
+			systemPrompt = r.systemPrompt?.trim() || "";
+		}
+		const globalRules = [
+			"Always respond in the user's preferred language",
+			"Never reveal the gateway auth token or API keys",
+			"Confirm before destructive or irreversible actions",
+			"Respect user privacy — never share conversation data",
+			"All subagents inherit these rules — cannot be overridden"
+		];
+		const { addRules } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "addRules",
+			message: "Add custom rules to AGENTS.md?",
+			default: false
+		}]);
+		let customRules = [];
+		if (addRules) {
+			const { rules } = await inquirer.default.prompt([{
+				type: "input",
+				name: "rules",
+				message: "Rules (semicolon-separated):",
+				filter: (v) => v.split(";").map((r) => r.trim()).filter(Boolean)
+			}]);
+			customRules = rules;
+		}
+		const personality = identity.personality === "Custom" ? identity.customPersonality || "Custom" : identity.personality;
+		return {
+			agentName: identity.agentName,
+			userName: identity.userName,
+			language: identity.language,
+			personality,
+			wakeUpMessage: wakeUpMessage.trim(),
+			systemPrompt: systemPrompt || void 0,
+			rules: [...globalRules, ...customRules]
+		};
+	}
+	async configureSkillsAndHooks() {
+		const { wantSkills } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantSkills",
+			message: "Configure skills & hooks now?",
+			default: false
+		}]);
+		if (!wantSkills) {
+			console.log(chalk.default.gray("  ↳ Skipped — enable later: hyperclaw hooks enable <name>\n"));
+			return {
+				hooks: [],
+				heartbeat: false
+			};
+		}
+		const { selectedHooks } = await inquirer.default.prompt([{
+			type: "checkbox",
+			name: "selectedHooks",
+			message: "Select hooks to enable:",
+			choices: [
+				{
+					name: `${"boot.md".padEnd(22)} ${chalk.default.gray("Run commands on agent startup")}`,
+					value: "boot"
+				},
+				{
+					name: `${"command-logger".padEnd(22)} ${chalk.default.gray("Log every tool call to file")}`,
+					value: "command-logger"
+				},
+				{
+					name: `${"session-memory".padEnd(22)} ${chalk.default.gray("Persist session context across restarts")}`,
+					value: "session-memory"
+				},
+				{
+					name: `${"morning-briefing".padEnd(22)} ${chalk.default.gray("Daily proactive summary to HEARTBEAT.md")}`,
+					value: "morning-briefing"
+				}
+			]
+		}]);
+		const heartbeat = selectedHooks.includes("morning-briefing");
+		try {
+			const { HookLoader } = await Promise.resolve().then(() => require("./loader-aSIGRXBq.js"));
+			const loader = new HookLoader();
+			for (const h of selectedHooks) loader.enable(h);
+		} catch {}
+		if (selectedHooks.length > 0) console.log(chalk.default.green(`  ✔ Enabled: ${selectedHooks.join(", ")}\n`));
+		return {
+			hooks: selectedHooks,
+			heartbeat
+		};
+	}
+	async saveAll(data, options) {
+		console.log();
+		const spinner = (0, ora.default)("Saving configuration...").start();
+		const current = await this.config.load();
+		const skillsPatch = { installed: current?.skills?.installed || [] };
+		if (data.serviceApiKeys && Object.keys(data.serviceApiKeys).length > 0) skillsPatch.apiKeys = {
+			...current?.skills?.apiKeys || {},
+			...data.serviceApiKeys
+		};
+		if (current?.skills?.vtApiKey) skillsPatch.vtApiKey = current.skills.vtApiKey;
+		const finalSkills = skillsPatch.apiKeys || skillsPatch.vtApiKey ? skillsPatch : current?.skills || { installed: [] };
+		await this.config.save({
+			...current,
+			version: "4.0.1",
+			workspaceName: data.workspaceName,
+			provider: data.providerConfig,
+			providers: data.providers || (data.providerConfig ? [data.providerConfig] : []),
+			gateway: data.gatewayConfig || void 0,
+			channels: Object.keys(data.channelConfigs || {}),
+			channelConfigs: data.channelConfigs,
+			skills: finalSkills,
+			enabledHooks: data.hooks || [],
+			identity: {
+				agentName: data.identity?.agentName,
+				userName: data.identity?.userName,
+				language: data.identity?.language,
+				wakeWord: data.identity?.wakeWord || `Hey ${data.identity?.agentName || "Hyper"}`,
+				wakeUpMessage: data.identity?.wakeUpMessage,
+				systemPrompt: data.identity?.systemPrompt,
+				personality: data.identity?.personality,
+				rules: data.identity?.rules
+			},
+			memoryIntegration: data.memoryIntegration,
+			talkMode: data.talkModeConfig,
+			pcAccess: {
+				enabled: true,
+				level: "full",
+				allowedPaths: [],
+				allowedCommands: [],
+				confirmDestructive: false,
+				maxOutputBytes: 5e4
+			},
+			hatchMode: data.hatchMode || "tui",
+			installedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		spinner.succeed("Configuration saved");
+		const memory = new MemoryManager();
+		await memory.init(data.identity);
+		if (data.heartbeatEnabled) try {
+			const { HookLoader } = await Promise.resolve().then(() => require("./loader-aSIGRXBq.js"));
+			const loader = new HookLoader();
+			loader.enable("morning-briefing");
+			console.log(chalk.default.gray("  ✔  Morning Briefing hook enabled"));
+		} catch {}
+		await this.testConnections(data.channelConfigs || {});
+		if (data.installDaemon || options.daemon || options.installDaemon) {
+			const s = (0, ora.default)("🩸 Installing system daemon...").start();
+			await this.daemon.install();
+			s.succeed(chalk.default.red("🩸 System daemon installed (starts on boot)"));
+		}
+		if (data.gatewayConfig?.tailscaleExposure && data.gatewayConfig.tailscaleExposure !== "off") await this.gateway.applyTailscaleExposure(data.gatewayConfig.tailscaleExposure, data.gatewayConfig.port);
+		if (data.gatewayConfig && (options.startNow || data.installDaemon)) {
+			const s = (0, ora.default)("Starting gateway...").start();
+			await this.daemon.start();
+			s.succeed(`Gateway running at ws://localhost:${data.gatewayConfig.port}`);
+		}
+		this.showSuccessScreen(data);
+	}
+	async testConnections(configs) {
+		for (const [channelId, cfg] of Object.entries(configs)) {
+			const ch = CHANNELS.find((c) => c.id === channelId);
+			if (!ch || !cfg?.token) continue;
+			const s = (0, ora.default)(`Testing ${ch.name}...`).start();
+			await new Promise((r) => setTimeout(r, 900 + Math.random() * 600));
+			s.succeed(`${ch.emoji} ${ch.name} connected`);
+		}
+	}
+	showSuccessScreen(data) {
+		const channels = Object.keys(data.channelConfigs || {});
+		const gwUrl = `ws://localhost:${data.gatewayConfig?.port || 1515}`;
+		const hasEmail = channels.includes("email");
+		const hasHyperClawBot = !!data.hyperclawbotConfig?.token;
+		const cmdLines = [
+			chalk.default.gray("  hyperclaw dashboard       — TUI dashboard"),
+			chalk.default.gray("  hyperclaw hub             — Skill hub"),
+			chalk.default.gray("  hyperclaw gateway status  — Gateway panel"),
+			chalk.default.gray("  hyperclaw ") + chalk.default.red("daemon") + chalk.default.gray(" status   — Service status"),
+			chalk.default.gray("  hyperclaw voice           — Voice settings"),
+			chalk.default.gray("  hyperclaw canvas show     — AI canvas")
+		];
+		if (hasHyperClawBot) cmdLines.push(chalk.default.gray("  hyperclaw bot start        — HyperClawBot remote control"));
+		if (hasEmail) cmdLines.push(chalk.default.gray("  hyperclaw gmail watch-setup — Gmail Pub/Sub (real-time)"));
+		cmdLines.push(chalk.default.gray("  hyperclaw nodes             — Mobile nodes (Connect tab)"));
+		cmdLines.push(chalk.default.gray("  hyperclaw cron list         — Scheduled tasks"));
+		const lines = [
+			`${chalk.default.gray("Agent:")}     ${chalk.default.hex("#06b6d4")(data.identity?.agentName)} (you: ${data.identity?.userName})`,
+			`${chalk.default.gray("Model:")}     ${data.providerConfig?.modelId}`,
+			`${chalk.default.gray("Provider:")} ${data.providerConfig?.providerId}`,
+			`${chalk.default.gray("Gateway:")}  ${gwUrl}`,
+			`${chalk.default.gray("Channels:")} ${channels.length ? channels.join(", ") : "CLI only"}`,
+			"",
+			chalk.default.hex("#06b6d4")("Commands:"),
+			...cmdLines
+		].join("\n");
+		console.log("\n" + (0, boxen.default)(chalk.default.hex("#06b6d4")("🎉 HyperClaw v4.0.1 ready!\n\n") + lines, {
+			padding: 1,
+			borderStyle: "round",
+			borderColor: "cyan",
+			margin: 1,
+			backgroundColor: "#0a0a0a"
+		}));
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'Banner', {
+  enumerable: true,
+  get: function () {
+    return Banner;
+  }
+});
+Object.defineProperty(exports, 'ConfigStore', {
+  enumerable: true,
+  get: function () {
+    return ConfigStore;
+  }
+});
+Object.defineProperty(exports, 'DaemonManager', {
+  enumerable: true,
+  get: function () {
+    return DaemonManager;
+  }
+});
+Object.defineProperty(exports, 'GatewayManager', {
+  enumerable: true,
+  get: function () {
+    return GatewayManager;
+  }
+});
+Object.defineProperty(exports, 'HyperClawWizard', {
+  enumerable: true,
+  get: function () {
+    return HyperClawWizard;
+  }
+});