hyperclaw 5.4.0 → 5.4.1

package/dist/manager-DuS-WQhZ.js

@@ -0,0 +1,120 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_paths = require('./paths-AIyBxIzm.js');
+const require_paths$1 = require('./paths-DPovhojT.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const crypto = require_chunk.__toESM(require("crypto"));
+
+//#region src/webhooks/manager.ts
+require_paths$1.init_paths();
+const getWebhooksFile = () => path.default.join(require_paths.getHyperClawDir(), "webhooks.json");
+function generateSecret() {
+	return crypto.default.randomBytes(24).toString("hex");
+}
+function generateId() {
+	return crypto.default.randomBytes(6).toString("hex");
+}
+var WebhookManager = class {
+	webhooks = [];
+	async load() {
+		try {
+			this.webhooks = await fs_extra.default.readJson(getWebhooksFile());
+		} catch {
+			this.webhooks = [];
+		}
+	}
+	async save() {
+		const f = getWebhooksFile();
+		await fs_extra.default.ensureDir(path.default.dirname(f));
+		await fs_extra.default.writeJson(f, this.webhooks, { spaces: 2 });
+	}
+	async add(opts) {
+		await this.load();
+		const wh = {
+			id: generateId(),
+			name: opts.name,
+			secret: opts.withSecret ? generateSecret() : void 0,
+			format: opts.format || "json",
+			routeTo: opts.routeTo,
+			enabled: true,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			hitCount: 0,
+			filterPath: opts.filterPath,
+			template: opts.template
+		};
+		this.webhooks.push(wh);
+		await this.save();
+		return wh;
+	}
+	async remove(id) {
+		await this.load();
+		this.webhooks = this.webhooks.filter((w) => w.id !== id);
+		await this.save();
+	}
+	async toggle(id) {
+		await this.load();
+		const wh = this.webhooks.find((w) => w.id === id);
+		if (wh) {
+			wh.enabled = !wh.enabled;
+			await this.save();
+		}
+	}
+	async recordHit(id) {
+		const wh = this.webhooks.find((w) => w.id === id);
+		if (wh) {
+			wh.hitCount++;
+			wh.lastHitAt = (/* @__PURE__ */ new Date()).toISOString();
+			await this.save();
+		}
+	}
+	verifySignature(webhook, payload, sig) {
+		if (!webhook.secret) return true;
+		const expected = crypto.default.createHmac("sha256", webhook.secret).update(payload).digest("hex");
+		return crypto.default.timingSafeEqual(Buffer.from(sig.replace("sha256=", ""), "hex"), Buffer.from(expected, "hex"));
+	}
+	extractMessage(webhook, rawBody) {
+		if (!webhook.filterPath && !webhook.template) return rawBody;
+		let body;
+		try {
+			body = JSON.parse(rawBody);
+		} catch {
+			body = { text: rawBody };
+		}
+		if (webhook.template) return webhook.template.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
+			const parts = key.trim().split(".");
+			let val = body;
+			for (const p of parts) val = val?.[p];
+			return val !== void 0 ? String(val) : "";
+		});
+		if (webhook.filterPath) {
+			const parts = webhook.filterPath.split(".");
+			let val = body;
+			for (const p of parts) val = val?.[p];
+			return val !== void 0 ? String(val) : rawBody;
+		}
+		return rawBody;
+	}
+	showList(gatewayPort = 18789) {
+		console.log(chalk.default.bold.cyan("\n  🪝 WEBHOOKS\n"));
+		if (this.webhooks.length === 0) {
+			console.log(chalk.default.gray("  No webhooks configured.\n"));
+			console.log(chalk.default.gray("  Add with: hyperclaw webhooks add\n"));
+			return;
+		}
+		for (const wh of this.webhooks) {
+			const dot = wh.enabled ? chalk.default.green("●") : chalk.default.gray("○");
+			const url = chalk.default.underline.cyan(`http://localhost:${gatewayPort}/webhook/${wh.id}`);
+			console.log(`  ${dot} ${chalk.default.white(wh.name)} ${chalk.default.gray(`[${wh.format}]`)}`);
+			console.log(`    ${chalk.default.gray("URL:")}    ${url}`);
+			console.log(`    ${chalk.default.gray("Route:")}  ${wh.routeTo.type} → ${wh.routeTo.target}`);
+			if (wh.secret) console.log(`    ${chalk.default.gray("Secret:")} ${wh.secret.slice(0, 8)}...`);
+			if (wh.template) console.log(`    ${chalk.default.gray("Template:")} ${wh.template.slice(0, 50)}`);
+			console.log(`    ${chalk.default.gray(`Hits: ${wh.hitCount}  Last: ${wh.lastHitAt ? new Date(wh.lastHitAt).toLocaleString() : "never"}`)}`);
+			console.log();
+		}
+	}
+};
+
+//#endregion
+exports.WebhookManager = WebhookManager;

