genexus-mcp 3.5.2 → 3.6.0

package/README.md

@@ -57,7 +57,7 @@ needed. Existing tool names, arguments, and MCP client configuration formats do
 not change.
 
 <!-- BEGIN GENERATED: gx-compatibility -->
-Supported SDK majors: **GeneXus 17, GeneXus 18**.
+Supported SDK majors: **GeneXus 16, GeneXus 17, GeneXus 18**.
 Primary SDK: **GeneXus 18**.
 Source of truth: `config/gx-versions.json`.
 <!-- END GENERATED: gx-compatibility -->
@@ -67,6 +67,13 @@ catalog only after compiling the Worker with that SDK and passing the focused
 tests plus a live KB smoke. This prevents the server from claiming compatibility
 based only on a version string.
 
+### Legacy GeneXus compatibility (GX8 to GX15)
+
+The server also includes best-effort dynamic compatibility for legacy installations:
+- **GeneXus Evolution 1 (10.1), Evolution 2 (10.2), Evolution 3 (10.3), and GeneXus 15**: Driven via runtime reflection (`dotnet-reflection`), dynamically adapting to missing types or structural differences (such as module-less KBs without `QualifiedName`).
+- **GeneXus 8.0 and GeneXus 9.0**: Driven via classic Win32 COM automation (`com-gxpublic`), late-binding to `GXPublic.GXPublic` on an STA thread to open, inspect, and read objects from classic `.gxi` Knowledge Bases.
+- **Graceful degradation**: Modern tools that require features introduced in newer GeneXus versions (such as `genexus_api`, `genexus_gam`, or `genexus_module`) return structured `UNSUPPORTED_IN_GENEXUS_VERSION` errors indicating the required minimum version rather than failing ungracefully.
+
 ---
 
 ## What you can do with it

package/cli/commands/axi.js

@@ -36,6 +36,7 @@ const {
     DEFAULT_MCP_SERVER_NAME
 } = require('../lib/config');
 const { getStdioErrorLogPath } = require('../lib/stdio-diagnostics');
