genexus-mcp 3.8.0 → 3.9.1

package/cli/commands/axi.js

@@ -813,6 +813,70 @@ function buildLegacyIdeLockCheck(gxMajor) {
     return { id: 'legacy_ide_lock', status: 'pass', detail: 'No conflicting GeneXus IDE process (gx.exe) detected.' };
 }
 
+function buildRuntimeStagingCheck() {
+    try {
+        const {
+            resolveDefaultRuntimeRoot,
+            listStagedRuntimes,
+            probeRunningGxMcpProcesses,
+            getRuntimeProcessUsage,
+            classifyProcessRuntime,
+            shouldStage
+        } = require('../lib/runtime-stager');
+
+        const runtimeRoot = resolveDefaultRuntimeRoot();
+        const stagedList = listStagedRuntimes(runtimeRoot);
+        const processProbe = probeRunningGxMcpProcesses();
+        const runningProcs = processProbe.processes || [];
+        if (processProbe.ok === false) {
+            return {
+                id: 'runtime_staging',
+                status: 'warn',
+                detail: `Runtime process inspection was incomplete; GC is fail-closed. ${processProbe.error || 'The process probe did not return executable paths.'}`
+            };
+        }
+        const npxProcs = runningProcs.filter((p) => classifyProcessRuntime(p.exePath, runtimeRoot) === 'npx-cache');
+        const stagedProcs = runningProcs.filter((p) => classifyProcessRuntime(p.exePath, runtimeRoot) === 'staged');
+        const inUseRuntimes = getRuntimeProcessUsage(runtimeRoot, runningProcs);
+        const inUseDetail = inUseRuntimes.length > 0
+            ? ` Retained in-use runtime(s): ${inUseRuntimes.map((entry) => `${entry.name} (PIDs: ${entry.pids.join(', ')})`).join('; ')}.`
+            : '';
+
+        if (npxProcs.length > 0) {
+            return {
+                id: 'runtime_staging',
+                status: 'warn',
+                detail: `${npxProcs.length} process(es) running directly from npx cache (PIDs: ${npxProcs.map((p) => p.pid).join(', ')}). Terminate them to prevent EBUSY during upgrades.${inUseDetail}`
+            };
+        }
+        if (shouldStage()) {
+            return {
+                id: 'runtime_staging',
+                status: 'pass',
+                detail: `Staging active at ${runtimeRoot}. ${stagedList.length} staged version(s) found, ${stagedProcs.length} active process(es).${inUseDetail}`
+            };
+        }
+        if (process.env.GENEXUS_MCP_GATEWAY_EXE) {
+            return {
+                id: 'runtime_staging',
+                status: 'pass',
+                detail: `Fixed-path runtime override active via GENEXUS_MCP_GATEWAY_EXE (${process.env.GENEXUS_MCP_GATEWAY_EXE}). Staging bypassed.${inUseDetail}`
+            };
+        }
+        return {
+            id: 'runtime_staging',
+            status: 'pass',
+            detail: `Development checkout active. Runtime staging bypassed.${inUseDetail}`
+        };
+    } catch {
+        return {
+            id: 'runtime_staging',
+            status: 'not_applicable',
+            detail: 'Runtime staging inspection unavailable.'
+        };
+    }
+}
+
 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
@@ -1124,6 +1188,7 @@ async function handleDoctor(options, ctx) {
     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 });
+    checks.push(buildRuntimeStagingCheck());
 
     // Client registration summary — one line answering "are my AI agents wired up?".
     const installedRows = clientRows.filter((r) => r.installed);

package/cli/index.js

@@ -450,7 +450,25 @@ async function launchGateway(passthroughArgs, options) {
         return EXIT_CODES.ERROR;
     }
 
-    const gatewayExePath = getGatewayExePath();
+    let gatewayExePath = getGatewayExePath();
+    try {
+        const { ensureStagedGateway } = require('./lib/runtime-stager');
+        const staged = ensureStagedGateway();
+        gatewayExePath = staged.gatewayExePath;
+        const cleanup = staged.cleanup;
+        if (cleanup && (cleanup.skipped?.length || cleanup.failed?.length || cleanup.processProbeAvailable === false)) {
+            const summary = [
+                cleanup.processProbeAvailable === false ? 'process probe unavailable' : null,
+                cleanup.skipped?.length ? `${cleanup.skipped.length} skipped` : null,
+                cleanup.failed?.length ? `${cleanup.failed.length} failed` : null
+            ].filter(Boolean).join(', ');
+            if (!options.quiet) launcherStderr.write(`[genexus-mcp] Runtime cleanup incomplete: ${summary}.\n`);
+        }
+    } catch (stageErr) {
+        if (!options.quiet) {
+            launcherStderr.write(`[genexus-mcp] Warning: Runtime staging failed (${stageErr.message}), falling back to direct binary.\n`);
+        }
+    }
     if (!require('fs').existsSync(gatewayExePath)) {
         const message = `[genexus-mcp] ERROR: Gateway executable not found at ${gatewayExePath}`;
         launcherStderr.write(`${message}\n`);

package/cli/lib/client-adapters.test.js

@@ -151,6 +151,7 @@ test('generateNeutralConfig produces valid shape without KB fields', () => {
     assert.equal(cfg.GeneXus.InstallationPath, 'C:\\GeneXus18');
     assert.ok(cfg.GeneXus.WorkerExecutable.endsWith(path.join('worker', 'GxMcp.Worker.exe')));
     assert.equal(cfg.Server.McpStdio, true);
+    assert.equal(cfg.Server.ToolProfile, 'standard');
     assert.equal(cfg.Server.TransportMode, undefined);
     assert.equal(cfg.Server.HttpPort, 0);
     assert.equal(cfg.Environment.ResolutionPolicy, 'strict');

package/cli/lib/config.js

@@ -8,6 +8,7 @@ function generateConfig(gxPath, kbPath) {
         Server: {
             HttpPort: 5000,
             McpStdio: true,
+            ToolProfile: 'standard',
             SessionIdleTimeoutMinutes: 10,
             WorkerIdleTimeoutMinutes: 5,
             // Lean + terse defaults: the MCP client is an LLM agent that reads
@@ -33,6 +34,7 @@ function generateNeutralConfig(gxPath, { workerPath, gatewayMode = 'stdio-isolat
         Server: {
             HttpPort: 0,
             McpStdio: true,
+            ToolProfile: 'standard',
             WorkerSharingMode: 'isolated',
             SessionIdleTimeoutMinutes: 10,
             WorkerIdleTimeoutMinutes: 5,
@@ -657,9 +659,18 @@ function createConfigFile(kbPath, gxPath) {
     }
     const nextConfig = {
         ...baseConfig,
+        Server: { ...baseConfig.Server },
         Environment: { ...baseConfig.Environment, ...preservedEnv }
     };
 
+    if (existing) {
+        if (existing.Server && Object.prototype.hasOwnProperty.call(existing.Server, 'ToolProfile')) {
+            nextConfig.Server.ToolProfile = existing.Server.ToolProfile;
+        } else {
+            delete nextConfig.Server.ToolProfile;
+        }
+    }
+
     const changed = !existing || JSON.stringify(existing) !== JSON.stringify(nextConfig);
     if (changed) {
         writeFileAtomic(targetConfigPath, JSON.stringify(nextConfig, null, 2));