sap-ai-dev-toolkit 0.3.3 → 0.3.7

package/src/setup.mjs

@@ -5,6 +5,8 @@ import { discoverDestinations, remediation } from './bas-discovery.mjs';
 import { discoverCloudFoundryDestinations, getCloudFoundryTarget, deleteManagedCloudFoundryServiceKeys } from './cf-destination.mjs';
 import { SAP_DEVELOPMENT_MCP_SERVERS, collectCloudFoundryKeyReferencesFromAllEntries, collectManagedCloudFoundryKeyReferences, installMcpConfig, readMcpConfig, resolveMcpConfigPath } from './mcp-config.mjs';
 import { readCredentials, removeDestinationCredentials, resolveCredentialsPath, storeDestinationCredentials } from './credentials-store.mjs';
+import { canPromptForCredentials, credentialKeyForDestination, credentialModeForDestination } from './credential-overrides.mjs';
+import { createBasDestinationRelay } from './bas-destination-relay.mjs';
 
 const SETUP_COMMAND = 'sap-ai-dev --setup';
 
@@ -24,54 +26,88 @@ async function confirmCloudFoundryImport({ input = stdin, output = stdout } = {}
   }
 }
 
-// Internet destinations reach SAP through the BAS .dest proxy, which strips
-// Set-Cookie and makes ADT CSRF-protected writes impossible. Ask once for
-// direct-connection credentials and store them next to the MCP config; the
-// relay then connects straight to the backend host with Basic auth.
-async function promptForInternetDestinationCredentials({ destinations, credentialsPath, existing = {}, input = stdin, output = stdout } = {}) {
-  const stored = {};
-  const internetDestinations = destinations.filter(destination =>
-    destination.source !== 'cloud-foundry'
-    && String(destination.proxyType || '').toLowerCase() === 'internet'
-    && /^basicauthentication$/i.test(String(destination.authentication || '')));
-  if (!internetDestinations.length) return stored;
+async function probeBasOnPremCredentialRoute({ destination, user, password, env }) {
+  const relay = createBasDestinationRelay({
+    ...destination,
+    credentials: { user, password, mode: 'bas-tunnel' }
+  }, { env, log: () => {} });
+  try {
+    await relay.ready;
+    return await relay.probeCsrfSession();
+  } finally {
+    await relay.close();
+  }
+}
+
+async function promptForDestinationCredentials({ destinations, credentialsPath, existing = {}, input = stdin, output = stdout, env = process.env, verifyOnPremCredentialRoute = probeBasOnPremCredentialRoute } = {}) {
+  const eligible = destinations.filter(canPromptForCredentials);
+  const retained = new Set();
+  if (!eligible.length) return retained;
 
   print(output, '');
-  print(output, formatStatus('Some selected destinations are Internet type with basic authentication.', 'step', output, 'Direct connect'));
-  print(output, '  The BAS proxy strips SAP session cookies, which blocks ADT writes (CSRF validation).');
-  print(output, '  Providing a user and password enables a direct connection for those destinations.');
-  print(output, `  Credentials are stored beside your MCP config in ${credentialsPath} (never inside mcp.json).`);
+  print(output, formatStatus('Credential overrides are optional and apply only to selected BasicAuthentication destinations.', 'step', output, 'Credentials'));
+  print(output, `  Overrides are stored beside your MCP config in ${credentialsPath} with owner-only permissions (never inside mcp.json).`);
+  print(output, '  For OnPremise destinations, BAS/Cloud Foundry proxy credentials remain separate from the SAP backend credentials.');
   print(output, '');
 
-  for (const destination of internetDestinations) {
-    const known = existing[destination.name];
+  for (const destination of eligible) {
+    const key = credentialKeyForDestination(destination);
+    if (!key) continue;
+    const mode = credentialModeForDestination(destination);
+    const known = existing[key];
+    const routeLabel = `${destination.source === 'cloud-foundry' ? 'Cloud Foundry' : 'BAS'} ${destination.proxyType} — ${destination.name}`;
+    const answer = await textPrompt({
+      message: colorText(`🔐 ${routeLabel} — override SAP credentials? (y/n)`, 'cyan', output),
+      required: true,
+      validate: value => /^(?:y|yes|n|no)$/i.test(value.trim()) || 'Enter y or n.'
+    }, { input, output });
+    if (/^n/i.test(answer.trim())) {
+      await removeDestinationCredentials(credentialsPath, [key]);
+      print(output, formatStatus(`Credential override disabled for ${destination.name}.`, 'info', output, 'Credentials'));
+      continue;
+    }
+
     if (known?.user && known?.password) {
-      print(output, formatStatus(`Credentials for ${destination.name} are already stored (user ${known.user}). Press Enter at both prompts to keep them.`, 'info', output, 'Direct connect'));
+      print(output, formatStatus(`Credentials for ${destination.name} are already stored. Press Enter at both prompts to keep them.`, 'info', output, 'Credentials'));
     }
     const userAnswer = await textPrompt({
-      message: colorText(`👤 ${destination.name} — SAP user`, 'cyan', output),
+      message: colorText(`👤 ${routeLabel} — SAP user`, 'cyan', output),
       required: false,
-      placeholder: known ? `${known.user} (Enter keeps stored user)` : 'SAP user name'
+      placeholder: known ? 'Enter keeps the stored user' : 'SAP user name'
     }, { input, output });
     const user = userAnswer.trim() || known?.user || '';
     const passwordAnswer = await textPrompt({
-      message: colorText(`🔒 ${destination.name} — SAP password${known ? ' (Enter keeps stored password)' : ''}`, 'cyan', output),
+      message: colorText(`🔒 ${routeLabel} — SAP password${known ? ' (Enter keeps stored password)' : ''}`, 'cyan', output),
       secret: true,
       required: false
     }, { input, output });
     const password = passwordAnswer || known?.password || '';
     if (!user || !password) {
-      print(output, formatStatus(`No complete credentials for ${destination.name}; direct connect stays inactive for it.`, 'warning', output, 'Direct connect'));
+      await removeDestinationCredentials(credentialsPath, [key]);
+      print(output, formatStatus(`No complete credentials for ${destination.name}; no override was stored.`, 'warning', output, 'Credentials'));
       continue;
     }
-    stored[destination.name] = {
-      host: destination.backendUrl || known?.host || '',
-      user,
-      password
-    };
-    print(output, formatStatus(`Stored credentials for ${destination.name}.`, 'success', output, 'Direct connect'));
+
+    if (mode === 'bas-tunnel') {
+      let route;
+      try {
+        route = await verifyOnPremCredentialRoute({ destination, user, password, env });
+      } catch {
+        route = null;
+      }
+      if (!(route?.httpStatus >= 200 && route.httpStatus < 300) || !route.tokenReceived || !(route.cookieCount > 0)) {
+        await removeDestinationCredentials(credentialsPath, [key]);
+        print(output, formatStatus(`No override stored for ${destination.name}: the BAS/Cloud Connector route did not return both a CSRF token and session cookie.`, 'warning', output, 'Credentials'));
+        continue;
+      }
+    }
+
+    const host = mode === 'direct' ? (destination.backendUrl || known?.host || '') : '';
+    await storeDestinationCredentials(credentialsPath, key, { host, user, password, mode });
+    retained.add(key);
+    print(output, formatStatus(`Stored credential override for ${destination.name}.`, 'success', output, 'Credentials'));
   }
-  return stored;
+  return retained;
 }
 
 function safeProbe(probe) {
@@ -137,6 +173,7 @@ function printConnectionInstructions(output, result) {
     print(output, `  • ${name} — ${detail}`);
   }
   print(output, formatStatus('Open the Command Palette → “MCP: List Servers”, select a generated server, and choose “Start Server”.', 'step', output, 'Next'));
+  print(output, formatStatus('In GitHub Copilot Chat, select an agent, open the Chat tools picker, and enable each selected destination server for this chat.', 'step', output, 'Copilot Chat'));
   print(output, formatStatus('Inspect or edit entries with “MCP: Open User Configuration”.', 'info', output, 'Config'));
 }
 
@@ -149,6 +186,7 @@ export async function runSetup({
   discoverCf = discoverCloudFoundryDestinations,
   confirmCfImport = confirmCloudFoundryImport,
   install = installMcpConfig,
+  verifyOnPremCredentialRoute = probeBasOnPremCredentialRoute,
   includeSapDevelopmentToolsPrompt = false
 } = {}) {
   if (!env.H2O_URL) {
@@ -268,8 +306,9 @@ export async function runSetup({
   let sapDevelopmentServers = [];
   if (includeSapDevelopmentToolsPrompt) {
     print(output, '');
-    print(output, formatStatus('Optionally add companion MCP servers for full-stack SAP development.', 'step', output, 'Tools'));
-    print(output, '  Recommended for RAP/Fiori/CAP/UI validation work. Leave empty to only configure ABAP/ADT destination servers.');
+    print(output, formatStatus('Optionally add companion MCP servers for full-stack SAP development and HANA inspection.', 'step', output, 'Tools'));
+    print(output, '  HANA Cloud inspector is read-only and uses HANA_RO_* or VCAP_SERVICES already present in the MCP host environment; credentials are not written to mcp.json.');
+    print(output, '  Leave empty to only configure ABAP/ADT destination servers.');
     print(output, '');
     sapDevelopmentServers = await checkboxPrompt({
       message: colorText('🧰 Select companion tools', 'cyan', output),
@@ -283,37 +322,24 @@ export async function runSetup({
     }, { input, output });
   }
 
-  // Ask for direct-connect credentials for selected Internet destinations
-  // so ADT writes work despite the BAS proxy stripping session cookies.
+  // Ask for an explicit credential override choice for each selected supported destination.
   const credentialsPath = await resolveCredentialsPath(env, configPath);
-  const internetSelected = selected.filter(destination =>
-    destination.source !== 'cloud-foundry'
-    && String(destination.proxyType || '').toLowerCase() === 'internet'
-    && /^basicauthentication$/i.test(String(destination.authentication || '')));
-  if (internetSelected.length) {
-    try {
-      const existingMap = (await readCredentials(credentialsPath).catch(() => ({ destinations: {} }))).destinations || {};
-      const storedNow = await promptForInternetDestinationCredentials({
-        destinations: selected,
-        credentialsPath,
-        existing: existingMap,
-        input,
-        output
-      });
-      for (const [name, entry] of Object.entries(storedNow)) {
-        await storeDestinationCredentials(credentialsPath, name, entry);
-      }
-      // Remove stored credentials for Internet destinations that are no
-      // longer selected, so the file only tracks active servers.
-      const stillSelected = new Set(selected.map(destination => destination.name));
-      const stale = Object.keys(existingMap)
-        .filter(name => !stillSelected.has(name))
-        .filter(name => internetSelected.every(destination => destination.name !== name));
-      if (stale.length) await removeDestinationCredentials(credentialsPath, stale);
-    } catch (error) {
-      if (/Prompt interrupted/.test(error.message)) throw error;
-      credentialWarnings.push(`Direct-connect credentials could not be stored: ${error.message}`);
-    }
+  try {
+    const existingMap = (await readCredentials(credentialsPath).catch(() => ({ destinations: {} }))).destinations || {};
+    const retained = await promptForDestinationCredentials({
+      destinations: selected,
+      credentialsPath,
+      existing: existingMap,
+      input,
+      output,
+      env,
+      verifyOnPremCredentialRoute
+    });
+    const stale = Object.keys(existingMap).filter(name => !retained.has(name));
+    if (stale.length) await removeDestinationCredentials(credentialsPath, stale);
+  } catch (error) {
+    if (/Prompt interrupted/.test(error.message)) throw error;
+    credentialWarnings.push(`Credential overrides could not be stored: ${error.message}`);
   }
   try {
     const result = await install(selected, { env, sapDevelopmentServers });

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

@@ -1,6 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import http from 'node:http';
+import net from 'node:net';
 import { request as httpRequest } from 'node:http';
 import { createBasDestinationRelay } from '../src/bas-destination-relay.mjs';
 
@@ -186,3 +187,52 @@ test('falls back to a proxy tunnel when the absolute-form request is refused', a
     await new Promise(resolve => server.close(resolve));
   }
 });
+
+test('keeps OnPremise Basic auth on a BAS proxy tunnel and verifies the CSRF session', async t => {
+  const { state, server } = sapLikeBackend();
+  const backendPort = await startServer(server);
+  const connectTargets = [];
+  const proxy = http.createServer();
+  proxy.on('connect', (request, clientSocket, head) => {
+    connectTargets.push(request.url);
+    const upstream = net.connect(backendPort, '127.0.0.1', () => {
+      clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
+      if (head.length) upstream.write(head);
+      clientSocket.pipe(upstream);
+      upstream.pipe(clientSocket);
+    });
+    clientSocket.on('error', () => upstream.destroy());
+    upstream.on('error', () => clientSocket.destroy());
+  });
+  const proxyPort = await startServer(proxy);
+  const logs = [];
+  const relay = createBasDestinationRelay({
+    name: 'CC-SYSTEM',
+    url: 'http://cc-system.dest',
+    authentication: 'BasicAuthentication',
+    credentials: { user: 'DEVELOPER', password: 'secret123', mode: 'bas-tunnel' }
+  }, {
+    env: { HTTP_PROXY: `http://127.0.0.1:${proxyPort}` },
+    log: message => logs.push(message)
+  });
+  const relayUrl = await relay.ready;
+  t.after(async () => {
+    await relay.close();
+    proxy.closeAllConnections?.();
+    await new Promise(resolve => proxy.close(resolve));
+    await new Promise(resolve => server.close(resolve));
+  });
+
+  const probe = await relay.probeCsrfSession();
+  assert.deepEqual(probe, { httpStatus: 200, tokenReceived: true, cookieCount: 2 });
+  const response = await relayFetch(relayUrl, '/sap/bc/adt/oo/classes', { method: 'POST', body: '<x/>' });
+  assert.equal(response.status, 201, `expected a paired CSRF session, got ${response.status}: ${response.body}`);
+  const post = state.requests.find(request => request.method === 'POST');
+  assert.match(post.headers.authorization, /^Basic /);
+  assert.match(String(post.headers.cookie), /sap-session-\d+=/);
+  assert.ok(connectTargets.length >= 2);
+  assert.ok(connectTargets.every(target => target === 'cc-system.dest:80'));
+  assert.equal(relay.stats.direct, false);
+  assert.equal(relay.stats.proxyTunnel, true);
+  assert.ok(logs.some(message => message.includes('BAS proxy tunnel')));
+});

package/test/cf-runtime.test.mjs

@@ -6,6 +6,7 @@ import { spawn } from 'node:child_process';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { storeDestinationCredentials } from '../src/credentials-store.mjs';
 
 const launcher = fileURLToPath(new URL('../src/launcher.mjs', import.meta.url));
 const fakeVsp = fileURLToPath(new URL('./fixtures/fake-vsp.mjs', import.meta.url));
@@ -257,6 +258,12 @@ test('routes a PrincipalPropagation MCP call through CF Connectivity to the SAP
     connectivityProxyPort,
     connectivityTokenUrl: `${serviceOrigin}/connectivity/oauth/token`
   });
+  const credentialsPath = join(directory, 'sap-ai-dev-toolkit-credentials.json');
+  await storeDestinationCredentials(credentialsPath, `cloud-foundry:cf:${SPACE_GUID}:${INSTANCE_GUID}:pp-target`, {
+    user: 'must-not-override',
+    password: 'must-not-override-secret',
+    mode: 'cf-connectivity'
+  });
   const childLog = join(directory, 'vsp-children.jsonl');
   t.after(async () => {
     await new Promise(resolve => service.close(resolve));
@@ -271,6 +278,7 @@ test('routes a PrincipalPropagation MCP call through CF Connectivity to the SAP
     SAP_AI_DEV_TOOLKIT_BINARY: fakeVsp,
     SAP_AI_DEV_TOOLKIT_DESTINATION_SOURCE: 'cloud-foundry',
     SAP_AI_DEV_TOOLKIT_DESTINATION: 'pp-target',
+    SAP_AI_DEV_TOOLKIT_CREDENTIALS_FILE: credentialsPath,
     BAS_CF_SPACE_GUID: SPACE_GUID,
     BAS_CF_DESTINATION_INSTANCE_GUID: INSTANCE_GUID,
     BAS_CF_DESTINATION_INSTANCE: INSTANCE_NAME,
@@ -313,17 +321,17 @@ test('routes a PrincipalPropagation MCP call through CF Connectivity to the SAP
   assert.equal(initialized.argv.includes('--proxy-auth'), true);
   assert.equal(initialized.env.user, undefined);
   assert.equal(initialized.env.password, undefined);
-  for (const secret of ['destination-key-secret', 'destination-api-token', 'connectivity-key-secret', 'user-exchange-token', 'current-cf-user-jwt', 'parent-user-secret', 'parent-password-secret']) {
+  for (const secret of ['must-not-override', 'must-not-override-secret', 'destination-key-secret', 'destination-api-token', 'connectivity-key-secret', 'user-exchange-token', 'current-cf-user-jwt', 'parent-user-secret', 'parent-password-secret']) {
     assert.equal(`${result.stdout}\\n${result.stderr}\\n${JSON.stringify(initialized.argv)}`.includes(secret), false);
   }
 });
 
-test('routes a CF Basic OnPremise MCP call through the HTTP Connectivity proxy', async t => {
+test('overrides CF Basic OnPremise backend auth while retaining the HTTP Connectivity proxy', async t => {
   const directory = await mkdtemp(join(tmpdir(), 'bas-cf-basic-onprem-'));
   const observed = { destinationToken: [], destinationList: [], connectivityToken: [], proxy: [], connect: [], target: [] };
   const target = createServer((request, response) => {
     observed.target.push({ path: request.url, authorization: request.headers.authorization });
-    response.writeHead(request.headers.authorization === `Basic ${Buffer.from('sap-user:sap-password').toString('base64')}` ? 200 : 401, {
+    response.writeHead(request.headers.authorization === `Basic ${Buffer.from('override-user:override-password').toString('base64')}` ? 200 : 401, {
       'content-type': 'text/plain'
     });
     response.end('SAP system information: client=100');
@@ -409,6 +417,12 @@ test('routes a CF Basic OnPremise MCP call through the HTTP Connectivity proxy',
     connectivityProxyPort,
     connectivityTokenUrl: `${serviceOrigin}/connectivity/oauth/token`
   });
+  const credentialsPath = join(directory, 'sap-ai-dev-toolkit-credentials.json');
+  await storeDestinationCredentials(credentialsPath, `cloud-foundry:cf:${SPACE_GUID}:${INSTANCE_GUID}:basic-onprem`, {
+    user: 'override-user',
+    password: 'override-password',
+    mode: 'cf-connectivity'
+  });
   const childLog = join(directory, 'vsp-children.jsonl');
   const servers = [service, target, connectivityProxy];
   t.after(async () => {
@@ -423,6 +437,7 @@ test('routes a CF Basic OnPremise MCP call through the HTTP Connectivity proxy',
     SAP_AI_DEV_TOOLKIT_BINARY: fakeVsp,
     SAP_AI_DEV_TOOLKIT_DESTINATION_SOURCE: 'cloud-foundry',
     SAP_AI_DEV_TOOLKIT_DESTINATION: 'basic-onprem',
+    SAP_AI_DEV_TOOLKIT_CREDENTIALS_FILE: credentialsPath,
     BAS_CF_SPACE_GUID: SPACE_GUID,
     BAS_CF_DESTINATION_INSTANCE_GUID: INSTANCE_GUID,
     BAS_CF_DESTINATION_INSTANCE: INSTANCE_NAME,
@@ -461,13 +476,20 @@ test('routes a CF Basic OnPremise MCP call through the HTTP Connectivity proxy',
     'GET',
     `${targetOrigin}/sap/bc/adt/discovery`,
     'Bearer application-proxy-token',
-    `Basic ${Buffer.from('sap-user:sap-password').toString('base64')}`
+    `Basic ${Buffer.from('override-user:override-password').toString('base64')}`
   ]]);
   assert.deepEqual(observed.connect, []);
   assert.deepEqual(observed.target, [{
     path: '/sap/bc/adt/discovery',
-    authorization: `Basic ${Buffer.from('sap-user:sap-password').toString('base64')}`
+    authorization: `Basic ${Buffer.from('override-user:override-password').toString('base64')}`
   }]);
+  const events = (await readFile(childLog, 'utf8')).trim().split('\n').map(line => JSON.parse(line));
+  const initialized = events.find(event => event.event === 'initialize');
+  assert.deepEqual([initialized.env.user, initialized.env.password], ['override-user', 'override-password']);
+  assert.equal(initialized.argv.includes('--proxy-auth'), false);
+  for (const secret of ['override-user', 'override-password', 'sap-password', 'connectivity-key-secret', 'application-proxy-token']) {
+    assert.equal(`${result.stdout}\n${result.stderr}\n${JSON.stringify(initialized.argv)}`.includes(secret), false, `${secret} must not appear in output or argv`);
+  }
 });
 
 test('CF list-destinations clears the CF name filter and remains BAS-only', async t => {

package/test/copilot-content.test.mjs

@@ -10,6 +10,7 @@ const skillsRoot = join(root, '.github', 'skills');
 const expectedAgents = [
   'abap-developer.agent.md',
   'abap-runtime-debugger.agent.md',
+  'hana-cloud-hdi-specialist.agent.md',
   'rap-service-developer.agent.md',
   'sap-solution-architect.agent.md'
 ];
@@ -20,6 +21,9 @@ const expectedSkills = [
   'abap-testing-quality',
   'cds-development',
   'clean-core-extensibility',
+  'hana-cloud-inspection',
+  'hana-cloud-native-development',
+  'hana-cloud-validation',
   'rap-development',
   'rap-service-delivery',
   'sap-sdlc-orchestration',
@@ -49,6 +53,12 @@ function assertMentionsLiveToolDiscovery(markdown, path) {
   assert.match(markdown, /schema/i, `${path} must tell agents to follow live tool schemas`);
 }
 
+function assertDirectMcpUsage(markdown, path) {
+  assert.match(markdown, /Direct MCP invocation is mandatory/i, `${path} must require direct MCP calls`);
+  assert.match(markdown, /Do not launch `sap-ai-dev`.*MCP operations/i, `${path} must forbid terminal-driven MCP discovery/calls`);
+  assert.match(markdown, /host\/session binding issue/i, `${path} must report host tool-binding failures instead of using a CLI fallback`);
+}
+
 function assertValidationPolicy(markdown, path) {
   assert.match(markdown, /ABAP Unit|RunUnitTests/i, `${path} must include ABAP Unit or test execution guidance`);
   assert.match(markdown, /runtime validation|Self-validate|executable validation|reproduce/i, `${path} must require executable/runtime validation evidence`);
@@ -85,6 +95,15 @@ test('packaged Copilot agent and skill inventory is complete and canonical', asy
   }
 });
 
+test('all bundled agents invoke chat-attached MCP tools without terminal JSON-RPC fallbacks', async () => {
+  for (const name of expectedAgents) {
+    const path = join(agentsRoot, name);
+    const markdown = await readMarkdown(path);
+    assertDirectMcpUsage(markdown, path);
+    assertMentionsLiveToolDiscovery(markdown, path);
+  }
+});
+
 test('ABAP Developer agent has valid metadata and invokes the packaged skills', async () => {
   const markdown = await readMarkdown(agentPath);
   const metadata = parseFrontmatter(markdown, agentPath);
@@ -121,6 +140,7 @@ test('SAP Solution Architect agent has valid metadata and planning/handoff polic
   assert.match(markdown, /ABAP Developer/i);
   assert.match(markdown, /RAP Service Developer/i);
   assert.match(markdown, /ABAP Runtime Debugger/i);
+  assert.match(markdown, /HANA Cloud\/HDI Specialist/i);
   assert.match(markdown, /SDLC|lifecycle/i);
   assertPlanFirstPolicy(markdown, path);
   assertLocalFirstPolicy(markdown, path);
@@ -143,6 +163,27 @@ test('RAP Service Developer agent has valid metadata and plan-first local-first
   assertNoUnsafeTransportClaims(markdown, path);
 });
 
+test('HANA Cloud/HDI Specialist agent has a read-only target-bound workflow', async () => {
+  const path = join(agentsRoot, 'hana-cloud-hdi-specialist.agent.md');
+  const markdown = await readMarkdown(path);
+  const metadata = parseFrontmatter(markdown, path);
+  assert.deepEqual(Object.keys(metadata).sort(), ['description', 'name', 'target', 'user-invocable']);
+  assert.equal(metadata.name, 'HANA Cloud/HDI Specialist');
+  assert.equal(metadata.target, 'vscode');
+  assert.equal(metadata['user-invocable'], 'true');
+  assert.match(metadata.description, /HANA Cloud/i);
+  assertDirectMcpUsage(markdown, path);
+  assertMentionsLiveToolDiscovery(markdown, path);
+  for (const tool of ['hana_connection_info', 'hana_list_objects', 'hana_describe_object', 'hana_read_rows']) {
+    assert.match(markdown, new RegExp(tool));
+  }
+  assert.match(markdown, /read-only/i);
+  assert.match(markdown, /HANA_RO_\*/);
+  assert.match(markdown, /cds build --for hana/);
+  assert.match(markdown, /user-run deployment|deployment is performed by the user/i);
+  assert.match(markdown, /never execute HANA DDL\/DML|Never execute HANA DDL\/DML/i);
+});
+
 test('each skill has valid metadata, matching name, and enforceable live-tool validation policy', async () => {
   for (const skill of expectedSkills) {
     const path = join(skillsRoot, skill, 'SKILL.md');
@@ -184,3 +225,25 @@ test('debugging skill requires evidence before fixes and bounded debugger use',
   assert.match(markdown, /Avoid attaching to another user's session|do not.*another user's session/i);
   assert.match(markdown, /before changing code|before proposing a cause/i);
 });
+
+test('HANA skills describe the read-only tool surface and safe CAP/HDI generation', async () => {
+  const inspection = await readMarkdown(join(skillsRoot, 'hana-cloud-inspection', 'SKILL.md'));
+  for (const tool of ['hana_connection_info', 'hana_list_objects', 'hana_describe_object', 'hana_read_rows']) {
+    assert.match(inspection, new RegExp(tool));
+  }
+  assert.match(inspection, /200-row limit/);
+  assert.match(inspection, /Do not launch `sap-ai-dev` or `sap-ai-hana` for MCP operations/);
+  assert.match(inspection, /schema-bound/);
+  assert.match(inspection, /credential-like columns/);
+
+  const development = await readMarkdown(join(skillsRoot, 'hana-cloud-native-development', 'SKILL.md'));
+  assert.match(development, /cds build --for hana/);
+  assert.match(development, /CAP-owned database models/);
+  assert.match(development, /Never execute `cds deploy` against HANA/);
+  assert.match(development, /HANA DDL\/DML/);
+
+  const validation = await readMarkdown(join(skillsRoot, 'hana-cloud-validation', 'SKILL.md'));
+  assert.match(validation, /deployment handoff/);
+  assert.match(validation, /HANA tools are metadata and bounded read-only inspection only/);
+  assert.match(validation, /Never claim HANA activation\/deployment/);
+});

package/test/credentials-store.test.mjs

@@ -7,6 +7,7 @@ import http from 'node:http';
 import { request as httpRequest } from 'node:http';
 import { createBasDestinationRelay } from '../src/bas-destination-relay.mjs';
 import { readCredentials, removeDestinationCredentials, resolveCredentialsPath, storeDestinationCredentials } from '../src/credentials-store.mjs';
+import { canPromptForCredentials, credentialKeyForDestination, credentialModeForDestination } from '../src/credential-overrides.mjs';
 
 const UNSAFE_METHODS = ['POST', 'PUT', 'PATCH', 'DELETE'];
 
@@ -105,6 +106,36 @@ test('credentials file with malformed entries keeps only complete records', asyn
   assert.deepEqual(Object.keys(stored.destinations), ['GOOD']);
 });
 
+test('credential overrides use route-aware modes and distinct CF destination keys', async t => {
+  const directory = await mkdtemp(join(tmpdir(), 'bas-creds-modes-'));
+  const path = join(directory, 'sap-ai-dev-toolkit-credentials.json');
+  t.after(async () => { await rm(directory, { recursive: true, force: true }); });
+
+  const basDestination = { name: 'shared-name', source: 'bas', proxyType: 'Internet', authentication: 'BasicAuthentication', backendUrl: 'https://internet.example' };
+  const basOnPremise = { name: 'shared-name', source: 'bas', proxyType: 'OnPremise', authentication: 'BasicAuthentication' };
+  const cfOnPremise = { name: 'shared-name', serverName: 'cf:space-one:instance-one:shared-name', source: 'cloud-foundry', proxyType: 'OnPremise', authentication: 'BasicAuthentication' };
+  const principalPropagation = { ...cfOnPremise, authentication: 'PrincipalPropagation' };
+
+  assert.equal(canPromptForCredentials(basDestination), true);
+  assert.equal(credentialModeForDestination(basDestination), 'direct');
+  assert.equal(credentialModeForDestination(basOnPremise), 'bas-tunnel');
+  assert.equal(credentialModeForDestination(cfOnPremise), 'cf-connectivity');
+  assert.equal(canPromptForCredentials(principalPropagation), false);
+  assert.equal(credentialModeForDestination({ ...cfOnPremise, proxyType: 'Internet' }), null);
+  assert.equal(canPromptForCredentials({ ...basDestination, backendUrl: null }), false);
+  assert.notEqual(credentialKeyForDestination(basOnPremise), credentialKeyForDestination(cfOnPremise));
+
+  const cfKey = credentialKeyForDestination(cfOnPremise);
+  await storeDestinationCredentials(path, cfKey, { user: 'OVERRIDE', password: 'secret', mode: 'cf-connectivity' });
+  const stored = await readCredentials(path);
+  assert.equal(stored.destinations[cfKey].mode, 'cf-connectivity');
+  assert.equal(stored.destinations[cfKey].host, undefined);
+  await assert.rejects(
+    () => storeDestinationCredentials(path, 'INVALID', { user: 'U', password: 'P', mode: 'bypass-cloud-connector' }),
+    /route mode is unsupported/
+  );
+});
+
 test('relay direct connect sends Basic auth and CSRF pairing succeeds', async t => {
   const { state, server } = authedBackend();
   await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));