@agent-native/core 0.49.2 → 0.49.4

package/dist/cli/connect.js

@@ -52,6 +52,13 @@ const CANONICAL_SERVER_NAME_BY_MCP_URL = {
     "https://design.agent-native.com/_agent-native/mcp": "agent-native-design",
     "https://context-xray.agent-native.com/_agent-native/mcp": "agent-native-context-xray",
 };
+const LEGACY_SERVER_NAMES_BY_MCP_URL = {
+    "https://plan.agent-native.com/_agent-native/mcp": [
+        "agent-native-plan",
+        "agent-native-plans",
+        "agent-native-visual-plans",
+    ],
+};
 const CONNECT_PROFILES_VERSION = 1;
 const DEFAULT_DEV_GATEWAY = "http://127.0.0.1:8080";
 const MCP_FULL_CATALOG_HEADER = "X-Agent-Native-MCP-Full-Catalog";
@@ -360,8 +367,25 @@ function appSlugFromUrl(url) {
     }
 }
 function defaultServerName(url) {
+    const canonical = canonicalServerNameForMcpUrl(mcpUrlForBaseUrl(url));
+    if (canonical)
+        return canonical;
     return `${SERVER_NAME_PREFIX}-${appSlugFromUrl(url)}`;
 }
+function canonicalServerNameForMcpUrl(mcpUrl) {
+    const key = canonicalMcpUrl(mcpUrl);
+    return key ? CANONICAL_SERVER_NAME_BY_MCP_URL[key] : undefined;
+}
+function reconnectServerNameForMcpUrl(mcpUrl, serverName) {
+    const key = canonicalMcpUrl(mcpUrl);
+    if (!key || !serverName)
+        return serverName;
+    const canonical = CANONICAL_SERVER_NAME_BY_MCP_URL[key];
+    if (!canonical || serverName === canonical)
+        return serverName;
+    const legacyNames = LEGACY_SERVER_NAMES_BY_MCP_URL[key] ?? [];
+    return legacyNames.includes(serverName) ? canonical : serverName;
+}
 // ---------------------------------------------------------------------------
 // Browser open (mirrors workspace-dev.ts openBrowser)
 // ---------------------------------------------------------------------------
@@ -1167,8 +1191,16 @@ function distinctReconnectEntries(entries) {
     }
     return out;
 }