package/dist/manager-Dz2eKYqo.js

@@ -0,0 +1,116 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_paths = require('./paths-AIyBxIzm.js');
+const require_paths$1 = require('./paths-DPovhojT.js');
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const crypto = require_chunk.__toESM(require("crypto"));
+
+//#region src/secrets/encrypt-config.ts
+var encrypt_config_exports = {};
+require_chunk.__export(encrypt_config_exports, {
+	decryptConfig: () => decryptConfig,
+	encryptConfig: () => encryptConfig,
+	isEncryptedContent: () => isEncryptedContent,
+	isEncryptionAvailable: () => isEncryptionAvailable
+});
+function getKey() {
+	const raw = process.env.HYPERCLAW_CONFIG_KEY;
+	if (!raw || raw.length !== 64 || !/^[0-9a-fA-F]+$/.test(raw)) return null;
+	return Buffer.from(raw, "hex");
+}
+function isEncryptionAvailable() {
+	return getKey() !== null;
+}
+function encryptConfig(plain) {
+	const key = getKey();
+	if (!key) throw new Error("HYPERCLAW_CONFIG_KEY not set (32-byte hex)");
+	const iv = crypto.default.randomBytes(IV_LEN);
+	const cipher = crypto.default.createCipheriv(ALGORITHM, key, iv);
+	const enc = Buffer.concat([cipher.update(plain, "utf8"), cipher.final()]);
+	const tag = cipher.getAuthTag();
+	return iv.toString("base64") + ":" + tag.toString("base64") + ":" + enc.toString("base64");
+}
+function decryptConfig(encrypted) {
+	const key = getKey();
+	if (!key) throw new Error("HYPERCLAW_CONFIG_KEY not set");
+	const parts = encrypted.split(":");
+	if (parts.length !== 3) throw new Error("Invalid encrypted config format");
+	const [ivB64, tagB64, encB64] = parts;
+	const iv = Buffer.from(ivB64, "base64");
+	const tag = Buffer.from(tagB64, "base64");
+	const enc = Buffer.from(encB64, "base64");
+	const decipher = crypto.default.createDecipheriv(ALGORITHM, key, iv);
+	decipher.setAuthTag(tag);
+	return decipher.update(enc) + decipher.final("utf8");
+}
+function isEncryptedContent(s) {
+	return /^[A-Za-z0-9+/=]+:[A-Za-z0-9+/=]+:[A-Za-z0-9+/=]+$/.test(s.trim()) && s.split(":").every((p) => p.length > 0);
+}
+var ALGORITHM, IV_LEN;
+var init_encrypt_config = require_chunk.__esm({ "src/secrets/encrypt-config.ts"() {
+	ALGORITHM = "aes-256-gcm";
+	IV_LEN = 16;
+} });
+
+//#endregion
+//#region src/config/manager.ts
+require_paths$1.init_paths();
+function tryEncrypt() {
+	try {
+		const m = (init_encrypt_config(), require_chunk.__toCommonJS(encrypt_config_exports));
+		if (m?.isEncryptionAvailable?.()) return {
+			encrypt: m.encryptConfig,
+			decrypt: m.decryptConfig,
+			available: true
+		};
+	} catch {}
+	return {
+		encrypt: (s) => s,
+		decrypt: (s) => s,
+		available: false
+	};
+}
+var ConfigManager = class {
+	async save(config) {
+		const target = require_paths.getConfigPath();
+		const tmp = target + ".tmp";
+		await fs_extra.default.ensureDir(require_paths.getHyperClawDir());
+		const json = JSON.stringify(config, null, 2);
+		const enc = tryEncrypt();
+		const out = enc.available ? enc.encrypt(json) : json;
+		await fs_extra.default.writeFile(tmp, out, "utf8");
+		await fs_extra.default.chmod(tmp, 384).catch(() => {});
+		await fs_extra.default.rename(tmp, target);
+	}
+	async load() {
+		const p = require_paths.getConfigPath();
+		if (!await fs_extra.default.pathExists(p)) return null;
+		const raw = await fs_extra.default.readFile(p, "utf8");
+		const enc = tryEncrypt();
+		let isEnc = false;
+		try {
+			const m = (init_encrypt_config(), require_chunk.__toCommonJS(encrypt_config_exports));
+			if (m?.isEncryptedContent?.(raw)) {
+				if (!enc.available) throw new Error("Config is encrypted. Set HYPERCLAW_CONFIG_KEY (32-byte hex) to decrypt.");
+				isEnc = true;
+			}
+		} catch (e) {
+			if (e?.message?.includes("encrypted")) throw e;
+		}
+		if (isEnc) return JSON.parse(enc.decrypt(raw));
+		return JSON.parse(raw);
+	}
+	async sync(_options) {
+		throw new Error("ConfigManager.sync() is not implemented. To back up your config, copy ~/.hyperclaw/hyperclaw.json manually.");
+	}
+	getConfigPath() {
+		return require_paths.getConfigPath();
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'ConfigManager', {
+  enumerable: true,
+  get: function () {
+    return ConfigManager;
+  }
+});

package/dist/manager-R0TlRMZy.js

@@ -0,0 +1,120 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_paths = require('./paths-AIyBxIzm.js');
+const require_paths$1 = require('./paths-DPovhojT.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const crypto = require_chunk.__toESM(require("crypto"));
+
+//#region src/webhooks/manager.ts
+require_paths$1.init_paths();
+const getWebhooksFile = () => path.default.join(require_paths.getHyperClawDir(), "webhooks.json");
+function generateSecret() {
+	return crypto.default.randomBytes(24).toString("hex");
+}
+function generateId() {
+	return crypto.default.randomBytes(6).toString("hex");
+}
+var WebhookManager = class {
+	webhooks = [];
+	async load() {
+		try {
+			this.webhooks = await fs_extra.default.readJson(getWebhooksFile());
+		} catch {
+			this.webhooks = [];
+		}
+	}
+	async save() {
+		const f = getWebhooksFile();
+		await fs_extra.default.ensureDir(path.default.dirname(f));
+		await fs_extra.default.writeJson(f, this.webhooks, { spaces: 2 });
+	}
+	async add(opts) {
+		await this.load();
+		const wh = {
+			id: generateId(),
+			name: opts.name,
+			secret: opts.withSecret ? generateSecret() : void 0,
+			format: opts.format || "json",
+			routeTo: opts.routeTo,
+			enabled: true,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			hitCount: 0,
+			filterPath: opts.filterPath,
+			template: opts.template
+		};
+		this.webhooks.push(wh);
+		await this.save();
+		return wh;
+	}
+	async remove(id) {
+		await this.load();
+		this.webhooks = this.webhooks.filter((w) => w.id !== id);
+		await this.save();
+	}
+	async toggle(id) {
+		await this.load();
+		const wh = this.webhooks.find((w) => w.id === id);
+		if (wh) {
+			wh.enabled = !wh.enabled;
+			await this.save();
+		}
+	}
+	async recordHit(id) {
+		const wh = this.webhooks.find((w) => w.id === id);
+		if (wh) {
+			wh.hitCount++;
+			wh.lastHitAt = (/* @__PURE__ */ new Date()).toISOString();
+			await this.save();
+		}
+	}
+	verifySignature(webhook, payload, sig) {
+		if (!webhook.secret) return true;
+		const expected = crypto.default.createHmac("sha256", webhook.secret).update(payload).digest("hex");
+		return crypto.default.timingSafeEqual(Buffer.from(sig.replace("sha256=", ""), "hex"), Buffer.from(expected, "hex"));
+	}
+	extractMessage(webhook, rawBody) {
+		if (!webhook.filterPath && !webhook.template) return rawBody;
+		let body;
+		try {
+			body = JSON.parse(rawBody);
+		} catch {
+			body = { text: rawBody };
+		}
+		if (webhook.template) return webhook.template.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
+			const parts = key.trim().split(".");
+			let val = body;
+			for (const p of parts) val = val?.[p];
+			return val !== void 0 ? String(val) : "";
+		});
+		if (webhook.filterPath) {
+			const parts = webhook.filterPath.split(".");
+			let val = body;
+			for (const p of parts) val = val?.[p];
+			return val !== void 0 ? String(val) : rawBody;
+		}
+		return rawBody;
+	}
+	showList(gatewayPort = 18789) {
+		console.log(chalk.default.bold.cyan("\n  🪝 WEBHOOKS\n"));
+		if (this.webhooks.length === 0) {
+			console.log(chalk.default.gray("  No webhooks configured.\n"));
+			console.log(chalk.default.gray("  Add with: hyperclaw webhooks add\n"));
+			return;
+		}
+		for (const wh of this.webhooks) {
+			const dot = wh.enabled ? chalk.default.green("●") : chalk.default.gray("○");
+			const url = chalk.default.underline.cyan(`http://localhost:${gatewayPort}/webhook/${wh.id}`);
+			console.log(`  ${dot} ${chalk.default.white(wh.name)} ${chalk.default.gray(`[${wh.format}]`)}`);
+			console.log(`    ${chalk.default.gray("URL:")}    ${url}`);
+			console.log(`    ${chalk.default.gray("Route:")}  ${wh.routeTo.type} → ${wh.routeTo.target}`);
+			if (wh.secret) console.log(`    ${chalk.default.gray("Secret:")} ${wh.secret.slice(0, 8)}...`);
+			if (wh.template) console.log(`    ${chalk.default.gray("Template:")} ${wh.template.slice(0, 50)}`);
+			console.log(`    ${chalk.default.gray(`Hits: ${wh.hitCount}  Last: ${wh.lastHitAt ? new Date(wh.lastHitAt).toLocaleString() : "never"}`)}`);
+			console.log();
+		}
+	}
+};
+
+//#endregion
+exports.WebhookManager = WebhookManager;

