sap-ai-dev-toolkit 0.5.0 → 0.5.5

package/test/bas-destination-relay.test.mjs

@@ -18,11 +18,20 @@ function sapLikeBackend({
   partialRefreshCookies = false,
   omitCookies = false,
   setCookieOnSafeGet = false,
-  secureSessionCookie = false
+  secureSessionCookie = false,
+  postOnlyPaths = [],
+  acceptTokenWithoutCookies = false
 } = {}) {
   const state = { sessionCounter: 0, requests: [] };
   const server = http.createServer((req, res) => {
     state.requests.push({ method: req.method, path: req.url, headers: { ...req.headers } });
+    // POST-only services (ADT data preview among them) reject every GET,
+    // including CSRF token fetches, the way real SAP does.
+    if (req.method === 'GET' && postOnlyPaths.some(prefix => req.url.startsWith(prefix))) {
+      res.writeHead(405, { allow: 'POST' });
+      res.end('<method-not-allowed/>');
+      return;
+    }
     if (req.method === 'GET' && req.headers['x-csrf-token'] === 'Fetch') {
       state.sessionCounter += 1;
       const headers = { 'x-csrf-token': `token-${state.sessionCounter}` };
@@ -63,12 +72,16 @@ function sapLikeBackend({
       const match = String(token || '').match(/^token-(\d+)$/);
       // Without rotation any still-live token+cookie pair is accepted; with
       // rotation only the newest issued session remains valid, matching SAP
-      // server-side session invalidation.
-      const valid = match
-        && cookie.includes(`sap-session-${match[1]}=`)
-        && (!rotateOnFetch || Number(match[1]) === state.sessionCounter)
-        && (!partialRefreshCookies || cookie.includes('sap-usercontext=sap-client=100'))
-        && (!partialRefreshCookies || Number(match[1]) === 1 || !cookie.includes('sap-stale='));
+      // server-side session invalidation. acceptTokenWithoutCookies models a
+      // BAS proxy route where Set-Cookie is stripped yet the backend honors
+      // the token on the proxy-established Basic-auth session.
+      const valid = acceptTokenWithoutCookies
+        ? Boolean(match)
+        : match
+          && cookie.includes(`sap-session-${match[1]}=`)
+          && (!rotateOnFetch || Number(match[1]) === state.sessionCounter)
+          && (!partialRefreshCookies || cookie.includes('sap-usercontext=sap-client=100'))
+          && (!partialRefreshCookies || Number(match[1]) === 1 || !cookie.includes('sap-stale='));
       if (!valid) {
         res.writeHead(403, { 'x-csrf-token': 'Required' });
         res.end('CSRF token validation failed');
@@ -135,6 +148,22 @@ test('pairs CSRF token with its session cookies so unsafe requests succeed', asy
   });
 });
 
+test('fetches the CSRF token from a GET-capable endpoint when the target is POST-only (ADT data preview)', async () => {
+  await withBackend({ postOnlyPaths: ['/sap/bc/adt/datapreview'] }, async ({ relayUrl, state }) => {
+    const response = await relayFetch(relayUrl, '/sap/bc/adt/datapreview/freestyle', {
+      method: 'POST',
+      headers: { accept: 'application/xml' },
+      body: '<query/>'
+    });
+    assert.equal(response.status, 201, `expected 201, got ${response.status}: ${response.body}`);
+    const tokenFetch = state.requests.find(request => request.headers['x-csrf-token'] === 'Fetch');
+    assert.equal(tokenFetch.path, '/sap/bc/adt/discovery', 'token must be fetched from the GET-capable discovery endpoint');
+    const post = state.requests.find(request => request.method === 'POST');
+    assert.match(post.headers['x-csrf-token'], /^token-\d+$/);
+    assert.match(String(post.headers.cookie), /sap-session-\d+=/);
+  });
+});
+
 test('reuses the cached CSRF session for subsequent unsafe requests', async () => {
   await withBackend(null, async ({ relay, relayUrl, state }) => {
     await relayFetch(relayUrl, '/sap/bc/adt/oo/classes', { method: 'POST', body: '<x/>' });
@@ -216,12 +245,22 @@ test('does not retry generic authorization failures as CSRF errors', async () =>
   });
 });
 
-test('does not repeat a CSRF failure when SAP returns a token without session cookies', async () => {
+test('sends a cookie-less token once and surfaces the rejection without retrying', async () => {
   await withBackend({ omitCookies: true }, async ({ relayUrl, relay, state }) => {
     const response = await relayFetch(relayUrl, '/sap/bc/adt/oo/classes', { method: 'POST', body: '<x/>' });
-    assert.equal(response.status, 503, `unsafe calls must fail closed without a paired session, got ${response.status}`);
-    assert.equal(state.requests.filter(request => request.method === 'POST').length, 0);
-    assert.equal(relay.stats.csrfRetries, 0);
+    assert.equal(response.status, 403, `a cookie-less session must surface SAP's verdict, got ${response.status}`);
+    assert.equal(state.requests.filter(request => request.method === 'POST').length, 1);
+    assert.equal(relay.stats.csrfRetries, 0, 'a cookie-less route cannot be fixed by a retry');
+  });
+});
+
+test('completes unsafe requests with a token-only session when the route strips cookies (BAS proxy)', async () => {
+  await withBackend({ omitCookies: true, acceptTokenWithoutCookies: true }, async ({ relayUrl, relay, state }) => {
+    const response = await relayFetch(relayUrl, '/sap/bc/adt/datapreview/freestyle', { method: 'POST', body: '<query/>' });
+    assert.equal(response.status, 201, `expected 201, got ${response.status}: ${response.body}`);
+    const post = state.requests.find(request => request.method === 'POST');
+    assert.match(post.headers['x-csrf-token'], /^token-\d+$/);
+    assert.equal(relay.stats.csrfSessionFailures, 0);
   });
 });
 
@@ -366,7 +405,9 @@ test('keeps OnPremise Basic auth on a BAS proxy tunnel and verifies the CSRF ses
   assert.match(post.headers.authorization, /^Basic /);
   assert.match(String(post.headers.cookie), /sap-session-\d+=/);
   assert.match(String(post.headers.cookie), /sap-secure=secure-value/, 'Secure SAP cookies must be sent through the HTTPS-backed BAS .dest route');
-  assert.ok(connectTargets.length >= 2);
+  // The POST reuses the probe's cached CSRF session (tokens are shared across
+  // paths), so a single pooled tunnel connection can carry both requests.
+  assert.ok(connectTargets.length >= 1, 'upstream traffic must reach the backend through the BAS proxy tunnel');
   assert.ok(connectTargets.every(target => target === 'cc-system.dest:80'));
   assert.equal(relay.stats.direct, false);
   assert.equal(relay.stats.proxyTunnel, true);

package/test/cf-runtime.test.mjs

@@ -298,7 +298,7 @@ test('routes a PrincipalPropagation MCP call through CF Connectivity to the SAP
   }, [], [
     { jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05' } },
     { jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} },
-    { jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'pp-target__GetSystemInfo', arguments: {} } }
+    { jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'sap_system_pp-target_get_system_info', arguments: {} } }
   ]);
   assert.equal(result.code, 0, `${result.stdout}\\n${result.stderr}`);
   const responses = result.stdout.trim().split('\n').map(line => JSON.parse(line));
@@ -455,7 +455,7 @@ test('overrides CF Basic OnPremise backend auth while retaining the HTTP Connect
   }, [], [
     { jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05' } },
     { jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} },
-    { jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'basic-onprem__GetSystemInfo', arguments: {} } }
+    { jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'sap_system_basic-onprem_get_system_info', arguments: {} } }
   ]);
 
   assert.equal(result.code, 0, `${result.stdout}\n${result.stderr}`);

package/test/discovery.test.mjs

@@ -47,6 +47,31 @@ test('accepts the previous destination environment variable during upgrades', as
   });
   assert.deepEqual(destinations.map(destination => destination.name), ['legacy-system']);
 });