-function describeReconnectEntry(entry) {
-    return `${entry.serverName} (${entry.url}) in ${entry.client}`;
+function uniqueClients(entries) {
+    return [...new Set(entries.map((entry) => entry.client))];
+}
+function preferredReconnectEntry(url, entries) {
+    const canonicalName = CANONICAL_SERVER_NAME_BY_MCP_URL[url];
+    return ((canonicalName
+        ? entries.find((entry) => entry.serverName === canonicalName)
+        : undefined) ??
+        entries.find((entry) => !entry.serverName.startsWith("agent-native-")) ??
+        entries[0]);
 }
 /**
  * Return true when `url` is an agent-native MCP endpoint.
@@ -1193,20 +1225,51 @@ async function resolveReconnectTarget(parsed, clients, deps) {
     if (parsed.url) {
         const normalizedUrl = normalizeUrl(parsed.url);
         const mcpUrl = mcpUrlForBaseUrl(normalizedUrl);
+        const matches = distinctReconnectEntries(entries.filter((entry) => sameMcpUrl(entry.url, mcpUrl)));
+        if (matches.length === 0) {
+            logErr(`  No existing Agent Native MCP entry found for ${mcpUrl}.`);
+            logErr("  First-time setup still uses: npx @agent-native/core@latest connect <url> --client <client>");
+            return null;
+        }
         if (parsed.name) {
-            return { rawUrl: parsed.url, serverName: parsed.name };
+            const namedMatches = matches.filter((entry) => entry.serverName === parsed.name);
+            if (namedMatches.length === 0) {
+                logErr(`  No existing MCP entry named "${parsed.name}" found for ${mcpUrl}.`);
+                logErr("  Re-run without --name to use the existing entry name.");
+                return null;
+            }
+            return {
+                rawUrl: parsed.url,
+                serverName: parsed.name,
+                clients: uniqueClients(namedMatches),
+            };
         }
-        const matches = distinctReconnectEntries(entries.filter((entry) => sameMcpUrl(entry.url, mcpUrl)));
-        const names = [...new Set(matches.map((entry) => entry.serverName))];
-        if (names.length === 1) {
-            return { rawUrl: parsed.url, serverName: names[0] };
+        const key = canonicalMcpUrl(mcpUrl) ?? mcpUrl;
+        const preferred = preferredReconnectEntry(key, matches);
+        if (preferred) {
+            const names = [...new Set(matches.map((entry) => entry.serverName))];
+            if (names.length > 1) {
+                logOut(`  Found duplicate MCP entries for ${mcpUrl}: ${names.join(", ")}.`);
+                logOut(`  Reconnecting "${preferred.serverName}" and removing the duplicate names.`);
+            }
+            return {
+                rawUrl: parsed.url,
+                serverName: reconnectServerNameForMcpUrl(mcpUrl, preferred.serverName) ??
+                    preferred.serverName,
+                clients: uniqueClients(matches),
+            };
         }
+        const names = [...new Set(matches.map((entry) => entry.serverName))];
         if (names.length > 1) {
             logErr(`  Found multiple MCP entries for ${mcpUrl}: ${names.join(", ")}.`);
             logErr("  Re-run with --name <serverName> to choose one.");
             return null;
         }
-        return { rawUrl: parsed.url };
+        return {
+            rawUrl: parsed.url,
+            serverName: names[0],
+            clients: uniqueClients(matches),
+        };
     }
     // No URL provided: scan all configs for agent-native MCP entries by URL
     // pattern, not by server name prefix. This finds the canonical "plan" entry
@@ -1234,13 +1297,13 @@ async function resolveReconnectTarget(parsed, clients, deps) {
         // Fall back to any entry whose name doesn't start with "agent-native-"
         // (short canonical names like "plan"), then bucket[0].
         const [url, bucket] = [...byUrl.entries()][0];
-        const canonicalName = CANONICAL_SERVER_NAME_BY_MCP_URL[url];
-        const preferred = (canonicalName
-            ? bucket.find((e) => e.serverName === canonicalName)
-            : undefined) ??
-            bucket.find((e) => !e.serverName.startsWith("agent-native-")) ??
-            bucket[0];
-        return { rawUrl: preferred.url, serverName: preferred.serverName };
+        const preferred = preferredReconnectEntry(url, bucket) ?? bucket[0];
+        return {
+            rawUrl: preferred.url,
+            serverName: reconnectServerNameForMcpUrl(preferred.url, preferred.serverName) ??
+                preferred.serverName,
+            clients: uniqueClients(bucket),
+        };
     }
     // Multiple distinct URLs: pick interactively when TTY, else list with hints.
     const urlList = [...byUrl.keys()];
@@ -1261,10 +1324,18 @@ async function resolveReconnectTarget(parsed, clients, deps) {
             clack.cancel("Cancelled.");
             return null;
         }
-        const chosen = byUrl.get(result)?.[0];
-        if (!chosen)
+        const bucket = byUrl.get(result);
+        const chosen = bucket
+            ? (preferredReconnectEntry(result, bucket) ?? bucket[0])
+            : undefined;
+        if (!chosen || !bucket)
             return null;
-        return { rawUrl: chosen.url, serverName: chosen.serverName };
+        return {
+            rawUrl: chosen.url,
+            serverName: reconnectServerNameForMcpUrl(chosen.url, chosen.serverName) ??
+                chosen.serverName,
+            clients: uniqueClients(bucket),
+        };
     }
     logErr("  Found multiple Agent Native MCP entries:");
     for (const [u, bucket] of byUrl) {
@@ -1274,7 +1345,7 @@ async function resolveReconnectTarget(parsed, clients, deps) {
     for (const u of urlList) {
         // Strip the MCP path suffix for a cleaner reconnect URL suggestion.
         const baseUrl = u.replace(/\/_agent-native\/mcp$/, "");
-        logErr(`    npx @agent-native/core@latest reconnect ${baseUrl}`);
+        logErr(`    npx -y @agent-native/core@latest reconnect ${baseUrl}`);
     }
     return null;
 }
@@ -1287,9 +1358,10 @@ async function reconnectOne(parsed, clients, deps) {
         url: target.rawUrl,
         name: target.serverName ?? parsed.name,
     };
+    const effectiveClients = target.clients?.length ? target.clients : clients;
     logOut("");
     logOut(`  Reconnecting${effectiveParsed.name ? ` "${effectiveParsed.name}"` : ""}...`);
-    const res = await connectOne(target.rawUrl, effectiveParsed, clients, deps);
+    const res = await connectOne(target.rawUrl, effectiveParsed, effectiveClients, deps);
     return res.ok;
 }
 async function connectOne(rawUrl, parsed, clients, deps) {
@@ -1330,7 +1402,11 @@ async function connectOne(rawUrl, parsed, clients, deps) {
             return { ok: false };
         token = grant.token;
         mcpUrl = grant.mcpUrl;
-        serverName = parsed.name ?? grant.serverName ?? defaultServerName(baseUrl);
+        serverName =
+            parsed.name ??
+                reconnectServerNameForMcpUrl(grant.mcpUrl, grant.serverName) ??
+                grant.serverName ??
+                defaultServerName(baseUrl);
         headers = grant.headers;
     }
     if (oauthClients.length > 0 && !parsed.token) {
@@ -1625,12 +1701,14 @@ Usage:
       org-visible. Org owner/admin only. Printed once; nothing is written
       to local MCP configs.
 
-  npx @agent-native/core@latest reconnect [<url>] [--client <c>] [--scope user|project]
-  npx @agent-native/core@latest connect reconnect [<url>] [--client <c>] [--scope user|project]
+  npx -y @agent-native/core@latest reconnect [<url>] [--client <c>] [--scope user|project]
+  npx -y @agent-native/core@latest connect reconnect [<url>] [--client <c>] [--scope user|project]
       Re-authenticate an existing MCP entry without reinstalling apps/skills.
       With a URL, it reuses the existing server name for that MCP URL when
-      possible. Without a URL, it reconnects the only matching Agent Native
-      entry in the selected client config. Use --name for custom server names.
+      possible, reconnecting only clients that already have that entry. Pass
+      --client to limit which configs it searches. Without a URL, it reconnects
+      the only matching Agent Native entry in local client configs. Use --name
+      for custom server names.
 
   npx @agent-native/core@latest connect --all [--client <c>] [--scope user|project]
       Connect every first-party hosted app as separate MCP resources.
@@ -1661,14 +1739,20 @@ export async function runConnect(args, deps = {}) {
     const parsed = parseConnectArgs(args);
     try {
         if (parsed.mode) {
-            const clients = await resolveConnectClients(parsed, deps);
-            if (!clients)
-                return;
-            const ok = parsed.mode === "dev"
-                ? await connectDevProfile(parsed, clients, deps)
-                : parsed.mode === "prod"
-                    ? await connectProdProfile(parsed, clients, deps)
-                    : await reconnectOne(parsed, clients, deps);
+            let ok;
+            if (parsed.mode === "reconnect" || parsed.mode === "reauth") {
+                const clients = resolveClients(parsed.client);
+                ok = await reconnectOne(parsed, clients, deps);
+            }
+            else {
+                const clients = await resolveConnectClients(parsed, deps);
+                if (!clients)
+                    return;
+                ok =
+                    parsed.mode === "dev"
+                        ? await connectDevProfile(parsed, clients, deps)
+                        : await connectProdProfile(parsed, clients, deps);
+            }
             if (!ok)
                 process.exitCode = 1;
             return;