package/dist/manager-aJfY7rt6.js

@@ -0,0 +1,120 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_paths = require('./paths-AIyBxIzm.js');
+const require_paths$1 = require('./paths-DPovhojT.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const crypto = require_chunk.__toESM(require("crypto"));
+
+//#region src/webhooks/manager.ts
+require_paths$1.init_paths();
+const getWebhooksFile = () => path.default.join(require_paths.getHyperClawDir(), "webhooks.json");
+function generateSecret() {
+	return crypto.default.randomBytes(24).toString("hex");
+}
+function generateId() {
+	return crypto.default.randomBytes(6).toString("hex");
+}
+var WebhookManager = class {
+	webhooks = [];
+	async load() {
+		try {
+			this.webhooks = await fs_extra.default.readJson(getWebhooksFile());
+		} catch {
+			this.webhooks = [];
+		}
+	}
+	async save() {
+		const f = getWebhooksFile();
+		await fs_extra.default.ensureDir(path.default.dirname(f));
+		await fs_extra.default.writeJson(f, this.webhooks, { spaces: 2 });
+	}
+	async add(opts) {
+		await this.load();
+		const wh = {
+			id: generateId(),
+			name: opts.name,
+			secret: opts.withSecret ? generateSecret() : void 0,
+			format: opts.format || "json",
+			routeTo: opts.routeTo,
+			enabled: true,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			hitCount: 0,
+			filterPath: opts.filterPath,
+			template: opts.template
+		};
+		this.webhooks.push(wh);
+		await this.save();
+		return wh;
+	}
+	async remove(id) {
+		await this.load();
+		this.webhooks = this.webhooks.filter((w) => w.id !== id);
+		await this.save();
+	}
+	async toggle(id) {
+		await this.load();
+		const wh = this.webhooks.find((w) => w.id === id);
+		if (wh) {
+			wh.enabled = !wh.enabled;
+			await this.save();
+		}
+	}
+	async recordHit(id) {
+		const wh = this.webhooks.find((w) => w.id === id);
+		if (wh) {
+			wh.hitCount++;
+			wh.lastHitAt = (/* @__PURE__ */ new Date()).toISOString();
+			await this.save();
+		}
+	}
+	verifySignature(webhook, payload, sig) {
+		if (!webhook.secret) return true;
+		const expected = crypto.default.createHmac("sha256", webhook.secret).update(payload).digest("hex");
+		return crypto.default.timingSafeEqual(Buffer.from(sig.replace("sha256=", ""), "hex"), Buffer.from(expected, "hex"));
+	}
+	extractMessage(webhook, rawBody) {
+		if (!webhook.filterPath && !webhook.template) return rawBody;
+		let body;
+		try {
+			body = JSON.parse(rawBody);
+		} catch {
+			body = { text: rawBody };
+		}
+		if (webhook.template) return webhook.template.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
+			const parts = key.trim().split(".");
+			let val = body;
+			for (const p of parts) val = val?.[p];
+			return val !== void 0 ? String(val) : "";
+		});
+		if (webhook.filterPath) {
+			const parts = webhook.filterPath.split(".");
+			let val = body;
+			for (const p of parts) val = val?.[p];
+			return val !== void 0 ? String(val) : rawBody;
+		}
+		return rawBody;
+	}
+	showList(gatewayPort = 18789) {
+		console.log(chalk.default.bold.cyan("\n  🪝 WEBHOOKS\n"));
+		if (this.webhooks.length === 0) {
+			console.log(chalk.default.gray("  No webhooks configured.\n"));
+			console.log(chalk.default.gray("  Add with: hyperclaw webhooks add\n"));
+			return;
+		}
+		for (const wh of this.webhooks) {
+			const dot = wh.enabled ? chalk.default.green("●") : chalk.default.gray("○");
+			const url = chalk.default.underline.cyan(`http://localhost:${gatewayPort}/webhook/${wh.id}`);
+			console.log(`  ${dot} ${chalk.default.white(wh.name)} ${chalk.default.gray(`[${wh.format}]`)}`);
+			console.log(`    ${chalk.default.gray("URL:")}    ${url}`);
+			console.log(`    ${chalk.default.gray("Route:")}  ${wh.routeTo.type} → ${wh.routeTo.target}`);
+			if (wh.secret) console.log(`    ${chalk.default.gray("Secret:")} ${wh.secret.slice(0, 8)}...`);
+			if (wh.template) console.log(`    ${chalk.default.gray("Template:")} ${wh.template.slice(0, 50)}`);
+			console.log(`    ${chalk.default.gray(`Hits: ${wh.hitCount}  Last: ${wh.lastHitAt ? new Date(wh.lastHitAt).toLocaleString() : "never"}`)}`);
+			console.log();
+		}
+	}
+};
+
+//#endregion
+exports.WebhookManager = WebhookManager;

