neon 4.1.0 → 4.2.1

package/dist/init/phases/status.js

@@ -1,5 +1,6 @@
 import { neonInitAgentCmd } from "../profile_cli.js";
-import { supportsSkills, tryResolveAddMcpAgentId } from "../agents.js";
+import { tryResolveAddMcpAgentId } from "../../mcp/agents.js";
+import { supportsSkills } from "../agents.js";
 import { isAuthenticated } from "../auth.js";
 import { inspectProject } from "../inspect.js";
 //#region src/init/phases/status.ts

package/dist/mcp/agents.js

@@ -0,0 +1,64 @@
+import { agents, detectGlobalAgents, getAgentTypes } from "add-mcp";
+//#region src/mcp/agents.ts
+const AGENT_ALIASES = {
+	cursor: "cursor",
+	copilot: "vscode",
+	"github-copilot": "vscode",
+	"vs-code": "vscode",
+	vscode: "vscode",
+	claude: "claude-code",
+	"claude-code": "claude-code",
+	"claude-desktop": "claude-desktop",
+	codex: "codex",
+	opencode: "opencode",
+	antigravity: "antigravity",
+	cline: "cline",
+	"cline-cli": "cline-cli",
+	"cline-vscode": "cline",
+	"gemini-cli": "gemini-cli",
+	gemini: "gemini-cli",
+	goose: "goose",
+	windsurf: "windsurf",
+	codeium: "windsurf",
+	cascade: "windsurf",
+	"github-copilot-cli": "github-copilot-cli",
+	mcporter: "mcporter",
+	zed: "zed",
+	grok: "grok-build",
+	"grok-build": "grok-build"
+};
+function listMcpAgentIds() {
+	return getAgentTypes();
+}
+function getAgentDisplayName(id) {
+	return agents[id].displayName;
+}
+function agentSupportsProjectMcp(id) {
+	return Boolean(agents[id].localConfigPath);
+}
+function agentSupportsHttpMcp(id) {
+	return agents[id].supportedTransports.includes("http");
+}
+function tryResolveAddMcpAgentId(rawAgent) {
+	return AGENT_ALIASES[rawAgent.toLowerCase()];
+}
+function resolveAddMcpAgentId(rawAgent) {
+	const resolved = tryResolveAddMcpAgentId(rawAgent);
+	if (!resolved) throw new Error(`Unknown agent: "${rawAgent}". Supported agents: ${listMcpAgentIds().join(", ")}`);
+	return resolved;
+}
+async function detectInstalledAgents() {
+	return detectGlobalAgents();
+}
+function uniqueAgentIds(ids) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const id of ids) {
+		if (seen.has(id)) continue;
+		seen.add(id);
+		out.push(id);
+	}
+	return out;
+}
+//#endregion
+export { agentSupportsHttpMcp, agentSupportsProjectMcp, detectInstalledAgents, getAgentDisplayName, listMcpAgentIds, resolveAddMcpAgentId, tryResolveAddMcpAgentId, uniqueAgentIds };

package/dist/mcp/install.js

