fix(SMI-2021): use server target for mcp add (#782)

## Summary
- bump @smithery/api to 0.66.0 from smithery-ai/typescript-api#103
- send registry-name `smithery mcp add` inputs as Connect `server` targets instead of constructing `server.smithery.ai` URLs locally
- keep explicit HTTP URLs on `mcpUrl` and remove the legacy URL normalization helper

## Test plan
- pnpm exec tsc --noEmit
- pnpm exec biome check
- pnpm exec vitest run
- pnpm run build (pre-push hook)

Author: calclavia

README.md

@@ -69,7 +69,7 @@ smithery mcp publish <bundle.mcpb> -n <org/server>  # Publish an MCP bundle
 ```bash
 # Search and connect to an MCP server
 smithery mcp search "github"
-smithery mcp add https://server.smithery.ai/github --id github
+smithery mcp add github --id github
 
 # Find and call tools from your connected MCP servers
 smithery tool find "create issue"

package.json

@@ -44,7 +44,7 @@
 		"@anthropic-ai/mcpb": "^1.1.1",
 		"@biomejs/biome": "2.3.10",
 		"@modelcontextprotocol/sdk": "^1.25.3",
-		"@smithery/api": "^0.64.2",
+		"@smithery/api": "^0.66.0",
 		"@smithery/sdk": "^4.1.0",
 		"@types/inquirer": "^8.2.4",
 		"@types/inquirer-autocomplete-prompt": "^3.0.3",

pnpm-lock.yaml

@@ -36,6 +36,10 @@ vi.mock("../mcp/api", () => ({
 	ConnectSession: {
 		create: mockCreateSession,
 	},
+	connectionTargetFromInput: (input: string) =>
+		input.startsWith("http://") || input.startsWith("https://")
+			? { mcpUrl: input }
+			: { server: input },
 }))
 
 vi.mock("../mcp/output-connection", () => ({
@@ -97,7 +101,10 @@ describe("mcp add duplicate handling", () => {
 			],
 		})
 
-		await addServer("calclavia/test-input-required-two", {})
+		await addServer(
+			"https://server.smithery.ai/calclavia/test-input-required-two",
+			{},
+		)
 
 		expect(mockCreateConnection).not.toHaveBeenCalled()
 		expect(mockOutputConnectionDetail).toHaveBeenCalledWith(
@@ -112,6 +119,30 @@ describe("mcp add duplicate handling", () => {
 		)
 	})
 
+	test("creates registry connections with the server target", async () => {
+		mockCreateConnection.mockResolvedValue({
+			connectionId: "github",
+			name: "github",
+			mcpUrl: "https://server.smithery.ai/github",
+			metadata: null,
+			status: {
+				state: "connected",
+			},
+		})
+
+		await addServer("github", {})
+
+		expect(mockListConnectionsByUrl).not.toHaveBeenCalled()
+		expect(mockCreateConnection).toHaveBeenCalledWith(
+			{ server: "github" },
+			{
+				name: undefined,
+				metadata: undefined,
+				headers: undefined,
+			},
+		)
+	})
+
 	test("prints setupUrl for auth_required duplicate connections", async () => {
 		mockListConnectionsByUrl.mockResolvedValue({
 			connections: [

src/commands/__tests__/mcp-add-impl.test.ts

@@ -44,6 +44,10 @@ vi.mock("../mcp/api", () => ({
 	ConnectSession: {
 		create: mockCreateSession,
 	},
+	connectionTargetFromInput: (input: string) =>
+		input.startsWith("http://") || input.startsWith("https://")
+			? { mcpUrl: input }
+			: { server: input },
 }))
 
 vi.mock("../../lib/uplink", async () => {

src/commands/__tests__/mcp-add-uplink.test.ts

@@ -28,6 +28,26 @@ describe("ConnectSession uplink compatibility", () => {
 		})
 	})
 
+	test("creates registry connections with server targets", async () => {
+		const create = vi.fn().mockResolvedValue({
+			connectionId: "exa",
+			name: "exa",
+			mcpUrl: "https://server.smithery.ai/exa",
+			metadata: null,
+			status: { state: "connected" },
+		})
+
+		const session = new ConnectSession(
+			{ connections: { create } } as never,
+			"calclavia",
+		)
+		await session.createConnection({ server: "exa" })
+
+		expect(create).toHaveBeenCalledWith("calclavia", {
+			server: "exa",
+		})
+	})
+
 	test("does not replace conflicting uplink connections on 409", async () => {
 		const conflict = new ConflictError(409, {}, undefined, new Headers())
 		const set = vi.fn().mockRejectedValueOnce(conflict)
@@ -80,6 +100,27 @@ describe("ConnectSession uplink compatibility", () => {
 		})
 	})
 
+	test("sets registry connections with server targets", async () => {
+		const set = vi.fn().mockResolvedValue({
+			connectionId: "exa",
+			name: "exa",
+			mcpUrl: "https://server.smithery.ai/exa",
+			metadata: null,
+			status: { state: "connected" },
+		})
+
+		const session = new ConnectSession(
+			{ connections: { set } } as never,
+			"calclavia",
+		)
+		await session.setConnection("exa", { server: "exa" })
+
+		expect(set).toHaveBeenCalledWith("exa", {
+			namespace: "calclavia",
+			server: "exa",
+		})
+	})
+
 	test("lists tools over smithery.run REST", async () => {
 		const get = vi.fn().mockResolvedValue({
 			tools: [

src/commands/__tests__/mcp-api.test.ts

@@ -5,9 +5,8 @@ import {
 	completeConnectionAuthorization,
 	finalizeAddedConnection,
 } from "./add-flow"
-import { ConnectSession } from "./api"
+import { ConnectSession, connectionTargetFromInput } from "./api"
 import { isInputRequiredStatus } from "./connection-status"
-import { normalizeMcpUrl } from "./normalize-url"
 import { outputConnectionDetail } from "./output-connection"
 import { parseJsonObject } from "./parse-json"
 
@@ -29,13 +28,15 @@ export async function addServer(
 			true,
 		)
 
-		const normalizedUrl = normalizeMcpUrl(mcpUrl)
+		const target = connectionTargetFromInput(mcpUrl)
 		const session = await ConnectSession.create(options.namespace)
 
-		// Check for existing connections with the same URL
-		if (!options.force) {
-			const { connections: existing } =
-				await session.listConnectionsByUrl(normalizedUrl)
+		// URL inputs can still be checked exactly. Registry-name inputs are sent
+		// as `server` so Connect owns canonical URL resolution.
+		if (!options.force && target.mcpUrl) {
+			const { connections: existing } = await session.listConnectionsByUrl(
+				target.mcpUrl,
+			)
 			if (existing.length > 0) {
 				let match = existing[0]
 				const status = match.status?.state ?? "unknown"
@@ -76,7 +77,7 @@ export async function addServer(
 			}
 		}
 
-		const connection = await session.createConnection(normalizedUrl, {
+		const connection = await session.createConnection(target, {
 			name: options.name,
 			metadata: parsedMetadata,
 			headers: parsedHeaders,

src/commands/mcp/add-impl.ts

@@ -12,8 +12,7 @@ import {
 	addBundleUplinkServer,
 	type BundleAddTarget,
 } from "./add-uplink-bundle"
-import { ConnectSession } from "./api"
-import { normalizeMcpUrl } from "./normalize-url"
+import { ConnectSession, connectionTargetFromInput } from "./api"
 import { outputConnectionDetail } from "./output-connection"
 import { parseJsonObject } from "./parse-json"
 import { classifyAddTarget } from "./uplink-target"
@@ -69,7 +68,7 @@ export async function addServer(
 			const session = await ConnectSession.create(options.namespace)
 			const connection = await session.setConnection(
 				options.id,
-				normalizeMcpUrl(mcpUrl),
+				connectionTargetFromInput(mcpUrl),
 				{
 					name,
 					metadata: parsedMetadata,

src/commands/mcp/add.ts

@@ -5,6 +5,7 @@ import type {
 	Connection,
 	ConnectionCreateParams,
 	ConnectionListParams,
+	ConnectionSetParams,
 	ConnectionsListResponse,
 } from "@smithery/api/resources/connections.js"
 import { createSmitheryClient } from "../../lib/smithery-client"
@@ -14,7 +15,9 @@ import {
 } from "../../utils/smithery-settings"
 
 export type { Connection, ConnectionsListResponse }
-export type ConnectionTransport = NonNullable<Connection["transport"]>
+export type ConnectionTarget =
+	| (Required<Pick<ConnectionCreateParams, "mcpUrl">> & { server?: never })
+	| (Required<Pick<ConnectionCreateParams, "server">> & { mcpUrl?: never })
 
 export interface Trigger {
 	name: string
@@ -156,12 +159,12 @@ export class ConnectSession {
 	}
 
 	async createConnection(
-		mcpUrl?: string,
+		target?: string | ConnectionTarget,
 		options: ConnectionWriteOptions = {},
 	): Promise<Connection> {
 		return this.smitheryClient.connections.create(
 			this.namespace,
-			buildConnectionBody(mcpUrl, options) as ConnectionCreateParams,
+			buildConnectionBody(target, options),
 		)
 	}
 
@@ -171,20 +174,20 @@ export class ConnectSession {
 	 */
 	async setConnection(
 		connectionId: string,
-		mcpUrl?: string,
+		target?: string | ConnectionTarget,
 		options: ConnectionWriteOptions = {},
 	): Promise<Connection> {
 		try {
 			return await this.smitheryClient.connections.set(
 				connectionId,
-				buildConnectionSetParams(this.namespace, mcpUrl, options),
+				buildConnectionSetParams(this.namespace, target, options),
 			)
 		} catch (error) {
 			if (error instanceof ConflictError && options.transport !== "uplink") {
 				await this.deleteConnection(connectionId)
 				return this.smitheryClient.connections.set(
 					connectionId,
-					buildConnectionSetParams(this.namespace, mcpUrl, options),
+					buildConnectionSetParams(this.namespace, target, options),
 				)
 			}
 			throw error
@@ -255,31 +258,46 @@ export class ConnectSession {
 	}
 }
 
+export function connectionTargetFromInput(input: string): ConnectionTarget {
+	return isHttpUrl(input) ? { mcpUrl: input } : { server: input }
+}
+
 function buildConnectionBody(
-	mcpUrl: string | undefined,
+	target: string | ConnectionTarget | undefined,
 	options: ConnectionWriteOptions,
-): Record<string, unknown> {
-	const body = {
-		...(mcpUrl ? { mcpUrl } : {}),
+): ConnectionCreateParams {
+	return {
+		...normalizeConnectionTarget(target),
 		...(options.name ? { name: options.name } : {}),
 		...(options.metadata ? { metadata: options.metadata } : {}),
 		...(options.headers ? { headers: options.headers } : {}),
 		...(options.transport ? { transport: options.transport } : {}),
 	}
-	return body
 }
 
 function buildConnectionSetParams(
 	namespace: string,
-	mcpUrl: string | undefined,
+	target: string | ConnectionTarget | undefined,
 	options: ConnectionWriteOptions,
-) {
+): ConnectionSetParams {
 	return {
 		namespace,
-		...buildConnectionBody(mcpUrl, options),
+		...buildConnectionBody(target, options),
 	}
 }
 
+function normalizeConnectionTarget(
+	target: string | ConnectionTarget | undefined,
+): Pick<ConnectionCreateParams, "mcpUrl" | "server"> {
+	if (!target) return {}
+	if (typeof target === "string") return { mcpUrl: target }
+	return target
+}
+
+function isHttpUrl(value: string): boolean {
+	return value.startsWith("http://") || value.startsWith("https://")
+}
+
 function namespacePath(namespace: string): string {
 	return `/${encodeURIComponent(namespace)}`
 }