+
+test('probes destinations concurrently while preserving order', async () => {
+  const body = [{ Name: 'c-system' }, { Name: 'a-system' }, { Name: 'b-system' }];
+  const started = [];
+  const release = [];
+  const probeImpl = url => new Promise(resolve => {
+    started.push(url);
+    release.push(() => resolve({ status: 200 }));
+  });
+  const discovery = discoverDestinations({ body, env: {}, probeImpl });
+  await new Promise(resolve => setTimeout(resolve, 100));
+  assert.equal(started.length, 3, 'all probes must be in flight at once');
+  assert.deepEqual(started, [
+    'http://a-system.dest/sap/bc/adt/discovery',
+    'http://b-system.dest/sap/bc/adt/discovery',
+    'http://c-system.dest/sap/bc/adt/discovery'
+  ], 'probes start in sorted destination order');
+  for (const resolve of release) resolve();
+  const destinations = await discovery;
+  assert.deepEqual(destinations.map(destination => [destination.name, destination.probe.status]), [
+    ['a-system', 'available'],
+    ['b-system', 'available'],
+    ['c-system', 'available']
+  ]);
+});
 test('parses sample-style destination records and enables every ADT heartbeat response', async () => {
   const body = [
     {

package/test/fixtures/fake-vsp.mjs

@@ -222,6 +222,9 @@ process.stdin.on('data', async chunk => {
           params: { level: 'info', logger: 'fake-vsp', data: 'fixture log notification' }
         })}\n`);
       }
+      if (message.params?.arguments?.emitListChanged) {
+        process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'notifications/tools/list_changed' })}\n`);
+      }
       const transportTools = [
         'ListTransports', 'GetTransport', 'GetUserTransports', 'GetTransportInfo',
         'CreateTransport', 'ReleaseTransport', 'DeleteTransport'

package/test/launcher.test.mjs

@@ -169,15 +169,16 @@ test('doctor preflights the failing ADT endpoint through the runtime relay and r
       }]));
       return;
     }
