genexus-mcp 2.48.0 → 2.49.1

package/cli/commands/axi.js

@@ -27,7 +27,8 @@ const {
     switchActiveKb,
     isPathLikelyAppLockerBlocked,
     normalizeExePath,
-    readClientCommandEntry
+    readClientCommandEntry,
+    DEFAULT_MCP_SERVER_NAME
 } = require('../lib/config');
 
 function resolveClientIds(options) {
@@ -1154,6 +1155,9 @@ async function handleLayout(subcommand, options, ctx) {
 
 function buildInteractiveInitHelp(patchResult) {
     const help = [];
+    if (patchResult.failed && patchResult.failed.some((f) => f.reason && f.reason.includes('third-party or HTTP MCP server'))) {
+        help.push('A collision with an existing MCP server (e.g. official GeneXus MCP) was detected. Re-run init with --server-name=<customName> (e.g. --server-name Gx18byLennix) or pass --force.');
+    }
     if (patchResult.patched.length === 0) {
         help.push('Set `GX_CONFIG_PATH` in your MCP client env to the generated config path.');
     } else if (process.platform === 'win32' && !process.env.GENEXUS_MCP_GATEWAY_EXE) {
@@ -1228,8 +1232,10 @@ async function runInteractiveInit(ctx) {
         }
 
         const created = createConfigFile(finalKb, finalGx);
+        const serverName = ctx.options && ctx.options.serverName ? ctx.options.serverName : DEFAULT_MCP_SERVER_NAME;
+        const force = Boolean(ctx.options && ctx.options.force);
         const patchResult = selectedIds.length
-            ? patchClientConfig(created.targetConfigPath, { ids: selectedIds, onlyExisting: false })
+            ? patchClientConfig(created.targetConfigPath, { ids: selectedIds, onlyExisting: false, serverName, force })
             : { patched: [], failed: [], skipped: [] };
 
         return {
@@ -1405,7 +1411,9 @@ async function handleInit(options, ctx) {
             }
             patchResult = patchClientConfig(created.targetConfigPath, {
                 ids,
-                onlyExisting: !options.allClients
+                onlyExisting: !options.allClients,
+                serverName: options.serverName || DEFAULT_MCP_SERVER_NAME,
+                force: options.force
             });
         }
 
@@ -1422,6 +1430,10 @@ async function handleInit(options, ctx) {
         }
 
         const help = [];
+        if (patchResult.failed.some((f) => f.reason && f.reason.includes('third-party or HTTP MCP server'))) {
+            help.push('A collision with an existing MCP server (e.g. official GeneXus MCP) was detected on one or more clients.');
+            help.push('Re-run init with --server-name=<customName> (e.g. --server-name Gx18byLennix), pass --force, or pass --no-write-clients.');
+        }
         if (patchResult.patched.length === 0 && shouldWriteClients) {
             help.push('No installed AI client config was found to patch. Pass --all-clients to write configs for all known clients, or register manually.');
             help.push(`For a GLOBAL (all-projects) registration that does not depend on the current directory, point your client at this config via the GX_CONFIG_PATH env var, e.g.: claude mcp add genexus -e GX_CONFIG_PATH="${created.targetConfigPath}" -- <launcher>`);
@@ -1752,19 +1764,20 @@ async function handleUninstall(options, ctx) {
 
 async function handleClients(subcommand, options, ctx) {
     const sub = subcommand || 'list';
+    const serverName = options.serverName || DEFAULT_MCP_SERVER_NAME;
 
     if (sub === 'list') {
-        const rows = clientsStatus();
+        const rows = clientsStatus({ serverName });
         const installedCount = rows.filter((r) => r.installed).length;
         const registeredCount = rows.filter((r) => r.registered).length;
         const help = [];
         const installedUnregistered = rows.filter((r) => r.installed && !r.registered && r.writeSupported);
         if (installedUnregistered.length > 0) {
-            help.push(`Register installed-but-unregistered agents: genexus-mcp clients add --clients ${installedUnregistered.map((r) => r.id).join(',')}`);
+            help.push(`Register installed-but-unregistered agents: genexus-mcp clients add --clients ${installedUnregistered.map((r) => r.id).join(',')}${serverName !== DEFAULT_MCP_SERVER_NAME ? ` --server-name ${serverName}` : ''}`);
         }
         const stale = rows.filter((r) => r.commandStale);
         if (stale.length > 0) {
-            help.push(`These clients point at a missing gateway exe (will fail to connect) — re-register: genexus-mcp clients add --clients ${stale.map((r) => r.id).join(',')}`);
+            help.push(`These clients point at a missing gateway exe (will fail to connect) — re-register: genexus-mcp clients add --clients ${stale.map((r) => r.id).join(',')}${serverName !== DEFAULT_MCP_SERVER_NAME ? ` --server-name ${serverName}` : ''}`);
         }
         for (const r of rows) {
             if (r.installed && !r.writeSupported && r.note) help.push(`${r.name}: ${r.note}`);
@@ -1774,7 +1787,7 @@ async function handleClients(subcommand, options, ctx) {
             envelope: {
                 ok: {
                     clients: rows,
-                    summary: { total: rows.length, installed: installedCount, registered: registeredCount }
+                    summary: { total: rows.length, installed: installedCount, registered: registeredCount, serverName }
                 },
                 help
             }
@@ -1808,7 +1821,12 @@ async function handleClients(subcommand, options, ctx) {
             let patch;
             try {
                 // Explicit add: write even if install markers are absent (the user asked for it).
-                patch = patchClientConfig(configPath, { ids, onlyExisting: false });
+                patch = patchClientConfig(configPath, {
+                    ids,
+                    onlyExisting: false,
+                    serverName,
+                    force: options.force
+                });
             } catch (err) {
                 return {
                     exitCode: ctx.EXIT_CODES.ERROR,
@@ -1820,11 +1838,16 @@ async function handleClients(subcommand, options, ctx) {
             }
             const help = [];
             if (patch.patched.length > 0) help.push('Restart the affected AI client(s) to load the new MCP config.');
-            if (patch.failed.length > 0) help.push('Some clients failed (see meta.failedClients).');
+            if (patch.failed.some((f) => f.reason && f.reason.includes('third-party or HTTP MCP server'))) {
+                help.push('A collision with an existing MCP server (e.g. official GeneXus MCP) was detected.');
+                help.push('Use --server-name=<customName> (e.g. --server-name Gx18byLennix) or pass --force.');
+            } else if (patch.failed.length > 0) {
+                help.push('Some clients failed (see meta.failedClients).');
+            }
             return {
                 exitCode: ctx.EXIT_CODES.OK,
                 envelope: {
-                    ok: { action: 'clients.add', configPath, patchedClients: patch.patched, patchedCount: patch.patched.length },
+                    ok: { action: 'clients.add', configPath, serverName, patchedClients: patch.patched, patchedCount: patch.patched.length },
                     help,
                     meta: { failedClients: patch.failed, skippedClients: patch.skipped }
                 }
@@ -1832,13 +1855,16 @@ async function handleClients(subcommand, options, ctx) {
         }
 
         // remove
-        const unpatch = unpatchClientConfig(ids ? { ids } : {});
+        const unpatch = unpatchClientConfig({
+            ...(ids ? { ids } : {}),
+            serverName
+        });
         const help = [];
         if (unpatch.removed.length > 0) help.push('Restart the affected AI client(s) to drop the stale MCP connection.');
         return {
             exitCode: ctx.EXIT_CODES.OK,
             envelope: {
-                ok: { action: 'clients.remove', removedClients: unpatch.removed, removedCount: unpatch.removed.length },
+                ok: { action: 'clients.remove', serverName, removedClients: unpatch.removed, removedCount: unpatch.removed.length },
                 help,
                 meta: { skippedClients: unpatch.skipped, failedClients: unpatch.failed }
             }
@@ -2009,10 +2035,11 @@ function commandHelpMap() {
             examples: ['genexus-mcp config show', 'genexus-mcp config show --full --format json']
         },
         init: {
-            usage: 'genexus-mcp init [--kb <path>] [--gx <path>] [--no-write-clients] [--clients <csv>] [--all-clients] [--no-smoke] [--warm] [--format ...] OR genexus-mcp init --interactive',
+            usage: 'genexus-mcp init [--kb <path>] [--gx <path>] [--server-name <name>] [--force] [--no-write-clients] [--clients <csv>] [--all-clients] [--no-smoke] [--warm] [--format ...] OR genexus-mcp init --interactive',
             examples: [
                 'genexus-mcp init   # zero-config: auto-discovers GX + KB, and registers detected AI clients',
                 'genexus-mcp init --kb "C:\\KBs\\MyKB" --gx "C:\\Program Files (x86)\\GeneXus\\GeneXus18"',
+                'genexus-mcp init --server-name Gx18byLennix   # register with custom MCP server key (coexists with official GeneXus MCP)',
                 'genexus-mcp init --interactive   # prompts per detected agent (Claude Desktop/Code, Gemini CLI, Cursor, Codex CLI, OpenCode, ...)',
                 'genexus-mcp init --kb <path> --gx <path> --clients claude-code,gemini-cli,cursor   # register only these',
                 'genexus-mcp init --kb <path> --gx <path> --no-write-clients   # write config.json only; register clients yourself',
@@ -2038,12 +2065,14 @@ function commandHelpMap() {
             ]
         },
         clients: {
-            usage: 'genexus-mcp clients [list] [--format ...] OR genexus-mcp clients add --clients <csv> OR genexus-mcp clients remove [--clients <csv>]',
+            usage: 'genexus-mcp clients [list] [--server-name <name>] [--format ...] OR genexus-mcp clients add --clients <csv> [--server-name <name>] [--force] OR genexus-mcp clients remove [--clients <csv>] [--server-name <name>]',
             examples: [
                 'genexus-mcp clients              # show every AI agent: installed? registered? where?',
                 'genexus-mcp clients --format json',
                 'genexus-mcp clients add --clients antigravity,vscode',
-                'genexus-mcp clients remove --clients cursor'
+                'genexus-mcp clients add --clients cursor --server-name Gx18byLennix',
+                'genexus-mcp clients remove --clients cursor',
+                'genexus-mcp clients remove --clients cursor --server-name Gx18byLennix'
             ]
         },
         llm: {

package/cli/index.js

@@ -43,6 +43,8 @@ const GLOBAL_DEFAULTS = {
     writeClients: false,
     clients: null,
     allClients: false,
+    serverName: null,
+    force: false,
     mcpSmoke: false,
     dump: false,
     noSmoke: false,
@@ -207,6 +209,22 @@ function parseArgs(argv) {
             case 'all-clients':
                 result.options.allClients = true;
                 break;
+            case 'server-name': {
+                const val = takeValue();
+                if (val) {
+                    if (!/^[a-zA-Z0-9_-]+$/.test(val)) {
+                        result.unknownFlags.push(`--server-name must be alphanumeric (letters, digits, _, -), got: "${val}"`);
+                    } else {
+                        result.options.serverName = val;
+                    }
+                } else {
+                    result.unknownFlags.push('--server-name requires a value');
+                }
+                break;
+            }
+            case 'force':
+                result.options.force = true;
+                break;
             case 'action': {
                 const val = takeValue();
                 if (val) result.options.action = val;

package/cli/lib/config.js

@@ -453,6 +453,57 @@ function getLauncher() {
         : { command: process.platform === 'win32' ? 'npx.cmd' : 'npx', args: ['-y', 'genexus-mcp@latest'] };
 }
 
+const DEFAULT_MCP_SERVER_NAME = 'genexus18mcp';
+
+function escapeRegex(str) {
+    return String(str).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// Detect whether an MCP server entry belongs to a third-party or official MCP
+// server (e.g. official GeneXus MCP over HTTP, or another tool).
+function isThirdPartyMcpEntry(entry) {
+    if (!entry || typeof entry !== 'object') return false;
+    // Explicit HTTP / SSE / remote URLs are third-party / official GeneXus MCP servers
+    if (entry.url || entry.type === 'http' || entry.type === 'sse' || entry.type === 'remote') {
+        return true;
+    }
+    // Environment markers written by genexus-mcp
+    const env = entry.env || entry.environment;
+    if (env && typeof env === 'object') {
+        if (env.GX_CONFIG_PATH || env.GX_PATH || env.GENEXUS_MCP_GATEWAY_EXE) {
+            return false;
+        }
+    }
+    // Command string or args mentioning genexus-mcp / GxMcp.Gateway / start_mcp.bat
+    if (typeof entry.command === 'string') {
+        if (/(^|[\\/])(genexus-mcp(\.cmd)?|GxMcp\.Gateway(\.exe)?|start_mcp\.bat)$/i.test(entry.command)) {
+            return false;
+        }
+        if (/(^|[\\/])(npx|npx\.cmd)$/i.test(entry.command) && (!entry.args || entry.args.length === 0)) {
+            return false;
+        }
+    }
+    if (Array.isArray(entry.args) && entry.args.some((a) => typeof a === 'string' && /genexus-mcp/i.test(a))) {
+        return false;
+    }
+    if (Array.isArray(entry.command)) {
+        if (entry.command.some((a) => typeof a === 'string' && /(genexus-mcp|GxMcp\.Gateway|start_mcp\.bat)/i.test(a))) {
+            return false;
+        }
+        if (entry.command.length === 1 && /(^|[\\/])(npx|npx\.cmd)$/i.test(entry.command[0])) {
+            return false;
+        }
+    }
+    // Any other custom command without our markers is third-party
+    return true;
+}
+
+function isOurMcpEntry(entry, key) {
+    if (!entry || typeof entry !== 'object') return false;
+    if (key === 'genexus18' || key === 'genexus18mcp') return true;
+    return !isThirdPartyMcpEntry(entry);
+}
+
 // Antigravity (Google's agentic IDE) ships its MCP config under ~/.gemini.
 // The newer unified location (shared across Antigravity CLI / IDE / SDK) is
 // ~/.gemini/config/mcp_config.json; the older IDE-specific one is
@@ -664,24 +715,29 @@ function clientCommandHealth(entry) {
 // is genexus registered, where, what launcher command it points at, and whether
 // that command is stale. Backs the `genexus-mcp clients` command.
 function clientsStatus(opts = {}) {
+    const serverName = opts.serverName || DEFAULT_MCP_SERVER_NAME;
     const targets = filterClientTargets(getClientConfigTargets(), {
         ids: opts.ids,
         platform: process.platform
     });
     return targets.map((client) => {
         const det = detectClientInstalled(client);
-        const entry = readClientCommandEntry(client);
+        const entry = readClientCommandEntry(client, serverName);
         const health = clientCommandHealth(entry);
+        const isThirdParty = entry && !isOurMcpEntry(entry.raw || entry, serverName);
         return {
             id: client.id,
             name: client.name,
             installed: det.installed,
             registered: entry !== null,
+            serverName,
+            isThirdParty: Boolean(isThirdParty),
             writeSupported: client.writeSupported !== false,
             configPath: client.path,
             command: entry && entry.command ? entry.command : null,
+            url: entry && entry.url ? entry.url : null,
             commandStale: health.stale,
-            commandStaleReason: health.reason,
+            commandStaleReason: health.reason || (isThirdParty ? 'configured as third-party / HTTP MCP server (e.g. official GeneXus MCP)' : null),
             detectedAt: det.markerHit || (det.hasConfig ? client.path : null),
             note: client.writeSupported === false ? (client.manualNote || null) : null
         };
@@ -713,6 +769,8 @@ function patchClientConfig(targetConfigPath, opts = {}) {
         throw err;
     }
 
+    const serverName = opts.serverName || DEFAULT_MCP_SERVER_NAME;
+    const force = Boolean(opts.force);
     const launcher = getLauncher();
     const onlyExisting = opts.onlyExisting !== false;
     const candidates = filterClientTargets(getClientConfigTargets(), {
@@ -742,11 +800,11 @@ function patchClientConfig(targetConfigPath, opts = {}) {
         }
         try {
             fs.mkdirSync(path.dirname(client.path), { recursive: true });
-            applyClientEntry(client, launcher, targetConfigPath);
+            applyClientEntry(client, launcher, targetConfigPath, { serverName, force });
             // Read-back: confirm the entry is actually present and the file still
             // parses, so a silently-corrupted write is reported as a failure.
-            if (!readClientCommandEntry(client)) {
-                throw new Error('post-write verification failed (genexus entry not found after write)');
+            if (!readClientCommandEntry(client, serverName)) {
+                throw new Error(`post-write verification failed (${serverName} entry not found after write)`);
             }
             patched.push(client.name);
         } catch (err) {
@@ -758,6 +816,7 @@ function patchClientConfig(targetConfigPath, opts = {}) {
 }
 
 function unpatchClientConfig(opts = {}) {
+    const serverName = opts.serverName || DEFAULT_MCP_SERVER_NAME;
     const targets = filterClientTargets(getClientConfigTargets(), {
         ids: opts.ids,
         onlyExisting: true,
@@ -774,9 +833,9 @@ function unpatchClientConfig(opts = {}) {
             continue;
         }
         try {
-            const wasRemoved = removeClientEntry(client);
+            const wasRemoved = removeClientEntry(client, { serverName });
             if (wasRemoved) removed.push(client.name);
-            else skipped.push({ client: client.name, reason: 'no genexus entry' });
+            else skipped.push({ client: client.name, reason: `no ${serverName} entry` });
         } catch (err) {
             failed.push({ client: client.name, reason: err && err.message ? err.message : 'Unknown error' });
         }
@@ -785,59 +844,79 @@ function unpatchClientConfig(opts = {}) {
     return { removed, skipped, failed };
 }
 
-function applyClientEntry(client, launcher, targetConfigPath) {
+function applyClientEntry(client, launcher, targetConfigPath, opts = {}) {
     switch (client.format) {
         case 'mcpServers':
-            return applyMcpServersJson(client.path, launcher, targetConfigPath);
+            return applyMcpServersJson(client.path, launcher, targetConfigPath, opts);
         case 'opencode':
-            return applyOpenCodeJson(client.path, launcher, targetConfigPath);
+            return applyOpenCodeJson(client.path, launcher, targetConfigPath, opts);
         case 'codex-toml':
-            return applyCodexToml(client.path, launcher, targetConfigPath);
+            return applyCodexToml(client.path, launcher, targetConfigPath, opts);
         case 'vscode-servers':
-            return applyVsCodeServersJson(client.path, launcher, targetConfigPath);
+            return applyVsCodeServersJson(client.path, launcher, targetConfigPath, opts);
         default:
             throw new Error(`Unknown client format: ${client.format}`);
     }
 }
 
-function removeClientEntry(client) {
+function removeClientEntry(client, opts = {}) {
     switch (client.format) {
         case 'mcpServers':
-            return removeMcpServersJson(client.path);
+            return removeMcpServersJson(client.path, opts);
         case 'opencode':
-            return removeOpenCodeJson(client.path);
+            return removeOpenCodeJson(client.path, opts);
         case 'codex-toml':
-            return removeCodexToml(client.path);
+            return removeCodexToml(client.path, opts);
         case 'vscode-servers':
-            return removeVsCodeServersJson(client.path);
+            return removeVsCodeServersJson(client.path, opts);
         default:
             throw new Error(`Unknown client format: ${client.format}`);
     }
 }
 
-function applyMcpServersJson(filePath, launcher, targetConfigPath) {
+function applyMcpServersJson(filePath, launcher, targetConfigPath, { serverName = DEFAULT_MCP_SERVER_NAME, force = false } = {}) {
     const parsed = fs.existsSync(filePath) ? readJsonFileSafe(filePath) : {};
     if (parsed === null) throw new Error('Invalid JSON');
     const cfgObj = parsed || {};
     cfgObj.mcpServers = cfgObj.mcpServers || {};
-    cfgObj.mcpServers.genexus = { ...launcher, env: { GX_CONFIG_PATH: targetConfigPath } };
-    // Drop the legacy `genexus18` key from older build-from-source installs so the
-    // user isn't left with two duplicate servers (and colliding tool names).
-    if (cfgObj.mcpServers.genexus18) delete cfgObj.mcpServers.genexus18;
+    const existing = cfgObj.mcpServers[serverName];
+    if (existing && !force && isThirdPartyMcpEntry(existing)) {
+        const err = new Error(`Existing '${serverName}' entry is a third-party or HTTP MCP server (e.g. official GeneXus MCP). Refusing to overwrite. Use --server-name=<customName> (e.g. --server-name Gx18byLennix) or --no-write-clients.`);
+        err.code = 'MCP_SERVER_COLLISION';
+        throw err;
+    }
+    cfgObj.mcpServers[serverName] = { ...launcher, env: { GX_CONFIG_PATH: targetConfigPath } };
+    // If registering default genexus18mcp, clean up legacy genexus/genexus18 entries only if they are not foreign HTTP servers
+    if (serverName === DEFAULT_MCP_SERVER_NAME) {
+        if (cfgObj.mcpServers.genexus && !isThirdPartyMcpEntry(cfgObj.mcpServers.genexus)) {
+            delete cfgObj.mcpServers.genexus;
+        }
+        if (cfgObj.mcpServers.genexus18 && !isThirdPartyMcpEntry(cfgObj.mcpServers.genexus18)) {
+            delete cfgObj.mcpServers.genexus18;
+        }
+    } else if (serverName === 'genexus') {
+        if (cfgObj.mcpServers.genexus18 && !isThirdPartyMcpEntry(cfgObj.mcpServers.genexus18)) {
+            delete cfgObj.mcpServers.genexus18;
+        }
+    }
     writeClientJson(filePath, cfgObj);
 }
 
-function removeMcpServersJson(filePath) {
+function removeMcpServersJson(filePath, { serverName = DEFAULT_MCP_SERVER_NAME } = {}) {
     const parsed = readJsonFileSafe(filePath);
     if (parsed === null) throw new Error('Invalid JSON');
     const cfgObj = parsed || {};
     if (!cfgObj.mcpServers) return false;
-    // Remove the current key plus the legacy `genexus18` key written by older
-    // versions of the build-from-source install.ps1, so uninstall fully cleans up
-    // regardless of which installer wrote the entry.
     let removedAny = false;
-    for (const key of ['genexus', 'genexus18']) {
-        if (cfgObj.mcpServers[key]) {
+    const keysToRemove = serverName === DEFAULT_MCP_SERVER_NAME
+        ? [DEFAULT_MCP_SERVER_NAME, 'genexus', 'genexus18']
+        : (serverName === 'genexus' ? ['genexus', 'genexus18'] : [serverName]);
+    for (const key of keysToRemove) {
+        const entry = cfgObj.mcpServers[key];
+        if (entry) {
+            if (key === 'genexus' && (entry.url || entry.type === 'http' || entry.type === 'sse' || entry.type === 'remote')) {
+                continue;
+            }
             delete cfgObj.mcpServers[key];
             removedAny = true;
         }
@@ -849,29 +928,50 @@ function removeMcpServersJson(filePath) {
 
 // VS Code native MCP lives in User\mcp.json and uses a top-level `servers` map
 // with `type: "stdio"` (distinct from the `mcpServers` shape Claude/Cursor use).
-function applyVsCodeServersJson(filePath, launcher, targetConfigPath) {
+function applyVsCodeServersJson(filePath, launcher, targetConfigPath, { serverName = DEFAULT_MCP_SERVER_NAME, force = false } = {}) {
     const parsed = fs.existsSync(filePath) ? readJsonFileSafe(filePath) : {};
     if (parsed === null) throw new Error('Invalid JSON');
     const cfgObj = parsed || {};
     cfgObj.servers = cfgObj.servers || {};
-    cfgObj.servers.genexus = {
+    const existing = cfgObj.servers[serverName];
+    if (existing && !force && isThirdPartyMcpEntry(existing)) {
+        const err = new Error(`Existing '${serverName}' entry is a third-party or HTTP MCP server (e.g. official GeneXus MCP). Refusing to overwrite. Use --server-name=<customName> (e.g. --server-name Gx18byLennix) or --no-write-clients.`);
+        err.code = 'MCP_SERVER_COLLISION';
+        throw err;
+    }
+    cfgObj.servers[serverName] = {
         type: 'stdio',
         ...launcher,
         env: { GX_CONFIG_PATH: targetConfigPath }
     };
-    // Drop the legacy `genexus18` key written by older build-from-source installs.
-    if (cfgObj.servers.genexus18) delete cfgObj.servers.genexus18;
+    if (serverName === DEFAULT_MCP_SERVER_NAME) {
+        if (cfgObj.servers.genexus && !isThirdPartyMcpEntry(cfgObj.servers.genexus)) {
+            delete cfgObj.servers.genexus;
+        }
+        if (cfgObj.servers.genexus18 && !isThirdPartyMcpEntry(cfgObj.servers.genexus18)) {
+            delete cfgObj.servers.genexus18;
+        }
+    } else if (serverName === 'genexus' && cfgObj.servers.genexus18 && !isThirdPartyMcpEntry(cfgObj.servers.genexus18)) {
+        delete cfgObj.servers.genexus18;
+    }
     writeClientJson(filePath, cfgObj);
 }
 
-function removeVsCodeServersJson(filePath) {
+function removeVsCodeServersJson(filePath, { serverName = DEFAULT_MCP_SERVER_NAME } = {}) {
     const parsed = readJsonFileSafe(filePath);
     if (parsed === null) throw new Error('Invalid JSON');
     const cfgObj = parsed || {};
     if (!cfgObj.servers) return false;
     let removedAny = false;
-    for (const key of ['genexus', 'genexus18']) {
-        if (cfgObj.servers[key]) {
+    const keysToRemove = serverName === DEFAULT_MCP_SERVER_NAME
+        ? [DEFAULT_MCP_SERVER_NAME, 'genexus', 'genexus18']
+        : (serverName === 'genexus' ? ['genexus', 'genexus18'] : [serverName]);
+    for (const key of keysToRemove) {
+        const entry = cfgObj.servers[key];
+        if (entry) {
+            if (key === 'genexus' && (entry.url || entry.type === 'http' || entry.type === 'sse' || entry.type === 'remote')) {
+                continue;
+            }
             delete cfgObj.servers[key];
             removedAny = true;
         }
@@ -898,7 +998,7 @@ function getOpenCodeMcpContainer(cfgObj) {
     };
 }
 
-function applyOpenCodeJson(filePath, launcher, targetConfigPath) {
+function applyOpenCodeJson(filePath, launcher, targetConfigPath, { serverName = DEFAULT_MCP_SERVER_NAME, force = false } = {}) {
     const parsed = fs.existsSync(filePath) ? readJsonFileSafe(filePath) : {};
     if (parsed === null) throw new Error('Invalid JSON');
     const cfgObj = parsed || {};
@@ -906,37 +1006,67 @@ function applyOpenCodeJson(filePath, launcher, targetConfigPath) {
     // absent (new file or a config that never had one) without clobbering a custom one.
     if (!cfgObj.$schema) cfgObj.$schema = 'https://opencode.ai/config.json';
     const { mcp, servers, nested } = getOpenCodeMcpContainer(cfgObj);
-    servers.genexus = {
+    const existing = servers[serverName] || (nested ? mcp[serverName] : null);
+    if (existing && !force && isThirdPartyMcpEntry(existing)) {
+        const err = new Error(`Existing '${serverName}' entry is a third-party or HTTP MCP server (e.g. official GeneXus MCP). Refusing to overwrite. Use --server-name=<customName> (e.g. --server-name Gx18byLennix) or --no-write-clients.`);
+        err.code = 'MCP_SERVER_COLLISION';
+        throw err;
+    }
+    servers[serverName] = {
         type: 'local',
         command: [launcher.command, ...(launcher.args || [])],
         environment: { GX_CONFIG_PATH: targetConfigPath },
         ...(nested ? { disabled: false } : { enabled: true })
     };
-    if (servers.genexus18) delete servers.genexus18;
+    if (serverName === DEFAULT_MCP_SERVER_NAME) {
+        if (servers.genexus && !isThirdPartyMcpEntry(servers.genexus)) delete servers.genexus;
+        if (servers.genexus18 && !isThirdPartyMcpEntry(servers.genexus18)) delete servers.genexus18;
+    } else if (serverName === 'genexus' && servers.genexus18 && !isThirdPartyMcpEntry(servers.genexus18)) {
+        delete servers.genexus18;
+    }
     // If a config was migrated manually and contains both shapes, leave unrelated
     // servers alone but remove our duplicate legacy entry.
     if (nested) {
-        if (mcp.genexus) delete mcp.genexus;
-        if (mcp.genexus18) delete mcp.genexus18;
+        if (serverName === DEFAULT_MCP_SERVER_NAME) {
+            if (mcp[DEFAULT_MCP_SERVER_NAME] && !isThirdPartyMcpEntry(mcp[DEFAULT_MCP_SERVER_NAME])) delete mcp[DEFAULT_MCP_SERVER_NAME];
+            if (mcp.genexus && !isThirdPartyMcpEntry(mcp.genexus)) delete mcp.genexus;
+            if (mcp.genexus18 && !isThirdPartyMcpEntry(mcp.genexus18)) delete mcp.genexus18;
+        } else if (serverName === 'genexus') {
+            if (mcp.genexus && !isThirdPartyMcpEntry(mcp.genexus)) delete mcp.genexus;
+            if (mcp.genexus18 && !isThirdPartyMcpEntry(mcp.genexus18)) delete mcp.genexus18;
+        } else {
+            if (mcp[serverName] && !isThirdPartyMcpEntry(mcp[serverName])) delete mcp[serverName];
+        }
     }
     writeClientJson(filePath, cfgObj);
 }
 
-function removeOpenCodeJson(filePath) {
+function removeOpenCodeJson(filePath, { serverName = DEFAULT_MCP_SERVER_NAME } = {}) {
     const parsed = readJsonFileSafe(filePath);
     if (parsed === null) throw new Error('Invalid JSON');
     const cfgObj = parsed || {};
     if (!cfgObj.mcp || typeof cfgObj.mcp !== 'object') return false;
     let removedAny = false;
-    for (const key of ['genexus', 'genexus18']) {
-        if (cfgObj.mcp[key]) {
+    const keysToRemove = serverName === DEFAULT_MCP_SERVER_NAME
+        ? [DEFAULT_MCP_SERVER_NAME, 'genexus', 'genexus18']
+        : (serverName === 'genexus' ? ['genexus', 'genexus18'] : [serverName]);
+    for (const key of keysToRemove) {
+        const entry = cfgObj.mcp[key];
+        if (entry) {
+            if (key === 'genexus' && (entry.url || entry.type === 'http' || entry.type === 'sse' || entry.type === 'remote')) {
+                continue;
+            }
             delete cfgObj.mcp[key];
             removedAny = true;
         }
     }
     if (cfgObj.mcp.servers && typeof cfgObj.mcp.servers === 'object' && !Array.isArray(cfgObj.mcp.servers)) {
-        for (const key of ['genexus', 'genexus18']) {
-            if (cfgObj.mcp.servers[key]) {
+        for (const key of keysToRemove) {
+            const entry = cfgObj.mcp.servers[key];
+            if (entry) {
+                if (key === 'genexus' && (entry.url || entry.type === 'http' || entry.type === 'sse' || entry.type === 'remote')) {
+                    continue;
+                }
                 delete cfgObj.mcp.servers[key];
                 removedAny = true;
             }
@@ -947,56 +1077,118 @@ function removeOpenCodeJson(filePath) {
     return true;
 }
 
+function extractCodexTomlEntry(content, serverName = DEFAULT_MCP_SERVER_NAME) {
+    if (!content) return null;
+    const escaped = escapeRegex(serverName);
+    const blockRe = new RegExp(`\\[mcp_servers\\.${escaped}\\]([\\s\\S]*?)(?=\\n\\[|$)`);
+    const m = content.match(blockRe);
+    if (!m) return null;
+    const cmdMatch = m[1].match(/^\s*command\s*=\s*"((?:[^"\\]|\\.)*)"/m);
+    const urlMatch = m[1].match(/^\s*url\s*=\s*"((?:[^"\\]|\\.)*)"/m);
+    const argsMatch = m[1].match(/^\s*args\s*=\s*\[([\s\S]*?)\]/m);
+    const envMatch = content.match(new RegExp(`\\[mcp_servers\\.${escaped}\\.env\\][\\s\\S]*?GX_CONFIG_PATH\\s*=\\s*"((?:[^"\\\\]|\\\\.)*)"`));
+    const command = cmdMatch ? cmdMatch[1].replace(/\\\\/g, '\\').replace(/\\"/g, '"') : null;
+    const url = urlMatch ? urlMatch[1].replace(/\\\\/g, '\\').replace(/\\"/g, '"') : null;
+    let args = [];
+    if (argsMatch && argsMatch[1]) {
+        const rawArgs = argsMatch[1].match(/"((?:[^"\\]|\\.)*)"/g);
+        if (rawArgs) {
+            args = rawArgs.map((a) => a.slice(1, -1).replace(/\\\\/g, '\\').replace(/\\"/g, '"'));
+        }
+    }
+    const gxConfig = envMatch ? envMatch[1].replace(/\\\\/g, '\\').replace(/\\"/g, '"') : null;
+    return {
+        command,
+        args,
+        url,
+        env: gxConfig ? { GX_CONFIG_PATH: gxConfig } : null
+    };
+}
+
+function stripCodexServerBlocks(content, serverName) {
+    if (!content) return '';
+    const lines = content.split('\n');
+    const out = [];
+    const headerRe = /^\[\[?[A-Za-z0-9_."'-]+/;
+    const ourRe = new RegExp(`^\\[\\[?mcp_servers\\.${escapeRegex(serverName)}(\\.[A-Za-z0-9_."'-]+)?\\]\\]?\\s*$`);
+    let inOurs = false;
+    for (const line of lines) {
+        if (headerRe.test(line)) {
+            inOurs = ourRe.test(line);
+            if (inOurs) continue;
+        }
+        if (inOurs) continue;
+        out.push(line);
+    }
+    return out.join('\n').replace(/\n{3,}/g, '\n\n');
+}
+
 // Codex CLI uses TOML. We do a minimal text-merge: strip any existing
 // [mcp_servers.genexus*] blocks and append fresh ones. Brittle on hand-edited
 // files that put other keys after our blocks without a blank line, but
 // adequate for the typical machine-managed config.
-function applyCodexToml(filePath, launcher, targetConfigPath) {
+function applyCodexToml(filePath, launcher, targetConfigPath, { serverName = DEFAULT_MCP_SERVER_NAME, force = false } = {}) {
     let existing = '';
     if (fs.existsSync(filePath)) existing = fs.readFileSync(filePath, 'utf8');
-    const stripped = stripCodexGenexusBlocks(existing);
+    const existingEntry = extractCodexTomlEntry(existing, serverName);
+    if (existingEntry && !force && isThirdPartyMcpEntry(existingEntry)) {
+        const err = new Error(`Existing '${serverName}' entry is a third-party or HTTP MCP server (e.g. official GeneXus MCP). Refusing to overwrite. Use --server-name=<customName> (e.g. --server-name Gx18byLennix) or --no-write-clients.`);
+        err.code = 'MCP_SERVER_COLLISION';
+        throw err;
+    }
+    let stripped = stripCodexServerBlocks(existing, serverName);
+    if (serverName === DEFAULT_MCP_SERVER_NAME) {
+        const legacyGx = extractCodexTomlEntry(stripped, 'genexus');
+        if (legacyGx && !isThirdPartyMcpEntry(legacyGx)) {
+            stripped = stripCodexServerBlocks(stripped, 'genexus');
+        }
+        const legacyGx18 = extractCodexTomlEntry(stripped, 'genexus18');
+        if (legacyGx18 && !isThirdPartyMcpEntry(legacyGx18)) {
+            stripped = stripCodexServerBlocks(stripped, 'genexus18');
+        }
+    } else if (serverName === 'genexus') {
+        const legacyEntry = extractCodexTomlEntry(stripped, 'genexus18');
+        if (legacyEntry && !isThirdPartyMcpEntry(legacyEntry)) {
+            stripped = stripCodexServerBlocks(stripped, 'genexus18');
+        }
+    }
     const args = launcher.args || [];
     const lines = [];
     if (stripped.length && !stripped.endsWith('\n')) lines.push('');
     if (stripped.length) lines.push('');
-    lines.push('[mcp_servers.genexus]');
+    lines.push(`[mcp_servers.${serverName}]`);
     lines.push(`command = ${tomlString(launcher.command)}`);
     lines.push(`args = [${args.map(tomlString).join(', ')}]`);
     lines.push('');
-    lines.push('[mcp_servers.genexus.env]');
+    lines.push(`[mcp_servers.${serverName}.env]`);
     lines.push(`GX_CONFIG_PATH = ${tomlString(targetConfigPath)}`);
     lines.push('');
     writeClientText(filePath, stripped + lines.join('\n'));
 }
 
-function removeCodexToml(filePath) {
+function removeCodexToml(filePath, { serverName = DEFAULT_MCP_SERVER_NAME } = {}) {
     if (!fs.existsSync(filePath)) return false;
     const existing = fs.readFileSync(filePath, 'utf8');
-    const stripped = stripCodexGenexusBlocks(existing);
+    const keysToRemove = serverName === DEFAULT_MCP_SERVER_NAME
+        ? [DEFAULT_MCP_SERVER_NAME, 'genexus', 'genexus18']
+        : (serverName === 'genexus' ? ['genexus', 'genexus18'] : [serverName]);
+    let stripped = existing;
+    for (const key of keysToRemove) {
+        const entry = extractCodexTomlEntry(stripped, key);
+        if (entry) {
+            if (key === 'genexus' && (entry.url || entry.type === 'http' || entry.type === 'sse' || entry.type === 'remote')) {
+                continue;
+            }
+            stripped = stripCodexServerBlocks(stripped, key);
+        }
+    }
     if (stripped === existing) return false;
     writeClientText(filePath, stripped);
     return true;
 }
 
 function stripCodexGenexusBlocks(content) {
-    // Walk line-by-line so values like `args = []` don't confuse the parser.
-    // A section ends at the next line that starts a [section] header (top-level
-    // tables and arrays of tables only — must begin at column 0).
-    const lines = content.split('\n');
-    const out = [];
-    const headerRe = /^\[\[?[A-Za-z0-9_."'-]+/;
-    const ourRe = /^\[\[?mcp_servers\.genexus(\.[A-Za-z0-9_."'-]+)?\]\]?\s*$/;
-    let inOurs = false;
-    for (const line of lines) {
-        if (headerRe.test(line)) {
-            inOurs = ourRe.test(line);
-            if (inOurs) continue;
-        }
-        if (inOurs) continue;
-        out.push(line);
-    }
-    // Collapse 3+ trailing blank lines we may have left behind.
-    return out.join('\n').replace(/\n{3,}/g, '\n\n');
+    return stripCodexServerBlocks(content, 'genexus');
 }
 
 function tomlString(value) {
@@ -1029,41 +1221,94 @@ function normalizeExePath(p) {
     return s;
 }
 
-function readClientCommandEntry(client) {
+function readClientCommandEntry(client, serverName = DEFAULT_MCP_SERVER_NAME) {
     if (client.writeSupported === false) return null;
     if (!fs.existsSync(client.path)) return null;
     try {
         if (client.format === 'mcpServers') {
             const parsed = readJsonFileSafe(client.path);
             if (!parsed || typeof parsed !== 'object') return null;
-            const entry = parsed.mcpServers && parsed.mcpServers.genexus;
+            let entry = parsed.mcpServers && parsed.mcpServers[serverName];
+            if (!entry && serverName === DEFAULT_MCP_SERVER_NAME) {
+                const legacyGx = parsed.mcpServers && parsed.mcpServers.genexus;
+                if (legacyGx && !isThirdPartyMcpEntry(legacyGx)) entry = legacyGx;
+                else if (parsed.mcpServers && parsed.mcpServers.genexus18) entry = parsed.mcpServers.genexus18;
+            }
             if (!entry) return null;
-            return { command: entry.command || null, args: Array.isArray(entry.args) ? entry.args : [] };
+            return {
+                command: entry.command || null,
+                args: Array.isArray(entry.args) ? entry.args : [],
+                url: entry.url || null,
+                type: entry.type || null,
+                env: entry.env || null,
+                raw: entry
+            };
         }
         if (client.format === 'opencode') {
             const parsed = readJsonFileSafe(client.path);
             if (!parsed || typeof parsed !== 'object') return null;
-            const entry = parsed.mcp?.servers?.genexus || parsed.mcp?.genexus;
-            if (!entry || !Array.isArray(entry.command) || entry.command.length === 0) return null;
-            return { command: entry.command[0], args: entry.command.slice(1) };
+            let entry = parsed.mcp?.servers?.[serverName] || parsed.mcp?.[serverName];
+            if (!entry && serverName === DEFAULT_MCP_SERVER_NAME) {
+                const legacyGx = parsed.mcp?.servers?.genexus || parsed.mcp?.genexus;
+                if (legacyGx && !isThirdPartyMcpEntry(legacyGx)) entry = legacyGx;
+                else entry = parsed.mcp?.servers?.genexus18 || parsed.mcp?.genexus18;
+            }
+            if (!entry) return null;
+            if (Array.isArray(entry.command) && entry.command.length > 0) {
+                return {
+                    command: entry.command[0],
+                    args: entry.command.slice(1),
+                    url: entry.url || null,
+                    type: entry.type || null,
+                    environment: entry.environment || null,
+                    raw: entry
+                };
+            }
+            return {
+                command: null,
+                args: [],
+                url: entry.url || null,
+                type: entry.type || null,
+                environment: entry.environment || null,
+                raw: entry
+            };
         }
         if (client.format === 'vscode-servers') {
             const parsed = readJsonFileSafe(client.path);
             if (!parsed || typeof parsed !== 'object') return null;
-            const entry = parsed.servers && parsed.servers.genexus;
+            let entry = parsed.servers && parsed.servers[serverName];
+            if (!entry && serverName === DEFAULT_MCP_SERVER_NAME) {
+                const legacyGx = parsed.servers && parsed.servers.genexus;
+                if (legacyGx && !isThirdPartyMcpEntry(legacyGx)) entry = legacyGx;
+                else if (parsed.servers && parsed.servers.genexus18) entry = parsed.servers.genexus18;
+            }
             if (!entry) return null;
-            return { command: entry.command || null, args: Array.isArray(entry.args) ? entry.args : [] };
+            return {
+                command: entry.command || null,
+                args: Array.isArray(entry.args) ? entry.args : [],
+                url: entry.url || null,
+                type: entry.type || null,
+                env: entry.env || null,
+                raw: entry
+            };
         }
         if (client.format === 'codex-toml') {
             const raw = fs.readFileSync(client.path, 'utf8');
-            // Minimal extraction: find [mcp_servers.genexus] block and pull command = "..."
-            const blockRe = /\[mcp_servers\.genexus\]([\s\S]*?)(?=\n\[|$)/;
-            const m = raw.match(blockRe);
-            if (!m) return null;
-            const cmdMatch = m[1].match(/^\s*command\s*=\s*"((?:[^"\\]|\\.)*)"/m);
-            if (!cmdMatch) return null;
-            const command = cmdMatch[1].replace(/\\\\/g, '\\').replace(/\\"/g, '"');
-            return { command, args: [] };
+            let entry = extractCodexTomlEntry(raw, serverName);
+            if (!entry && serverName === DEFAULT_MCP_SERVER_NAME) {
+                const legacyGx = extractCodexTomlEntry(raw, 'genexus');
+                if (legacyGx && !isThirdPartyMcpEntry(legacyGx)) entry = legacyGx;
+                else entry = extractCodexTomlEntry(raw, 'genexus18');
+            }
+            if (!entry) return null;
+            return {
+                command: entry.command || null,
+                args: entry.args || [],
+                url: entry.url || null,
+                type: entry.type || null,
+                env: entry.env || null,
+                raw: entry
+            };
         }
     } catch {
         return null;
@@ -1274,5 +1519,7 @@ module.exports = {
     applyLauncherConfigOrExit,
     isPathLikelyAppLockerBlocked,
     normalizeExePath,
-    readClientCommandEntry
+    readClientCommandEntry,
+    isOurMcpEntry,
+    DEFAULT_MCP_SERVER_NAME
 };

package/cli/run.test.js

@@ -757,7 +757,7 @@ test('clients add registers a client into a sandbox home with backup + atomic wr
     assert.ok(parsed.ok.patchedClients.includes('Cursor'));
 
     const written = JSON.parse(fs.readFileSync(cursorCfg, 'utf8'));
-    assert.ok(written.mcpServers.genexus, 'genexus entry should be written');
+    assert.ok(written.mcpServers.genexus18mcp, 'genexus18mcp entry should be written');
     assert.ok(written.mcpServers.other, 'pre-existing entries preserved');
 
     const baks = fs.readdirSync(path.dirname(cursorCfg)).filter((f) => f.includes('.bak'));
@@ -784,7 +784,7 @@ test('clients add tolerates a JSONC (commented) VS Code mcp.json', () => {
     assert.ok(parsed.ok.patchedClients.includes('VS Code'), 'VS Code should be patched despite comments');
 
     const written = JSON.parse(fs.readFileSync(vscodeCfg, 'utf8'));
-    assert.ok(written.servers.genexus, 'genexus server entry written');
+    assert.ok(written.servers.genexus18mcp, 'genexus18mcp server entry written');
     assert.ok(written.servers.foo, 'pre-existing server preserved');
 
     fs.rmSync(tempRoot, { recursive: true, force: true });
@@ -806,12 +806,12 @@ test('clients add preserves OpenCode 1.x direct mcp shape', () => {
     });
     assert.equal(res.status, 0);
     const written = JSON.parse(fs.readFileSync(openCodeCfg, 'utf8'));
-    assert.ok(written.mcp.genexus, 'direct OpenCode entry should be written');
-    assert.equal(written.mcp.genexus.enabled, true);
-    assert.equal(written.mcp.genexus.disabled, undefined);
+    assert.ok(written.mcp.genexus18mcp, 'direct OpenCode entry should be written');
+    assert.equal(written.mcp.genexus18mcp.enabled, true);
+    assert.equal(written.mcp.genexus18mcp.disabled, undefined);
     assert.ok(written.mcp.other, 'unrelated direct MCP server should be preserved');
     assert.equal(written.mcp.servers, undefined);
-    assert.deepEqual(written.mcp.genexus.environment, { GX_CONFIG_PATH: cfgPath });
+    assert.deepEqual(written.mcp.genexus18mcp.environment, { GX_CONFIG_PATH: cfgPath });
 
     const listed = runCli(['clients', '--format', 'json'], { env });
     assert.equal(listed.status, 0);
@@ -837,12 +837,12 @@ test('clients add preserves OpenCode v2 nested mcp.servers shape', () => {
     });
     assert.equal(res.status, 0);
     const written = JSON.parse(fs.readFileSync(openCodeCfg, 'utf8'));
-    assert.ok(written.mcp.servers.genexus, 'nested OpenCode entry should be written');
-    assert.equal(written.mcp.servers.genexus.disabled, false);
-    assert.equal(written.mcp.servers.genexus.enabled, undefined);
+    assert.ok(written.mcp.servers.genexus18mcp, 'nested OpenCode entry should be written');
+    assert.equal(written.mcp.servers.genexus18mcp.disabled, false);
+    assert.equal(written.mcp.servers.genexus18mcp.enabled, undefined);
     assert.ok(written.mcp.servers.other, 'unrelated nested MCP server should be preserved');
-    assert.equal(written.mcp.genexus, undefined);
-    assert.deepEqual(written.mcp.servers.genexus.environment, { GX_CONFIG_PATH: cfgPath });
+    assert.equal(written.mcp.genexus18mcp, undefined);
+    assert.deepEqual(written.mcp.servers.genexus18mcp.environment, { GX_CONFIG_PATH: cfgPath });
 
     const listed = runCli(['clients', '--format', 'json'], { env });
     assert.equal(listed.status, 0);
@@ -877,7 +877,7 @@ test('init auto-registers detected OpenCode in either config layout', () => {
             assert.ok(parsed.meta.patchedClients.includes('OpenCode (CLI)'));
 
             const written = JSON.parse(fs.readFileSync(openCodeCfg, 'utf8'));
-            const entry = label === 'nested' ? written.mcp.servers.genexus : written.mcp.genexus;
+            const entry = label === 'nested' ? written.mcp.servers.genexus18mcp : written.mcp.genexus18mcp;
             assert.ok(entry, `${label} OpenCode entry should be present after init`);
             assert.deepEqual(entry.environment, { GX_CONFIG_PATH: path.join(kbDir, 'config.json') });
             assert.ok(label === 'nested' ? written.mcp.servers.other : written.mcp.other);
@@ -903,7 +903,7 @@ test('clients add replaces a legacy genexus18 entry instead of duplicating it',
     assert.equal(res.status, 0);
 
     const written = JSON.parse(fs.readFileSync(cursorCfg, 'utf8'));
-    assert.ok(written.mcpServers.genexus, 'new genexus entry present');
+    assert.ok(written.mcpServers.genexus18mcp, 'new genexus18mcp entry present');
     assert.equal(written.mcpServers.genexus18, undefined, 'legacy genexus18 removed (no duplicate)');
 
     fs.rmSync(tempRoot, { recursive: true, force: true });
@@ -916,7 +916,7 @@ test('clients list flags a registered command pointing at a missing launcher as
     fs.mkdirSync(path.dirname(cursorCfg), { recursive: true });
     // A non-.exe launcher (.bat) that no longer exists must also be flagged stale.
     const missing = path.join(tempRoot, 'gone', 'start_mcp.bat');
-    fs.writeFileSync(cursorCfg, JSON.stringify({ mcpServers: { genexus: { command: missing, args: [] } } }, null, 2));
+    fs.writeFileSync(cursorCfg, JSON.stringify({ mcpServers: { genexus18mcp: { command: missing, args: [] } } }, null, 2));
 
     const res = runCli(['clients', '--format', 'json'], { env });
     assert.equal(res.status, 0);
@@ -964,7 +964,7 @@ test('clients remove drops the genexus entry (sandbox home)', () => {
     const env = sandboxHomeEnv(tempRoot);
     const cursorCfg = path.join(tempRoot, '.cursor', 'mcp.json');
     fs.mkdirSync(path.dirname(cursorCfg), { recursive: true });
-    fs.writeFileSync(cursorCfg, JSON.stringify({ mcpServers: { genexus: { command: 'npx' }, genexus18: { command: 'old' } } }, null, 2));
+    fs.writeFileSync(cursorCfg, JSON.stringify({ mcpServers: { genexus18mcp: { command: 'npx' }, genexus18: { command: 'old' } } }, null, 2));
 
     const res = runCli(['clients', 'remove', '--clients', 'cursor', '--format', 'json'], { env });
     assert.equal(res.status, 0);
@@ -972,7 +972,7 @@ test('clients remove drops the genexus entry (sandbox home)', () => {
     assert.ok(parsed.ok.removedClients.includes('Cursor'));
 
     const written = JSON.parse(fs.readFileSync(cursorCfg, 'utf8'));
-    assert.equal(written.mcpServers.genexus, undefined, 'genexus removed');
+    assert.equal(written.mcpServers.genexus18mcp, undefined, 'genexus18mcp removed');
     assert.equal(written.mcpServers.genexus18, undefined, 'legacy genexus18 also removed');
 
     fs.rmSync(tempRoot, { recursive: true, force: true });
@@ -987,9 +987,11 @@ test('clients remove drops both OpenCode config shapes and legacy key', () => {
         mcp: {
             genexus: { type: 'local', command: ['old'] },
             genexus18: { type: 'local', command: ['older'] },
+            genexus18mcp: { type: 'local', command: ['latest'] },
             servers: {
                 genexus: { type: 'local', command: ['nested'] },
                 genexus18: { type: 'local', command: ['nested-old'] },
+                genexus18mcp: { type: 'local', command: ['nested-latest'] },
                 other: { type: 'local', command: ['other'] }
             }
         }
@@ -1000,8 +1002,10 @@ test('clients remove drops both OpenCode config shapes and legacy key', () => {
     const written = JSON.parse(fs.readFileSync(openCodeCfg, 'utf8'));
     assert.equal(written.mcp.genexus, undefined);
     assert.equal(written.mcp.genexus18, undefined);
+    assert.equal(written.mcp.genexus18mcp, undefined);
     assert.equal(written.mcp.servers.genexus, undefined);
     assert.equal(written.mcp.servers.genexus18, undefined);
+    assert.equal(written.mcp.servers.genexus18mcp, undefined);
     assert.ok(written.mcp.servers.other, 'unrelated nested MCP server should be preserved');
 
     fs.rmSync(tempRoot, { recursive: true, force: true });
@@ -1096,3 +1100,146 @@ test('npm package contains all bin, postinstall and required runtime files', ()
         }
     }
 });
+
+test('isOurMcpEntry identifies third-party / HTTP servers vs our own entry', () => {
+    const { isOurMcpEntry } = require('./lib/config');
+
+    // Official / third-party MCP servers
+    assert.equal(isOurMcpEntry({ url: 'http://localhost:8001/mcp' }), false);
+    assert.equal(isOurMcpEntry({ type: 'http', url: 'https://example.com/mcp' }), false);
+    assert.equal(isOurMcpEntry({ type: 'sse', url: 'http://127.0.0.1:8000/sse' }), false);
+    assert.equal(isOurMcpEntry({ command: 'node', args: ['some-other-server.js'] }), false);
+
+    // Our entries
+    assert.equal(isOurMcpEntry({ command: 'npx.cmd', args: ['-y', 'genexus-mcp@latest'] }), true);
+    assert.equal(isOurMcpEntry({ command: 'C:\\path\\start_mcp.bat' }), true);
+    assert.equal(isOurMcpEntry({ command: 'C:\\bin\\GxMcp.Gateway.exe' }), true);
+    assert.equal(isOurMcpEntry({ command: 'node', env: { GX_CONFIG_PATH: 'C:\\kb\\config.json' } }), true);
+    assert.equal(isOurMcpEntry({ url: 'http://custom' }, 'genexus18mcp'), true);
+});
+
+test('clients add refuses to overwrite a third-party HTTP MCP server without --force', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-collision-'));
+    const env = sandboxHomeEnv(tempRoot);
+    const cfgPath = path.join(tempRoot, 'config.json');
+    fs.writeFileSync(cfgPath, JSON.stringify({ Environment: { KBPath: tempRoot } }));
+
+    // Pre-existing official GeneXus MCP entry under genexus18mcp
+    const cursorCfg = path.join(tempRoot, '.cursor', 'mcp.json');
+    fs.mkdirSync(path.dirname(cursorCfg), { recursive: true });
+    fs.writeFileSync(cursorCfg, JSON.stringify({
+        mcpServers: {
+            genexus18mcp: { url: 'http://localhost:8001/mcp', type: 'http' }
+        }
+    }, null, 2));
+
+    const res = runCli(['clients', 'add', '--clients', 'cursor', '--format', 'json'], {
+        env: { ...env, GX_CONFIG_PATH: cfgPath }
+    });
+    assert.equal(res.status, 0);
+    const parsed = JSON.parse(res.stdout);
+    assert.equal(parsed.ok.patchedClients.length, 0);
+    assert.equal(parsed.meta.failedClients.length, 1);
+    assert.match(parsed.meta.failedClients[0].reason, /third-party or HTTP MCP server/);
+
+    // Ensure the original HTTP server was NOT modified or deleted
+    const after = JSON.parse(fs.readFileSync(cursorCfg, 'utf8'));
+    assert.equal(after.mcpServers.genexus18mcp.url, 'http://localhost:8001/mcp');
+
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+test('clients add with --force overwrites an existing third-party entry', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-force-'));
+    const env = sandboxHomeEnv(tempRoot);
+    const cfgPath = path.join(tempRoot, 'config.json');
+    fs.writeFileSync(cfgPath, JSON.stringify({ Environment: { KBPath: tempRoot } }));
+
+    const cursorCfg = path.join(tempRoot, '.cursor', 'mcp.json');
+    fs.mkdirSync(path.dirname(cursorCfg), { recursive: true });
+    fs.writeFileSync(cursorCfg, JSON.stringify({
+        mcpServers: {
+            genexus18mcp: { url: 'http://localhost:8001/mcp', type: 'http' }
+        }
+    }, null, 2));
+
+    const res = runCli(['clients', 'add', '--clients', 'cursor', '--force', '--format', 'json'], {
+        env: { ...env, GX_CONFIG_PATH: cfgPath }
+    });
+    assert.equal(res.status, 0);
+    const parsed = JSON.parse(res.stdout);
+    assert.ok(parsed.ok.patchedClients.includes('Cursor'));
+
+    const after = JSON.parse(fs.readFileSync(cursorCfg, 'utf8'));
+    assert.equal(after.mcpServers.genexus18mcp.url, undefined);
+    assert.ok(after.mcpServers.genexus18mcp.command);
+
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+test('clients add supports custom --server-name across all formats for multi-MCP coexistence', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-custom-name-'));
+    const env = sandboxHomeEnv(tempRoot);
+    const cfgPath = path.join(tempRoot, 'config.json');
+    fs.writeFileSync(cfgPath, JSON.stringify({ Environment: { KBPath: tempRoot } }));
+
+    // 1. mcpServers (Cursor)
+    const cursorCfg = path.join(tempRoot, '.cursor', 'mcp.json');
+    fs.mkdirSync(path.dirname(cursorCfg), { recursive: true });
+    fs.writeFileSync(cursorCfg, JSON.stringify({
+        mcpServers: { genexus: { url: 'http://localhost:8001/mcp' } }
+    }, null, 2));
+
+    // 2. VS Code servers
+    const vscodeCfg = path.join(env.APPDATA, 'Code', 'User', 'mcp.json');
+    fs.mkdirSync(path.dirname(vscodeCfg), { recursive: true });
+    fs.writeFileSync(vscodeCfg, JSON.stringify({
+        servers: { genexus: { url: 'http://localhost:8001/mcp' } }
+    }, null, 2));
+
+    // 3. OpenCode nested
+    const openCodeCfg = path.join(env.XDG_CONFIG_HOME, 'opencode', 'opencode.json');
+    fs.mkdirSync(path.dirname(openCodeCfg), { recursive: true });
+    fs.writeFileSync(openCodeCfg, JSON.stringify({
+        mcp: { servers: { genexus: { url: 'http://localhost:8001/mcp' } } }
+    }, null, 2));
+
+    // 4. Codex TOML
+    const codexCfg = path.join(tempRoot, '.codex', 'config.toml');
+    fs.mkdirSync(path.dirname(codexCfg), { recursive: true });
+    fs.writeFileSync(codexCfg, '[mcp_servers.genexus]\nurl = "http://localhost:8001/mcp"\n');
+
+    const res = runCli(['clients', 'add', '--clients', 'cursor,vscode,opencode,codex-cli', '--server-name', 'Gx18byLennix', '--format', 'json'], {
+        env: { ...env, GX_CONFIG_PATH: cfgPath }
+    });
+    assert.equal(res.status, 0);
+    const parsed = JSON.parse(res.stdout);
+    assert.equal(parsed.ok.patchedCount, 4);
+
+    // Assert both coexist side-by-side
+    const cursorWritten = JSON.parse(fs.readFileSync(cursorCfg, 'utf8'));
+    assert.equal(cursorWritten.mcpServers.genexus.url, 'http://localhost:8001/mcp');
+    assert.ok(cursorWritten.mcpServers.Gx18byLennix);
+
+    const vsCodeWritten = JSON.parse(fs.readFileSync(vscodeCfg, 'utf8'));
+    assert.equal(vsCodeWritten.servers.genexus.url, 'http://localhost:8001/mcp');
+    assert.ok(vsCodeWritten.servers.Gx18byLennix);
+
+    const openCodeWritten = JSON.parse(fs.readFileSync(openCodeCfg, 'utf8'));
+    assert.equal(openCodeWritten.mcp.servers.genexus.url, 'http://localhost:8001/mcp');
+    assert.ok(openCodeWritten.mcp.servers.Gx18byLennix);
+
+    const codexWritten = fs.readFileSync(codexCfg, 'utf8');
+    assert.ok(codexWritten.includes('[mcp_servers.genexus]'));
+    assert.ok(codexWritten.includes('[mcp_servers.Gx18byLennix]'));
+
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+test('clients add rejects invalid --server-name characters with usage error', () => {
+    const res = runCli(['clients', 'add', '--clients', 'cursor', '--server-name', 'bad name with spaces!', '--format', 'json']);
+    assert.equal(res.status, 2);
+    const parsed = JSON.parse(res.stdout);
+    assert.equal(parsed.error.code, 'usage_error');
+    assert.match(parsed.error.message, /alphanumeric/);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genexus-mcp",
-  "version": "2.48.0",
+  "version": "2.49.1",
   "mcpName": "io.github.lennix1337/genexus",
   "description": "GeneXus 18 MCP server — read, edit, and analyze GeneXus knowledge base objects (transactions, web panels, procedures, SDTs) directly from Claude, Cursor, and other AI agents over the Model Context Protocol.",
   "keywords": [

package/publish/GxMcp.Gateway.deps.json

@@ -7,7 +7,7 @@
   "targets": {
     ".NETCoreApp,Version=v8.0": {},
     ".NETCoreApp,Version=v8.0/win-x64": {
-      "GxMcp.Gateway/2.48.0": {
+      "GxMcp.Gateway/2.49.1": {
         "dependencies": {
           "Newtonsoft.Json": "13.0.3",
           "System.Management": "10.0.5",
@@ -66,7 +66,7 @@
     }
   },
   "libraries": {
-    "GxMcp.Gateway/2.48.0": {
+    "GxMcp.Gateway/2.49.1": {
       "type": "project",
       "serviceable": false,
       "sha512": ""

package/publish/config.json

@@ -1,17 +1,17 @@
 {
+  "GeneXus": {
+    "InstallationPath": "C:\\\\Program Files (x86)\\\\GeneXus\\\\GeneXus18",
+    "WorkerExecutable": "C:\\Projetos\\Genexus18MCP\\publish\\\\worker\\\\GxMcp.Worker.exe"
+  },
   "Environment": {
     "KBPath": "C:\\\\KBs\\\\YourKB"
   },
   "Logging": {
-    "Level": "Debug",
-    "Path": "logs"
+    "Path": "logs",
+    "Level": "Debug"
   },
   "Server": {
-    "McpStdio": true,
-    "HttpPort": 5000
-  },
-  "GeneXus": {
-    "WorkerExecutable": "C:\\Projetos\\Genexus18MCP\\publish\\\\worker\\\\GxMcp.Worker.exe",
-    "InstallationPath": "C:\\\\Program Files (x86)\\\\GeneXus\\\\GeneXus18"
+    "HttpPort": 5000,
+    "McpStdio": true
   }
 }