+const { getPackageVersion } = require('../lib/update-check');
 
 function resolveClientIds(options) {
     if (!options || !options.clients) return null;
@@ -58,7 +59,9 @@ function validateClientIds(ids) {
 
 function isSupportedCatalogMajor(catalog, major) {
     if (!major) return true;
-    return catalog.supportedMajors.some((entry) => String(entry.major) === String(major));
+    const inSupported = catalog.supportedMajors && catalog.supportedMajors.some((entry) => String(entry.major) === String(major));
+    if (inSupported) return true;
+    return Array.isArray(catalog.legacyMajors) && catalog.legacyMajors.some((entry) => String(entry.major) === String(major));
 }
 
 function parseFieldSelection(raw) {
@@ -175,6 +178,37 @@ function buildStatusData(cwd) {
     return { ready, configFound, gatewayExeFound, kbLooksValid, configPath, gatewayExePath, kbPath, gxPath, configSource };
 }
 
+const PROBE_EXIT_GRACE_MS = 2000;
+
+// Stop a probe child and wait for it to actually exit. On Windows child.kill()
+// only signals the direct process and returns before the OS releases the
+// executable image, so reporting success right after kill() left the exe file
+// handle open (Issue #211: the shared gateway stub in cli/run.test.js made the
+// suite teardown fail with EPERM while every assertion passed). Resolves true
+// once the child exited, false when it did not within the bounded grace.
+function stopProbeChild(child, graceMs = PROBE_EXIT_GRACE_MS) {
+    return new Promise((resolve) => {
+        if (!child || child.exitCode !== null || child.signalCode !== null) {
+            resolve(true);
+            return;
+        }
+        let settled = false;
+        const finish = (exited) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(exited);
+        };
+        const timer = setTimeout(() => finish(false), graceMs);
+        child.once('exit', () => finish(true));
+        try {
+            child.kill();
+        } catch {
+            finish(true);
+        }
+    });
+}
+
 async function spawnGatewayProbe({ env = process.env, spawnHoldMs, timeoutMs, label, successDetail }) {
     const gatewayExePath = getGatewayExePath();
 
@@ -208,17 +242,25 @@ async function spawnGatewayProbe({ env = process.env, spawnHoldMs, timeoutMs, la
             });
 
             child.once('spawn', () => {
-                setTimeout(() => {
-                    try { child.kill(); } catch { }
-                    finish({ status: 'pass', detail: successDetail });
+                setTimeout(async () => {
+                    const exited = await stopProbeChild(child);
+                    if (exited) {
+                        finish({ status: 'pass', detail: successDetail });
+                    } else {
+                        finish({ status: 'warn', detail: `${label}: process did not exit after the stop signal; it may still hold the gateway exe.` });
+                    }
                 }, spawnHoldMs);
             });
 
-            setTimeout(() => {
-                if (!done) {
-                    try { child.kill(); } catch { }
-                    finish({ status: 'warn', detail: `${label} timed out; process was force-stopped.` });
-                }
+            setTimeout(async () => {
+                if (done) return;
+                const exited = await stopProbeChild(child);
+                finish({
+                    status: 'warn',
+                    detail: exited
+                        ? `${label} timed out; process was force-stopped.`
+                        : `${label} timed out and did not exit after the stop signal; it may still hold the gateway exe.`
+                });
             }, timeoutMs);
         } catch (err) {
             finish({ status: 'fail', detail: `${label} threw: ${err.message}` });
@@ -561,6 +603,50 @@ function buildInProcessBuildAssemblyLoadCheck(gxPath) {
     };
 }
 
+function buildGxPublicComCheck(gxMajor, gxPath) {
+    if (gxMajor !== '8' && gxMajor !== '9') {
+        return { id: 'gxpublic_com_registration', status: 'not_applicable', detail: 'Not a GeneXus 8.0/9.0 installation.' };
+    }
+    const child_process = require('child_process');
+    let isRegistered = false;
+    try {
+        const res = child_process.spawnSync('reg', ['query', 'HKCR\\GXPublic.GXPublic'], { encoding: 'utf8', timeout: 2000 });
+        isRegistered = res.status === 0;
+    } catch { }
+
+    if (isRegistered) {
+        return { id: 'gxpublic_com_registration', status: 'pass', detail: 'GXPublic COM automation server (GXPublic.GXPublic) is registered.' };
+    }
+    const dllHint = gxPath ? path.join(gxPath, 'GxPublic.dll') : 'GxPublic.dll';
+    return {
+        id: 'gxpublic_com_registration',
+        status: 'warn',
+        detail: `GXPublic COM component is not registered. Run 'regsvr32 "${dllHint}"' to enable GeneXus ${gxMajor}.0 COM automation.`
+    };
+}
+
+function buildLegacyIdeLockCheck(gxMajor) {
+    if (gxMajor !== '8' && gxMajor !== '9' && gxMajor !== '10.1' && gxMajor !== '10.2') {
+        return { id: 'legacy_ide_lock', status: 'not_applicable', detail: 'Lock check not applicable for modern GeneXus versions.' };
+    }
+    const child_process = require('child_process');
+    let ideRunning = false;
+    try {
+        const res = child_process.spawnSync('tasklist', ['/FI', 'IMAGENAME eq gx.exe', '/NH'], { encoding: 'utf8', timeout: 2000 });
+        if (res.stdout && res.stdout.toLowerCase().includes('gx.exe')) {
+            ideRunning = true;
+        }
+    } catch { }
+    if (ideRunning) {
+        return {
+            id: 'legacy_ide_lock',
+            status: 'warn',
+            detail: 'GeneXus IDE (gx.exe) process is currently running. Legacy engines hold exclusive file locks on the KB.'
+        };
+    }
+    return { id: 'legacy_ide_lock', status: 'pass', detail: 'No conflicting GeneXus IDE process (gx.exe) detected.' };
+}
+
 function redactConfig(cfg) {
     // Replace absolute paths with `<redacted:hash8>` so the structure is preserved
     // but filesystem layout, usernames, and KB names are not leaked. Hash is stable
@@ -709,7 +795,7 @@ async function handleDoctor(options, ctx) {
     const kbPath = data.kbPath;
     const gxPath = data.gxPath;
     const kbExists = !!(kbPath && fs.existsSync(kbPath));
-    const gxExeExists = !!(gxPath && fs.existsSync(path.join(gxPath, 'genexus.exe')));
+    const gxExeExists = !!(gxPath && (fs.existsSync(path.join(gxPath, 'genexus.exe')) || fs.existsSync(path.join(gxPath, 'gx.exe'))));
     const kbSdkCompatibility = kbExists && gxExeExists
         ? compareGeneXusKbAndInstallation(kbPath, gxPath)
         : null;
@@ -730,15 +816,18 @@ async function handleDoctor(options, ctx) {
             compatibilityDetail = `${unsupportedCompatibilityMajor} is not supported by this MCP distribution. Supported majors: ${catalog.supportedMajors.map((entry) => entry.major).join(', ')}.`;
         } else if (kbSdkCompatibility.status === 'mismatch') {
             compatibilityStatus = 'fail';
-            compatibilityDetail = `KB major ${kbSdkCompatibility.kb.major} does not match GeneXus SDK major ${kbSdkCompatibility.gx.major}. Re-run init with the matching --gx path.`;
+            compatibilityDetail = `KB major ${kbSdkCompatibility.kb.major} does not match GeneXus SDK major ${kbSdkCompatibility.gx.major}${kbSdkCompatibility.gx.version ? ` (${kbSdkCompatibility.gx.version})` : ''}. Re-run init with the matching --gx path.`;
         } else if (kbSdkCompatibility.status === 'match') {
             compatibilityStatus = 'pass';
-            compatibilityDetail = `KB major ${kbSdkCompatibility.kb.major} matches GeneXus SDK major ${kbSdkCompatibility.gx.major}.`;
+            compatibilityDetail = `KB major ${kbSdkCompatibility.kb.major} matches GeneXus SDK major ${kbSdkCompatibility.gx.major}${kbSdkCompatibility.gx.version ? ` (${kbSdkCompatibility.gx.version})` : ''}.`;
         } else {
             compatibilityDetail = `KB/SDK major compatibility could not be verified (KB: ${kbSdkCompatibility.kb.source}; SDK: ${kbSdkCompatibility.gx.source}).`;
         }
     }
 
+    const gxIdent = gxPath ? readGeneXusInstallationIdentity(gxPath) : null;
+    const gxVersionLabel = gxIdent && gxIdent.version ? ` (GeneXus ${gxIdent.major || ''} version ${gxIdent.version})` : (gxIdent && gxIdent.major ? ` (GeneXus ${gxIdent.major})` : '');
+
     const riskyZone = isPathLikelyAppLockerBlocked(gatewayExePath);
     const clientCrossCheck = buildClientExeCrossCheck(gatewayExePath);
 
@@ -766,7 +855,7 @@ async function handleDoctor(options, ctx) {
         // Same logic for the GeneXus install: missing genexus.exe at a configured path
         // guarantees a worker crash on first MCP call. Promote from warn to fail so init
         // exits non-zero and the caller (install.ps1, AI client) actually sees the problem.
-        { id: 'gx_installation', status: gxExeExists ? 'pass' : (gxPath ? 'fail' : 'warn'), detail: gxExeExists ? 'GeneXus installation has genexus.exe.' : (gxPath ? `Configured GeneXus installation is missing genexus.exe at: ${gxPath}` : 'No GeneXus installation path is configured.') },
+        { id: 'gx_installation', status: gxExeExists ? 'pass' : (gxPath ? 'fail' : 'warn'), detail: gxExeExists ? `GeneXus installation has ${gxPath && fs.existsSync(path.join(gxPath, 'gx.exe')) && !fs.existsSync(path.join(gxPath, 'genexus.exe')) ? 'gx.exe' : 'genexus.exe'}${gxVersionLabel}.` : (gxPath ? `Configured GeneXus installation is missing executable at: ${gxPath}` : 'No GeneXus installation path is configured.') },
         {
             id: 'kb_sdk_compatibility',
             status: compatibilityStatus,
@@ -783,6 +872,13 @@ async function handleDoctor(options, ctx) {
     const inProcessLoad = buildInProcessBuildAssemblyLoadCheck(gxPath);
     checks.push({ id: 'in_process_build_assembly_load', status: inProcessLoad.status, detail: inProcessLoad.detail });
 
+    // Legacy GeneXus checks (GX 8.0, 9.0, Ev1, Ev2)
+    const gxMajor = (gxIdent && gxIdent.major) || (kbSdkCompatibility && kbSdkCompatibility.gx && kbSdkCompatibility.gx.major) || null;
+    const comCheck = buildGxPublicComCheck(gxMajor, gxPath);
+    checks.push({ id: 'gxpublic_com_registration', status: comCheck.status, detail: comCheck.detail });
+    const ideLockCheck = buildLegacyIdeLockCheck(gxMajor);
+    checks.push({ id: 'legacy_ide_lock', status: ideLockCheck.status, detail: ideLockCheck.detail });
+
     // Client registration summary — one line answering "are my AI agents wired up?".
     const clientRows = clientsStatus();
     const installedRows = clientRows.filter((r) => r.installed);
@@ -1343,6 +1439,7 @@ function buildClientLauncherHelp(patchResult) {
     }
     if (patched.length > 0 && process.platform === 'win32' && !process.env.GENEXUS_MCP_GATEWAY_EXE) {
         help.push('Windows launcher paths may resolve under the npm cache and be blocked by AppLocker/SRP. Use scripts/install.ps1 for a stable whitelisted path.');
+        help.push('Working from a local checkout? Register the clients with the checkout gateway from the repo root instead: `$env:GENEXUS_MCP_GATEWAY_EXE="<repoRoot>\\publish\\GxMcp.Gateway.exe"; node cli\\run.js clients add --clients <ids>` (or re-run `.\\install.ps1`). Avoid `npx @latest clients add` there, because it rewrites the registration to this npm package\'s launcher; validate with the same checkout CLI (`node cli\\run.js clients` / `doctor`).');
     }
     return help;
 }
@@ -1938,6 +2035,7 @@ async function probeWorkerStartup({ configPath, observeMs = 2500 }) {
         };
 
         let child;
+        let stopping = false;
         try {
             child = spawn(gatewayExePath, [], {
                 stdio: ['ignore', 'pipe', 'pipe'],
@@ -1956,6 +2054,9 @@ async function probeWorkerStartup({ configPath, observeMs = 2500 }) {
         });
 
         child.once('exit', (code) => {
+            // The observation timeout stops the gateway itself; that deliberate
+            // signal is reported by the timeout branch, not as a crash.
+            if (stopping) return;
             if (code === 0) {
                 finish({ status: 'pass', detail: 'Worker smoke: gateway exited cleanly during observation window.' });
             } else {
@@ -1969,10 +2070,15 @@ async function probeWorkerStartup({ configPath, observeMs = 2500 }) {
             }
         });
 
-        setTimeout(() => {
-            try { child.kill(); } catch { }
-            // Still alive after observeMs → worker bootstrapped without crashing.
-            finish({ status: 'pass', detail: `Worker smoke: gateway stayed alive for ${observeMs}ms with KB and GX configured.` });
+        setTimeout(async () => {
+            stopping = true;
+            const exited = await stopProbeChild(child);
+            if (exited) {
+                // Still alive after observeMs → worker bootstrapped without crashing.
+                finish({ status: 'pass', detail: `Worker smoke: gateway stayed alive for ${observeMs}ms with KB and GX configured.` });
+            } else {
+                finish({ status: 'warn', detail: 'Worker smoke: gateway did not exit after the stop signal; it may still hold the gateway exe.' });
+            }
         }, observeMs);
     });
 }
@@ -2149,11 +2255,12 @@ async function handleClients(subcommand, options, ctx) {
         if (invalidLaunchers.length > 0) {
             help.push(`These clients have a known-invalid MCP launcher (check command and args) — re-register: genexus-mcp clients add --clients ${invalidLaunchers.map((r) => r.id).join(',')}${serverName !== DEFAULT_MCP_SERVER_NAME ? ` --server-name ${serverName}` : ''}`);
         }
-        const otherStale = stale.filter((r) =>
-            r.launcherStructuralState !== 'missing' && r.launcherSemanticState !== 'invalid'
-        );
-        if (otherStale.length > 0) {
-            help.push(`These clients have a stale launcher — re-register: genexus-mcp clients add --clients ${otherStale.map((r) => r.id).join(',')}${serverName !== DEFAULT_MCP_SERVER_NAME ? ` --server-name ${serverName}` : ''}`);
+        // A launcher that exists but is not this CLI's gateway is a different working
+        // install (checkout, fixed-path, other package cache), so it is reported as
+        // informational drift instead of a stale registration that needs repair.
+        const driftedLaunchers = rows.filter((r) => r.launcherPathDrift && !r.commandStale);
+        if (driftedLaunchers.length > 0) {
+            help.push(`Note: ${driftedLaunchers.map((r) => r.name).join(', ')} point at a gateway that is not this CLI's (informational — the launcher exists and is valid). Re-register with this CLI only if you want them to track it: genexus-mcp clients add --clients ${driftedLaunchers.map((r) => r.id).join(',')}${serverName !== DEFAULT_MCP_SERVER_NAME ? ` --server-name ${serverName}` : ''}`);
         }
         const semanticValidCount = rows.filter((r) => r.launcherSemanticState === 'valid').length;
         const semanticInvalidCount = rows.filter((r) => r.launcherSemanticState === 'invalid').length;
@@ -2483,6 +2590,13 @@ function commandHelpMap() {
                 'genexus-mcp update --channel next   # check the @next dist-tag'
             ]
         },
+        version: {
+            usage: 'genexus-mcp --version | -v | version [--format toon|json|text]',
+            examples: [
+                'genexus-mcp --version          # prints the bare version (scripts/CI)',
+                'genexus-mcp -v --format json   # axi-cli/1 envelope with ok.version'
+            ]
+        },
         layout: {
             usage: 'genexus-mcp layout status [--title "GeneXus"] [--format ...] OR genexus-mcp layout run --action <focus|activate-layout|activate-tab|send-keys|type-text|click> [--tab "Layout"] [--keys "..."] [--text "..."] [--x N --y N] [--title "..."] [--format ...] OR genexus-mcp layout inspect [--tab "Layout"] [--limit N] [--full] [--title "..."] [--format ...]',
             examples: ['genexus-mcp layout status --format json', 'genexus-mcp layout run --action activate-tab --tab "Layout" --format json', 'genexus-mcp layout inspect --tab Layout --format json']
@@ -2518,6 +2632,34 @@ async function handleHome(_options, ctx) {
     };
 }
 
+// Issue #207: `genexus-mcp --version` / `-v` / `version` used to fall through to the
+// gateway passthrough (which never answers that token) and exit 0 with no output — a
+// silent false positive for install checks. The package version is read from the same
+// helper the update flow uses.
+// `deps` is an injection seam so the unreadable-package.json path is testable.
+async function handleVersion(_options, ctx, deps = {}) {
+    const readVersion = deps.getPackageVersion || getPackageVersion;
+    const version = readVersion();
+    if (!version) {
+        return {
+            exitCode: ctx.EXIT_CODES.ERROR,
+            envelope: operationalErrorEnvelope(
+                'Could not read the genexus-mcp package version (package.json missing or unreadable).',
+                ctx.EXIT_CODES.ERROR,
+                ['Reinstall the CLI (`genexus-mcp update`) so package.json can be read.'],
+                'version_unavailable'
+            )
+        };
+    }
+    return {
+        exitCode: ctx.EXIT_CODES.OK,
+        envelope: {
+            ok: { version },
+            help: []
+        }
+    };
+}
+
 async function handleHelp(targetCommand, ctx) {
     const binPath = collapseHome(process.argv[1] || process.execPath);
     const map = commandHelpMap();
@@ -2547,7 +2689,7 @@ async function handleHelp(targetCommand, ctx) {
                 bin: binPath,
                 command: 'genexus-mcp',
                 description: 'GeneXus MCP launcher and AXI-oriented utility CLI',
-                commands: ['home', 'axi home', 'status', 'doctor', 'tools list', 'config show', 'config create', 'layout status', 'layout run', 'layout inspect', 'init', 'whoami', 'uninstall', 'kb list', 'kb add', 'kb remove', 'kb switch', 'llm help', 'update', 'help'],
+                commands: ['home', 'axi home', 'status', 'doctor', 'tools list', 'config show', 'config create', 'layout status', 'layout run', 'layout inspect', 'init', 'whoami', 'uninstall', 'kb list', 'kb add', 'kb remove', 'kb switch', 'llm help', 'update', 'version', 'help'],
                 defaults: { format: 'toon', limit: 100 }
             },
             help: [
@@ -2660,6 +2802,7 @@ module.exports = {
     handleLlmHelp,
     handleLayout,
     handleHelp,
+    handleVersion,
     usageEnvelope,
     operationalErrorEnvelope,
     resolveMcpSmokeTarget,

package/cli/index.js

@@ -26,6 +26,7 @@ const {
     handleLlmHelp,
     handleLayout,
     handleHelp,
+    handleVersion,
     usageEnvelope,
     commandHelpMap
 } = require('./commands/axi');
@@ -63,7 +64,19 @@ const GLOBAL_DEFAULTS = {
     help: false
 };
 
-const KNOWN_COMMANDS = new Set(['status', 'doctor', 'tools', 'config', 'init', 'setup', 'whoami', 'uninstall', 'kb', 'clients', 'help', 'home', 'axi', 'llm', 'layout', 'update']);
+// Single source of truth for command routing: cli/run.js imports both sets so the
+// AXI-vs-passthrough decision (stdout vs stderr for unhandled errors) cannot drift
+// from the parser again — issue #207 was caused by two hand-synced copies.
+const KNOWN_COMMANDS = new Set(['status', 'doctor', 'tools', 'config', 'init', 'setup', 'whoami', 'uninstall', 'kb', 'clients', 'help', 'home', 'axi', 'llm', 'layout', 'update', 'version']);
+
+// Version query aliases. `-v` deliberately is NOT an alias of `--help`/`-h`: those
+// return immediately, while the version aliases are command tokens so that remaining
+// flags (`-v --format json`) are still parsed and honored (issue #207).
+const VERSION_ALIASES = new Set(['version', '-v', '--version']);
+
+function isKnownCommandToken(token) {
+    return KNOWN_COMMANDS.has(token) || VERSION_ALIASES.has(token);
+}
 
 function parseArgs(argv) {
     const result = {
@@ -79,7 +92,8 @@ function parseArgs(argv) {
     if (tokens.length === 0) return result;
 
     const first = tokens[0];
-    if (!KNOWN_COMMANDS.has(first) && !first.startsWith('--')) {
+    const versionIntent = VERSION_ALIASES.has(first);
+    if (!versionIntent && !KNOWN_COMMANDS.has(first) && !first.startsWith('--')) {
         return result;
     }
 
@@ -89,7 +103,13 @@ function parseArgs(argv) {
         return result;
     }
 
-    if (KNOWN_COMMANDS.has(first)) {
+    if (versionIntent) {
+        // Treat the alias as a consumed command token and keep parsing the remaining
+        // flags, so `version --format json`, `-v --format json` and `--version --format json`
+        // all reach the format validation instead of falling through to passthrough.
+        result.command = 'version';
+        tokens.shift();
+    } else if (KNOWN_COMMANDS.has(first)) {
         result.command = first === 'setup' ? 'init' : first;
         tokens.shift();
     }
@@ -534,7 +554,9 @@ function resolveMetaCommand(parsed, targetHelp) {
 async function main(argv) {
     const parsed = parseArgs(argv);
 
-    if (parsed.command !== 'update') {
+    // `version` is a quiet query: no update-check banner (it would corrupt the raw
+    // version string scripts read) and no launcher config side effects.
+    if (parsed.command !== 'update' && parsed.command !== 'version') {
         startBackgroundUpdateCheck({ quiet: parsed.options.quiet });
     }
 
@@ -568,6 +590,19 @@ async function main(argv) {
         return helpResult.exitCode;
     }
 
+    if (parsed.command === 'version') {
+        const versionResult = await handleVersion(parsed.options, ctx);
+        // Default formats print the bare version so `genexus-mcp --version` is usable
+        // from scripts/CI; only --format json opts into the axi-cli/1 envelope.
+        if (versionResult.exitCode === EXIT_CODES.OK
+            && (parsed.options.format === 'toon' || parsed.options.format === 'text')) {
+            process.stdout.write(`${versionResult.envelope.ok.version}\n`);
+        } else {
+            writeStructured(process.stdout, withCommandMeta(versionResult.envelope, 'version'), parsed.options.format);
+        }
+        return versionResult.exitCode;
+    }
+
     let result;
 
     switch (parsed.command) {
@@ -682,6 +717,9 @@ module.exports = {
     main,
     parseArgs,
     EXIT_CODES,
+    KNOWN_COMMANDS,
+    VERSION_ALIASES,
+    isKnownCommandToken,
     renderOutput,
     formatToonObject
 };

package/cli/lib/client-adapters.js

@@ -78,10 +78,16 @@ class OpenCodeJsoncAdapter extends BaseClientAdapter {
         this.config = configModule || require('./config');
     }
     apply(client, launcher, targetConfigPath, opts = {}) {
-        return this.config.applyOpenCodeJson(client.path, launcher, targetConfigPath, opts);
+        return this.config.applyOpenCodeJson(client.path, launcher, targetConfigPath, {
+            ...opts,
+            alternatePaths: client.alternatePaths || []
+        });
     }
     remove(client, opts = {}) {
-        return this.config.removeOpenCodeJson(client.path, opts);
+        return this.config.removeOpenCodeJson(client.path, {
+            ...opts,
+            alternatePaths: client.alternatePaths || []
+        });
     }
     read(client, serverName) {
         if (!fs.existsSync(client.path)) return null;