neon 3.3.0 → 3.5.0

package/dist/commands/connection_string.js

@@ -106,7 +106,7 @@ const handler = async (props) => {
 	let host = props.pooled ? endpoint.host.replace(endpoint.id, `${endpoint.id}-pooler`) : endpoint.host;
 	if (parsedPIT.tag !== "head") host = endpoint.host.replace(endpoint.id, endpoint.branch_id);
 	const connectionString = new URL(`postgresql://${host}`);
-	connectionString.pathname = database;
+	connectionString.pathname = `/${encodeURIComponent(database)}`;
 	connectionString.username = role;
 	connectionString.password = password;
 	if (props.prisma) {

package/dist/commands/inspect.js

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "../_chunks/rolldown-runtime-8H4AJuhK.js";
 import { writer } from "../writer.js";
 import { fillSingleProject } from "../utils/enrichers.js";
-import { resolveConnectionUri, runInspectQuery } from "../utils/inspect_db.js";
+import { formatInspectQueryError, resolveInspectTargets, runInspectQuery } from "../utils/inspect_db.js";
 import { INSPECT_QUERIES } from "../utils/inspect_queries.js";
 //#region src/commands/inspect.ts
 var inspect_exports = /* @__PURE__ */ __exportAll({
@@ -12,7 +12,7 @@ var inspect_exports = /* @__PURE__ */ __exportAll({
 	handler: () => handler
 });
 const command = "inspect";
-const describe = "Inspect a database's health and configuration";
+const describe = "Inspect a branch's Postgres health and configuration";
 const aliases = ["inspection"];
 /**
 * `fillSingleProject` hits the API to auto-resolve a project. When the user
@@ -24,11 +24,36 @@ const fillSingleProjectUnlessDbUrl = async (props) => {
 };
 const runSubcommand = async (name, props) => {
 	const query = INSPECT_QUERIES[name];
-	const connectionUri = props.dbUrl ?? (await resolveConnectionUri(props)).connectionUri;
-	const rows = await runInspectQuery(connectionUri, query.sql, { requiresExtension: query.requiresExtension });
+	const { targets, includeDatabaseColumn, branchDatabaseCount } = await resolveInspectTargets(props, query.scope);
+	const rows = [];
+	for (const target of targets) {
+		let batch;
+		try {
+			batch = await runInspectQuery(target.connectionUri, query.sql, { requiresExtension: query.requiresExtension });
+		} catch (err) {
+			const reason = err instanceof Error ? err.message : String(err);
+			const wrapped = formatInspectQueryError({
+				reason,
+				database: target.database,
+				dbUrl: props.dbUrl,
+				databaseName: props.databaseName,
+				offerDatabaseNameHint: branchDatabaseCount > 1,
+				scope: query.scope,
+				requiresExtension: query.requiresExtension
+			});
+			if (wrapped === void 0) throw err instanceof Error ? err : new Error(reason);
+			throw new Error(wrapped);
+		}
+		if (includeDatabaseColumn) rows.push(...batch.map((row) => ({
+			database: target.database,
+			...row
+		})));
+		else rows.push(...batch);
+	}
+	const fields = includeDatabaseColumn ? ["database", ...query.fields] : query.fields;
 	writer(props).end(rows, {
-		fields: query.fields,
-		emptyMessage: query.emptyMessage
+		fields,
+		emptyMessage: includeDatabaseColumn ? query.emptyMessageAll ?? query.emptyMessage : query.emptyMessage
 	});
 };
 const dbBuilder = (argv) => {
@@ -42,7 +67,7 @@ const dbBuilder = (argv) => {
 			type: "string"
 		},
 		"database-name": {
-			describe: "Database name",
+			describe: "Database to inspect. Omit to cover every database the API lists for the branch. Ranking and row limits stay per database. One failing database fails the whole run. Compute-wide checks run once against the first listed database. Ignored with --db-url.",
 			type: "string"
 		},
 		"role-name": {

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 };