genexus-mcp 3.5.2 → 3.6.0

package/cli/lib/config.js

@@ -88,9 +88,12 @@ function getGeneXusVersionCatalog() {
             const catalog = JSON.parse(fs.readFileSync(candidate, 'utf8'));
             if (!catalog || !catalog.primaryMajor || !Array.isArray(catalog.supportedMajors)) continue;
             const entries = catalog.supportedMajors.filter((entry) => entry && /^\d+$/.test(String(entry.major)));
+            const legacyEntries = Array.isArray(catalog.legacyMajors)
+                ? catalog.legacyMajors.filter((entry) => entry && /^(?:10\.[1-3]|\d+)$/.test(String(entry.major)))
+                : [];
             const primary = entries.find((entry) => String(entry.major) === String(catalog.primaryMajor));
             if (entries.length > 0 && primary?.defaultInstallPath) {
-                return { ...catalog, supportedMajors: entries };
+                return { ...catalog, supportedMajors: entries, legacyMajors: legacyEntries };
             }
         } catch {
         }
@@ -101,13 +104,19 @@ function getGeneXusVersionCatalog() {
             { major: '17', displayName: 'GeneXus 17', defaultInstallPath: 'C:\\Program Files (x86)\\GeneXus\\GeneXus17Trial' },
             { major: '18', displayName: 'GeneXus 18', defaultInstallPath: 'C:\\Program Files (x86)\\GeneXus\\GeneXus18' }
         ],
