genexus-mcp 3.9.0 → 3.9.2

package/cli/lib/runtime-stager.test.js

@@ -13,7 +13,8 @@ const {
     ensureStagedGateway,
     cleanOldRuntimes,
     verifyManifest,
-    classifyProcessRuntime
+    classifyProcessRuntime,
+    getRuntimeProcessUsage
 } = require('./runtime-stager');
 
 function sha256(content) {
@@ -167,7 +168,8 @@ test('runtime-stager: ensureStagedGateway fails closed and cleans tmp on manifes
             packageRoot: fakePkg,
             publishDir: fakePublish,
             runtimeRoot,
-            forceStaging: true
+            forceStaging: true,
+            getRunningProcesses: () => []
         });
     }, /Manifest verification failed/);
 
@@ -175,6 +177,58 @@ test('runtime-stager: ensureStagedGateway fails closed and cleans tmp on manifes
     assert.equal(fs.readdirSync(runtimeRoot).length, 0);
 });
 
+test('runtime-stager: temporary staging cleanup retains a live process and reports the final-probe skip', (t) => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gx-stage-live-process-'));
+    t.after(() => {
+        try { fs.rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+    });
+
+    const fakePkg = path.join(tmpRoot, 'package');
+    const fakePublish = path.join(fakePkg, 'publish');
+    const runtimeRoot = path.join(tmpRoot, 'runtime');
+    fs.mkdirSync(fakePublish, { recursive: true });
+    fs.writeFileSync(path.join(fakePkg, 'package.json'), JSON.stringify({ version: '3.9.1' }));
+    fs.writeFileSync(path.join(fakePublish, 'GxMcp.Gateway.exe'), 'partial gateway');
+    fs.writeFileSync(path.join(fakePublish, 'gxmcp-manifest.json'), JSON.stringify({
+        artifacts: [{ path: 'GxMcp.Gateway.exe', size: 9999, sha256: 'deadbeef' }]
+    }));
+
+    let probeCalls = 0;
+    let stagingError;
+    try {
+        ensureStagedGateway({
+            packageRoot: fakePkg,
+            publishDir: fakePublish,
+            runtimeRoot,
+            forceStaging: true,
+            getRunningProcesses: () => {
+                probeCalls++;
+                if (probeCalls === 1) return [];
+                const tmpName = fs.readdirSync(runtimeRoot).find((name) => name.includes('.tmp-'));
+                return [{
+                    pid: 5150,
+                    exePath: path.join(runtimeRoot, tmpName, 'worker', 'GxMcp.Worker.exe')
+                }];
+            }
+        });
+    } catch (err) {
+        stagingError = err;
+    }
+
+    assert.ok(stagingError);
+    assert.match(stagingError.message, /Manifest verification failed/);
+    assert.match(stagingError.message, /Runtime cleanup skipped/);
+    assert.equal(stagingError.runtimeCleanup.processProbeAvailable, true);
+    assert.equal(stagingError.runtimeCleanup.skipped.length, 1);
+    assert.equal(stagingError.runtimeCleanup.skipped[0].reason, 'in-use-before-delete');
+    assert.deepEqual(stagingError.runtimeCleanup.skipped[0].pids, [5150]);
+    assert.equal(probeCalls, 2);
+    assert.equal(
+        fs.readdirSync(runtimeRoot).filter((name) => name.includes('.tmp-')).length,
+        1
+    );
+});
+
 test('runtime-stager: cleanOldRuntimes retains current version plus keepCount newest versions', (t) => {
     const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gx-gc-test-'));
     t.after(() => {
@@ -196,7 +250,7 @@ test('runtime-stager: cleanOldRuntimes retains current version plus keepCount ne
     fs.utimesSync(v4, 4000, 4000);
 
     // Current is v4. Keep count = 2 -> keep v4, v3, v2. v1 should be deleted.
-    cleanOldRuntimes(tmpRoot, v4, 2);
+    cleanOldRuntimes(tmpRoot, v4, 2, { getRunningProcesses: () => [] });
 
     assert.equal(fs.existsSync(v4), true, 'current version must be kept');
     assert.equal(fs.existsSync(v3), true, 'newest previous version must be kept');
@@ -219,3 +273,235 @@ test('runtime-stager: classifyProcessRuntime identifies staged vs npx-cache', ()
         'other'
     );
 });
+
+test('runtime-stager: cleanOldRuntimes retains a runtime with a live child process and reports its PID', (t) => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gx-gc-in-use-'));
+    t.after(() => {
+        try { fs.rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+    });
+
+    const oldRuntime = path.join(tmpRoot, '3.6.0-old');
+    const currentRuntime = path.join(tmpRoot, '3.9.0-current');
+    fs.mkdirSync(oldRuntime);
+    fs.mkdirSync(currentRuntime);
+    fs.utimesSync(oldRuntime, 1000, 1000);
+    fs.utimesSync(currentRuntime, 2000, 2000);
+
+    const result = cleanOldRuntimes(tmpRoot, currentRuntime, 0, {
+        getRunningProcesses: () => [{
+            pid: 4242,
+            exePath: path.join(oldRuntime, 'worker', 'GxMcp.Worker.exe')
+        }]
+    });
+
+    assert.equal(fs.existsSync(oldRuntime), true);
+    assert.equal(result.skipped.length, 1);
+    assert.equal(result.skipped[0].reason, 'in-use');
+    assert.deepEqual(result.skipped[0].pids, [4242]);
+});
+
+test('runtime-stager: cleanOldRuntimes renames before removal and leaves the original on rename failure', (t) => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gx-gc-atomic-'));
+    t.after(() => {
+        try { fs.rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+    });
+
+    const oldRuntime = path.join(tmpRoot, '3.6.0-atomic');
+    const currentRuntime = path.join(tmpRoot, '3.9.0-current');
+    fs.mkdirSync(oldRuntime);
+    fs.mkdirSync(currentRuntime);
+    fs.writeFileSync(path.join(oldRuntime, 'keep.txt'), 'payload');
+    fs.utimesSync(oldRuntime, 1000, 1000);
+    fs.utimesSync(currentRuntime, 2000, 2000);
+
+    const renameCalls = [];
+    const result = cleanOldRuntimes(tmpRoot, currentRuntime, 0, {
+        getRunningProcesses: () => [],
+        renameSync: (from, to) => {
+            renameCalls.push([from, to]);
+            fs.renameSync(from, to);
+        }
+    });
+
+    assert.equal(renameCalls.length, 1);
+    assert.equal(fs.existsSync(oldRuntime), false);
+    assert.equal(result.deleted.length, 1);
+
+    const failedRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gx-gc-rename-fail-'));
+    t.after(() => {
+        try { fs.rmSync(failedRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+    });
+    const failedOld = path.join(failedRoot, '3.6.0-failed');
+    const failedCurrent = path.join(failedRoot, '3.9.0-current');
+    fs.mkdirSync(failedOld);
+    fs.mkdirSync(failedCurrent);
+    fs.writeFileSync(path.join(failedOld, 'keep.txt'), 'payload');
+
+    const failed = cleanOldRuntimes(failedRoot, failedCurrent, 0, {
+        getRunningProcesses: () => [],
+        renameSync: () => { throw new Error('directory is in use'); }
+    });
+    assert.equal(fs.existsSync(failedOld), true);
+    assert.equal(failed.failed.length, 1);
+    assert.match(failed.failed[0].error, /directory is in use/);
+});
+
+test('runtime-stager: process-probe failure is fail-closed and reported', (t) => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gx-gc-probe-fail-'));
+    t.after(() => {
+        try { fs.rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+    });
+    const oldRuntime = path.join(tmpRoot, 'old');
+    const currentRuntime = path.join(tmpRoot, 'current');
+    fs.mkdirSync(oldRuntime);
+    fs.mkdirSync(currentRuntime);
+
+    const result = cleanOldRuntimes(tmpRoot, currentRuntime, 0, {
+        getRunningProcesses: () => ({ ok: false, processes: [], error: 'access denied' })
+    });
+    assert.equal(result.processProbeAvailable, false);
+    assert.equal(fs.existsSync(oldRuntime), true);
+    assert.equal(result.skipped[0].reason, 'process-probe-unavailable');
+});
+
+test('runtime-stager: a process appearing during retirement restores the original directory name', (t) => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gx-gc-race-'));
+    t.after(() => {
+        try { fs.rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+    });
+    const oldRuntime = path.join(tmpRoot, 'old');
+    const currentRuntime = path.join(tmpRoot, 'current');
+    fs.mkdirSync(oldRuntime);
+    fs.mkdirSync(currentRuntime);
+    fs.writeFileSync(path.join(oldRuntime, 'payload.txt'), 'keep');
+
+    let calls = 0;
+    const result = cleanOldRuntimes(tmpRoot, currentRuntime, 0, {
+        getRunningProcesses: () => {
+            calls++;
+            return calls < 3
+                ? []
+                : [{ pid: 777, exePath: path.join(oldRuntime, 'GxMcp.Gateway.exe') }];
+        }
+    });
+
+    assert.equal(fs.existsSync(oldRuntime), true);
+    assert.equal(fs.existsSync(path.join(oldRuntime, 'payload.txt')), true);
+    assert.equal(result.skipped[0].reason, 'in-use-after-rename');
+    assert.equal(result.skipped[0].restored, true);
+});
+
+test('runtime-stager: a process appearing at the final delete probe restores the renamed runtime', (t) => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gx-gc-final-race-'));
+    t.after(() => {
+        try { fs.rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+    });
+    const oldRuntime = path.join(tmpRoot, 'old');
+    const currentRuntime = path.join(tmpRoot, 'current');
+    fs.mkdirSync(oldRuntime);
+    fs.mkdirSync(currentRuntime);
+    fs.writeFileSync(path.join(oldRuntime, 'payload.txt'), 'keep');
+
+    let calls = 0;
+    let deletingPath = null;
+    const result = cleanOldRuntimes(tmpRoot, currentRuntime, 0, {
+        getRunningProcesses: () => {
+            calls++;
+            if (calls < 4 || !deletingPath) return [];
+            return [{ pid: 778, exePath: path.join(deletingPath, 'GxMcp.Gateway.exe') }];
+        },
+        renameSync: (from, to) => {
+            deletingPath = to;
+            fs.renameSync(from, to);
+        }
+    });
+
+    assert.equal(fs.existsSync(oldRuntime), true);
+    assert.equal(fs.existsSync(path.join(oldRuntime, 'payload.txt')), true);
+    assert.equal(result.skipped[0].reason, 'in-use-before-delete');
+    assert.equal(result.skipped[0].restored, true);
+});
+
+test('runtime-stager: a failed removal leaves a retryable tombstone and the next pass collects it', (t) => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gx-gc-tombstone-'));
+    t.after(() => {
+        try { fs.rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+    });
+    const oldRuntime = path.join(tmpRoot, 'old');
+    const currentRuntime = path.join(tmpRoot, 'current');
+    fs.mkdirSync(oldRuntime);
+    fs.mkdirSync(currentRuntime);
+    fs.writeFileSync(path.join(oldRuntime, 'payload.txt'), 'keep');
+
+    const failed = cleanOldRuntimes(tmpRoot, currentRuntime, 0, {
+        getRunningProcesses: () => [],
+        rmSync: () => { throw new Error('temporary delete failure'); }
+    });
+    assert.equal(failed.failed.length, 1);
+    assert.equal(fs.existsSync(oldRuntime), false);
+    assert.equal(fs.readdirSync(tmpRoot).some((name) => name.includes('.deleting-')), true);
+
+    const retried = cleanOldRuntimes(tmpRoot, currentRuntime, 0, {
+        getRunningProcesses: () => []
+    });
+    assert.equal(retried.failed.length, 0);
+    assert.equal(fs.readdirSync(tmpRoot).some((name) => name.includes('.deleting-')), false);
+});
+test('runtime-stager: a failed tombstone restore is retained when the live process still reports the original path', (t) => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gx-gc-tombstone-restore-'));
+    t.after(() => {
+        try { fs.rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+    });
+    const oldRuntime = path.join(tmpRoot, 'old');
+    const currentRuntime = path.join(tmpRoot, 'current');
+    fs.mkdirSync(oldRuntime);
+    fs.mkdirSync(currentRuntime);
+    fs.writeFileSync(path.join(oldRuntime, 'payload.txt'), 'keep');
+
+    let deletingPath = null;
+    const first = cleanOldRuntimes(tmpRoot, currentRuntime, 0, {
+        getRunningProcesses: () => deletingPath
+            ? [{ pid: 779, exePath: path.join(oldRuntime, 'GxMcp.Gateway.exe') }]
+            : [],
+        renameSync: (from, to) => {
+            if (from.includes('.deleting-') && to === oldRuntime) {
+                throw new Error('restore failed while process is live');
+            }
+            deletingPath = to;
+            fs.renameSync(from, to);
+        }
+    });
+    assert.equal(first.skipped[0].restored, false);
+    assert.equal(fs.existsSync(oldRuntime), false);
+    assert.equal(fs.readdirSync(tmpRoot).some((name) => name.includes('.deleting-')), true);
+
+    const second = cleanOldRuntimes(tmpRoot, currentRuntime, 0, {
+        getRunningProcesses: () => [{ pid: 779, exePath: path.join(oldRuntime, 'GxMcp.Gateway.exe') }]
+    });
+    assert.equal(second.skipped.some((entry) => entry.reason === 'in-use'), true);
+    assert.equal(fs.readdirSync(tmpRoot).some((name) => name.includes('.deleting-')), true);
+});
+
+test('runtime-stager: getRuntimeProcessUsage maps Gateway, broker, and Worker PIDs to their runtime', (t) => {
+    const runtimeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gx-gc-usage-'));
+    t.after(() => {
+        try { fs.rmSync(runtimeRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+    });
+    const runtimeDir = path.join(runtimeRoot, '3.8.0-old');
+    const siblingDir = path.join(runtimeRoot, '3.8.0-old-suffix');
+    fs.mkdirSync(runtimeDir);
+    fs.mkdirSync(siblingDir);
+    const gateway = path.join(runtimeDir, 'GxMcp.Gateway.exe');
+    const worker = path.join(runtimeDir, 'worker', 'GxMcp.Worker.exe');
+    const usage = getRuntimeProcessUsage(runtimeRoot, [
+        { pid: 10, exePath: gateway },
+        { pid: 11, exePath: worker },
+        { pid: 12, exePath: path.join(siblingDir, 'GxMcp.Gateway.exe') }
+    ]);
+
+    assert.equal(usage.length, 2);
+    const oldUsage = usage.find((entry) => entry.name === '3.8.0-old');
+    const siblingUsage = usage.find((entry) => entry.name === '3.8.0-old-suffix');
+    assert.deepEqual(oldUsage.pids, [10, 11]);
+    assert.deepEqual(siblingUsage.pids, [12]);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genexus-mcp",
-  "version": "3.9.0",
+  "version": "3.9.2",
   "mcpName": "io.github.lennix1337/genexus",
   "description": "GeneXus 16, GeneXus 17, GeneXus 18 MCP server with native SDK support; basic legacy compatibility for GeneXus Evolution 3, GeneXus Evolution 2, GeneXus Evolution 1, GeneXus 15, GeneXus 9.0, GeneXus 8.0 via com-gxpublic and dotnet-reflection drivers — read, edit, and analyze Knowledge Base objects 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=v10.0": {},
     ".NETCoreApp,Version=v10.0/win-x64": {
-      "GxMcp.Gateway/3.9.0": {
+      "GxMcp.Gateway/3.9.2": {
         "dependencies": {
           "Newtonsoft.Json": "13.0.3",
           "System.Management": "10.0.5",
@@ -66,7 +66,7 @@
     }
   },
   "libraries": {
-    "GxMcp.Gateway/3.9.0": {
+    "GxMcp.Gateway/3.9.2": {
       "type": "project",
       "serviceable": false,
       "sha512": ""

package/publish/config.json

@@ -1,19 +1,19 @@
 {
+  "Environment": {
+    "ResolutionPolicy": "strict"
+  },
   "Server": {
-    "SessionIdleTimeoutMinutes": 10,
-    "HttpPort": 0,
     "TerseResponses": true,
     "McpStdio": true,
-    "WorkerIdleTimeoutMinutes": 5,
-    "EmitStructuredContent": false
+    "HttpPort": 0,
+    "SessionIdleTimeoutMinutes": 10,
+    "EmitStructuredContent": false,
+    "WorkerIdleTimeoutMinutes": 5
   },
   "ConfigSchemaVersion": 2,
-  "Environment": {
-    "ResolutionPolicy": "strict"
-  },
-  "GatewayMode": "stdio-isolated",
   "GeneXus": {
     "WorkerExecutable": "worker\\\\GxMcp.Worker.exe",
     "InstallationPath": "C:\\Program Files (x86)\\GeneXus\\GeneXus18"
-  }
+  },
+  "GatewayMode": "stdio-isolated"
 }

package/publish/gxmcp-manifest.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": "gxmcp-release-manifest/1",
-  "version": "3.9.0",
-  "sourceCommit": "9fac6a8ada3f87a633a857dbeb43eea101b0c085",
+  "version": "3.9.2",
+  "sourceCommit": "a198d035ce7c54a8563382a9bc814fc241287e85",
   "sourceCommitPolicy": "exact-tag",
-  "generatedAtUtc": "2026-09-24T02:07:35.4354126Z",
+  "generatedAtUtc": "2026-09-27T23:21:16.1079775Z",
   "runtime": {
     "gateway": "net10.0-windows",
     "worker": "net48-x86",
@@ -15,28 +15,33 @@
     "2026-07-28"
   ],
   "schema": "tool_definitions.json",
-  "schemaSha256": "e3d3d6247eb5725ed1622e99c8d1a85ffe614ac950e9e2c58d2e37a8404b0b87",
+  "schemaSha256": "3868e10738a997877b6350bf38e9748ddeffd2a194af77dc6fd89e1af0a32fe9",
   "provenance": "gxmcp-sbom.json",
   "artifacts": [
     {
       "path": "gxmcp-sbom.json",
       "size": 590,
-      "sha256": "864d16603041e8c62a86ab1870149af58ac400c3b421a1eeb659fb85d0456fa3"
+      "sha256": "657932e329aef821997783720744484e68d35e2b9227c0e13610010411f32155"
     },
     {
       "path": "GxMcp.Gateway.exe",
       "size": 162304,
-      "sha256": "4660652b1710719df9ed4e31e742d2ef0ea433d4fe0a3a4b1e5dd37d98ce749a"
+      "sha256": "2309948ca38d9e8f5687b6172663c4aa83eb4b8d45eb6b4b46a1fd0ee345da21"
+    },
+    {
+      "path": "nexus-ide.vsix",
+      "size": 1319958,
+      "sha256": "de680984e7caaac86ca017cb2389138642a72c0f4a6879317e777b393c595750"
     },
     {
       "path": "tool_definitions.json",
-      "size": 127996,
-      "sha256": "e3d3d6247eb5725ed1622e99c8d1a85ffe614ac950e9e2c58d2e37a8404b0b87"
+      "size": 132679,
+      "sha256": "3868e10738a997877b6350bf38e9748ddeffd2a194af77dc6fd89e1af0a32fe9"
     },
     {
       "path": "worker/GxMcp.Worker.exe",
-      "size": 3588096,
-      "sha256": "75b511b894704797e623f580b5bd95b77ba64239000f49c7f7706a10c8848953"
+      "size": 3846144,
+      "sha256": "3d19cfc9e8e40d830303fcfd7414f885331fcce4f43b5429686435a82cdfe614"
     }
   ]
 }

package/publish/gxmcp-sbom.json

@@ -1,20 +1,20 @@
 {
   "schemaVersion": "gxmcp-provenance/1",
-  "version": "3.9.0",
-  "sourceCommit": "9fac6a8ada3f87a633a857dbeb43eea101b0c085",
+  "version": "3.9.2",
+  "sourceCommit": "a198d035ce7c54a8563382a9bc814fc241287e85",
   "sourceCommitPolicy": "exact-tag",
   "components": [
     {
       "name": "genexus-mcp",
       "lockfile": "package-lock.json",
-      "size": 39914,
-      "sha256": "f4b4ba71cb46893641b6724d23f6fd374915c7b1e1ed86cf809f6a55256893c6"
+      "size": 38804,
+      "sha256": "02dde3331f502f0856ecdf807cde097d2db71b83128f3ecfc6561430b09de33c"
     },
     {
       "name": "nexus-ide",
       "lockfile": "src/nexus-ide/package-lock.json",
-      "size": 274983,
-      "sha256": "5d9ec910d7b16b23b039bd3b1221504967dc861103999d3b44b47485fa9343a9"
+      "size": 267536,
+      "sha256": "64db440edd7ea7c9f51b6ab4f087b8265c03a722e5f9146f12efec7c8138a082"
     }
   ]
 }