xaq-cli 0.0.0 → 0.1.0-nightly.71

package/dist/mcpsetup-DXXo2qjf.js

@@ -0,0 +1,1053 @@
+#!/usr/bin/env node
+import { t as NPX } from "./version-BxH7OuWD.js";
+import { a as mcpServerName, c as backupFile, f as writePrivateFile, u as isTooOpen } from "./profile-NmMKAczz.js";
+import "./paths-yzOKD6ow.js";
+import { c as helperScriptPath, n as claudeServerEntry, o as helperNodeNote } from "./mcpheader-C9H4vudu.js";
+import "./recipes-DG_-doGq.js";
+import { i as safeText } from "./ui-B8Sd4Y7Y.js";
+import { chmodSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { spawnSync } from "node:child_process";
+import { isDeepStrictEqual } from "node:util";
+//#region server/connections-cli/toml.ts
+/**
+* A small TOML reader for Codex's `[mcp_servers.*]` tables, without a TOML library. It reads table headers,
+* dotted and quoted keys, basic and literal strings, numbers, booleans, single- or multi-line arrays of those,
+* and one-line inline tables. Multi-line strings, dates and arrays of tables are UNREADABLE (for their value or
+* table), so the caller can skip an entry it can't read instead of guessing.
+*/
+const UNREADABLE$1 = Symbol("unreadable");
+var Cursor = class {
+	s;
+	i = 0;
+	constructor(s) {
+		this.s = s;
+	}
+	ws() {
+		while (this.i < this.s.length && /[ \t]/.test(this.s[this.i])) this.i++;
+	}
+	/** Whitespace, newlines and comments (inside arrays). */
+	wsAll() {
+		for (;;) {
+			while (this.i < this.s.length && /[ \t\r\n]/.test(this.s[this.i])) this.i++;
+			if (this.s[this.i] !== "#") return;
+			while (this.i < this.s.length && this.s[this.i] !== "\n") this.i++;
+		}
+	}
+	peek() {
+		return this.s[this.i];
+	}
+	done() {
+		return this.i >= this.s.length;
+	}
+};
+var Unreadable = class extends Error {};
+const ESCAPES = {
+	b: "\b",
+	t: "	",
+	n: "\n",
+	f: "\f",
+	r: "\r",
+	"\"": "\"",
+	"\\": "\\",
+	e: "\x1B"
+};
+function readString(c) {
+	const q = c.peek();
+	if (c.s.startsWith(`${q}${q}${q}`, c.i)) throw new Unreadable("multi-line string");
+	c.i++;
+	let out = "";
+	while (!c.done()) {
+		const ch = c.s[c.i++];
+		if (ch === "\n") break;
+		if (ch === q) return out;
+		if (q === "\"" && ch === "\\") {
+			const e = c.s[c.i++];
+			if (ESCAPES[e] !== void 0) out += ESCAPES[e];
+			else if (e === "u" || e === "U") {
+				const len = e === "u" ? 4 : 8;
+				const hex = c.s.slice(c.i, c.i + len);
+				if (!/^[0-9a-fA-F]+$/.test(hex) || hex.length !== len) throw new Unreadable("bad escape");
+				out += String.fromCodePoint(Number.parseInt(hex, 16));
+				c.i += len;
+			} else throw new Unreadable("bad escape");
+		} else out += ch;
+	}
+	throw new Unreadable("unterminated string");
+}
+function readKey(c) {
+	const parts = [];
+	for (;;) {
+		c.ws();
+		const ch = c.peek();
+		if (ch === "\"" || ch === "'") parts.push(readString(c));
+		else {
+			const m = /^[A-Za-z0-9_-]+/.exec(c.s.slice(c.i));
+			if (!m) throw new Unreadable("bad key");
+			parts.push(m[0]);
+			c.i += m[0].length;
+		}
+		c.ws();
+		if (c.peek() !== ".") return parts;
+		c.i++;
+	}
+}
+function readValue(c, multiline) {
+	const ch = c.peek();
+	if (ch === "\"" || ch === "'") return readString(c);
+	if (ch === "[") {
+		c.i++;
+		const items = [];
+		for (;;) {
+			if (multiline) c.wsAll();
+			else c.ws();
+			if (c.peek() === "]") {
+				c.i++;
+				return items;
+			}
+			items.push(readValue(c, multiline));
+			if (multiline) c.wsAll();
+			else c.ws();
+			if (c.peek() === ",") c.i++;
+			else if (c.peek() !== "]") throw new Unreadable("bad array");
+		}
+	}
+	if (ch === "{") {
+		c.i++;
+		const table = {};
+		c.ws();
+		if (c.peek() === "}") {
+			c.i++;
+			return table;
+		}
+		for (;;) {
+			const key = readKey(c);
+			if (c.peek() !== "=") throw new Unreadable("bad inline table");
+			c.i++;
+			c.ws();
+			setPath(table, key, readValue(c, false));
+			c.ws();
+			if (c.peek() === ",") {
+				c.i++;
+				continue;
+			}
+			if (c.peek() === "}") {
+				c.i++;
+				return table;
+			}
+			throw new Unreadable("bad inline table");
+		}
+	}
+	const m = /^[^\s,\]}#]+/.exec(c.s.slice(c.i));
+	if (!m) throw new Unreadable("missing value");
+	c.i += m[0].length;
+	if (m[0] === "true") return true;
+	if (m[0] === "false") return false;
+	const n = m[0].replace(/_/g, "");
+	if (/^[-+]?(\d+(\.\d+)?([eE][-+]?\d+)?|0x[0-9a-fA-F]+|0o[0-7]+|0b[01]+)$/.test(n)) return Number(n);
+	throw new Unreadable("unsupported value");
+}
+function setPath(table, path, value) {
+	let t = table;
+	for (const p of path.slice(0, -1)) {
+		const next = t[p];
+		if (next === void 0) t = t[p] = {};
+		else if (typeof next === "object" && !Array.isArray(next)) t = next;
+		else throw new Unreadable("key redefined");
+	}
+	const last = path[path.length - 1];
+	if (Object.hasOwn(t, last)) throw new Unreadable("key redefined");
+	t[last] = value;
+}
+function tableAt(root, path) {
+	let t = root;
+	for (const p of path) {
+		const next = t[p];
+		if (next === void 0) t = t[p] = {};
+		else if (typeof next === "object" && !Array.isArray(next)) t = next;
+		else throw new Unreadable("table redefined");
+	}
+	return t;
+}
+/**
+* The `mcp_servers` table of a Codex config.toml: server name → entry. A server whose table (or a value in it)
+* can't be read maps to UNREADABLE. Problems outside mcp_servers are ignored.
+*/
+function readTomlMcpServers(toml) {
+	const root = {};
+	const bad = /* @__PURE__ */ new Set();
+	let current = [];
+	const lines = toml.replace(/^/, "").split("\n");
+	for (let n = 0; n < lines.length; n++) {
+		const line = lines[n];
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		if (trimmed.startsWith("[[")) {
+			const c = new Cursor(trimmed.slice(2));
+			try {
+				current = ["\0array", ...readKey(c)];
+			} catch {
+				current = ["\0array"];
+			}
+			if (current[1] === "mcp_servers" && current[2]) bad.add(current[2]);
+			continue;
+		}
+		if (trimmed.startsWith("[")) {
+			const c = new Cursor(trimmed.slice(1));
+			try {
+				current = readKey(c);
+				if (c.peek() !== "]") throw new Unreadable("bad header");
+				if (current[0] === "mcp_servers") tableAt(root, current);
+			} catch {
+				current = ["\0bad"];
+			}
+			continue;
+		}
+		if (current[0] !== "mcp_servers" && !/^\s*mcp_servers\s*[.=]/.test(line)) continue;
+		let text = line;
+		let consumed = n;
+		let parsed = null;
+		for (;;) {
+			const c = new Cursor(text);
+			try {
+				const key = readKey(c);
+				if (c.peek() !== "=") throw new Unreadable("missing =");
+				c.i++;
+				c.ws();
+				const value = readValue(c, true);
+				c.ws();
+				if (!c.done() && c.peek() !== "#") throw new Unreadable("trailing characters");
+				parsed = {
+					key,
+					value
+				};
+				break;
+			} catch {
+				if (!((text.match(/\[/g) ?? []).length > (text.match(/]/g) ?? []).length) || consumed + 1 >= lines.length) break;
+				text += `\n${lines[++consumed]}`;
+			}
+		}
+		n = consumed;
+		const full = parsed ? [...current, ...parsed.key] : current;
+		const server = full[0] === "mcp_servers" ? full[1] : current[1];
+		if (!parsed) {
+			if (server) bad.add(server);
+			continue;
+		}
+		try {
+			setPath(root, full, parsed.value);
+		} catch {
+			if (server) bad.add(server);
+		}
+	}
+	const servers = root.mcp_servers;
+	const out = {};
+	if (servers && typeof servers === "object" && !Array.isArray(servers)) for (const [name, entry] of Object.entries(servers)) out[name] = bad.has(name) || !entry || typeof entry !== "object" || Array.isArray(entry) ? UNREADABLE$1 : entry;
+	for (const name of bad) out[name] = UNREADABLE$1;
+	return out;
+}
+//#endregion
+//#region server/connections-cli/yaml.ts
+/**
+* A small reader for the `mcp_servers:` block of a Hermes config.yaml, without a YAML library (like
+* server/listen/mcpsetup.ts). It handles the block style Hermes writes and documents: nested maps, plain and
+* quoted scalars, flow sequences of scalars (`args: ["-y", "pkg"]`) and block sequences of scalars. Anything else
+* (anchors, block scalars, flow maps, tabs) becomes UNREADABLE for that value, so the caller can skip the entry
+* that uses it instead of guessing. Only the mcp_servers block is read: the rest of the file never matters.
+*/
+const UNREADABLE = Symbol("unreadable");
+/** The text of a line without a trailing comment (a `#` after whitespace, outside quotes). */
+function stripComment(line) {
+	let quote = null;
+	for (let i = 0; i < line.length; i++) {
+		const ch = line[i];
+		if (quote) {
+			if (ch === "\\" && quote === "\"") i++;
+			else if (ch === quote) quote = null;
+		} else if (ch === "\"" || ch === "'") {
+			if (i === 0 || /[\s:[{,-]/.test(line[i - 1])) quote = ch;
+		} else if (ch === "#" && (i === 0 || /\s/.test(line[i - 1]))) return line.slice(0, i).trimEnd();
+	}
+	return line.trimEnd();
+}
+/** The line range of the top-level `mcp_servers:` block, or null when there isn't exactly one. */
+function mcpServersBlock(yaml) {
+	return topBlock(yaml, "mcp_servers");
+}
+const keyRe = (key) => new RegExp(`^${key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*:`);
+/** The line range of a top-level `<key>:` block, or null when there isn't exactly one. */
+function topBlock(yaml, key) {
+	const re = keyRe(key);
+	const lines = yaml.replace(/^/, "").split("\n");
+	const tops = lines.flatMap((l, i) => re.test(l) ? [i] : []);
+	if (tops.length !== 1) return null;
+	const start = tops[0];
+	let end = start + 1;
+	while (end < lines.length && (lines[end].trim() === "" || /^\s/.test(lines[end]) || lines[end].startsWith("#"))) end++;
+	while (end > start + 1 && (lines[end - 1].trim() === "" || lines[end - 1].startsWith("#"))) end--;
+	return {
+		start,
+		end,
+		inline: stripComment(lines[start].replace(re, "")).trim()
+	};
+}
+function unquote(raw) {
+	if (raw.startsWith("\"")) {
+		if (!raw.endsWith("\"") || raw.length < 2) return UNREADABLE;
+		try {
+			return JSON.parse(raw.replace(/\\\//g, "/"));
+		} catch {
+			return UNREADABLE;
+		}
+	}
+	if (raw.startsWith("'")) {
+		if (!raw.endsWith("'") || raw.length < 2) return UNREADABLE;
+		return raw.slice(1, -1).replace(/''/g, "'");
+	}
+	return raw;
+}
+/** Splits a flow sequence body on top-level commas. */
+function splitFlow(body) {
+	const out = [];
+	let cur = "";
+	let quote = null;
+	for (let i = 0; i < body.length; i++) {
+		const ch = body[i];
+		if (quote) {
+			cur += ch;
+			if (ch === "\\" && quote === "\"") cur += body[++i] ?? "";
+			else if (ch === quote) quote = null;
+		} else if (ch === "\"" || ch === "'") {
+			quote = ch;
+			cur += ch;
+		} else if (ch === "[" || ch === "{" || ch === "]" || ch === "}") return null;
+		else if (ch === ",") {
+			out.push(cur.trim());
+			cur = "";
+		} else cur += ch;
+	}
+	if (quote) return null;
+	if (cur.trim()) out.push(cur.trim());
+	return out;
+}
+function scalar(raw) {
+	const v = raw.trim();
+	if (v === "" || v === "~" || v === "null" || v === "Null" || v === "NULL") return null;
+	if (/^[&*!|>]/.test(v) || v.startsWith("<<") || v.startsWith("{")) return UNREADABLE;
+	if (v.startsWith("[")) {
+		if (!v.endsWith("]")) return UNREADABLE;
+		const items = splitFlow(v.slice(1, -1));
+		return items ? items.map((i) => scalar(i)) : UNREADABLE;
+	}
+	if (v.startsWith("\"") || v.startsWith("'")) return unquote(v);
+	if (/^(true|True|TRUE)$/.test(v)) return true;
+	if (/^(false|False|FALSE)$/.test(v)) return false;
+	if (/^[-+]?\d+(\.\d+)?$/.test(v)) return Number(v);
+	return v;
+}
+/** `key: rest` with a plain or quoted key; null when the line isn't one. */
+function keyValue(text) {
+	const m = /^("(?:[^"\\]|\\.)*"|'(?:[^']|'')*'|[^"'#:\s][^:]*?)\s*:(?:\s+(.*)|$)/.exec(text);
+	if (!m) return null;
+	const key = unquote(m[1]);
+	if (key === UNREADABLE) return null;
+	return {
+		key,
+		rest: (m[2] ?? "").trim()
+	};
+}
+function parseLines(lines, from, indent) {
+	const first = lines[from];
+	if (!first || first.indent < indent) return {
+		value: null,
+		next: from
+	};
+	const childIndent = first.indent;
+	if (first.text.startsWith("- ") || first.text === "-") {
+		const items = [];
+		let i = from;
+		while (i < lines.length && lines[i].indent === childIndent && (lines[i].text.startsWith("- ") || lines[i].text === "-")) {
+			const item = lines[i].text.slice(1).trim();
+			i++;
+			if (!item || keyValue(item)) {
+				items.push(UNREADABLE);
+				while (i < lines.length && lines[i].indent > childIndent) i++;
+			} else items.push(scalar(item));
+		}
+		return {
+			value: items,
+			next: i
+		};
+	}
+	const map = {};
+	let i = from;
+	while (i < lines.length && lines[i].indent >= childIndent) {
+		const line = lines[i];
+		if (line.indent > childIndent) {
+			const keys = Object.keys(map);
+			if (keys.length) map[keys[keys.length - 1]] = UNREADABLE;
+			i++;
+			continue;
+		}
+		const kv = keyValue(line.text);
+		i++;
+		if (!kv) {
+			map[`\u0000line${i}`] = UNREADABLE;
+			continue;
+		}
+		if (kv.rest) {
+			map[kv.key] = Object.hasOwn(map, kv.key) ? UNREADABLE : scalar(kv.rest);
+			continue;
+		}
+		if (!(i < lines.length && (lines[i].indent > childIndent || lines[i].indent === childIndent && lines[i].text.startsWith("- ")))) {
+			map[kv.key] = null;
+			continue;
+		}
+		const sub = parseLines(lines, i, lines[i].indent > childIndent ? childIndent + 1 : childIndent);
+		map[kv.key] = Object.hasOwn(map, kv.key) ? UNREADABLE : sub.value;
+		i = sub.next;
+	}
+	return {
+		value: map,
+		next: i
+	};
+}
+/**
+* The `mcp_servers` map of a Hermes config.yaml: server name → its (partly) parsed entry. null when the file has
+* no single readable block (`{}` and an absent key give an empty map).
+*/
+function readMcpServers(yaml) {
+	return readTopMap(yaml, "mcp_servers");
+}
+/** A top-level block map (e.g. `platform_toolsets`), read like mcp_servers. */
+function readTopMap(yaml, key) {
+	const block = topBlock(yaml, key);
+	if (!block) return new RegExp(keyRe(key).source, "m").test(yaml) ? null : {};
+	if (block.inline) return block.inline === "{}" || block.inline === "null" || block.inline === "~" ? {} : null;
+	const raw = yaml.replace(/^/, "").split("\n").slice(block.start + 1, block.end);
+	const lines = [];
+	for (const l of raw) {
+		const text = stripComment(l);
+		if (!text.trim()) continue;
+		const ws = /^(\s*)/.exec(text)[1];
+		if (ws.includes("	")) return null;
+		lines.push({
+			indent: ws.length,
+			text: text.trim()
+		});
+	}
+	if (!lines.length) return {};
+	const { value } = parseLines(lines, 0, 1);
+	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+const escapeRe$1 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+* Removes `mcp_servers.<name>` for each name, keeping everything else byte for byte. Returns null when any of
+* them isn't a plain block entry this can cut out safely (then nothing should be written).
+*/
+/**
+* Cuts the named entries out of an mcp_servers block body (its lines after `mcp_servers:`), whose entries sit at
+* `indent`. Comment and blank lines met inside a cut entry are held until the next real line decides: a sibling
+* key at `indent` (or less) keeps them with what follows (unless that is cut too), a deeper line means they were
+* part of the cut entry. So a commented-out property (`#    timeout: 120`) or a note (`  # TODO`) inside an entry
+* never ends it early, and none of its lines can end up under a neighbour. null when a layout can't be cut safely.
+*/
+/**
+* Whether lines use YAML anchors, aliases or merge keys (`&a`, `*a`, `<<:`) outside quotes and comments. Cutting
+* an entry could then remove an anchor a kept entry still refers to, so those blocks are never rewritten.
+*/
+function hasAnchors(lines) {
+	return lines.some((l) => {
+		const t = stripComment(l).replace(/"(?:[^"\\]|\\.)*"/g, "\"\"").replace(/'(?:[^']|'')*'/g, "''");
+		return /(^|[\s:[{,-])[&*][^\s,\]}]/.test(t) || /(^|[\s{,-])<<\s*:/.test(t);
+	});
+}
+function cutEntries(body, indent, names) {
+	if (hasAnchors(body)) return null;
+	const isKey = (l, name) => new RegExp(`^${escapeRe$1(indent)}(["']?)${escapeRe$1(name)}\\1\\s*:`).test(l);
+	const ind = (l) => /^(\s*)/.exec(l)[1].length;
+	const isComment = (l) => l.trimStart().startsWith("#");
+	const kept = [];
+	const found = /* @__PURE__ */ new Set();
+	let skipping = false;
+	let pending = [];
+	for (const l of body) {
+		const blank = !l.trim();
+		if (skipping && (blank || isComment(l))) {
+			pending.push(l);
+			continue;
+		}
+		if (blank || isComment(l)) {
+			kept.push(l);
+			continue;
+		}
+		const own = ind(l);
+		if (own < indent.length) return null;
+		if (own > indent.length) {
+			if (skipping) pending = [];
+			else kept.push(l);
+			continue;
+		}
+		const hit = names.find((n) => isKey(l, n)) ?? null;
+		if (hit) {
+			if (found.has(hit)) return null;
+			found.add(hit);
+			if (stripComment(l).replace(/^[^:]*:/, "").trim()) return null;
+			pending = [];
+			while (kept.length && isComment(kept[kept.length - 1]) && ind(kept[kept.length - 1]) <= indent.length) kept.pop();
+			skipping = true;
+			continue;
+		}
+		if (skipping) kept.push(...pending.filter((x) => !x.trim() || ind(x) <= indent.length));
+		pending = [];
+		skipping = false;
+		kept.push(l);
+	}
+	return {
+		kept,
+		found
+	};
+}
+/**
+* Removes `mcp_servers.<name>` for each name, keeping everything else byte for byte. Returns null when any of
+* them isn't a plain block entry this can cut out safely (then nothing should be written).
+*/
+function removeYamlServers(yaml, names) {
+	if (!names.length) return yaml;
+	const block = mcpServersBlock(yaml);
+	if (!block || block.inline) return null;
+	const lines = yaml.split("\n");
+	const body = lines.slice(block.start + 1, block.end);
+	const first = body.find((l) => l.trim() && !l.trimStart().startsWith("#"));
+	if (!first) return null;
+	const indent = /^(\s*)/.exec(first)[1];
+	if (!indent || indent.includes("	")) return null;
+	const cut = cutEntries(body, indent, names);
+	if (!cut || cut.found.size !== names.length) return null;
+	const { kept } = cut;
+	const hasChild = kept.some((l) => l.trim() && !l.trimStart().startsWith("#"));
+	const head = hasChild ? lines[block.start] : "mcp_servers: {}";
+	return [
+		...lines.slice(0, block.start),
+		head,
+		...hasChild ? kept : kept.filter((l) => l.trim()),
+		...lines.slice(block.end)
+	].join("\n");
+}
+//#endregion
+//#region server/listen/mcpsetup.ts
+/**
+* The safety net under every rewrite: the new file, read back with the same readers, must hold exactly the old
+* entries minus the removed ones (each unchanged, deep-equal), plus our entry as intended. Anything else means the
+* rewrite moved a line where it doesn't belong (e.g. a header under another server): refuse it. Returns the
+* problem, or null when it's right.
+*/
+function checkRewrite(before, after, ours, removed) {
+	if (!before || !after) return "it can't be read back";
+	const opaque = (v) => typeof v === "symbol" || !!v && typeof v === "object" && Object.values(v).some(opaque);
+	const gone = new Set(removed);
+	for (const [name, entry] of Object.entries(before)) {
+		if (name === ours.name || gone.has(name)) continue;
+		if (!(name in after)) return `"${name}" would disappear`;
+		if (opaque(entry) || opaque(after[name])) return `"${name}" has a value this can't read, so the result can't be verified`;
+		if (!isDeepStrictEqual(after[name], entry)) return `"${name}" would change`;
+	}
+	for (const name of removed) if (name in after) return `"${name}" would still be there`;
+	for (const name of Object.keys(after)) if (name !== ours.name && !(name in before)) return `"${name}" would appear`;
+	if (!isDeepStrictEqual(after[ours.name], ours.entry)) return `"${ours.name}" wouldn't be exactly the new entry`;
+	return null;
+}
+const refused = (file, why, manual) => ({
+	ok: false,
+	message: `Not rewriting ${file}: read back, the result isn't right (${why}). Nothing was changed.`,
+	manual
+});
+/** The entries to remove, never the xaq entry itself. */
+const removals = (t, opts) => (opts.removeServers ?? []).filter((r) => r.name !== t.name);
+const removedNote = (extra) => extra.length ? ` Removed ${extra.map((r) => `"${r.name}"`).join(", ")} (now served through xaq).` : "";
+const removedLine = (name, file) => `remove ${name} from ${file} (it's now served through xaq)`;
+/** Placeholder shown wherever the key would go in printed file contents. */
+const KEY_SHOWN = "<the key from your xaq profile>";
+const backupLine = (file) => existsSync(file) ? `back up ${file} to ${file}.xaq-backup-<timestamp> (0600)` : `${file} doesn't exist yet: nothing to back up`;
+const indent = (text) => text.replace(/\n$/, "").split("\n").map((l) => `    ${l}`);
+const redact = (s, key) => s.split(key).join("aib_…(redacted)");
+/**
+* The MCP endpoint is always derived from the URL the user connected to (and transport-checked
+* there), never taken from the daemon: a daemon's advertised mcpUrl comes from its publicUrl setting,
+* which defaults to http://localhost:8425 and could also point the key somewhere else entirely.
+*/
+function mcpTarget(profileName, profile) {
+	return {
+		name: mcpServerName(profileName),
+		url: `${profile.url}/mcp`,
+		key: profile.apiKey,
+		profile: profileName
+	};
+}
+function setupMcp(tool, t, profileFile, opts = {}) {
+	switch (tool) {
+		case "claude-code": return setupClaude(t, t.profile ?? "default", opts);
+		case "codex": return setupCodex(t, profileFile, opts);
+		case "cursor": return setupCursor(t, profileFile, opts);
+		case "hermes": return setupHermes(t, profileFile, opts);
+		default: return {
+			ok: false,
+			message: "No automatic MCP setup for --tool other.",
+			manual: manualGeneric(t, profileFile)
+		};
+	}
+}
+function manualGeneric(t, profileFile) {
+	return [`MCP endpoint (streamable HTTP): ${t.url}`, `Header: Authorization: Bearer <key>. The key is the "apiKey" field in ${profileFile}; tools that run a header helper can use \`${NPX} mcp-header\`, which prints it as JSON to a pipe.`];
+}
+const claudeConfigFile = () => process.env.CLAUDE_CONFIG_DIR ? join(process.env.CLAUDE_CONFIG_DIR, ".claude.json") : join(homedir(), ".claude.json");
+function setupClaude(t, profile, opts) {
+	const json = JSON.stringify(claudeServerEntry(t.url, profile, { install: !opts.dryRun }));
+	const addCommand = `claude mcp add-json --scope user ${t.name} '${json.replace(/'/g, `'"'"'`)}'`;
+	const manual = [addCommand];
+	const file = claudeConfigFile();
+	const verify = [`claude mcp list   (shows "${t.name}" as connected; inside Claude Code: /mcp)`];
+	const notes = [helperNodeNote(profile, `${NPX} setup-mcp --tool claude-code${profile === "default" ? "" : ` --profile ${profile}`}`)];
+	const removeArgs = removals(t, opts).map((r) => ({
+		r,
+		args: [
+			"mcp",
+			"remove",
+			r.name,
+			"--scope",
+			r.scope ?? "user"
+		],
+		cwd: r.projectDir
+	}));
+	const changes = [
+		`write the header helper ${helperScriptPath()} (0600; reads the key from your profile when Claude Code connects)`,
+		backupLine(file),
+		`run: claude mcp remove ${t.name} --scope user   (drops an earlier "${t.name}" entry, if any)`,
+		`run: ${addCommand}`,
+		...removeArgs.map((x) => `run: claude ${x.args.join(" ")}${x.cwd ? `   (in ${x.cwd})` : ""}   (now served through xaq)`),
+		`the key stays in your xaq profile: neither the command line nor ${file} contains it`
+	];
+	if (opts.dryRun) return {
+		ok: true,
+		dryRun: true,
+		message: `Dry run for Claude Code: nothing was changed. setup-mcp would:`,
+		changes,
+		verify,
+		notes
+	};
+	const probe = spawnSync("claude", ["--version"], { stdio: "ignore" });
+	if (probe.error || probe.status !== 0) return {
+		ok: false,
+		message: "The `claude` CLI was not found on PATH.",
+		manual
+	};
+	const backup = backupFile(file);
+	spawnSync("claude", [
+		"mcp",
+		"remove",
+		t.name,
+		"--scope",
+		"user"
+	], { stdio: "ignore" });
+	const r = spawnSync("claude", [
+		"mcp",
+		"add-json",
+		"--scope",
+		"user",
+		t.name,
+		json
+	], {
+		encoding: "utf8",
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	if (r.status !== 0) {
+		const out = redact(`${r.stderr ?? ""}${r.stdout ?? ""}`, t.key).trim();
+		return {
+			ok: false,
+			message: `claude mcp add-json failed${out ? `: ${safeText(out, 300)}` : ""}`,
+			backup,
+			manual
+		};
+	}
+	const done = [];
+	for (const x of removeArgs) if (spawnSync("claude", x.args, {
+		encoding: "utf8",
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		cwd: x.cwd
+	}).status === 0) done.push(`ran: claude ${x.args.join(" ")}`);
+	else notes.push(`Couldn't remove "${x.r.name}" (${x.r.scope ?? "user"} scope): remove it yourself with claude ${x.args.join(" ")}${x.cwd ? ` in ${x.cwd}` : ""}.`);
+	if (existsSync(file) && isTooOpen(file)) chmodSync(file, 384);
+	return {
+		ok: true,
+		message: `Registered MCP server "${t.name}" in Claude Code (user scope). The key stays in your xaq profile; Claude Code asks for it through a header helper.`,
+		backup,
+		changes: [
+			`ran: ${addCommand}`,
+			`${file} now lists "${t.name}" (user scope)`,
+			...done
+		],
+		verify,
+		notes,
+		removed: removeArgs.filter((x) => done.includes(`ran: claude ${x.args.join(" ")}`)).map((x) => x.r.name)
+	};
+}
+const codexConfigFile = () => join(process.env.CODEX_HOME || join(homedir(), ".codex"), "config.toml");
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const tomlString = (s) => JSON.stringify(s);
+/** Removes `[mcp_servers.<name>]` and its sub-tables from a TOML document, or returns null if it's defined in a form we won't rewrite safely. */
+function removeTomlServer(toml, name) {
+	const keyForms = `(?:${escapeRe(name)}|"${escapeRe(name)}"|'${escapeRe(name)}')`;
+	const header = new RegExp(`^\\s*\\[\\s*mcp_servers\\s*\\.\\s*${keyForms}\\s*(?:\\.[^\\]]*)?\\]\\s*(?:#.*)?$`);
+	const anyHeader = /^\s*\[/;
+	if (new RegExp(`^\\s*mcp_servers\\s*(?:=|\\.\\s*${keyForms}\\s*[.=])`, "m").test(toml)) return null;
+	const out = [];
+	let skipping = false;
+	for (const line of toml.split("\n")) {
+		if (anyHeader.test(line)) skipping = header.test(line);
+		if (!skipping && line.trim() !== CODEX_MARKER && line.trim() !== LEGACY_CODEX_MARKER) out.push(line);
+	}
+	return out.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+const CODEX_MARKER = "# Added by `xaq setup-mcp`. The key is also in your xaq profile; rotate it in the console.";
+/** The marker setup-mcp wrote before the rename: dropped too when the table is rewritten. */
+const LEGACY_CODEX_MARKER = "# Added by `agentinbox setup-mcp`. The key is also in your agentinbox profile; rotate it in the console.";
+function codexBlock(t) {
+	return [
+		CODEX_MARKER,
+		`[mcp_servers.${t.name}]`,
+		`url = ${tomlString(t.url)}`,
+		`http_headers = { Authorization = ${tomlString(`Bearer ${t.key}`)} }`,
+		`# codex exec never prompts: approve ${t.name} tools up front (the grant's send mode still applies).`,
+		`default_tools_approval_mode = "approve"`,
+		""
+	].join("\n");
+}
+function setupCodex(t, profileFile, opts) {
+	const file = codexConfigFile();
+	const manual = [
+		`Add to ${file}:`,
+		`  [mcp_servers.${t.name}]`,
+		`  url = "${t.url}"`,
+		`  http_headers = { Authorization = "Bearer <key>" }   # <key>: the apiKey field of ${profileFile}`,
+		`  default_tools_approval_mode = "approve"`
+	];
+	const current = existsSync(file) ? readFileSync(file, "utf8") : "";
+	const withoutOurs = removeTomlServer(current, t.name);
+	if (withoutOurs === null) return {
+		ok: false,
+		message: `${file} defines mcp_servers inline; not rewriting it automatically.`,
+		manual
+	};
+	let without = withoutOurs;
+	const extra = removals(t, opts);
+	for (const r of extra) {
+		const next = removeTomlServer(without, r.name);
+		if (next === null || next === without) return {
+			ok: false,
+			message: `Couldn't remove [mcp_servers.${r.name}] from ${file} safely; nothing was changed.`,
+			manual
+		};
+		without = next;
+	}
+	const verify = [`codex mcp list   (shows "${t.name}")`];
+	const replaces = withoutOurs !== current.replace(/\n{3,}/g, "\n\n") ? `replace [mcp_servers.${t.name}] in` : `add [mcp_servers.${t.name}] to`;
+	const changes = [
+		backupLine(file),
+		...extra.map((r) => removedLine(`[mcp_servers.${r.name}]`, file)),
+		`${replaces} ${file} (other tables are kept) and set the file to 0600, since it will hold the key:`,
+		...indent(codexBlock({
+			...t,
+			key: KEY_SHOWN
+		}))
+	];
+	const base = without.replace(/\s*$/, "");
+	const next = `${base ? `${base}\n\n` : ""}${codexBlock(t)}`;
+	const toTable = (x) => x;
+	const problem = checkRewrite(toTable(readTomlMcpServers(current)), toTable(readTomlMcpServers(next)), {
+		name: t.name,
+		entry: {
+			url: t.url,
+			http_headers: { Authorization: `Bearer ${t.key}` },
+			default_tools_approval_mode: "approve"
+		}
+	}, extra.map((r) => r.name));
+	if (problem) return refused(file, problem, manual);
+	if (opts.dryRun) return {
+		ok: true,
+		dryRun: true,
+		message: `Dry run for Codex: nothing was changed. setup-mcp would:`,
+		changes,
+		verify
+	};
+	const backup = backupFile(file);
+	writePrivateFile(file, next, { privateDir: false });
+	return {
+		ok: true,
+		message: `Added [mcp_servers.${t.name}] to ${file} (now mode 0600: it holds the key).${removedNote(extra)}`,
+		backup,
+		verify,
+		removed: extra.map((r) => r.name)
+	};
+}
+const cursorConfigFile = () => join(homedir(), ".cursor", "mcp.json");
+function setupCursor(t, profileFile, opts) {
+	const file = cursorConfigFile();
+	const manual = [`Add to ${file} under "mcpServers":`, `  "${t.name}": { "url": "${t.url}", "headers": { "Authorization": "Bearer <key>" } }   // <key>: the apiKey field of ${profileFile}`];
+	let doc = {};
+	if (existsSync(file)) {
+		const text = readFileSync(file, "utf8");
+		if (text.trim()) {
+			try {
+				doc = JSON.parse(text);
+			} catch {
+				return {
+					ok: false,
+					message: `${file} is not plain JSON (comments?); not rewriting it automatically.`,
+					manual
+				};
+			}
+			if (!doc || typeof doc !== "object" || Array.isArray(doc)) return {
+				ok: false,
+				message: `${file} is not a JSON object.`,
+				manual
+			};
+		}
+	}
+	const servers = doc.mcpServers && typeof doc.mcpServers === "object" && !Array.isArray(doc.mcpServers) ? doc.mcpServers : {};
+	const verify = [`agent mcp list   (Cursor CLI; or Cursor Settings → MCP shows "${t.name}")`];
+	const entry = (key) => ({
+		url: t.url,
+		headers: { Authorization: `Bearer ${key}` }
+	});
+	const extra = removals(t, opts);
+	const absent = extra.find((r) => !(r.name in servers));
+	if (absent) return {
+		ok: false,
+		message: `"mcpServers.${absent.name}" isn't in ${file}; nothing was changed.`,
+		manual
+	};
+	const changes = [
+		backupLine(file),
+		...extra.map((r) => removedLine(`"mcpServers.${r.name}"`, file)),
+		`${t.name in servers ? "replace" : "add"} "mcpServers.${t.name}" ${t.name in servers ? "in" : "to"} ${file} (other servers are kept) and set the file to 0600, since it will hold the key:`,
+		...indent(`"${t.name}": ${JSON.stringify(entry(KEY_SHOWN), null, 2)}`)
+	];
+	if (opts.dryRun) return {
+		ok: true,
+		dryRun: true,
+		message: `Dry run for Cursor: nothing was changed. setup-mcp would:`,
+		changes,
+		verify
+	};
+	const before = structuredClone(servers);
+	for (const r of extra) delete servers[r.name];
+	servers[t.name] = entry(t.key);
+	doc.mcpServers = servers;
+	const reread = JSON.parse(JSON.stringify(doc)).mcpServers;
+	const problem = checkRewrite(before, reread, {
+		name: t.name,
+		entry: entry(t.key)
+	}, extra.map((r) => r.name));
+	if (problem) return refused(file, problem, manual);
+	const backup = backupFile(file);
+	writePrivateFile(file, JSON.stringify(doc, null, 2) + "\n", { privateDir: false });
+	return {
+		ok: true,
+		message: `Added "${t.name}" to ${file} (now mode 0600: it holds the key).${removedNote(extra)} Cursor may ask you to enable it once.`,
+		backup,
+		verify,
+		removed: extra.map((r) => r.name)
+	};
+}
+/**
+* The Hermes home a bare `hermes` uses (hermes_constants.py / hermes_cli/profiles.py): $HERMES_HOME, else
+* ~/.hermes (plus HERMES_DATA_DIR_SUFFIX), switched to profiles/<name> by the sticky `active_profile` file.
+* Commands xaq runs get HERMES_HOME set to this, so they edit the same files.
+*/
+function hermesHome(env = process.env) {
+	const set = env.HERMES_HOME?.trim();
+	if (set) return set.replace(/^~(?=\/|$)/, homedir());
+	const root = join(homedir(), `.hermes${env.HERMES_DATA_DIR_SUFFIX ?? ""}`);
+	let active = "";
+	try {
+		active = readFileSync(join(root, "active_profile"), "utf8").replace(/^\uFEFF/, "").trim().toLowerCase();
+	} catch {}
+	return active && active !== "default" && /^[a-z0-9][a-z0-9_-]*$/.test(active) ? join(root, "profiles", active) : root;
+}
+/**
+* Whether `mcp_servers.<name>` is on in a Hermes config.yaml ("enabled" absent, null or not a false word
+* is on, like Hermes' mcp_server_enabled). "unknown" for layouts this small block-YAML reader won't judge:
+* callers that need it on treat that as not on.
+*/
+function yamlMcpServerState(yaml, name) {
+	const lines = yaml.replace(/^\uFEFF/, "").split("\n");
+	const tops = lines.flatMap((l, i) => /^mcp_servers\s*:/.test(l) ? [i] : []);
+	if (tops.length === 0) return "missing";
+	if (tops.length > 1) return "unknown";
+	const top = tops[0];
+	const rest = lines[top].replace(/^mcp_servers\s*:/, "").replace(/\s#.*$/, "").trim();
+	if (rest) return rest === "{}" || rest === "null" || rest === "~" ? "missing" : "unknown";
+	let end = top + 1;
+	while (end < lines.length && (lines[end].trim() === "" || /^\s/.test(lines[end]) || lines[end].startsWith("#"))) end++;
+	const body = lines.slice(top + 1, end).filter((l) => l.trim() && !l.trimStart().startsWith("#"));
+	if (!body.length) return "missing";
+	const indent = body[0].match(/^(\s*)/)[1];
+	if (!indent || /\t/.test(indent) || body.some((l) => /[&*]|<</.test(l.split("#")[0]))) return "unknown";
+	const key = new RegExp(`^${indent}(["']?)${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\1\\s*:(.*)$`);
+	const starts = body.flatMap((l, i) => key.test(l) ? [i] : []);
+	if (starts.length === 0) return "missing";
+	if (starts.length > 1) return "unknown";
+	if (key.exec(body[starts[0]])[2].replace(/\s#.*$/, "").trim()) return "unknown";
+	const own = [];
+	for (const l of body.slice(starts[0] + 1)) {
+		if (l.match(/^(\s*)/)[1].length <= indent.length) break;
+		own.push(l);
+	}
+	if (!own.length) return "unknown";
+	const childIndent = own[0].match(/^(\s*)/)[1].length;
+	const enabled = own.filter((l) => l.match(/^(\s*)/)[1].length === childIndent && /^\s*["']?enabled["']?\s*:/.test(l));
+	if (enabled.length > 1) return "unknown";
+	if (!enabled.length) return "enabled";
+	const value = enabled[0].replace(/^\s*["']?enabled["']?\s*:/, "").replace(/\s#.*$/, "").trim().replace(/^["']|["']$/g, "").toLowerCase();
+	return [
+		"false",
+		"0",
+		"no",
+		"off"
+	].includes(value) ? "disabled" : "enabled";
+}
+const hermesEnvVar = (name) => name.toUpperCase().replace(/[^A-Z0-9]/g, "_") + "_API_KEY";
+/**
+* Inserts or replaces `mcp_servers.<name>` in a YAML document without a YAML library, handling the
+* common block-style layout. Returns null for anything unusual (flow style, anchors, odd indentation).
+*/
+function upsertYamlServer(yaml, name, entry) {
+	const lines = yaml.split("\n");
+	const top = lines.findIndex((l) => /^mcp_servers\s*:/.test(l));
+	const block = (indent) => [`${indent}${name}:`, ...entry.map((e) => `${indent}${indent}${e}`)];
+	if (top < 0) {
+		const base = yaml.replace(/\s*$/, "");
+		return `${base ? `${base}\n\n` : ""}mcp_servers:\n${block("  ").join("\n")}\n`;
+	}
+	const rest = lines[top].replace(/^mcp_servers\s*:/, "").replace(/#.*$/, "").trim();
+	if (rest && rest !== "{}" && rest !== "null" && rest !== "~") return null;
+	if (rest) lines[top] = "mcp_servers:";
+	let end = top + 1;
+	while (end < lines.length && (lines[end].trim() === "" || /^\s/.test(lines[end]))) end++;
+	const body = lines.slice(top + 1, end);
+	const firstChild = body.find((l) => l.trim() && !l.trimStart().startsWith("#"));
+	const indent = firstChild ? firstChild.match(/^(\s*)/)[1] : "  ";
+	if (!indent || /\t/.test(indent)) return null;
+	const cut = cutEntries(body, indent, [name]);
+	if (!cut) return null;
+	const { kept } = cut;
+	const insert = block(indent);
+	return [
+		...lines.slice(0, top + 1),
+		...insert,
+		...kept,
+		...lines.slice(end)
+	].join("\n");
+}
+function upsertEnvLine(text, key, value) {
+	const line = `${key}=${value}`;
+	const re = new RegExp(`^\\s*(?:export\\s+)?${escapeRe(key)}\\s*=.*$`, "m");
+	if (re.test(text)) return text.replace(re, line);
+	const base = text.replace(/\s*$/, "");
+	return `${base ? `${base}\n` : ""}${line}\n`;
+}
+function setupHermes(t, profileFile, opts) {
+	const home = hermesHome();
+	const configFile = join(home, "config.yaml");
+	const envFile = join(home, ".env");
+	const envVar = hermesEnvVar(t.name);
+	const entry = [
+		`url: ${JSON.stringify(t.url)}`,
+		`headers:`,
+		`  Authorization: "Bearer \${${envVar}}"`
+	];
+	const manual = [
+		`Add to ${configFile}:`,
+		`  mcp_servers:`,
+		`    ${t.name}:`,
+		...entry.map((e) => `      ${e}`),
+		`and to ${envFile}:  ${envVar}=<key>   (<key>: the apiKey field of ${profileFile})`,
+		`then check it with: hermes mcp test ${t.name}`
+	];
+	const current = existsSync(configFile) ? readFileSync(configFile, "utf8") : "";
+	const extra = removals(t, opts);
+	const blk = mcpServersBlock(current);
+	if (blk && hasAnchors(current.split("\n").slice(blk.start + 1, blk.end))) return {
+		ok: false,
+		message: `${configFile} uses YAML anchors, aliases or merge keys (&, *, <<) under mcp_servers; not rewriting it automatically. Nothing was changed.`,
+		manual
+	};
+	const upserted = upsertYamlServer(current, t.name, entry);
+	const next = upserted === null ? null : removeYamlServers(upserted, extra.map((r) => r.name));
+	if (upserted !== null && next === null) return {
+		ok: false,
+		message: `Couldn't remove ${extra.map((r) => `"${r.name}"`).join(", ")} from ${configFile} safely; nothing was changed.`,
+		manual
+	};
+	if (next === null) return {
+		ok: false,
+		message: `${configFile} uses a layout we won't rewrite automatically.`,
+		manual
+	};
+	{
+		const ours = {
+			url: t.url,
+			headers: { Authorization: `Bearer \${${envVar}}` }
+		};
+		const problem = checkRewrite(readMcpServers(current), readMcpServers(next), {
+			name: t.name,
+			entry: ours
+		}, extra.map((r) => r.name));
+		if (problem) return refused(configFile, problem, manual);
+	}
+	const verify = [`hermes mcp test ${t.name}`];
+	const changes = [
+		backupLine(configFile),
+		backupLine(envFile),
+		...extra.map((r) => removedLine(`"mcp_servers.${r.name}"`, configFile)),
+		`add (or replace) "mcp_servers.${t.name}" in ${configFile} (0600):`,
+		...indent([
+			"mcp_servers:",
+			`  ${t.name}:`,
+			...entry.map((e) => `    ${e}`)
+		].join("\n")),
+		`set ${envVar}=${KEY_SHOWN} in ${envFile} (0600; Hermes' place for secrets)`
+	];
+	if (opts.dryRun) return {
+		ok: true,
+		dryRun: true,
+		message: `Dry run for Hermes: nothing was changed. setup-mcp would:`,
+		changes,
+		verify
+	};
+	const envCurrent = existsSync(envFile) ? readFileSync(envFile, "utf8") : "";
+	const backup = backupFile(configFile);
+	const envBackup = backupFile(envFile);
+	writePrivateFile(envFile, upsertEnvLine(envCurrent, envVar, t.key), { privateDir: false });
+	writePrivateFile(configFile, next.endsWith("\n") ? next : `${next}\n`, { privateDir: false });
+	return {
+		ok: true,
+		message: `Added "${t.name}" to ${configFile}; the key is in ${envFile} as ${envVar} (0600).${removedNote(extra)}`,
+		backup: [backup, envBackup].filter(Boolean).join(", ") || null,
+		verify,
+		removed: extra.map((r) => r.name)
+	};
+}
+//#endregion
+export { readTomlMcpServers as _, cursorConfigFile as a, mcpTarget as c, upsertYamlServer as d, yamlMcpServerState as f, UNREADABLE$1 as g, readTopMap as h, codexConfigFile as i, removeTomlServer as l, readMcpServers as m, claudeConfigFile as n, hermesEnvVar as o, UNREADABLE as p, codexBlock as r, hermesHome as s, checkRewrite as t, setupMcp as u };
+
+//# sourceMappingURL=mcpsetup-DXXo2qjf.js.map