+        legacyMajors: [
+            { major: '10.3', displayName: 'GeneXus Evolution 3', defaultInstallPath: 'C:\\Program Files (x86)\\GeneXus\\GeneXusXEv3' },
+            { major: '9', displayName: 'GeneXus 9.0', defaultInstallPath: 'C:\\Program Files (x86)\\ARTech\\GeneXus\\GeneXus 9.0' },
+            { major: '8', displayName: 'GeneXus 8.0', defaultInstallPath: 'C:\\Program Files (x86)\\ARTech\\GeneXus\\GeneXus 8.0' }
+        ],
         source: 'built-in-fallback'
     };
 }
 
 function getGeneXusCatalogEntries(preferredMajor = null) {
     const catalog = getGeneXusVersionCatalog();
-    return [...catalog.supportedMajors].sort((left, right) => {
+    const all = [...catalog.supportedMajors, ...(catalog.legacyMajors || [])];
+    return all.sort((left, right) => {
         const leftPreferred = preferredMajor !== null && String(left.major) === String(preferredMajor);
         const rightPreferred = preferredMajor !== null && String(right.major) === String(preferredMajor);
         if (leftPreferred !== rightPreferred) return Number(rightPreferred) - Number(leftPreferred);
@@ -708,6 +717,12 @@ function resolveOpenCodeConfigPath(xdgConfig) {
     return path.join(xdgConfig, 'opencode', 'opencode.json');
 }
 
+function alternateOpenCodeConfigPath(filePath) {
+    return path.extname(filePath).toLowerCase() === '.jsonc'
+        ? filePath.slice(0, -1)
+        : filePath.replace(/\.json$/i, '.jsonc');
+}
+
 // VS Code stores its user profile (and native MCP mcp.json) in a per-platform
 // location. `variant` is 'Code' (stable) or 'Code - Insiders'.
 function vscodeUserDir(variant, { appData, macAppSupport, xdgConfig }) {
@@ -807,6 +822,7 @@ function getClientConfigTargets() {
             name: 'OpenCode (CLI)',
             format: 'opencode',
             path: resolveOpenCodeConfigPath(xdgConfig),
+            alternatePaths: [alternateOpenCodeConfigPath(resolveOpenCodeConfigPath(xdgConfig))],
             installMarkers: [
                 path.join(xdgConfig, 'opencode'),
                 path.join(home, '.local', 'share', 'opencode')
@@ -826,6 +842,7 @@ function getClientConfigTargets() {
             name: 'OpenCode Desktop',
             format: 'opencode',
             path: resolveOpenCodeConfigPath(xdgConfig),
+            alternatePaths: [alternateOpenCodeConfigPath(resolveOpenCodeConfigPath(xdgConfig))],
             detectByMarkerOnly: true,
             installMarkers: [
                 path.join(localAppData, 'Programs', '@opencode-aidesktop'),
@@ -937,21 +954,27 @@ function clientCommandHealth(entry, client = null, { fs: fileSystem = fs } = {})
         reason: null,
         structuralState: 'indeterminate',
         semanticState: 'unknown',
-        semanticReason: null
+        semanticReason: null,
+        pathDrift: false,
+        pathDriftReason: null
     };
     const invalid = (reason, structuralState = 'present') => ({
         stale: true,
         reason,
         structuralState,
         semanticState: 'invalid',
-        semanticReason: reason
+        semanticReason: reason,
+        pathDrift: false,
+        pathDriftReason: null
     });
     const valid = (structuralState = 'present') => ({
         stale: false,
         reason: null,
         structuralState,
         semanticState: 'valid',
-        semanticReason: null
+        semanticReason: null,
+        pathDrift: false,
+        pathDriftReason: null
     });
     const missingLauncherReason = 'configured launcher does not exist on disk';
 
@@ -961,7 +984,9 @@ function clientCommandHealth(entry, client = null, { fs: fileSystem = fs } = {})
             reason: null,
             structuralState: 'not-registered',
             semanticState: 'not-applicable',
-            semanticReason: null
+            semanticReason: null,
+            pathDrift: false,
+            pathDriftReason: null
         };
     }
     if (typeof entry !== 'object') {
@@ -973,7 +998,9 @@ function clientCommandHealth(entry, client = null, { fs: fileSystem = fs } = {})
             reason: null,
             structuralState: 'not-applicable',
             semanticState: 'not-applicable',
-            semanticReason: null
+            semanticReason: null,
+            pathDrift: false,
+            pathDriftReason: null
         };
     }
 
@@ -1004,13 +1031,21 @@ function clientCommandHealth(entry, client = null, { fs: fileSystem = fs } = {})
             };
         }
         if (!exists) return invalid(missingLauncherReason, 'missing');
+        // A gateway exe that exists at a different absolute path is a *different,
+        // working* install — a local checkout's publish/ copy, a fixed-path install,
+        // or another package cache — not a broken registration. Reporting it as
+        // `stale` made `npx genexus-mcp clients` tell a checkout operator to
+        // re-register, which rewrote the harness away from the checkout gateway
+        // (Issue #210). The drift is still surfaced (as `pathDrift`, never `stale`)
+        // and doctor's `client_config_sync` check keeps the "not this CLI's packaged
+        // gateway" warning with its own remediation.
         if (client && client.preferDirectGateway) {
             const currentPackageGateway = getGatewayExePath();
-            if (fs.existsSync(currentPackageGateway) && normalizeExePath(command) !== normalizeExePath(currentPackageGateway)) {
+            if (fileSystem.existsSync(currentPackageGateway) && normalizeExePath(command) !== normalizeExePath(currentPackageGateway)) {
                 return {
                     ...valid('present'),
-                    stale: true,
-                    reason: 'configured launcher points at a different package gateway; re-register the client'
+                    pathDrift: true,
+                    pathDriftReason: `configured gateway differs from this CLI's gateway (${currentPackageGateway})`
                 };
             }
         }
@@ -1131,13 +1166,16 @@ function clientsStatus(opts = {}) {
             serverName,
             isThirdParty: Boolean(isThirdParty),
             writeSupported: client.writeSupported !== false,
-            configPath: client.path,
+            configPath: entry && entry.configPath ? entry.configPath : client.path,
+            configPaths: entry && entry.configPath ? [entry.configPath] : [client.path],
             command: entry && entry.command ? entry.command : null,
             args: entry && Array.isArray(entry.args) ? entry.args : [],
             url: entry && entry.url ? entry.url : null,
             launcherStructuralState: health.structuralState,
             launcherSemanticState: health.semanticState,
             launcherSemanticReason: health.semanticReason,
+            launcherPathDrift: health.pathDrift,
+            launcherPathDriftReason: health.pathDriftReason,
             commandStale: health.stale,
             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),
@@ -1426,7 +1464,7 @@ function getOpenCodeMcpContainer(cfgObj) {
     };
 }
 
-function applyOpenCodeJson(filePath, launcher, targetConfigPath, { serverName = DEFAULT_MCP_SERVER_NAME, force = false, globalConfig = false, fs: fileSystem = fs } = {}) {
+function applyOpenCodeJson(filePath, launcher, targetConfigPath, { serverName = DEFAULT_MCP_SERVER_NAME, force = false, globalConfig = false, alternatePaths = [], fs: fileSystem = fs } = {}) {
     const parsed = fileSystem.existsSync(filePath) ? readJsonFileSafe(filePath, fileSystem) : {};
     if (parsed === null) throw new Error('Invalid JSON');
     const cfgObj = parsed || {};
@@ -1470,10 +1508,20 @@ function applyOpenCodeJson(filePath, launcher, targetConfigPath, { serverName =
         }
     }
     writeClientJson(filePath, cfgObj, fileSystem);
+    for (const alternatePath of alternatePaths || []) {
+        if (!fileSystem.existsSync(alternatePath)) continue;
+        applyOpenCodeJson(alternatePath, launcher, targetConfigPath, {
+            serverName,
+            force,
+            globalConfig,
+            alternatePaths: [],
+            fs: fileSystem
+        });
+    }
 }
 
-function removeOpenCodeJson(filePath, { serverName = DEFAULT_MCP_SERVER_NAME, fs: fileSystem = fs } = {}) {
-    const parsed = readJsonFileSafe(filePath);
+function removeOpenCodeJson(filePath, { serverName = DEFAULT_MCP_SERVER_NAME, alternatePaths = [], fs: fileSystem = fs } = {}) {
+    const parsed = readJsonFileSafe(filePath, fileSystem);
     if (parsed === null) throw new Error('Invalid JSON');
     const cfgObj = parsed || {};
     if (!cfgObj.mcp || typeof cfgObj.mcp !== 'object') return false;
@@ -1503,9 +1551,17 @@ function removeOpenCodeJson(filePath, { serverName = DEFAULT_MCP_SERVER_NAME, fs
             }
         }
     }
-    if (!removedAny) return false;
-    writeClientJson(filePath, cfgObj, fileSystem);
-    return true;
+    if (removedAny) writeClientJson(filePath, cfgObj, fileSystem);
+    let removedAlternate = false;
+    for (const alternatePath of alternatePaths || []) {
+        if (!fileSystem.existsSync(alternatePath)) continue;
+        removedAlternate = removeOpenCodeJson(alternatePath, {
+            serverName,
+            alternatePaths: [],
+            fs: fileSystem
+        }) || removedAlternate;
+    }
+    return removedAny || removedAlternate;
 }
 
 function extractCodexTomlEntry(content, serverName = DEFAULT_MCP_SERVER_NAME) {
@@ -1650,8 +1706,49 @@ function normalizeExePath(p) {
     return s;
 }
 
+function readOpenCodeCommandEntry(filePath, serverName, fileSystem) {
+    if (!fileSystem.existsSync(filePath)) return null;
+    const parsed = readJsonFileSafe(filePath, fileSystem);
+    if (!parsed || typeof parsed !== 'object') return null;
+    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,
+            configPath: filePath
+        };
+    }
+    return {
+        command: null,
+        args: [],
+        url: entry.url || null,
+        type: entry.type || null,
+        environment: entry.environment || null,
+        raw: entry,
+        configPath: filePath
+    };
+}
+
 function readClientCommandEntry(client, serverName = DEFAULT_MCP_SERVER_NAME, { fs: fileSystem = fs } = {}) {
     if (client.writeSupported === false) return null;
+    if (client.format === 'opencode') {
+        const paths = [client.path, ...(client.alternatePaths || [])];
+        for (const configPath of paths) {
+            const entry = readOpenCodeCommandEntry(configPath, serverName, fileSystem);
+            if (entry) return entry;
+        }
+        return null;
+    }
     if (!fileSystem.existsSync(client.path)) return null;
     try {
         if (client.format === 'mcpServers') {
@@ -1752,7 +1849,7 @@ function getLocalAppDataCacheDir() {
 }
 
 function getGeneXusMajor(version) {
-    const match = String(version || '').match(/^\s*(\d+)/);
+    const match = String(version || '').match(/^\s*(10\.[1-3](?!\d)|\d+)/);
     return match ? match[1] : null;
 }
 
@@ -1809,7 +1906,10 @@ function readGeneXusInstallationIdentity(gxPath, options = {}) {
     const readExecutableVersion = typeof options.readExecutableVersion === 'function'
         ? options.readExecutableVersion
         : readExecutableProductVersion;
-    const executableVersion = readExecutableVersion(path.join(gxPath, 'GeneXus.exe'));
+    let executableVersion = readExecutableVersion(path.join(gxPath, 'GeneXus.exe'));
+    if (!executableVersion) {
+        executableVersion = readExecutableVersion(path.join(gxPath, 'gx.exe'));
+    }
     if (executableVersion) {
         return {
             version: executableVersion,
@@ -1895,14 +1995,24 @@ function readGeneXusKbIdentity(kbPath) {
     if (!kbPath) return { version: null, major: null, source: 'unavailable', reason: 'missing-kb-path' };
 
     let gxwFiles;
+    let gxiFiles = [];
     try {
-        gxwFiles = fs.readdirSync(kbPath)
+        const allFiles = fs.readdirSync(kbPath);
+        gxwFiles = allFiles
             .filter((fileName) => fileName.toLowerCase().endsWith('.gxw'))
             .map((fileName) => path.join(kbPath, fileName));
+        gxiFiles = allFiles
+            .filter((fileName) => fileName.toLowerCase().endsWith('.gxi'))
+            .map((fileName) => path.join(kbPath, fileName));
     } catch {
         return { version: null, major: null, source: 'unavailable', reason: 'unreadable-kb-path' };
     }
-    if (gxwFiles.length === 0) return { version: null, major: null, source: 'unavailable', reason: 'no-gxw' };
+    if (gxwFiles.length === 0) {
+        if (gxiFiles.length > 0) {
+            return { version: '9.0', major: '9', source: 'gxi-classic', reason: null };
+        }
+        return { version: null, major: null, source: 'unavailable', reason: 'no-gxw' };
+    }
     if (gxwFiles.length > 1) return { version: null, major: null, source: 'unavailable', reason: 'multiple-gxw' };
 
     try {

package/cli/run.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const { main, EXIT_CODES } = require('./index');
+const { main, EXIT_CODES, isKnownCommandToken } = require('./index');
 const { writeStructured } = require('./lib/output');
 const { operationalErrorEnvelope } = require('./commands/axi');
 const { writeLastStdioError } = require('./lib/stdio-diagnostics');
@@ -8,8 +8,9 @@ const { writeLastStdioError } = require('./lib/stdio-diagnostics');
 // as the MCP JSON-RPC channel. Writing a JSON envelope to stdout there would
 // corrupt the protocol stream. Route errors to stderr instead.
 const argv = process.argv.slice(2);
-const KNOWN_COMMANDS = new Set(['status', 'doctor', 'tools', 'config', 'init', 'setup', 'whoami', 'uninstall', 'kb', 'clients', 'help', 'home', 'axi', 'llm', 'layout', 'update']);
-const isInteractiveCommand = argv.length > 0 && KNOWN_COMMANDS.has(argv[0]);
+// Issue #207: share the command table with the parser instead of keeping a second
+// hand-synced copy here.
+const isInteractiveCommand = argv.length > 0 && isKnownCommandToken(argv[0]);
 const errorOut = isInteractiveCommand ? process.stdout : process.stderr;
 
 main(argv)