+    if (requestPath === '/sap/bc/adt/discovery' && request.method === 'GET' && request.headers['x-csrf-token'] === 'Fetch') {
+      // Real SAP issues CSRF tokens from GET-capable endpoints only.
+      response.writeHead(200, {
+        'x-csrf-token': 'doctor-token',
+        'set-cookie': 'sap-session=doctor-session; Path=/'
+      });
+      response.end('<ok/>');
+      return;
+    }
     if (requestPath === '/sap/bc/adt/datapreview/freestyle') {
-      if (request.method === 'GET' && request.headers['x-csrf-token'] === 'Fetch') {
-        response.writeHead(200, {
-          'x-csrf-token': 'doctor-token',
-          'set-cookie': 'sap-session=doctor-session; Path=/'
-        });
-        response.end('<ok/>');
-        return;
-      }
       if (request.method === 'POST'
         && request.headers['x-csrf-token'] === 'doctor-token'
         && String(request.headers.cookie).includes('sap-session=doctor-session')) {
@@ -217,14 +218,14 @@ test('doctor preflights the failing ADT endpoint through the runtime relay and r
   assert.ok(report.checks.some(check => check.stage === 'SAP system check' && check.status === 'passed'));
   assert.ok(report.checks.some(check => check.stage === 'MCP config repair' && check.status === 'passed' && /1 managed BAS entry repaired/.test(check.detail)));
   assert.ok(report.checks.some(check => check.stage === 'MCP tools/list' && /total MCP tools returned; chat-picker binding is host-managed/.test(check.detail)));
-  assert.ok(requests.some(request => request.method === 'GET' && request.path === '/sap/bc/adt/datapreview/freestyle' && request.csrf === 'Fetch'));
+  assert.ok(requests.some(request => request.method === 'GET' && request.path === '/sap/bc/adt/discovery' && request.csrf === 'Fetch'));
   assert.ok(requests.some(request => request.method === 'POST' && request.path === '/sap/bc/adt/datapreview/freestyle' && request.csrf === 'doctor-token' && String(request.cookie).includes('sap-session=doctor-session')));
   const repairedConfig = JSON.parse(await readFile(configPath, 'utf8'));
   assert.equal(repairedConfig.servers['doctor-system'].env.H2O_URL, `http://127.0.0.1:${server.address().port}`);
   assert.deepEqual(repairedConfig.servers.ActionS4D_100, config.servers.ActionS4D_100);
 });
 
-test('doctor stops before GetSystemInfo when the runtime CSRF preflight has no session cookie', async t => {
+test('doctor stops before GetSystemInfo when the runtime CSRF preflight receives no token', async t => {
   const directory = await mkdtemp(join(tmpdir(), 'bas-doctor-csrf-missing-cookie-'));
   const configPath = join(directory, 'mcp.json');
   await writeFile(configPath, JSON.stringify({ servers: {} }));
@@ -245,8 +246,9 @@ test('doctor stops before GetSystemInfo when the runtime CSRF preflight has no s
       }]));
       return;
     }
-    if (requestPath === '/sap/bc/adt/datapreview/freestyle') {
-      response.writeHead(200, { 'x-csrf-token': 'orphan-token' });
+    if (requestPath === '/sap/bc/adt/discovery' && request.method === 'GET' && request.headers['x-csrf-token'] === 'Fetch') {
+      // Issues no token at all: the relay must fail closed before any write.
+      response.writeHead(200);
       response.end('<ok/>');
       return;
     }
@@ -276,7 +278,7 @@ test('doctor stops before GetSystemInfo when the runtime CSRF preflight has no s
   assert.equal(report.ok, false);
   assert.ok(report.checks.some(check => check.stage === 'BAS relay CSRF preflight' && check.status === 'failed' && /cookies=0; usableSession=false/.test(check.detail)));
   assert.ok(report.checks.some(check => check.stage === 'SAP system check' && check.status === 'skipped' && /validated BAS proxy tunnel credential override/.test(check.detail)));
-  assert.equal(requests.some(request => request.method === 'GET' && request.path === '/sap/bc/adt/datapreview/freestyle' && request.csrf === 'Fetch'), true);
+  assert.equal(requests.some(request => request.method === 'GET' && request.path === '/sap/bc/adt/discovery' && request.csrf === 'Fetch'), true);
   assert.equal(requests.some(request => request.method === 'POST' && request.path === '/sap/bc/adt/datapreview/freestyle'), false, 'doctor must not call GetSystemInfo after a failed preflight');
 });
 

package/test/live-s4h.test.mjs

@@ -6,11 +6,13 @@ import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { slugifyDestination } from '../src/bas-discovery.mjs';
+import { snakeCaseName, TOOL_NAME_PREFIX } from '../src/mcp-proxy.mjs';
 
 const launcher = fileURLToPath(new URL('../src/launcher.mjs', import.meta.url));
 const LIVE = /^(1|true|yes)$/iu.test(process.env.SAP_AI_DEV_LIVE_S4H || '');
 const DESTINATION = process.env.SAP_AI_DEV_LIVE_DESTINATION || 'S4H';
-const SLUG = process.env.SAP_AI_DEV_LIVE_DESTINATION_SLUG || DESTINATION.toLowerCase().replace(/[^a-z0-9_-]+/gu, '-');
+const SLUG = process.env.SAP_AI_DEV_LIVE_DESTINATION_SLUG || slugifyDestination(DESTINATION);
 const REQUEST_TIMEOUT_MS = Number(process.env.SAP_AI_DEV_LIVE_TIMEOUT_MS || 45_000);
 
 async function readConfiguredServer() {
@@ -29,7 +31,7 @@ async function readConfiguredServer() {
     } catch {
       continue;
     }
-    const server = parsed?.servers?.[DESTINATION];
+    const server = parsed?.servers?.[SLUG] || parsed?.servers?.[DESTINATION];
     if (server?.command) return { path, server };
   }
   return null;
@@ -131,7 +133,7 @@ async function withLiveClient(t) {
   t.after(() => client.close());
   const initialized = await client.request('initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'sap-ai-dev-live-test', version: '1.0.0' } });
   client.notify('notifications/initialized');
-  assert.equal(initialized.serverInfo.name, DESTINATION);
+  assert.equal(initialized.serverInfo.name, SLUG);
   return client;
 }
 
@@ -140,7 +142,7 @@ test('live S4H MCP exposes a curated ABAP lifecycle surface under 60 tools', { s
   const listed = await client.request('tools/list', {});
   const tools = listed.tools || [];
   const names = new Set(tools.map(tool => tool.name));
-  const prefix = `${SLUG}__`;
+  const prefix = `${TOOL_NAME_PREFIX}${SLUG}_`;
 
   assert.ok(tools.length > 25, `expected a useful ABAP lifecycle surface, got ${tools.length}`);
   assert.ok(tools.length < 60, `curated destination tool count must stay below 60, got ${tools.length}`);
@@ -154,24 +156,24 @@ test('live S4H MCP exposes a curated ABAP lifecycle surface under 60 tools', { s
     'GetTransport', 'GetTransportInfo', 'ListTransports', 'CreateTransport',
     'GetApplicationLog', 'PrepareABAPChangeSet', 'ApplyABAPChangeSet', 'CheckTransportReadiness', 'PlanABAPCloudMigration'
   ]) {
-    assert.ok(names.has(`${prefix}${required}`), `expected curated lifecycle tool ${required}`);
+    assert.ok(names.has(`${prefix}${snakeCaseName(required)}`), `expected curated lifecycle tool ${required}`);
   }
 
   for (const hidden of [
     'SAP', 'ReleaseTransport', 'DeleteTransport', 'DeleteObject', 'ExecuteABAP', 'CallRFC',
     'ListSQLTraces', 'AnalyzeABAPCode', 'CreateObject', 'CreateClassWithTests', 'WriteClass', 'UpdateSource'
   ]) {
-    assert.equal(names.has(`${prefix}${hidden}`), false, `broad/destructive tool ${hidden} must remain hidden`);
+    assert.equal(names.has(`${prefix}${snakeCaseName(hidden)}`), false, `broad/destructive tool ${hidden} must remain hidden`);
   }
 });
 
 test('live S4H MCP handles safe local and read-only SAP calls', { skip: LIVE ? false : 'set SAP_AI_DEV_LIVE_S4H=1 to run against a live BAS/S4H destination' }, async t => {
   const client = await withLiveClient(t);
-  const prefix = `${SLUG}__`;
+  const prefix = `${TOOL_NAME_PREFIX}${SLUG}_`;
   await client.request('tools/list', {});
 
   const lint = await client.request('tools/call', {
-    name: `${prefix}LintABAP`,
+    name: `${prefix}lint_abap`,
     arguments: { files: [{ filename: 'zlive_probe.prog.abap', source: "REPORT zlive_probe.\nWRITE / 'ok'.\n" }] }
   });
   const lintJson = JSON.parse(textPayload(lint));
@@ -183,19 +185,19 @@ test('live S4H MCP handles safe local and read-only SAP calls', { skip: LIVE ? f
     ['GetFeatures', {}],
     ['GetInstalledComponents', {}]
   ]) {
-    const result = await client.request('tools/call', { name: `${prefix}${tool}`, arguments: args });
+    const result = await client.request('tools/call', { name: `${prefix}${snakeCaseName(tool)}`, arguments: args });
     assert.notEqual(result.isError, true, `${tool} returned an MCP tool error: ${textPayload(result)}`);
   }
 
   const query = await client.request('tools/call', {
-    name: `${prefix}RunQuery`,
+    name: `${prefix}run_query`,
     arguments: { sql_query: 'SELECT * FROM T000', max_rows: 1 }
   });
   assert.notEqual(query.isError, true, `RunQuery returned an MCP tool error: ${textPayload(query)}`);
   assert.match(textPayload(query), /T000|MANDT|client|rows|\[/iu);
 
   const appLog = await client.request('tools/call', {
-    name: `${prefix}GetApplicationLog`,
+    name: `${prefix}get_application_log`,
     arguments: { max_results: 1 }
   });
   assert.notEqual(appLog.isError, true, `GetApplicationLog returned an MCP tool error: ${textPayload(appLog)}`);

package/test/mcp-config-cf.test.mjs

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { buildMcpEntries, buildSapDevelopmentMcpEntries, collectCloudFoundryKeyReferencesFromAllEntries, collectManagedCloudFoundryKeyReferences, installMcpConfig, readMcpConfig, repairManagedMcpConfig, resolveMcpConfigPath } from '../src/mcp-config.mjs';
+import { buildMcpEntries, buildSapDevelopmentMcpEntries, collectCloudFoundryKeyReferencesFromAllEntries, collectManagedCloudFoundryKeyReferences, generatedServerName, installMcpConfig, readMcpConfig, repairManagedMcpConfig, resolveMcpConfigPath } from '../src/mcp-config.mjs';
 
 const bas = {
   source: 'bas', name: 'shared', serverName: 'shared', url: 'http://shared.dest',
@@ -38,11 +38,11 @@ test('writes source-qualified CF entries beside same-named BAS destinations', ()
   const second = cfDestination('space-one', 'instance-two', 'key-two');
   const entries = buildMcpEntries([bas, first, second], { H2O_URL: 'http://h2o.example' });
   assert.deepEqual(Object.keys(entries).sort(), [
-    'cf:space-one:instance-one:shared',
-    'cf:space-one:instance-two:shared',
+    'cf-space-one-instance-one-shared',
+    'cf-space-one-instance-two-shared',
     'shared'
   ]);
-  assert.deepEqual(entries['cf:space-one:instance-one:shared'].env, {
+  assert.deepEqual(entries['cf-space-one-instance-one-shared'].env, {
     H2O_URL: 'http://h2o.example',
     SAP_ALLOW_TRANSPORTABLE_EDITS: 'true',
     SAP_AI_DEV_TOOLKIT_DESTINATION_SOURCE: 'cloud-foundry',
@@ -58,7 +58,7 @@ test('writes source-qualified CF entries beside same-named BAS destinations', ()
   assert.equal(JSON.stringify(entries).includes('Password'), false);
 
   const onPremise = buildMcpEntries([cfDestination('space-one', 'onprem-instance', 'destination-key', 'OnPremise')], { H2O_URL: 'http://h2o.example' });
-  assert.equal(onPremise['cf:space-one:onprem-instance:shared'].env.BAS_CF_CONNECTIVITY_KEY, 'connectivity-key');
+  assert.equal(onPremise['cf-space-one-onprem-instance-shared'].env.BAS_CF_CONNECTIVITY_KEY, 'connectivity-key');
 });
 
 test('stores and reconciles the MCP launcher executable location', async t => {
@@ -99,7 +99,7 @@ test('doctor repair updates only discovered toolkit BAS entries and is idempoten
   const strictDestination = { ...bas, name: 'strict', serverName: 'strict', url: 'http://strict.dest' };
   const managed = buildMcpEntries([bas], { H2O_URL: 'http://old-h2o.example' }).shared;
   const strictManaged = buildMcpEntries([strictDestination], { H2O_URL: 'http://old-h2o.example' }).strict;
-  const cfEntry = buildMcpEntries([cf], { H2O_URL: 'http://cf-h2o.example' })[cf.serverName];
+  const cfEntry = buildMcpEntries([cf], { H2O_URL: 'http://cf-h2o.example' })[generatedServerName(cf.serverName)];
   const companion = buildSapDevelopmentMcpEntries(['sap-fiori-tools'])['sap-fiori-tools'];
   const unrelated = { type: 'stdio', command: 'external-server' };
   const unverifiedManaged = {
@@ -112,7 +112,7 @@ test('doctor repair updates only discovered toolkit BAS entries and is idempoten
       shared: { ...managed, env: { ...managed.env, H2O_URL: 'http://old-h2o.example' } },
       strict: { ...strictManaged, env: { ...strictManaged.env, SAP_ALLOW_TRANSPORTABLE_EDITS: 'false' } },
       'temporarily-unavailable': unverifiedManaged,
-      [cf.serverName]: cfEntry,
+      [generatedServerName(cf.serverName)]: cfEntry,
       'sap-fiori-tools': companion,
       ActionS4D_100: unrelated
     }
@@ -128,7 +128,7 @@ test('doctor repair updates only discovered toolkit BAS entries and is idempoten
   assert.equal(repaired.servers.shared.env.SAP_ALLOW_TRANSPORTABLE_EDITS, 'true');
   assert.equal(repaired.servers.strict.env.SAP_ALLOW_TRANSPORTABLE_EDITS, 'false', "doctor must preserve a user's restricted write setting");
   assert.deepEqual(repaired.servers['temporarily-unavailable'], unverifiedManaged);
-  assert.deepEqual(repaired.servers[cf.serverName], cfEntry);
+  assert.deepEqual(repaired.servers[generatedServerName(cf.serverName)], cfEntry);
   assert.deepEqual(repaired.servers['sap-fiori-tools'], companion);
   assert.deepEqual(repaired.servers.ActionS4D_100, unrelated);
   assert.equal(repaired.servers.newDestination, undefined, 'repair must not add unselected destinations');
@@ -209,7 +209,7 @@ test('doctor repair refreshes stale toolkit launchers without changing npx behav
 test('extracts key references only from package-managed Cloud Foundry entries', () => {
   const cloudFoundry = buildMcpEntries([
     cfDestination('space-one', 'instance-one', 'destination-key', 'OnPremise')
-  ], { H2O_URL: 'http://h2o.example' })['cf:space-one:instance-one:shared'];
+  ], { H2O_URL: 'http://h2o.example' })['cf-space-one-instance-one-shared'];
   const managedNpx = {
     ...cloudFoundry,
     command: 'npx',
@@ -320,10 +320,10 @@ test('installs and removes CF entries without deleting unrelated MCP servers', a
     command: 'npx',
     args: ['--yes', '--package=sap-ai-dev-toolkit@0.1.0', 'sap-ai-dev']
   });
-  assert.deepEqual(Object.keys(result.servers).sort(), ['cf:space-one:instance-one:shared', 'shared']);
+  assert.deepEqual(Object.keys(result.servers).sort(), ['cf-space-one-instance-one-shared', 'shared']);
   const written = await readMcpConfig(path);
   assert.equal(written.unrelated, true);
-  assert.deepEqual(Object.keys(written.servers).sort(), ['cf:space-one:instance-one:shared', 'shared', 'userServer']);
+  assert.deepEqual(Object.keys(written.servers).sort(), ['cf-space-one-instance-one-shared', 'shared', 'userServer']);
   assert.deepEqual(collectManagedCloudFoundryKeyReferences(written), [
     { kind: 'destination', spaceGuid: 'space-one', instanceGuid: 'instance-one', instanceName: 'destination-instance-one', keyName: 'managed-key' }
   ]);
@@ -359,7 +359,7 @@ test('wizard replaces legacy launcher entries with the branded command and envir
 });
 
 test('recognizes old npx Cloud Foundry entries so setup can reuse their service keys', () => {
-  const current = buildMcpEntries([cfDestination('space-one', 'instance-one', 'old-key')], { H2O_URL: 'http://h2o.example' })['cf:space-one:instance-one:shared'];
+  const current = buildMcpEntries([cfDestination('space-one', 'instance-one', 'old-key')], { H2O_URL: 'http://h2o.example' })['cf-space-one-instance-one-shared'];
   const legacy = {
     ...current,
     command: 'npx',
@@ -405,3 +405,71 @@ test('setup removes untagged legacy bas-mcp-addon launchers that expose the full
   assert.equal(migrated.servers.shared.command, 'sap-ai-dev');
   assert.equal(migrated.servers.shared.env.SAP_AI_DEV_TOOLKIT_DESTINATION, 'shared');
 });
+
+test('install registers mixed-case destinations under lowercase server names', async t => {
+  const directory = await mkdtemp(join(tmpdir(), 'sap-ai-toolkit-lowercase-install-'));
+  const path = join(directory, 'mcp.json');
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const destination = { ...bas, name: 'ActionS4D', serverName: 'ActionS4D', url: 'http://ActionS4D.dest' };
+  await writeFile(path, JSON.stringify({ servers: {} }));
+
+  const result = await installMcpConfig([destination], { env: { H2O_URL: 'http://h2o.example' }, path });
+  assert.deepEqual(Object.keys(result.servers), ['actions4d']);
+  assert.match(Object.keys(result.servers)[0], /^[a-z0-9-]+$/, 'server names must be lowercase slugs');
+  assert.equal(result.servers.actions4d.env.SAP_AI_DEV_TOOLKIT_DESTINATION, 'ActionS4D');
+
+  // Re-running setup replaces a legacy mixed-case managed entry with the slug key.
+  const legacy = { ...result.servers.actions4d };
+  await writeFile(path, JSON.stringify({ servers: { ActionS4D: legacy, userServer: { command: 'other' } } }));
+  await installMcpConfig([destination], { env: { H2O_URL: 'http://h2o.example' }, path });
+  const written = await readMcpConfig(path);
+  assert.deepEqual(Object.keys(written.servers).sort(), ['actions4d', 'userServer']);
+
+  // Destination names that only differ in case or punctuation now collide.
+  assert.throws(
+    () => buildMcpEntries([destination, { ...bas, name: 'actions4d' }], { H2O_URL: 'http://h2o.example' }),
+    /normalize to the same lowercase server name/
+  );
+});
+
+test('doctor repair renames legacy mixed-case managed entries to the lowercase slug', async t => {
+  const directory = await mkdtemp(join(tmpdir(), 'sap-ai-toolkit-doctor-rename-'));
+  const path = join(directory, 'mcp.json');
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const destination = { ...bas, name: 'ActionS4D', serverName: 'ActionS4D', url: 'http://ActionS4D.dest' };
+  const legacy = buildMcpEntries([destination], { H2O_URL: 'http://old-h2o.example' }).actions4d;
+  const unrelated = { type: 'stdio', command: 'third-party' };
+  await writeFile(path, JSON.stringify({ servers: { ActionS4D: legacy, ActionS4D_100: unrelated } }));
+
+  const first = await repairManagedMcpConfig([destination], { env: { H2O_URL: 'http://current-h2o.example' }, path, discoveryComplete: true });
+  assert.equal(first.changed, true);
+  assert.equal(first.repaired, 1);
+  const renamed = await readMcpConfig(path);
+  assert.equal(renamed.servers.ActionS4D, undefined, 'the legacy mixed-case key must be removed');
+  assert.equal(renamed.servers.actions4d.env.H2O_URL, 'http://current-h2o.example');
+  assert.equal(renamed.servers.actions4d.env.SAP_AI_DEV_TOOLKIT_DESTINATION, 'ActionS4D');
+  assert.deepEqual(renamed.servers.ActionS4D_100, unrelated);
+
+  const beforeSecond = await readFile(path, 'utf8');
+  const second = await repairManagedMcpConfig([destination], { env: { H2O_URL: 'http://current-h2o.example' }, path, discoveryComplete: true });
+  assert.equal(second.changed, false);
+  assert.equal(second.repaired, 0);
+  assert.equal(await readFile(path, 'utf8'), beforeSecond, 'the rename must be idempotent');
+});
+
+test('doctor repair keeps the legacy entry when a user-owned server holds the slug key', async t => {
+  const directory = await mkdtemp(join(tmpdir(), 'sap-ai-toolkit-doctor-rename-blocked-'));
+  const path = join(directory, 'mcp.json');
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const destination = { ...bas, name: 'ActionS4D', serverName: 'ActionS4D', url: 'http://ActionS4D.dest' };
+  const legacy = buildMcpEntries([destination], { H2O_URL: 'http://old-h2o.example' }).actions4d;
+  const userOwned = { type: 'stdio', command: 'user-server' };
+  const initial = { servers: { ActionS4D: legacy, actions4d: userOwned } };
+  await writeFile(path, JSON.stringify(initial));
+
+  const result = await repairManagedMcpConfig([destination], { env: { H2O_URL: 'http://current-h2o.example' }, path, discoveryComplete: true });
+  assert.equal(result.repaired, 0, 'a user-owned entry on the slug key must block the rename');
+  const config = await readMcpConfig(path);
+  assert.deepEqual(config, initial);
+});
+