@@ -0,0 +1,216 @@
+import { chmodSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { agents, upsertServer } from "add-mcp";
+//#region src/mcp/install.ts
+const NEON_MCP_URL = "https://mcp.neon.tech/mcp";
+const NEON_MCP_NAME = "Neon";
+const NEON_MCP_CATEGORIES = [
+	"projects",
+	"branches",
+	"schema",
+	"querying",
+	"neon_auth",
+	"data_api",
+	"observability",
+	"docs"
+];
+function isMcpCategory(value) {
+	for (const category of NEON_MCP_CATEGORIES) if (category === value) return true;
+	return false;
+}
+function parseMcpCategories(raw) {
+	const out = [];
+	for (const value of raw) {
+		if (!isMcpCategory(value)) throw new Error(`Unknown MCP category: "${value}". Supported categories: ${NEON_MCP_CATEGORIES.join(", ")}`);
+		out.push(value);
+	}
+	return out;
+}
+function isNeonMcpUrl(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === "https:" && url.hostname === "mcp.neon.tech" && url.pathname === "/mcp";
+	} catch {
+		return false;
+	}
+}
+function neonMcpUrl(options = {}) {
+	const url = new URL(NEON_MCP_URL);
+	if (options.readOnly === true) url.searchParams.set("readonly", "true");
+	for (const category of options.categories ?? []) url.searchParams.append("category", category);
+	const projectId = options.projectId?.trim();
+	if (projectId) url.searchParams.set("projectId", projectId);
+	return url.href;
+}
+const BEARER_RE = /Bearer\s+([^\s"]+)/i;
+function nestedValue(root, key) {
+	let current = root;
+	for (const part of key.split(".")) {
+		if (!current || typeof current !== "object" || Array.isArray(current)) return;
+		current = current[part];
+	}
+	return current;
+}
+function recordOf(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function bearerFromNeonMcpConfig(config) {
+	const record = recordOf(config);
+	if (!record || typeof record.url !== "string" || !isNeonMcpUrl(record.url)) return;
+	const headerRecord = recordOf(record.headers ?? record.http_headers);
+	if (!headerRecord) return;
+	const authorization = headerRecord.Authorization ?? headerRecord.authorization;
+	if (typeof authorization !== "string") return;
+	return BEARER_RE.exec(authorization.trim())?.[1];
+}
+function neonServers(value) {
+	const record = recordOf(value);
+	if (!record) return;
+	return record["Neon"] ?? record.neon;
+}
+function neonApiKeyFromFile(path, configKey) {
+	let raw;
+	try {
+		raw = readFileSync(path, "utf8");
+	} catch {
+		return;
+	}
+	try {
+		return bearerFromNeonMcpConfig(neonServers(nestedValue(JSON.parse(raw), configKey)));
+	} catch {
+		const neonBlock = raw.match(/\[mcp_servers\.Neon\][\s\S]*?(?=\n\[|$)/)?.[0];
+		if (!neonBlock) return;
+		const url = neonBlock.match(/^url\s*=\s*"([^"]*)"/m)?.[1];
+		if (!url || !isNeonMcpUrl(url)) return;
+		return BEARER_RE.exec(neonBlock)?.[1];
+	}
+}
+function configPathFor(agent, scope, cwd) {
+	const spec = agents[agent];
+	if (scope === "project") {
+		if (!spec.localConfigPath) return;
+		return join(cwd, spec.localConfigPath);
+	}
+	return spec.configPath;
+}
+function configKeyFor(agent, scope) {
+	const spec = agents[agent];
+	if (scope === "project" && spec.localConfigKey) return spec.localConfigKey;
+	return spec.configKey;
+}
+function existingNeonApiKey(options) {
+	for (const agent of options.agents) {
+		const path = configPathFor(agent, options.scope, options.cwd);
+		if (!path) continue;
+		const key = neonApiKeyFromFile(path, configKeyFor(agent, options.scope));
+		if (key) return key;
+	}
+}
+function isTrackedByGit(cwd, relativePath) {
+	try {
+		execFileSync("git", [
+			"-C",
+			cwd,
+			"ls-files",
+			"--error-unmatch",
+			"--",
+			relativePath
+		], { stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		] });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function trackedProjectMcpConfig(options) {
+	for (const agent of options.agents) {
+		const relativePath = agents[agent].localConfigPath;
+		if (!relativePath) continue;
+		if (isTrackedByGit(options.cwd, relativePath)) return relativePath;
+	}
+}
+function mcpUnsupportedReason(agent, scope) {
+	const spec = agents[agent];
+	if (!spec.supportedTransports.includes("http")) return spec.unsupportedTransportMessage ?? `${spec.displayName} does not support remote HTTP MCP servers.`;
+	if (scope === "project" && !spec.localConfigPath) return `${spec.displayName} does not support project-level MCP config.`;
+}
+function gitignoreProjectConfig(path) {
+	const dir = dirname(path);
+	const entry = basename(path);
+	const gitignorePath = join(dir, ".gitignore");
+	try {
+		if (!existsSync(gitignorePath)) {
+			writeFileSync(gitignorePath, `${entry}\n`);
+			return;
+		}
+		const current = readFileSync(gitignorePath, "utf8");
+		if (current.split(/\r?\n/).some((line) => line.trim() === entry)) return;
+		const needsLeadingNewline = current.length > 0 && !current.endsWith("\n");
+		writeFileSync(gitignorePath, `${current}${needsLeadingNewline ? "\n" : ""}${entry}\n`);
+		return;
+	} catch (err) {
+		return `Could not gitignore ${path}: ${err instanceof Error ? err.message : String(err)}`;
+	}
+}
+function protectWrittenConfig(path, scope) {
+	try {
+		chmodSync(path, 384);
+	} catch (err) {
+		return `Could not restrict permissions on ${path}: ${err instanceof Error ? err.message : String(err)}`;
+	}
+	if (scope === "project") return gitignoreProjectConfig(path);
+}
+function redactSecrets(text) {
+	return text.replace(/Bearer\s+\S+/gi, "Bearer [redacted]").replace(/napi_[A-Za-z0-9_]+/gi, "napi_[redacted]");
+}
+function installNeonMcpServer(options) {
+	const auth = options.auth ?? { kind: "oauth" };
+	const url = options.url ?? "https://mcp.neon.tech/mcp";
+	const unsupported = mcpUnsupportedReason(options.agent, options.scope);
+	if (unsupported) return {
+		ok: false,
+		unsupported: true,
+		error: unsupported
+	};
+	const server = auth.kind === "api-key" ? {
+		type: "http",
+		url,
+		headers: { Authorization: `Bearer ${auth.apiKey}` }
+	} : {
+		type: "http",
+		url
+	};
+	const result = upsertServer(options.agent, NEON_MCP_NAME, server, {
+		local: options.scope === "project",
+		cwd: options.cwd
+	});
+	if (result.success) {
+		if (auth.kind === "api-key") {
+			const paths = [result.path, ...result.extraPaths ?? []];
+			for (const path of paths) {
+				const error = protectWrittenConfig(path, options.scope);
+				if (error) return {
+					ok: false,
+					unsupported: false,
+					error
+				};
+			}
+		}
+		return {
+			ok: true,
+			path: result.path
+		};
+	}
+	return {
+		ok: false,
+		unsupported: false,
+		error: redactSecrets(result.error ?? "Failed to write Neon MCP server config")
+	};
+}
+//#endregion
+export { NEON_MCP_CATEGORIES, NEON_MCP_NAME, NEON_MCP_URL, existingNeonApiKey, installNeonMcpServer, isMcpCategory, isNeonMcpUrl, mcpUnsupportedReason, neonMcpUrl, parseMcpCategories, trackedProjectMcpConfig };

package/dist/mcp/mint.js

@@ -0,0 +1,46 @@
+import { log } from "../log.js";
+import { isNeonApiError } from "../api.js";
+import { getCliName } from "../utils/cli_name.js";
+import { mintedKeyName } from "../profile_keys.js";
+//#region src/mcp/mint.ts
+const cannotMintMessage = "This CLI credential cannot mint API keys. Organization and project-scoped keys cannot create other keys. Sign in with `neon auth` or pass a personal API key.";
+const withdraw = async (client, keyId) => {
+	if (!Number.isSafeInteger(keyId) || keyId === void 0 || keyId <= 0) return false;
+	try {
+		const { data } = await client.revokeApiKey(keyId);
+		return data.revoked === true && data.id === keyId;
+	} catch (err) {
+		log.error("Failed to revoke API key %d: %s", keyId, err instanceof Error ? err.message : String(err));
+		return false;
+	}
+};
+const assertUsable = async (client, data, fallbackName) => {
+	const problem = typeof data.key !== "string" || data.key.trim() === "" ? "Neon returned no key." : data.project_id !== void 0 ? `Neon returned a key scoped to ${data.project_id} rather than the whole account.` : !Number.isSafeInteger(data.id) ? "Neon returned no key id." : null;
+	if (problem) {
+		const withdrawn = await withdraw(client, data.id);
+		throw new Error(`${problem} ${withdrawn ? "The key has been revoked; nothing was issued." : `The key could NOT be revoked and may still be live${data.id === void 0 ? "" : `. Remove it with \`${getCliName()} api-keys revoke ${data.id}\``}.`}`);
+	}
+	const id = data.id;
+	const key = data.key;
+	if (id === void 0 || key === void 0) throw new Error("Neon returned no key.");
+	return {
+		id,
+		name: data.name ?? fallbackName,
+		key
+	};
+};
+async function mintMcpApiKey(options) {
+	const name = mintedKeyName("mcp");
+	try {
+		const { data } = await options.apiClient.createApiKey({ key_name: name });
+		return assertUsable(options.apiClient, data, name);
+	} catch (err) {
+		if (isNeonApiError(err) && (err.status === 403 || err.status === 404)) throw new Error(cannotMintMessage);
+		throw err;
+	}
+}
+async function withdrawMintedKey(apiClient, key) {
+	return withdraw(apiClient, key.id);
+}
+//#endregion
+export { mintMcpApiKey, withdrawMintedKey };

package/dist/mcp/plan.js

@@ -0,0 +1,43 @@
+import { tryResolveAddMcpAgentId } from "./agents.js";
+import { agentChoicesFrom, pickAgentsInteractively, resolveAgentSelection } from "../utils/agent_picker.js";
+import { detectMcpAgents, mcpInstallableAgents } from "./targets.js";
+import { pickMcpAuth, pickMcpProjectPin, pickMcpScope } from "./wizard.js";
+//#region src/mcp/plan.ts
+async function resolveMcpPlan(options) {
+	const prompt = options.interactive && !options.yes;
+	const scope = options.project ? "project" : prompt ? await (options.pickScope ?? pickMcpScope)() : "global";
+	const available = mcpInstallableAgents(scope);
+	const detected = await detectMcpAgents({
+		scope,
+		cwd: options.cwd
+	});
+	const agents = await resolveAgentSelection({
+		specified: options.agents,
+		choices: agentChoicesFrom(available, detected),
+		detected,
+		message: "Which coding agents should get the Neon MCP server? (space to toggle, enter to confirm)",
+		nonInteractiveMessage: scope === "project" ? `No coding agents detected in this project. Pass --agent <name>. Supported agents: ${available.join(", ")}` : `No coding agents detected. Pass --agent <name>. Supported agents: ${available.join(", ")}`,
+		resolveSpecified: (raw) => {
+			const id = tryResolveAddMcpAgentId(raw);
+			if (!id) throw new Error(`Unknown agent: "${raw}". Supported agents: ${available.join(", ")}`);
+			return id;
+		},
+		pick: prompt ? options.pickAgents ?? pickAgentsInteractively : void 0,
+		interactive: prompt
+	});
+	const auth = options.oauth ? "oauth" : prompt ? await (options.pickAuth ?? pickMcpAuth)() : "api-key";
+	let urlProjectId = options.projectId;
+	if (urlProjectId === void 0 && prompt && scope === "project" && options.linkedProjectId) {
+		if (await (options.pickProjectPin ?? pickMcpProjectPin)(options.linkedProjectId)) urlProjectId = options.linkedProjectId;
+	}
+	return {
+		scope,
+		agents,
+		auth,
+		readOnly: options.readOnly,
+		urlProjectId,
+		categories: options.categories
+	};
+}
+//#endregion
+export { resolveMcpPlan };

package/dist/mcp/targets.js

@@ -0,0 +1,34 @@
+import { mcpUnsupportedReason } from "./install.js";
+import { detectInstalledAgents, listMcpAgentIds, resolveAddMcpAgentId, uniqueAgentIds } from "./agents.js";
+import { detectProjectAgents } from "add-mcp";
+//#region src/mcp/targets.ts
+function mcpInstallableAgents(scope) {
+	return listMcpAgentIds().filter((id) => mcpUnsupportedReason(id, scope) === void 0);
+}
+async function detectMcpAgents(options) {
+	const detected = options.scope === "project" ? detectProjectAgents(options.cwd) : await detectInstalledAgents();
+	return uniqueAgentIds(detected).filter((id) => mcpUnsupportedReason(id, options.scope) === void 0);
+}
+function resolveInstallTargets(options) {
+	const requested = uniqueAgentIds(options.agents.map(resolveAddMcpAgentId));
+	const install = [];
+	const skipped = [];
+	for (const agent of requested) {
+		const error = mcpUnsupportedReason(agent, options.scope);
+		if (error) skipped.push({
+			agent,
+			error
+		});
+		else install.push(agent);
+	}
+	if (install.length === 0) {
+		const details = skipped.map((row) => row.error).join(" ");
+		throw new Error(details || `None of the selected agents can install the Neon MCP server. Supported agents: ${mcpInstallableAgents(options.scope).join(", ")}`);
+	}
+	return {
+		install,
+		skipped
+	};
+}
+//#endregion
+export { detectMcpAgents, mcpInstallableAgents, resolveInstallTargets };

package/dist/mcp/wizard.js

@@ -0,0 +1,91 @@
+import { getAgentDisplayName } from "./agents.js";
+import { canPickAgentsInteractively } from "../utils/agent_picker.js";
+import prompts from "prompts";
+//#region src/mcp/wizard.ts
+const restoreCursorOnAbort = (state) => {
+	if (state.aborted) {
+		process.stdout.write("\x1B[?25h");
+		process.stdout.write("\n");
+		process.exit(1);
+	}
+};
+const pickMcpScope = async () => {
+	if (!canPickAgentsInteractively()) throw new Error("No interactive terminal. Pass --project for project config, or -y for global.");
+	const { scope } = await prompts({
+		onState: restoreCursorOnAbort,
+		type: "select",
+		name: "scope",
+		message: "Where should the Neon MCP server be installed?",
+		initial: 0,
+		choices: [{
+			title: "Global",
+			value: "global",
+			description: "User-level agent config"
+		}, {
+			title: "Project",
+			value: "project",
+			description: "This directory"
+		}]
+	});
+	if (scope !== "global" && scope !== "project") throw new Error("Aborted.");
+	return scope;
+};
+const pickMcpAuth = async () => {
+	if (!canPickAgentsInteractively()) throw new Error("No interactive terminal. Pass --oauth for OAuth, or -y to mint an API key.");
+	const { auth } = await prompts({
+		onState: restoreCursorOnAbort,
+		type: "select",
+		name: "auth",
+		message: "How should agents authenticate to Neon?",
+		initial: 0,
+		choices: [{
+			title: "API key",
+			value: "api-key",
+			description: "Mint a key and write it into agent config"
+		}, {
+			title: "OAuth",
+			value: "oauth",
+			description: "The agent signs in on first use"
+		}]
+	});
+	if (auth !== "api-key" && auth !== "oauth") throw new Error("Aborted.");
+	return auth;
+};
+const pickMcpProjectPin = async (linkedProjectId) => {
+	if (!canPickAgentsInteractively()) return false;
+	const { pin } = await prompts({
+		onState: restoreCursorOnAbort,
+		type: "confirm",
+		name: "pin",
+		message: `Pin MCP tools to the linked project ${linkedProjectId}?`,
+		initial: true
+	});
+	return pin === true;
+};
+const mcpInstallSummary = (options) => {
+	const agents = options.install.map(getAgentDisplayName).join(", ");
+	const auth = options.auth === "oauth" ? "OAuth, agent signs in on first use" : options.reuse ? "reuse the API key already in agent config" : "mint an account-wide API key that reaches every organization";
+	const rows = [
+		["Config", options.scope === "project" ? "this directory" : "user-level"],
+		["Agents", agents],
+		["Auth", auth],
+		["URL", options.url]
+	];
+	if (options.skipped.length > 0) rows.push(["Skipped", options.skipped.map((row) => `${getAgentDisplayName(row.agent)} (${row.error})`).join("; ")]);
+	const labelWidth = Math.max(...rows.map(([label]) => label.length));
+	return rows.map(([label, value]) => `${label.padEnd(labelWidth)}  ${value}`).join("\n");
+};
+const confirmMcpInstall = async (options) => {
+	if (!canPickAgentsInteractively()) return true;
+	process.stdout.write(`\n${mcpInstallSummary(options)}\n\n`);
+	const { ok } = await prompts({
+		onState: restoreCursorOnAbort,
+		type: "confirm",
+		name: "ok",
+		message: "Write the Neon MCP server into these agents?",
+		initial: true
+	});
+	return ok === true;
+};
+//#endregion
+export { confirmMcpInstall, mcpInstallSummary, pickMcpAuth, pickMcpProjectPin, pickMcpScope };

package/dist/test_utils/fixtures.js

@@ -57,9 +57,8 @@ const test = test$1.extend({
 				apiHost,
 				"--output",
 				options.output ?? (options.outputTable ? "table" : "yaml"),
-				"--api-key",
-				"test-key",
 				"--no-analytics",
+				...options.apiKey === false ? [] : ["--api-key", options.apiKey ?? "test-key"],
 				...args
 			], {
 				stdio: "pipe",
@@ -84,9 +83,13 @@ const test = test$1.extend({
 				cp.on("close", (code) => {
 					try {
 						expect(code).toBe(options?.code ?? 0);
-						expect(output).toMatchSnapshot();
+						if (options.snapshot !== false) expect(output).toMatchSnapshot();
 						if (options.stderr !== void 0) expect(strip(error).replace(/\s+/g, " ").trim()).toEqual(typeof options.stderr === "string" ? options.stderr.toString().replace(/\s+/g, " ") : options.stderr);
-						resolve();
+						resolve({
+							stdout: output,
+							stderr: error,
+							code
+						});
 					} catch (err) {
 						reject(err instanceof Error ? err : new Error(String(err)));
 					}

package/dist/utils/agent_picker.js

@@ -0,0 +1,70 @@
+import { isCi } from "../env.js";
+import { getAgentDisplayName, resolveAddMcpAgentId, uniqueAgentIds } from "../mcp/agents.js";
+import prompts from "prompts";
+//#region src/utils/agent_picker.ts
+const canPickAgentsInteractively = () => !isCi() && Boolean(process.stdout.isTTY) && Boolean(process.stdin.isTTY);
+const pickAgentsInteractively = async (options) => {
+	if (!canPickAgentsInteractively()) throw new Error("No interactive terminal. Pass --agent <name>, or run this command in a terminal to pick agents.");
+	if (options.choices.length === 0) throw new Error("No coding agents are available to pick.");
+	const selected = new Set(options.selected ?? []);
+	const { agents } = await prompts({
+		onState: (state) => {
+			if (state.aborted) {
+				process.stdout.write("\x1B[?25h");
+				process.stdout.write("\n");
+				process.exit(1);
+			}
+		},
+		type: "multiselect",
+		name: "agents",
+		message: options.message,
+		instructions: false,
+		min: 1,
+		choices: options.choices.map((choice) => ({
+			value: choice.id,
+			title: choice.title,
+			description: choice.description,
+			selected: selected.has(choice.id)
+		}))
+	});
+	if (!Array.isArray(agents)) throw new Error("Aborted: no agents selected.");
+	const picked = [];
+	for (const value of agents) {
+		const id = agentIdInChoices(value, options.choices);
+		if (id === void 0) throw new Error(`Unknown agent: "${String(value)}".`);
+		picked.push(id);
+	}
+	return uniqueAgentIds(picked);
+};
+const resolveAgentSelection = async (options) => {
+	if (options.specified.length > 0) {
+		const resolve = options.resolveSpecified ?? resolveAddMcpAgentId;
+		return uniqueAgentIds(options.specified.map(resolve));
+	}
+	const pick = options.pick ?? (options.interactive ?? canPickAgentsInteractively() ? pickAgentsInteractively : void 0);
+	if (pick) {
+		const selected = await pick({
+			message: options.message,
+			choices: options.choices,
+			selected: options.detected.filter((id) => options.choices.some((choice) => choice.id === id))
+		});
+		if (selected.length === 0) throw new Error("No agents selected. Pass --agent <name>, or pick at least one agent.");
+		return uniqueAgentIds(selected);
+	}
+	if (options.detected.length > 0) return uniqueAgentIds(options.detected);
+	throw new Error(options.nonInteractiveMessage);
+};
+const agentChoicesFrom = (available, detected) => {
+	const detectedSet = new Set(detected);
+	return [...available.filter((id) => detectedSet.has(id)), ...available.filter((id) => !detectedSet.has(id))].map((id) => ({
+		id,
+		title: getAgentDisplayName(id),
+		...detectedSet.has(id) ? { description: "detected" } : {}
+	}));
+};
+const agentIdInChoices = (value, choices) => {
+	if (typeof value !== "string") return;
+	for (const choice of choices) if (choice.id === value) return choice.id;
+};
+//#endregion
+export { agentChoicesFrom, canPickAgentsInteractively, pickAgentsInteractively, resolveAgentSelection };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neon",
-  "version": "4.1.0",
+  "version": "4.2.1",
   "description": "CLI tool for Neon, the cloud backend primitives built around Lakebase Postgres",
   "keywords": [
     "neon",
@@ -64,8 +64,8 @@
     "yargs": "17.7.2",
     "yoctocolors": "^2.1.2",
     "@neon/sdk": "2.2.0",
-    "@neon/config-runtime": "1.0.2",
-    "@neon/config": "1.0.2"
+    "@neon/config": "1.0.2",
+    "@neon/config-runtime": "1.0.2"
   },
   "optionalDependencies": {
     "@napi-rs/keyring": "1.3.0",

package/dist/init/install_mcp.js

@@ -1,35 +0,0 @@
-import { agents, upsertServer } from "add-mcp";
-//#region src/init/install_mcp.ts
-const NEON_MCP_URL = "https://mcp.neon.tech/mcp";
-const NEON_MCP_NAME = "Neon";
-function installNeonMcpServer(options) {
-	const agent = agents[options.agent];
-	if (!agent.supportedTransports.includes("http")) return {
-		ok: false,
-		unsupported: true,
-		error: agent.unsupportedTransportMessage ?? `${agent.displayName} does not support remote HTTP MCP servers.`
-	};
-	if (options.scope === "project" && !agent.localConfigPath) return {
-		ok: false,
-		unsupported: true,
-		error: `${agent.displayName} does not support project-level MCP config.`
-	};
-	const result = upsertServer(options.agent, NEON_MCP_NAME, {
-		type: "http",
-		url: NEON_MCP_URL
-	}, {
-		local: options.scope === "project",
-		cwd: options.cwd
-	});
-	if (result.success) return {
-		ok: true,
-		path: result.path
-	};
-	return {
-		ok: false,
-		unsupported: false,
-		error: result.error ?? "Failed to write Neon MCP server config"
-	};
-}
-//#endregion
-export { NEON_MCP_NAME, NEON_MCP_URL, installNeonMcpServer };