package/dist/mcp-BH7HtOQ8.js

@@ -0,0 +1,142 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_paths = require('./paths-AIyBxIzm.js');
+const require_paths$1 = require('./paths-DPovhojT.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const inquirer = require_chunk.__toESM(require("inquirer"));
+const ora = require_chunk.__toESM(require("ora"));
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+
+//#region src/commands/mcp.ts
+require_paths$1.init_paths();
+const getMcpFile = () => path.default.join(require_paths.getHyperClawDir(), "mcp-servers.json");
+async function loadServers() {
+	try {
+		return await fs_extra.default.readJson(getMcpFile());
+	} catch {
+		return [];
+	}
+}
+async function saveServers(servers) {
+	const mcpFile = getMcpFile();
+	await fs_extra.default.ensureDir(path.default.dirname(mcpFile));
+	await fs_extra.default.writeJson(mcpFile, servers, { spaces: 2 });
+}
+async function mcpList() {
+	const servers = await loadServers();
+	console.log(chalk.default.bold.cyan("\n  🔌 MCP SERVERS\n"));
+	if (servers.length === 0) {
+		console.log(chalk.default.gray("  No MCP servers registered.\n"));
+		console.log(chalk.default.gray("  Add one: hyperclaw mcp add\n"));
+		console.log(chalk.default.gray("  Or install via skill hub: hyperclaw hub --install mcp-filesystem\n"));
+		return;
+	}
+	for (const s of servers) {
+		const dot = s.enabled ? chalk.default.green("●") : chalk.default.gray("○");
+		console.log(`  ${dot} ${chalk.default.white(s.name)} ${chalk.default.gray(`[${s.transport}]`)}`);
+		if (s.command) console.log(`    ${chalk.default.gray("cmd:")} ${s.command}`);
+		if (s.url) console.log(`    ${chalk.default.gray("url:")} ${chalk.default.cyan(s.url)}`);
+		if (s.tools?.length) console.log(`    ${chalk.default.gray("tools:")} ${s.tools.slice(0, 5).join(", ")}${s.tools.length > 5 ? ` +${s.tools.length - 5} more` : ""}`);
+		if (s.lastProbeAt) console.log(`    ${chalk.default.gray(`last probe: ${new Date(s.lastProbeAt).toLocaleString()}`)}`);
+		console.log();
+	}
+}
+async function mcpAdd() {
+	console.log(chalk.default.bold.cyan("\n  ➕ ADD MCP SERVER\n"));
+	const { name } = await inquirer.default.prompt([{
+		type: "input",
+		name: "name",
+		message: "Server name:",
+		validate: (v) => !!v.trim() || "Required"
+	}]);
+	const { transport } = await inquirer.default.prompt([{
+		type: "list",
+		name: "transport",
+		message: "Transport:",
+		choices: [
+			"stdio",
+			"sse",
+			"http"
+		]
+	}]);
+	let command;
+	let url;
+	if (transport === "stdio") {
+		const res = await inquirer.default.prompt([{
+			type: "input",
+			name: "command",
+			message: "Start command (e.g. node /path/to/server.js):",
+			validate: (v) => !!v.trim() || "Required"
+		}]);
+		command = res.command;
+	} else {
+		const res = await inquirer.default.prompt([{
+			type: "input",
+			name: "url",
+			message: `URL (e.g. http://localhost:3001):`,
+			validate: (v) => v.startsWith("http") || "Must start with http"
+		}]);
+		url = res.url;
+	}
+	const server = {
+		id: name.toLowerCase().replace(/\s+/g, "-"),
+		name,
+		transport,
+		command,
+		url,
+		enabled: true,
+		addedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const servers = await loadServers();
+	servers.push(server);
+	await saveServers(servers);
+	console.log(chalk.default.green(`\n  ✔  MCP server added: ${name}`));
+	console.log(chalk.default.gray("  Run: hyperclaw mcp probe    to test the connection\n"));
+}
+async function mcpRemove(id) {
+	const servers = await loadServers();
+	const idx = servers.findIndex((s) => s.id === id);
+	if (idx === -1) {
+		console.log(chalk.default.red(`\n  ✖  Server not found: ${id}\n`));
+		return;
+	}
+	servers.splice(idx, 1);
+	await saveServers(servers);
+	console.log(chalk.default.green(`\n  ✔  MCP server removed: ${id}\n`));
+}
+async function mcpProbe(id) {
+	const servers = await loadServers();
+	const targets = id ? servers.filter((s) => s.id === id) : servers;
+	if (targets.length === 0) {
+		console.log(chalk.default.gray("\n  No servers to probe. Add one: hyperclaw mcp add\n"));
+		return;
+	}
+	console.log(chalk.default.bold.cyan("\n  🔍 PROBING MCP SERVERS\n"));
+	for (const server of targets) {
+		const spinner = (0, ora.default)(`  Probing ${server.name}...`).start();
+		await new Promise((r) => setTimeout(r, 800));
+		if (server.transport === "http" || server.transport === "sse") try {
+			const axios = (await import("axios")).default;
+			const res = await axios.get(`${server.url}/tools`, { timeout: 3e3 });
+			server.tools = res.data?.tools?.map((t) => t.name) || [];
+			server.lastProbeAt = (/* @__PURE__ */ new Date()).toISOString();
+			await saveServers(servers);
+			spinner.succeed(`${server.name} — ${server.tools?.length ?? 0} tools`);
+			if ((server.tools?.length ?? 0) > 0) console.log(chalk.default.gray(`    ${server.tools?.join(", ") ?? ""}`));
+		} catch {
+			spinner.warn(`${server.name} — unreachable (${server.url})`);
+		}
+		else {
+			server.lastProbeAt = (/* @__PURE__ */ new Date()).toISOString();
+			await saveServers(servers);
+			spinner.succeed(`${server.name} — stdio (probe requires running server)`);
+		}
+		console.log();
+	}
+}
+
+//#endregion
+exports.mcpAdd = mcpAdd;
+exports.mcpList = mcpList;
+exports.mcpProbe = mcpProbe;
+exports.mcpRemove = mcpRemove;