neon 3.4.0 → 3.5.1

package/dist/init/agents.js

@@ -1,93 +1,6 @@
+import { agents, detectGlobalAgents, getAgentTypes } from "add-mcp";
 //#region src/init/agents.ts
-/**
-* All agents that can be configured via neon-init.
-* Aligns with add-mcp's supported agents table.
-* https://github.com/neondatabase/add-mcp#supported-agents
-*/
-const ALL_CONFIGURABLE_AGENTS = [
-	{
-		editor: "Cursor",
-		addMcpId: "cursor",
-		hint: "Neon Local Connect extension"
-	},
-	{
-		editor: "VS Code",
-		addMcpId: "vscode",
-		hint: "Neon Local Connect extension"
-	},
-	{
-		editor: "Claude CLI",
-		addMcpId: "claude-code",
-		hint: "MCP Server"
-	},
-	{
-		editor: "Claude Desktop",
-		addMcpId: "claude-desktop",
-		hint: "MCP Server"
-	},
-	{
-		editor: "Codex",
-		addMcpId: "codex",
-		hint: "MCP Server"
-	},
-	{
-		editor: "OpenCode",
-		addMcpId: "opencode",
-		hint: "MCP Server"
-	},
-	{
-		editor: "Antigravity",
-		addMcpId: "antigravity",
-		hint: "MCP Server"
-	},
-	{
-		editor: "Cline",
-		addMcpId: "cline",
-		hint: "MCP Server"
-	},
-	{
-		editor: "Cline CLI",
-		addMcpId: "cline-cli",
-		hint: "MCP Server"
-	},
-	{
-		editor: "Gemini CLI",
-		addMcpId: "gemini-cli",
-		hint: "MCP Server"
-	},
-	{
-		editor: "GitHub Copilot CLI",
-		addMcpId: "github-copilot-cli",
-		hint: "MCP Server"
-	},
-	{
-		editor: "Goose",
-		addMcpId: "goose",
-		hint: "MCP Server"
-	},
-	{
-		editor: "MCPorter",
-		addMcpId: "mcporter",
-		hint: "MCP Server"
-	},
-	{
-		editor: "Zed",
-		addMcpId: "zed",
-		hint: "MCP Server"
-	}
-];
-function getAddMcpAgentId(editor) {
-	const agent = ALL_CONFIGURABLE_AGENTS.find((a) => a.editor === editor);
-	if (!agent) throw new Error(`No add-mcp agent ID found for editor: ${editor}`);
-	return agent.addMcpId;
-}
-/**
-* Maps a raw agent identifier (as reported by agents or passed via --agent)
-* to the add-mcp compatible agent ID.
-*
-* This handles aliases like "copilot" → "vscode", "claude" → "claude-code", etc.
-*/
-const AGENT_ALIAS_TO_MCP_ID = {
+const AGENT_ALIASES = {
 	cursor: "cursor",
 	copilot: "vscode",
 	"github-copilot": "vscode",
@@ -101,46 +14,87 @@ const AGENT_ALIAS_TO_MCP_ID = {
 	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"
+	zed: "zed",
+	grok: "grok-build",
+	"grok-build": "grok-build"
+};
+const SKILLS_AGENT_BY_TYPE = {
+	cursor: "cursor",
+	vscode: "github-copilot",
+	"claude-code": "claude-code",
+	"claude-desktop": "claude-code",
+	codex: "codex",
+	opencode: "opencode",
+	antigravity: "antigravity",
+	cline: "cline",
+	"cline-cli": "cline",
+	"gemini-cli": "gemini-cli",
+	goose: "goose",
+	"github-copilot-cli": "github-copilot",
+	windsurf: "windsurf",
+	zed: "zed",
+	"grok-build": "grok"
 };
+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 = AGENT_ALIAS_TO_MCP_ID[rawAgent.toLowerCase()];
-	if (!resolved) throw new Error(`Unknown agent: "${rawAgent}". Supported agents: ${Object.keys(AGENT_ALIAS_TO_MCP_ID).join(", ")}`);
+	const resolved = tryResolveAddMcpAgentId(rawAgent);
+	if (!resolved) throw new Error(`Unknown agent: "${rawAgent}". Supported agents: ${listMcpAgentIds().join(", ")}`);
 	return resolved;
 }
-/**
-* Maps a raw agent identifier to the skills CLI agent name.
-*/
 function getSkillsAgentName(agent) {
-	switch (agent.toLowerCase()) {
-		case "cursor": return "cursor";
-		case "copilot":
-		case "vscode":
-		case "vs-code":
-		case "github-copilot": return "github-copilot";
-		case "claude":
-		case "claude-code": return "claude-code";
-		case "codex": return "codex";
-		case "opencode": return "opencode";
-		case "antigravity": return "antigravity";
-		case "cline": return "cline";
-		case "gemini-cli": return "gemini-cli";
-		case "goose": return "goose";
-		case "claude-desktop": return "claude-code";
-		case "cline-cli": return "cline";
-		case "gemini": return "gemini-cli";
-		case "windsurf": return "windsurf";
-		case "github-copilot-cli": return "github-copilot";
-		case "mcporter": return "mcporter";
-		case "zed": return "zed";
-		default: return "cursor";
-	}
+	if (Object.prototype.hasOwnProperty.call(SKILLS_AGENT_BY_TYPE, agent)) return SKILLS_AGENT_BY_TYPE[agent];
+	const id = tryResolveAddMcpAgentId(agent);
+	if (!id) return void 0;
+	return SKILLS_AGENT_BY_TYPE[id];
+}
+function supportsSkills(agent) {
+	return getSkillsAgentName(agent) !== void 0;
+}
+function agentPickerHint(id) {
+	if (id === "cursor" || id === "vscode") return "Neon Local Connect extension";
+	if (id === "claude-desktop") return supportsSkills(id) ? "Connectors in the app, skills" : agents[id].unsupportedTransportMessage ?? "Add remote servers through Connectors in the app";
+	if (supportsSkills(id)) return "MCP server, skills";
+	return "MCP server";
+}
+async function detectInstalledAgents() {
+	return detectGlobalAgents();
+}
+function mcpPickerOptions() {
+	return listMcpAgentIds().map((id) => ({
+		value: id,
+		label: getAgentDisplayName(id),
+		hint: agentPickerHint(id)
+	}));
+}
+function skillsPickerOptions() {
+	return listMcpAgentIds().filter((id) => supportsSkills(id)).map((id) => ({
+		value: id,
+		label: getAgentDisplayName(id),
+		hint: "agent skills"
+	}));
 }
 //#endregion
-export { ALL_CONFIGURABLE_AGENTS, getAddMcpAgentId, getSkillsAgentName, resolveAddMcpAgentId };
+export { agentPickerHint, agentSupportsHttpMcp, agentSupportsProjectMcp, detectInstalledAgents, getAgentDisplayName, getSkillsAgentName, listMcpAgentIds, mcpPickerOptions, resolveAddMcpAgentId, skillsPickerOptions, supportsSkills, tryResolveAddMcpAgentId };

package/dist/init/editors.js

@@ -1,10 +1,6 @@
-import { existsSync } from "node:fs";
+import { detectInstalledAgents } from "./agents.js";
 import { resolve } from "node:path";
-import { execa } from "execa";
 //#region src/init/editors.ts
-/**
-* Gets VS Code's global config directory based on the platform
-*/
 function getVSCodeGlobalConfigDir(homeDir) {
 	const platform = process.platform;
 	if (platform === "darwin") return resolve(homeDir, "Library", "Application Support", "Code", "User");
@@ -15,31 +11,8 @@ function getVSCodeGlobalConfigDir(homeDir) {
 	}
 	return null;
 }
-/**
-* Checks if Claude CLI is installed
-*/
-async function isClaudeCLIInstalled() {
-	try {
-		await execa("claude", ["--version"], {
-			stdio: "ignore",
-			timeout: 5e3
-		});
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Detects which editors are installed on the system
-*/
-async function detectAvailableEditors(homeDir) {
-	const editors = [];
-	const cursorDir = resolve(homeDir, ".cursor");
-	if (existsSync(cursorDir)) editors.push("Cursor");
-	const vscodeGlobalDir = getVSCodeGlobalConfigDir(homeDir);
-	if (vscodeGlobalDir && existsSync(vscodeGlobalDir)) editors.push("VS Code");
-	if (await isClaudeCLIInstalled()) editors.push("Claude CLI");
-	return editors;
+async function detectAvailableEditors(_homeDir) {
+	return detectInstalledAgents();
 }
 //#endregion
 export { detectAvailableEditors, getVSCodeGlobalConfigDir };

package/dist/init/inspect.js

@@ -1,5 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { resolve, sep } from "node:path";
+import { homedir } from "node:os";
+import { agents, getAgentTypes } from "add-mcp";
 //#region src/init/inspect.ts
 /**
 * Filesystem-based project inspection for interactive (agentless) mode.
@@ -15,9 +17,10 @@ async function inspectProject(checks) {
 	const cwd = process.cwd();
 	for (const check of checks) switch (check.id) {
 		case "mcp_server": {
-			const mcpScope = checkMcpServer(cwd);
-			results.mcpConfigured = mcpScope !== false;
-			results.mcpScope = mcpScope;
+			const hits = findNeonMcpAgents(cwd);
+			results.mcpAgents = hits;
+			results.mcpConfigured = hits.length > 0;
+			results.mcpScope = mcpScopeFromHits(hits);
 			break;
 		}
 		case "connection_string":
@@ -51,24 +54,70 @@ async function inspectProject(checks) {
 	}
 	return results;
 }
-function checkMcpServer(cwd) {
-	const home = process.env.HOME || process.env.USERPROFILE || "";
-	const projectConfigs = [resolve(cwd, ".cursor", "mcp.json"), resolve(cwd, ".vscode", "settings.json")];
-	for (const configPath of projectConfigs) if (existsSync(configPath)) try {
-		const content = readFileSync(configPath, "utf-8");
-		if (content.includes("neon") || content.includes("mcp.neon.tech")) return "project";
-	} catch {}
-	const globalConfigs = [
-		resolve(home, ".cursor", "mcp.json"),
-		resolve(home, ".claude", "settings.local.json"),
-		resolve(home, ".claude", "settings.json")
-	];
-	for (const configPath of globalConfigs) if (existsSync(configPath)) try {
-		const content = readFileSync(configPath, "utf-8");
-		if (content.includes("neon") || content.includes("mcp.neon.tech")) return "global";
-	} catch {}
+function mcpScopeFromHits(hits) {
+	if (hits.some((hit) => hit.scope === "project")) return "project";
+	if (hits.some((hit) => hit.scope === "global")) return "global";
 	return false;
 }
+function addMcpBakedHome() {
+	const cursorPath = agents.cursor.configPath;
+	const suffix = `${sep}.cursor${sep}mcp.json`;
+	if (cursorPath.endsWith(suffix)) return cursorPath.slice(0, -suffix.length);
+	return homedir();
+}
+function rebaseAddMcpHome(configPath) {
+	const currentHome = process.env.HOME || process.env.USERPROFILE || homedir();
+	const baked = addMcpBakedHome();
+	if (configPath.startsWith(baked)) return currentHome + configPath.slice(baked.length);
+	return configPath;
+}
+function agentProjectPath(id, cwd) {
+	const agent = agents[id];
+	if (agent.resolveConfigPath && agent.localConfigPath) return agent.resolveConfigPath(agent, {
+		local: true,
+		cwd
+	});
+	if (agent.localConfigPath) return resolve(cwd, agent.localConfigPath);
+}
+function agentGlobalPath(id, cwd) {
+	const agent = agents[id];
+	if (agent.resolveConfigPath) return rebaseAddMcpHome(agent.resolveConfigPath(agent, {
+		local: false,
+		cwd
+	}));
+	return rebaseAddMcpHome(agent.configPath);
+}
+function fileHasNeonMcp(configPath) {
+	if (!existsSync(configPath)) return false;
+	try {
+		const content = readFileSync(configPath, "utf-8");
+		if (content.toLowerCase().includes("mcp.neon.tech")) return true;
+		if (/"neon"\s*:/i.test(content)) return true;
+		if (/\[mcp_servers\.neon\]/i.test(content)) return true;
+		if (/^neon\s*=/im.test(content)) return true;
+		return false;
+	} catch {
+		return false;
+	}
+}
+function findNeonMcpAgents(cwd) {
+	const hits = [];
+	for (const id of getAgentTypes()) {
+		const projectPath = agentProjectPath(id, cwd);
+		if (projectPath && fileHasNeonMcp(projectPath)) {
+			hits.push({
+				agent: id,
+				scope: "project"
+			});
+			continue;
+		}
+		if (fileHasNeonMcp(agentGlobalPath(id, cwd))) hits.push({
+			agent: id,
+			scope: "global"
+		});
+	}
+	return hits;
+}
 function checkConnectionString(cwd) {
 	for (const envFile of [".env", ".env.local"]) {
 		const envPath = resolve(cwd, envFile);

package/dist/init/install_mcp.js

@@ -0,0 +1,35 @@
+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 };