xaq-cli 0.0.0 → 0.1.0-nightly.72

package/dist/import-DsN5NZT3.js

@@ -0,0 +1,910 @@
+#!/usr/bin/env node
+import { t as NPX } from "./version-BxH7OuWD.js";
+import { a as mcpServerName, n as loadProfile, r as profileExists } from "./profile-NmMKAczz.js";
+import { c as profilePath } from "./paths-yzOKD6ow.js";
+import "./recipes-DG_-doGq.js";
+import { i as safeText } from "./ui-B8Sd4Y7Y.js";
+import { _ as readTomlMcpServers, a as cursorConfigFile, c as mcpTarget, g as UNREADABLE$1, h as readTopMap, i as codexConfigFile, m as readMcpServers, n as claudeConfigFile, p as UNREADABLE, s as hermesHome, u as setupMcp } from "./mcpsetup-DXXo2qjf.js";
+import { _ as chooseAccess, a as isWorking, d as waitWorking, f as reconnectHint, g as agentsLabel, h as accessLabel, m as checkTarget, p as slugify, v as chooseAgents, y as parseAccess } from "./manage-Bo6COB4p.js";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import pc from "picocolors";
+//#region server/connections-cli/routes.ts
+/**
+* Places in a client's config that confine something to the xaq MCP server alone: Hermes platform toolsets,
+* webhook routes (`toolsets: ["mcp-<server>", …]`) and cron jobs (`enabled_toolsets: ["<server>"]`). Once the
+* imported servers are served through xaq, each of these also sees their tools, so `import` warns before
+* replacing anything (docs/listen.md: an email-triggered route confined to xaq).
+*/
+function confinedRoutes(client, serverName, env = process.env) {
+	if (client !== "hermes") return [];
+	const home = hermesHome(env);
+	const names = /* @__PURE__ */ new Set([serverName, `mcp-${serverName}`]);
+	const confines = (v) => Array.isArray(v) && v.some((x) => typeof x === "string" && names.has(x));
+	const out = [];
+	const read = (file) => {
+		try {
+			return existsSync(file) ? JSON.parse(readFileSync(file, "utf8").replace(/^/, "")) : null;
+		} catch {
+			return null;
+		}
+	};
+	try {
+		const config = join(home, "config.yaml");
+		if (existsSync(config)) {
+			const yaml = readFileSync(config, "utf8");
+			const platforms = readTopMap(yaml, "platform_toolsets") ?? {};
+			for (const [platform, toolsets] of Object.entries(platforms)) if (confines(toolsets)) out.push(`platform_toolsets.${platform} (config.yaml)`);
+			const get = (v, k) => v && typeof v === "object" && !Array.isArray(v) ? v[k] : void 0;
+			const routes = get(get(get(readTopMap(yaml, "platforms") ?? void 0, "webhook"), "extra"), "routes");
+			if (routes === UNREADABLE || Array.isArray(routes) && routes.some((r) => r === UNREADABLE)) out.push("webhook routes in config.yaml (platforms.webhook.extra.routes: couldn't be read, so check their toolsets)");
+			else if (Array.isArray(routes)) routes.forEach((r, i) => {
+				if (confines(get(r, "toolsets"))) out.push(`webhook route ${String(get(r, "name") ?? `#${i + 1}`)} (config.yaml)`);
+			});
+			else if (routes && typeof routes === "object") {
+				for (const [name, r] of Object.entries(routes)) if (confines(get(r, "toolsets"))) out.push(`webhook route ${name} (config.yaml)`);
+			}
+		}
+	} catch {}
+	const subs = read(join(home, "webhook_subscriptions.json"));
+	if (subs && typeof subs === "object" && !Array.isArray(subs)) {
+		for (const [route, r] of Object.entries(subs)) if (confines(r?.toolsets)) out.push(`webhook route ${route}`);
+	}
+	const cron = read(join(home, "cron", "jobs.json"));
+	const jobs = Array.isArray(cron) ? cron : cron?.jobs ?? [];
+	if (Array.isArray(jobs)) {
+		for (const j of jobs) if (confines(j?.enabled_toolsets)) out.push(`cron job ${String(j.name ?? j.id ?? "?")}`);
+	}
+	return out;
+}
+//#endregion
+//#region server/connections-cli/clients.ts
+/** Reads the MCP servers an agent's own tool is configured with (for `import --from`). */
+const IMPORT_CLIENTS = [
+	"hermes",
+	"claude-code",
+	"cursor",
+	"codex"
+];
+const CLIENT_LABELS = {
+	hermes: "Hermes",
+	"claude-code": "Claude Code",
+	cursor: "Cursor",
+	codex: "Codex"
+};
+const strings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : void 0;
+function droppedFrom(e, filters, settingKeys) {
+	const d = { settings: settingKeys.filter((k) => e[k] !== void 0 && e[k] !== null) };
+	const inc = strings(filters.include);
+	const exc = strings(filters.exclude);
+	if (inc?.length) d.include = inc;
+	if (exc?.length) d.exclude = exc;
+	return d.include || d.exclude || d.settings.length ? d : void 0;
+}
+/** Parses a dotenv file (KEY=VALUE, optional `export`, quotes). */
+function parseDotenv(text) {
+	const out = {};
+	for (const raw of text.split("\n")) {
+		const m = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/.exec(raw);
+		if (!m) continue;
+		let v = m[2];
+		if (v.startsWith("\"") && v.endsWith("\"") && v.length >= 2 || v.startsWith("'") && v.endsWith("'") && v.length >= 2) v = v.slice(1, -1);
+		else v = v.replace(/\s+#.*$/, "");
+		out[m[1]] = v;
+	}
+	return out;
+}
+/** `${VAR}` (and `${VAR:-default}`, `${env:VAR}`) from `vars`. */
+function expandVars(value, vars) {
+	const used = [];
+	let missing = null;
+	const out = value.replace(/\$\{(?:env:)?([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g, (_m, name, def) => {
+		const v = vars[name];
+		if (v !== void 0 && v !== "") {
+			used.push(name);
+			return v;
+		}
+		if (def !== void 0) return def;
+		missing ??= name;
+		return "";
+	});
+	return missing ? { missing } : {
+		value: out,
+		vars: used
+	};
+}
+const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const readJson = (file) => {
+	if (!existsSync(file)) return null;
+	const text = readFileSync(file, "utf8");
+	if (!text.trim()) return {};
+	try {
+		const doc = JSON.parse(text);
+		if (!isObj(doc)) throw new Error("not an object");
+		return doc;
+	} catch {
+		throw new Error(`${file} isn't plain JSON (comments?), so it can't be read automatically.`);
+	}
+};
+/** Shared by the JSON-shaped clients (Claude Code, Cursor): one `mcpServers` entry. */
+function jsonEntry(name, raw, file, vars, extra = {}) {
+	const base = {
+		name,
+		file,
+		transport: "http",
+		headers: {},
+		headerVars: [],
+		headerSources: {},
+		oauth: false,
+		enabled: true,
+		...extra
+	};
+	if (!isObj(raw)) return {
+		...base,
+		problem: "this entry isn't an object"
+	};
+	if (raw.disabled === true || raw.enabled === false) base.enabled = false;
+	const type = typeof raw.type === "string" ? raw.type.toLowerCase() : null;
+	if (type === "stdio" || typeof raw.command === "string" && !raw.url) {
+		const args = Array.isArray(raw.args) ? raw.args.map(String) : [];
+		return {
+			...base,
+			transport: "stdio",
+			command: [String(raw.command ?? ""), ...args].join(" ").trim()
+		};
+	}
+	if (typeof raw.url !== "string") return {
+		...base,
+		problem: "no url"
+	};
+	const url = expandVars(raw.url, vars);
+	if ("missing" in url) return {
+		...base,
+		problem: `its url uses \${${url.missing}}, which isn't set here`
+	};
+	const entry = {
+		...base,
+		url: url.value,
+		transport: type === "sse" ? "sse" : "http"
+	};
+	if (raw.headersHelper !== void 0 || raw.headers_helper !== void 0) return {
+		...entry,
+		problem: "it gets its headers from a helper command, which the broker can't run"
+	};
+	if (raw.oauth !== void 0 || raw.auth !== void 0) entry.oauth = true;
+	return withHeaders(entry, raw.headers, vars);
+}
+function withHeaders(entry, headers, vars) {
+	if (headers === void 0 || headers === null) return entry;
+	if (!isObj(headers)) return {
+		...entry,
+		problem: "its headers can't be read"
+	};
+	for (const [k, v] of Object.entries(headers)) {
+		if (typeof v !== "string") return {
+			...entry,
+			problem: `its ${k} header can't be read`
+		};
+		const x = expandVars(v, vars);
+		if ("missing" in x) return {
+			...entry,
+			problem: `its ${k} header uses \${${x.missing}}, which isn't set here`
+		};
+		entry.headers[k] = x.value;
+		entry.headerVars.push(...x.vars);
+		entry.headerSources[k] = x.vars;
+	}
+	return entry;
+}
+function hermesFiles(env = process.env) {
+	const home = hermesHome(env);
+	return {
+		config: join(home, "config.yaml"),
+		env: join(home, ".env")
+	};
+}
+function readHermes(opts) {
+	const env = opts.env ?? process.env;
+	const files = hermesFiles(env);
+	const result = {
+		client: "hermes",
+		files: [files.config],
+		entries: []
+	};
+	if (!existsSync(files.config)) return result;
+	const servers = readMcpServers(readFileSync(files.config, "utf8"));
+	if (!servers) throw new Error(`${files.config} has an mcp_servers layout this can't read (flow style, several blocks, or tabs). Nothing was changed.`);
+	const vars = {
+		...env,
+		...existsSync(files.env) ? parseDotenv(readFileSync(files.env, "utf8")) : {}
+	};
+	for (const [name, raw] of Object.entries(servers)) {
+		if (name.startsWith("\0")) continue;
+		const base = {
+			name,
+			file: files.config,
+			transport: "http",
+			headers: {},
+			headerVars: [],
+			headerSources: {},
+			oauth: false,
+			enabled: true
+		};
+		if (!raw || raw === UNREADABLE || typeof raw !== "object" || Array.isArray(raw)) {
+			result.entries.push({
+				...base,
+				problem: "this entry can't be read"
+			});
+			continue;
+		}
+		const e = raw;
+		const unreadable = [
+			"url",
+			"headers",
+			"command",
+			"auth",
+			"transport",
+			"enabled"
+		].find((k) => e[k] === UNREADABLE);
+		if (unreadable) {
+			result.entries.push({
+				...base,
+				problem: `its ${unreadable} can't be read`
+			});
+			continue;
+		}
+		if (e.enabled === false || typeof e.enabled === "string" && [
+			"false",
+			"no",
+			"off",
+			"0"
+		].includes(e.enabled.toLowerCase())) base.enabled = false;
+		if (typeof e.command === "string") {
+			const args = Array.isArray(e.args) ? e.args.filter((a) => typeof a === "string") : [];
+			result.entries.push({
+				...base,
+				transport: "stdio",
+				command: [e.command, ...args].join(" ")
+			});
+			continue;
+		}
+		if (typeof e.url !== "string") {
+			result.entries.push({
+				...base,
+				problem: "no url"
+			});
+			continue;
+		}
+		const url = expandVars(e.url, vars);
+		if ("missing" in url) {
+			result.entries.push({
+				...base,
+				problem: `its url uses \${${url.missing}}, which isn't set in ${files.env}`
+			});
+			continue;
+		}
+		const tools = isObj(e.tools) ? e.tools : {};
+		const entry = {
+			...base,
+			url: url.value,
+			transport: e.transport === "sse" ? "sse" : "http",
+			oauth: e.auth === "oauth" || isObj(e.oauth),
+			dropped: droppedFrom(e, {
+				include: tools.include,
+				exclude: tools.exclude
+			}, ["timeout", "connect_timeout"])
+		};
+		if (e.client_cert !== void 0 || e.identity_header !== void 0) {
+			result.entries.push({
+				...entry,
+				problem: "it uses a client certificate or identity header, which the broker doesn't support yet"
+			});
+			continue;
+		}
+		result.entries.push(withHeaders(entry, e.headers ?? void 0, vars));
+	}
+	return result;
+}
+function readClaude(opts) {
+	const env = opts.env ?? process.env;
+	const cwd = opts.cwd ?? process.cwd();
+	const userFile = claudeConfigFile();
+	const projectFile = join(cwd, ".mcp.json");
+	const result = {
+		client: "claude-code",
+		files: [userFile, projectFile].filter(existsSync),
+		entries: []
+	};
+	const seen = /* @__PURE__ */ new Set();
+	const add = (e) => {
+		if (seen.has(e.name)) return;
+		seen.add(e.name);
+		result.entries.push(e);
+	};
+	const doc = readJson(userFile);
+	const proj = doc && isObj(doc.projects) && isObj(doc.projects[cwd]) ? doc.projects[cwd] : {};
+	const local = proj.mcpServers;
+	if (isObj(local)) for (const [n, raw] of Object.entries(local)) add(jsonEntry(n, raw, userFile, env, {
+		scope: "local",
+		projectDir: cwd
+	}));
+	const project = readJson(projectFile);
+	if (project && isObj(project.mcpServers)) {
+		const list = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+		const enabled = new Set(list(proj.enabledMcpjsonServers));
+		const disabled = new Set(list(proj.disabledMcpjsonServers));
+		const all = proj.enableAllProjectMcpServers === true;
+		for (const [n, raw] of Object.entries(project.mcpServers)) {
+			const e = jsonEntry(n, raw, projectFile, env, {
+				scope: "project",
+				projectDir: cwd,
+				fromProject: true
+			});
+			const why = disabled.has(n) ? "turned off for this project in Claude Code" : !all && !enabled.has(n) ? "not approved in Claude Code" : null;
+			if (why) result.entries.push({
+				...e,
+				problem: why
+			});
+			else add(e);
+		}
+	}
+	if (doc && isObj(doc.mcpServers)) for (const [n, raw] of Object.entries(doc.mcpServers)) add(jsonEntry(n, raw, userFile, env, { scope: "user" }));
+	return result;
+}
+function readCursor(opts) {
+	const env = opts.env ?? process.env;
+	const file = cursorConfigFile();
+	const result = {
+		client: "cursor",
+		files: [file],
+		entries: []
+	};
+	const doc = readJson(file);
+	if (doc && isObj(doc.mcpServers)) for (const [n, raw] of Object.entries(doc.mcpServers)) result.entries.push(jsonEntry(n, raw, file, env));
+	return result;
+}
+function readCodex(opts) {
+	const env = opts.env ?? process.env;
+	const file = codexConfigFile();
+	const result = {
+		client: "codex",
+		files: [file],
+		entries: []
+	};
+	if (!existsSync(file)) return result;
+	for (const [name, raw] of Object.entries(readTomlMcpServers(readFileSync(file, "utf8")))) {
+		const base = {
+			name,
+			file,
+			transport: "http",
+			headers: {},
+			headerVars: [],
+			headerSources: {},
+			oauth: false,
+			enabled: true
+		};
+		if (raw === UNREADABLE$1) {
+			result.entries.push({
+				...base,
+				problem: "this entry can't be read"
+			});
+			continue;
+		}
+		const e = raw;
+		if (e.enabled === false) base.enabled = false;
+		if (typeof e.command === "string") {
+			const args = Array.isArray(e.args) ? e.args.filter((a) => typeof a === "string") : [];
+			result.entries.push({
+				...base,
+				transport: "stdio",
+				command: [e.command, ...args].join(" ")
+			});
+			continue;
+		}
+		if (typeof e.url !== "string") {
+			result.entries.push({
+				...base,
+				problem: "no url"
+			});
+			continue;
+		}
+		const entry = {
+			...base,
+			url: e.url,
+			oauth: isObj(e.oauth) || e.auth === "oauth",
+			dropped: droppedFrom(e, {
+				include: e.enabled_tools,
+				exclude: e.disabled_tools
+			}, ["tool_timeout_sec", "startup_timeout_sec"])
+		};
+		if (e.http_headers_helper !== void 0) {
+			result.entries.push({
+				...entry,
+				problem: "it gets its headers from a helper command, which the broker can't run"
+			});
+			continue;
+		}
+		const headers = {};
+		let problem;
+		if (e.http_headers !== void 0) {
+			if (!isObj(e.http_headers) || Object.values(e.http_headers).some((v) => typeof v !== "string")) problem = "its http_headers can't be read";
+			else {
+				Object.assign(headers, e.http_headers);
+				for (const h of Object.keys(e.http_headers)) entry.headerSources[h] = [];
+			}
+		}
+		const fromEnv = isObj(e.env_http_headers) ? { ...e.env_http_headers } : {};
+		if (e.bearer_token_env_var !== void 0) fromEnv.Authorization = e.bearer_token_env_var;
+		for (const [h, varName] of Object.entries(fromEnv)) if (typeof varName !== "string") problem ??= `its ${h} header can't be read`;
+		else if (!env[varName]) problem ??= `its ${h} header comes from $${varName}, which isn't set here`;
+		else {
+			headers[h] = h === "Authorization" && e.bearer_token_env_var === varName ? `Bearer ${env[varName]}` : env[varName];
+			entry.headerVars.push(varName);
+			entry.headerSources[h] = [varName];
+		}
+		entry.headers = headers;
+		result.entries.push(problem ? {
+			...entry,
+			problem
+		} : entry);
+	}
+	return result;
+}
+function readClientConfig(client, opts = {}) {
+	switch (client) {
+		case "hermes": return readHermes(opts);
+		case "claude-code": return readClaude(opts);
+		case "cursor": return readCursor(opts);
+		case "codex": return readCodex(opts);
+	}
+}
+function parseImportClient(value) {
+	const v = value.trim().toLowerCase().replace(/^claude$/, "claude-code");
+	if (!IMPORT_CLIENTS.includes(v)) throw new Error(`Unknown --from "${value}". Choose one of: ${IMPORT_CLIENTS.join(", ")}.`);
+	return v;
+}
+//#endregion
+//#region server/connections-cli/import.ts
+const SELF_NAME = /^(?:xaq|agentinbox)(?:-[a-z0-9][a-z0-9_-]*)?$/;
+function isSelf(e, selfOrigins) {
+	if (SELF_NAME.test(e.name)) return true;
+	if (Object.values(e.headers).some((v) => /^Bearer\s+aib_/i.test(v.trim()))) return true;
+	if (!e.url) return false;
+	try {
+		const u = new URL(e.url);
+		return u.pathname.replace(/\/+$/, "").endsWith("/mcp") && selfOrigins.includes(u.origin);
+	} catch {
+		return false;
+	}
+}
+const sameUrl = (a, b) => {
+	try {
+		return !!a && new URL(a).href.replace(/\/+$/, "") === new URL(b).href.replace(/\/+$/, "");
+	} catch {
+		return false;
+	}
+};
+async function planImport(config, ctx = {}) {
+	const label = CLIENT_LABELS[config.client];
+	const taken = new Set((ctx.existing ?? []).map((c) => c.slug));
+	const items = [];
+	for (const entry of config.entries) {
+		if (isSelf(entry, ctx.selfOrigins ?? [])) {
+			items.push({
+				action: "self",
+				entry
+			});
+			continue;
+		}
+		if (entry.transport === "stdio") {
+			items.push({
+				action: "stdio",
+				entry
+			});
+			continue;
+		}
+		if (entry.problem) {
+			items.push({
+				action: "skip",
+				entry,
+				reason: entry.problem
+			});
+			continue;
+		}
+		if (!entry.enabled) {
+			items.push({
+				action: "skip",
+				entry,
+				reason: `it's turned off in ${label}`
+			});
+			continue;
+		}
+		let url;
+		try {
+			url = new URL(entry.url);
+			if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("scheme");
+		} catch {
+			items.push({
+				action: "skip",
+				entry,
+				reason: "its url isn't an http(s) URL"
+			});
+			continue;
+		}
+		const headerNames = Object.keys(entry.headers);
+		if (headerNames.length > 1) {
+			items.push({
+				action: "skip",
+				entry,
+				reason: `it sends ${headerNames.length} headers (${headerNames.join(", ")}); a connection keeps one (not supported yet)`
+			});
+			continue;
+		}
+		const existing = (ctx.existing ?? []).find((c) => sameUrl(c.url, url.href));
+		if (existing) {
+			items.push({
+				action: "exists",
+				entry,
+				connection: existing
+			});
+			continue;
+		}
+		const target = await checkTarget(url, ctx.lookup);
+		if (target.kind === "never") {
+			items.push({
+				action: "skip",
+				entry,
+				reason: target.why === "ipv6_literal" ? `the private-network allow takes a hostname or an IPv4 address, not ${target.address}` : `it's on ${target.address}, a link-local or cloud metadata address, which is never allowed`
+			});
+			continue;
+		}
+		if (target.kind === "public" && url.protocol === "http:") {
+			items.push({
+				action: "skip",
+				entry,
+				reason: "plain http to a public host isn't allowed; use its https URL"
+			});
+			continue;
+		}
+		let slug = slugify(entry.name);
+		for (let n = 2; taken.has(slug); n++) slug = `${slugify(entry.name).slice(0, 21)}-${n}`;
+		taken.add(slug);
+		const auth = headerNames.length ? {
+			type: "header",
+			name: headerNames[0],
+			value: entry.headers[headerNames[0]]
+		} : entry.oauth ? { type: "oauth" } : { type: "none" };
+		items.push({
+			action: "create",
+			entry,
+			slug,
+			url: entry.url.trim(),
+			auth,
+			privateTarget: target.kind === "private" ? target.origin : null
+		});
+	}
+	return items;
+}
+const where = (e) => e.scope ? ` (${e.scope} scope)` : "";
+const hostOf = (url) => {
+	try {
+		return new URL(url).host;
+	} catch {
+		return url;
+	}
+};
+/** "its Authorization header (from $GITHUB_TOKEN) is sent to mcp.example.com": where each secret ends up. */
+function headerLine(i) {
+	if (i.auth.type !== "header") return null;
+	const vars = i.entry.headerSources[i.auth.name] ?? [];
+	const from = vars.length ? ` (from ${vars.map((v) => `$${v}`).join(", ")})` : "";
+	return `its ${i.auth.name} header${from} moves into xaq (encrypted; never shown) and is sent to ${safeText(hostOf(i.url), 120)}`;
+}
+/** The plan in plain words. Never prints a header value. */
+function renderPlan(config, items) {
+	const label = CLIENT_LABELS[config.client];
+	const out = [];
+	const width = Math.min(24, Math.max(4, ...items.map((i) => i.entry.name.length)));
+	const pad = (s) => s.padEnd(width);
+	const cont = " ".repeat(width + 4);
+	out.push(`${label}: ${config.files.join(", ") || "no config file"} lists ${items.length} MCP server${items.length === 1 ? "" : "s"}.`);
+	for (const i of items) {
+		const name = `  ${pad(safeText(i.entry.name, 40))}  `;
+		switch (i.action) {
+			case "self":
+				out.push(`${name}${pc.dim("skip: this is xaq itself")}`);
+				break;
+			case "stdio":
+				out.push(`${name}${pc.yellow("not supported yet (M4)")}: a local command (${safeText(i.entry.command ?? "", 60)}); it stays in ${label}`);
+				break;
+			case "skip":
+				out.push(`${name}${pc.yellow("skip")}: ${i.reason}; it stays in ${label}`);
+				break;
+			case "exists":
+				if (isWorking(i.connection)) out.push(`${name}already connected: "${i.connection.slug}" (${i.connection.tools.total} tools)`);
+				else {
+					const why = i.entry.oauth || i.connection.authType === "oauth" || i.connection.status === "needs_reauth" ? "needs Connect" : `${i.connection.status}, ${i.connection.tools.total} tools`;
+					out.push(`${name}already a connection: "${i.connection.slug}", ${why}; it stays in ${label} until it works`);
+					out.push(`${cont}${reconnectHint(i.connection)}`);
+				}
+				out.push(...droppedLines(i.entry, cont));
+				break;
+			case "create": {
+				out.push(`${name}${pc.green("create")} connection "${i.slug}" → ${safeText(i.url, 120)}${where(i.entry)}`);
+				if (i.entry.fromProject) out.push(`${cont}${pc.yellow("from the project's .mcp.json")}: asked separately (--yes doesn't answer it)`);
+				const h = headerLine(i);
+				if (h) out.push(`${cont}${h}`);
+				else if (i.auth.type === "oauth") out.push(`${cont}OAuth: created needing Connect (${label} keeps its own tokens); sign in once with the link it prints`);
+				else out.push(`${cont}no credential in ${label}: connected as it is (if it turns out to use OAuth, it needs Connect)`);
+				if (i.privateTarget) out.push(`${cont}${pc.yellow("private network")}: needs the allow for exactly ${i.privateTarget}`);
+				out.push(...droppedLines(i.entry, cont));
+				break;
+			}
+		}
+	}
+	return out;
+}
+/** What the client did for this server that the broker doesn't: said in the plan, never silently dropped. */
+function droppedLines(e, cont) {
+	const d = e.dropped;
+	if (!d) return [];
+	const out = [];
+	const list = (xs) => xs.map((x) => safeText(x, 64)).join(", ");
+	if (d.exclude) out.push(`${cont}${pc.yellow("not carried over")}: its tool filter hides ${list(d.exclude)}; through xaq every tool is listed (subject to the access level)`);
+	if (d.include) out.push(`${cont}${pc.yellow("not carried over")}: its tool filter shows only ${list(d.include)}; through xaq every tool is listed (subject to the access level)`);
+	if (d.settings.length) out.push(`${cont}${pc.yellow("not carried over")}: ${d.settings.join(", ")} (xaq uses its own 60 s per call)`);
+	return out;
+}
+const works = isWorking;
+function setupLines(r) {
+	const out = [r.ok ? `${r.dryRun ? pc.cyan("○") : pc.green("✔")} ${r.message}` : `${pc.yellow("!")} ${r.message}`];
+	for (const l of r.changes ?? []) out.push(l.startsWith(" ") ? pc.gray(`  ${l}`) : `  - ${l}`);
+	if (r.backup) out.push(pc.gray(`  Backup: ${r.backup}`));
+	if (!r.ok) for (const l of r.manual ?? []) out.push(`    ${l}`);
+	for (const n of r.notes ?? []) out.push(pc.dim(`  ${n}`));
+	if (r.ok && r.verify?.length) out.push(`  ${r.dryRun ? "Afterwards, check it with" : "Check it with"}: ${r.verify.map((v) => pc.cyan(v)).join("; ")}`);
+	return out;
+}
+const toRemove = (e) => ({
+	name: e.name,
+	scope: e.scope,
+	projectDir: e.scope === "user" ? void 0 : e.projectDir
+});
+async function runImport(flags, deps) {
+	const p = deps.prompter;
+	const client = parseImportClient(flags.from);
+	const label = CLIENT_LABELS[client];
+	const access = flags.access ? parseAccess(flags.access) : void 0;
+	const config = readClientConfig(client, {
+		env: deps.env,
+		cwd: deps.cwd
+	});
+	if (!config.entries.length) {
+		p.print(`${label} has no MCP servers configured (${config.files.join(", ") || "no config file"}). Nothing to import.`);
+		return 0;
+	}
+	const profileName = flags.profile ?? "default";
+	if (flags.dryRun) {
+		let existing;
+		try {
+			existing = await deps.openApi().list();
+		} catch {
+			existing = void 0;
+		}
+		const items = await planImport(config, {
+			existing,
+			lookup: deps.lookup,
+			selfOrigins: deps.selfOrigins
+		});
+		p.print(pc.bold("Dry run: nothing is created or changed."));
+		for (const l of renderPlan(config, items)) p.print(l);
+		const creates = items.filter((i) => i.action === "create");
+		const priv = creates.filter((i) => i.privateTarget);
+		p.print("");
+		p.print(`Would create ${creates.length} connection${creates.length === 1 ? "" : "s"} with ${access ? accessLabel(access) : "the access you choose (default: Ask before risky actions)"}.`);
+		if (priv.length) p.print(`Would ask before allowing ${priv.map((i) => i.privateTarget).join(", ")} (--yes never does; --allow-private <origin> does for that origin).`);
+		if (!existing) p.print(pc.dim("xaq wasn't reachable, so existing connections weren't checked (the real run does: nothing is created twice)."));
+		const removable = [...items.filter((i) => i.action === "exists" && works(i.connection)).map((i) => toRemove(i.entry)), ...creates.filter((i) => i.auth.type !== "oauth").map((i) => toRemove(i.entry))];
+		p.print("");
+		if (!removable.length) p.print(`${label}'s config isn't changed.`);
+		else if (!profileExists(profileName)) p.print(`Afterwards it offers to replace the imported entries in ${label} with the single xaq entry, once this machine's ${label} is paired (${NPX} connect <xaq-url> --tool ${client}).`);
+		else {
+			p.print(`Afterwards it offers setup-mcp --tool ${client}, which would (for the entries whose connection works and that ${label}'s agent can use; OAuth ones after you Reconnect them):`);
+			const r = setupMcp(client, mcpTarget(profileName, loadProfile(profileName)), profilePath(profileName), {
+				dryRun: true,
+				removeServers: removable
+			});
+			for (const l of setupLines(r)) p.print(l);
+		}
+		return 0;
+	}
+	const api = deps.openApi();
+	const items = await planImport(config, {
+		existing: await api.list(),
+		lookup: deps.lookup,
+		selfOrigins: deps.selfOrigins
+	});
+	for (const l of renderPlan(config, items)) p.print(l);
+	let creates = items.filter((i) => i.action === "create");
+	const already = items.filter((i) => i.action === "exists");
+	p.print("");
+	const fromProject = creates.filter((i) => i.entry.fromProject);
+	if (fromProject.length) {
+		p.print(pc.yellow(`These come from ${fromProject[0].entry.file}, which ships with the project (anyone who can commit to it wrote them):`));
+		for (const i of fromProject) p.print(`  ${safeText(i.entry.name, 40)} → ${safeText(i.url, 120)}${headerLine(i) ? `; ${headerLine(i)}` : ""}`);
+		if (!await p.confirmExplicit(`Import ${fromProject.length === 1 ? "it" : `these ${fromProject.length}`} into xaq?`, "they stay in Claude Code")) creates = creates.filter((i) => !i.entry.fromProject);
+	}
+	const preAllowed = new Set(flags.allowPrivate ?? []);
+	const priv = creates.filter((i) => i.privateTarget && !preAllowed.has(i.privateTarget));
+	for (const i of creates.filter((x) => x.privateTarget && preAllowed.has(x.privateTarget))) p.print(`Allowing ${i.privateTarget} (${safeText(i.entry.name, 40)}): --allow-private.`);
+	if (priv.length) {
+		p.print(pc.yellow("These servers are on this machine or your private network:"));
+		for (const i of priv) p.print(`  ${i.privateTarget}  (${safeText(i.entry.name, 40)})`);
+		p.print(pc.dim("A connection to such a server can reach other services there too. Each allow covers exactly that scheme://host:port, for that connection only."));
+		const names = priv.map((i) => i.entry.name).join(", ");
+		if (!await p.confirmExplicit(`Allow xaq to connect to ${priv.length === 1 ? "it" : `these ${priv.length}`}?`, `skipping ${names} (pass --allow-private <origin> to allow one)`)) creates = creates.filter((i) => !priv.includes(i));
+	}
+	const who = await clientAgent(api, profileName);
+	if (!creates.length) {
+		p.print("Nothing to create.");
+		return offerSetup(deps, api, client, who, already.filter((a) => works(a.connection)).map((a) => ({
+			entry: a.entry,
+			connection: a.connection
+		})), already.filter((a) => !works(a.connection)).map((a) => a.entry.name), 0);
+	}
+	const level = await chooseAccess(p, access);
+	let agents = await chooseAgents(p, api, flags.agent);
+	if (agents !== "all" && who.agent && !agents.includes(who.agent.id)) {
+		p.print(pc.yellow(`${safeText(who.agent.name, 60)} (the agent ${label} on this machine uses) isn't among them, so ${label} couldn't use these through xaq.`));
+		if (await p.confirm(`Include ${safeText(who.agent.name, 60)}?`, true)) agents = [...agents, who.agent.id];
+	}
+	if (!await p.confirm(`Create ${creates.length} connection${creates.length === 1 ? "" : "s"} (${accessLabel(level)}, ${agentsLabel(agents)})?`, true)) {
+		p.print("Nothing was created.");
+		return 0;
+	}
+	const outcomes = [];
+	for (const item of creates) {
+		let created = null;
+		try {
+			created = await api.create({
+				slug: item.slug,
+				name: item.entry.name,
+				url: item.url,
+				levelDefault: level,
+				...agents === "all" ? {} : { agentIds: agents }
+			});
+			if (item.privateTarget) await api.allowPrivateTarget(created.id, true);
+			const r = await api.connect(created.id, item.auth.type === "header" ? { header: {
+				name: item.auth.name,
+				value: item.auth.value
+			} } : {});
+			if (r.status === "connected") {
+				const after = await waitWorking(api, r.connection, {
+					pollMs: deps.pollMs,
+					ms: deps.verifyMs
+				});
+				outcomes.push({
+					item,
+					status: works(after) ? "connected" : "unverified",
+					connection: after
+				});
+			} else if (r.status === "authorize") outcomes.push({
+				item,
+				status: "authorize",
+				connection: created,
+				authorizeUrl: r.authorizeUrl
+			});
+			else throw new Error(r.message);
+		} catch (err) {
+			if (created) await api.remove(created.id).catch(() => {});
+			outcomes.push({
+				item,
+				status: "failed",
+				error: err instanceof Error ? err.message : String(err)
+			});
+		}
+	}
+	p.print("");
+	for (const o of outcomes) {
+		const name = safeText(o.item.entry.name, 40);
+		if (o.status === "failed") p.print(`${pc.red("✘")} ${name}: ${safeText(o.error, 300)} (it stays in ${label})`);
+		else if (o.status === "connected") p.print(`${pc.green("✔")} ${name} → "${o.connection.slug}", ${o.connection.tools.total} tools`);
+		else if (o.status === "unverified") {
+			const c = o.connection;
+			p.print(`${pc.yellow("○")} ${name} → "${c.slug}": not working (${c.status}${c.statusReason ? `: ${safeText(c.statusReason, 200)}` : ""}, ${c.tools.total} tools), so it stays in ${label}.`);
+			p.print(`    ${reconnectHint(c)}   then run this import again.`);
+		} else {
+			p.print(`${pc.yellow("○")} ${name} → "${o.connection.slug}": needs Connect. Sign in (link valid 15 minutes):`);
+			p.print(`    ${pc.cyan(o.authorizeUrl)}`);
+			p.print(`    ${reconnectHint(o.connection)}`);
+		}
+	}
+	const failed = outcomes.filter((o) => o.status === "failed").length;
+	return offerSetup(deps, api, client, who, [...already.filter((a) => works(a.connection)).map((a) => ({
+		entry: a.entry,
+		connection: a.connection
+	})), ...outcomes.filter((o) => o.status === "connected").map((o) => ({
+		entry: o.item.entry,
+		connection: o.connection
+	}))], [...already.filter((a) => !works(a.connection)).map((a) => a.entry.name), ...outcomes.filter((o) => o.status === "authorize" || o.status === "unverified").map((o) => o.item.entry.name)], failed ? 1 : 0);
+}
+async function clientAgent(api, profileName) {
+	if (!profileExists(profileName)) return {
+		profileName,
+		profile: null,
+		agent: null
+	};
+	const profile = loadProfile(profileName);
+	return {
+		profileName,
+		profile,
+		agent: (await api.agents()).find((a) => a.id === profile.agentId && !a.disabled) ?? null
+	};
+}
+/**
+* Step 2: replace the entries now served by the broker with the single xaq entry (setup-mcp). Only entries
+* the client's own agent can use through xaq go: the profile's agent must be on this daemon and have a grant
+* on the connection (offered when it has none).
+*/
+async function offerSetup(deps, api, client, who, working, pending, code) {
+	const p = deps.prompter;
+	const label = CLIENT_LABELS[client];
+	if (pending.length) p.print(pc.dim(`${pending.join(", ")} stay${pending.length === 1 ? "s" : ""} in ${label} until ${pending.length === 1 ? "it works" : "they work"} through xaq (Reconnect); then run this import again to replace ${pending.length === 1 ? "it" : "them"}.`));
+	if (!working.length) return code;
+	if (!who.profile) {
+		p.print(`To replace ${working.map((w) => w.entry.name).join(", ")} in ${label} with the single xaq entry, pair it first (${NPX} connect <xaq-url> --tool ${client}) and run this import again.`);
+		return code;
+	}
+	if (!who.agent) {
+		p.print(pc.yellow(`The agent in your "${who.profileName}" profile (${safeText(who.profile.agentId, 40)}) isn't an agent of this xaq (or is disabled), so ${label} couldn't use these through it. Not replacing anything in ${label}. Pair it with this xaq (${NPX} connect <xaq-url> --tool ${client} --force), then run this import again.`));
+		return code;
+	}
+	const agentName = safeText(who.agent.name, 60);
+	const usable = [];
+	for (const w of working) {
+		if (w.entry.fromProject) {
+			p.print(pc.dim(`  "${w.entry.name}" stays in ${w.entry.file}: it ships with the project. Remove it there if the project no longer needs it.`));
+			continue;
+		}
+		const grants = await api.grants(w.connection.id);
+		if (grants.some((g) => g.agentId === who.agent.id)) {
+			usable.push(w.entry);
+			continue;
+		}
+		if (await p.confirm(`${agentName} (the agent ${label} uses) has no access to "${w.connection.slug}". Give it ${accessLabel(w.connection.levelDefault)}?`, true)) {
+			await api.setGrants(w.connection.id, [...grants.map((g) => ({
+				agentId: g.agentId,
+				level: g.level
+			})), {
+				agentId: who.agent.id,
+				level: w.connection.levelDefault
+			}]);
+			usable.push(w.entry);
+		} else p.print(pc.dim(`  "${w.entry.name}" stays in ${label}: its agent couldn't use "${w.connection.slug}".`));
+	}
+	if (!usable.length) return code;
+	p.print("");
+	const question = `Replace ${usable.map((e) => `"${e.name}"`).join(", ")} in ${label} with the single xaq entry (setup-mcp --tool ${client}, with a backup)?`;
+	const routes = confinedRoutes(client, mcpServerName(who.profileName), deps.env);
+	let ok;
+	if (routes.length) {
+		const slugs = working.filter((w) => usable.includes(w.entry)).map((w) => w.connection.slug);
+		p.print(pc.yellow(`These ${label} settings are limited to the xaq server only:`));
+		for (const r of routes) p.print(`  ${safeText(r, 120)}`);
+		p.print(pc.yellow(`Through xaq they now also see the tools of ${slugs.map((s) => `"${s}"`).join(", ")} (as <name>__<tool>), which ${routes.length === 1 ? "it" : "they"} couldn't reach before. If one is triggered by email or webhooks, those tools become reachable from that content. Give ${agentName} less access on those connections, or keep them out, if that's not what you want.`));
+		ok = await p.confirmExplicit(question, `${label}'s config wasn't changed; decide in a terminal`);
+	} else ok = await p.confirm(question, true);
+	if (!ok) {
+		p.print(`${label}'s config wasn't changed. Run this import again any time to do it.`);
+		return code;
+	}
+	const r = setupMcp(client, mcpTarget(who.profileName, who.profile), profilePath(who.profileName), { removeServers: usable.map(toRemove) });
+	for (const l of setupLines(r)) p.print(l);
+	const vars = [...new Set(usable.flatMap((e) => (r.removed ?? []).includes(e.name) ? e.headerVars : []))];
+	if (r.ok && vars.length) p.print(pc.dim(`  ${vars.join(", ")} ${vars.length === 1 ? "is" : "are"} no longer needed by the removed entries; delete ${vars.length === 1 ? "it" : "them"} from your environment${client === "hermes" ? " (~/.hermes/.env)" : ""} once everything works through xaq.`));
+	return r.ok ? code : 1;
+}
+//#endregion
+export { runImport };
+
+//# sourceMappingURL=import-DsN5NZT3.js.map