sap-ai-dev-toolkit 0.7.5 → 0.7.9

package/src/install-user-assets.mjs

@@ -69,17 +69,43 @@ async function planDestinations(harness, files) {
   for (const file of files) {
     const raw = await readFile(file.source);
     if (!file.target.startsWith(`agents${sep}`)) {
-      destinations.push({ target: file.target, content: raw });
+      destinations.push({ target: file.target, content: raw, aliases: [] });
       continue;
     }
     if (!harness.supportsAgents) continue;
-    const fileName = harness.agentFileName ? harness.agentFileName(basename(file.target)) : basename(file.target);
+    const sourceName = basename(file.target);
+    const fileName = harness.agentFileName ? harness.agentFileName(sourceName) : sourceName;
+    const prefix = harness.agentTargetPrefix || 'agents';
+    const target = join(prefix, fileName);
+    const aliasCandidates = [
+      file.target,
+      join(prefix, sourceName),
+      join('agents', fileName)
+    ];
+    const aliases = [...new Set(aliasCandidates.filter(alias => alias !== target))];
     const content = harness.agentDocument ? Buffer.from(harness.agentDocument(raw.toString('utf8')), 'utf8') : raw;
-    destinations.push({ target: join('agents', fileName), content });
+    destinations.push({ target, content, aliases });
   }
   return destinations;
 }
 
+async function reconcileRemovableFile({ targetRoot, target, contentHash, previousFiles }) {
+  const path = join(targetRoot, target);
+  let existing;
+  try {
+    existing = await readFile(path);
+  } catch (error) {
+    if (error.code === 'ENOENT') return 'missing';
+    throw error;
+  }
+  const existingHash = digest(existing);
+  if (previousFiles[target] === existingHash || existingHash === contentHash) {
+    await rm(path, { force: true });
+    return 'removed';
+  }
+  return 'conflict';
+}
+
 export async function installUserAssets({ harness, home = process.env.HOME || homedir(), root = packageRoot, env = process.env } = {}) {
   const destinations = await planDestinations(harness, await collectSourceFiles(root));
   const targetRoot = harnessRoot(harness, { home, env });
@@ -89,15 +115,22 @@ export async function installUserAssets({ harness, home = process.env.HOME || ho
   const legacyFiles = harness.legacyManifest ? await readManagedFiles(legacyManifestPath) : {};
   const currentFiles = await readManagedFiles(manifestPath);
   const previousFiles = { ...legacyFiles, ...currentFiles };
-  const managedFiles = { ...previousFiles };
+  const managedFiles = {};
+  const activeTargets = new Set(destinations.flatMap(file => [file.target, ...file.aliases]));
   const conflicts = [];
   let installed = 0;
   let updated = 0;
   let unchanged = 0;
+  let removed = 0;
 
   for (const file of destinations) {
     const destination = join(targetRoot, file.target);
     const contentHash = digest(file.content);
+    for (const alias of file.aliases) {
+      const status = await reconcileRemovableFile({ targetRoot, target: alias, contentHash, previousFiles });
+      if (status === 'removed') removed += 1;
+      if (status === 'conflict') conflicts.push(alias);
+    }
     await mkdir(dirname(destination), { recursive: true, mode: 0o755 });
 
     let existing;
@@ -129,9 +162,16 @@ export async function installUserAssets({ harness, home = process.env.HOME || ho
     }
   }
 
+  for (const target of Object.keys(previousFiles)) {
+    if (activeTargets.has(target) || managedFiles[target]) continue;
+    const status = await reconcileRemovableFile({ targetRoot, target, contentHash: '', previousFiles });
+    if (status === 'removed') removed += 1;
+    if (status === 'conflict') conflicts.push(target);
+  }
+
   await replaceFile(manifestPath, `${JSON.stringify({ version: 1, files: managedFiles }, null, 2)}\n`);
   if (harness.legacyManifest) await rm(legacyManifestPath, { force: true });
-  return { harness: harness.id, label: harness.label, root: targetRoot, installed, updated, unchanged, conflicts };
+  return { harness: harness.id, label: harness.label, root: targetRoot, installed, updated, unchanged, removed, conflicts };
 }
 
 export async function installUserAssetsForHarnesses(ids, { home, root = packageRoot, env = process.env } = {}) {

package/src/launcher.mjs

@@ -4,11 +4,13 @@ import { readFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { discoverDestinations, remediation, slugifyDestination, statusRows } from './bas-discovery.mjs';
+import { discoverSapGuiSystems } from './local-sap-gui.mjs';
 import { findBinary } from './binary.mjs';
 import { MCPProxy } from './mcp-proxy.mjs';
 import { installMcpConfig, repairManagedMcpConfig } from './mcp-config.mjs';
 import { runSetup } from './setup.mjs';
 import { resolveConfiguredCloudFoundryDestination } from './cf-destination.mjs';
+import { createWindowsSsoAdtProxy } from './windows-sso-adt-proxy.mjs';
 import { withBrandedEnvironment } from './branding.mjs';
 import { redactText } from './redact.mjs';
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
@@ -25,7 +27,7 @@ function usage() {
   return [
     'Usage: sap-ai-dev [options]',
     '',
-    'With H2O_URL set and no command, starts the SAP AI Dev Toolkit stdio server for selected BAS destinations.',
+    'With H2O_URL set, starts the SAP AI Dev Toolkit stdio server for selected BAS destinations; with local SAP GUI setup, starts the selected local ADT system.',
     'Options:',
     '  --setup                  Configure generated BAS MCP servers',
     '  --tools                  Also offer full-stack SAP companion MCP servers (use with --setup)',
@@ -161,9 +163,46 @@ async function binaryOrError() {
 async function discoverForCommand() {
   const env = { ...runtimeEnv };
   if (env.SAP_AI_DEV_TOOLKIT_DESTINATION_SOURCE === 'cloud-foundry') env.SAP_AI_DEV_TOOLKIT_DESTINATION = '';
+  if (!env.H2O_URL) {
+    const systems = await discoverSapGuiSystems({ env });
+    if (!systems.length) throw new Error('H2O_URL is required for BAS destination discovery');
+    return systems;
+  }
   return discoverDestinations({ env });
 }
 
+async function configuredLocalSapGuiDestination(env) {
+  const name = env.SAP_AI_DEV_TOOLKIT_DESTINATION || env.SAP_SYSTEM_ID || 'local-sap';
+  if (!env.SAP_URL) throw new Error('SAP_URL is required for local SAP GUI MCP entries. Rerun sap-ai-dev --setup and enter the ADT URL.');
+  const authMode = String(env.SAP_AUTH_MODE || '').toLowerCase();
+  if (authMode === 'windows-sso') {
+    const route = await createWindowsSsoAdtProxy({ destinationUrl: env.SAP_URL, env });
+    return {
+      source: 'sap-gui-local',
+      name,
+      url: route.url,
+      backendUrl: env.SAP_URL,
+      client: env.SAP_CLIENT || '001',
+      authentication: 'WindowsSSO',
+      childEnv: {},
+      close: route.close,
+      probe: { status: 'configured', available: true }
+    };
+  }
+  return {
+    source: 'sap-gui-local',
+    name,
+    url: env.SAP_URL,
+    client: env.SAP_CLIENT || '001',
+    authentication: 'Basic',
+    childEnv: {
+      SAP_USER: env.SAP_USER || env.SAP_USERNAME || '',
+      SAP_PASSWORD: env.SAP_PASSWORD || env.SAP_PASS || ''
+    },
+    probe: { status: 'configured', available: true }
+  };
+}
+
 async function main() {
   const setup = hasFlag('--setup');
   const check = hasFlag('--check');
@@ -184,7 +223,9 @@ async function main() {
     try {
       const destinations = runtimeEnv.SAP_AI_DEV_TOOLKIT_DESTINATION_SOURCE === 'cloud-foundry'
         ? [await resolveConfiguredCloudFoundryDestination({ env: runtimeEnv })]
-        : await discoverForCommand();
+        : (runtimeEnv.SAP_AI_DEV_TOOLKIT_DESTINATION_SOURCE === 'sap-gui-local'
+          ? [await configuredLocalSapGuiDestination(runtimeEnv)]
+          : await discoverForCommand());
       report = await runDoctor(destinations);
     } catch (error) {
       report = { ok: false, destinations: 0, checks: [doctorRow('-', 'destination discovery', 'failed', redactText(error.message || error).slice(0, 300))] };
@@ -219,8 +260,10 @@ async function main() {
     return;
   }
 
-  if (runtimeEnv.SAP_AI_DEV_TOOLKIT_DESTINATION_SOURCE === 'cloud-foundry') {
-    const destination = await resolveConfiguredCloudFoundryDestination({ env: runtimeEnv });
+  if (['cloud-foundry', 'sap-gui-local'].includes(runtimeEnv.SAP_AI_DEV_TOOLKIT_DESTINATION_SOURCE)) {
+    const destination = runtimeEnv.SAP_AI_DEV_TOOLKIT_DESTINATION_SOURCE === 'cloud-foundry'
+      ? await resolveConfiguredCloudFoundryDestination({ env: runtimeEnv })
+      : await configuredLocalSapGuiDestination(runtimeEnv);
     let proxy;
     try {
       const binary = await binaryOrError();

package/src/local-sap-gui.mjs

@@ -0,0 +1,217 @@
+import { platform, homedir } from 'node:os';
+import { join } from 'node:path';
+import { readdir, readFile, stat } from 'node:fs/promises';
+
+function text(value) { return value == null ? '' : String(value).trim(); }
+function decodeXml(value) {
+  return text(value)
+    .replace(/"/g, '"')
+    .replace(/'/g, "'")
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&');
+}
+
+async function exists(path) {
+  try { await stat(path); return true; }
+  catch (error) { if (error?.code === 'ENOENT') return false; throw error; }
+}
+
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+export function sapGuiLandscapeCandidates(env = process.env) {
+  const home = env.HOME || env.USERPROFILE || homedir();
+  const appData = env.APPDATA || (env.USERPROFILE ? join(env.USERPROFILE, 'AppData', 'Roaming') : '');
+  const candidates = [];
+  if (platform() === 'win32' || appData) {
+    candidates.push(
+      join(appData || '', 'SAP', 'Common', 'SAPUILandscape.xml'),
+      join(appData || '', 'SAP', 'Common', 'SAPUILandscapeGlobal.xml'),
+      join(appData || '', 'SAP', 'Common', 'saplogon.ini')
+    );
+  }
+  candidates.push(
+    join(home, 'Library', 'Preferences', 'SAP', 'SAPGUILandscape.xml'),
+    join(home, 'Library', 'Preferences', 'SAP', 'SAPUILandscape.xml'),
+    join(home, 'Library', 'Preferences', 'SAP', 'connections'),
+    join(home, '.SAPGUI', 'SAPGUILandscape.xml')
+  );
+  return unique(candidates);
+}
+
+function attributes(fragment) {
+  const result = {};
+  for (const match of fragment.matchAll(/([A-Za-z_:][\w:.-]*)\s*=\s*"([^"]*)"|([A-Za-z_:][\w:.-]*)\s*=\s*'([^']*)'/g)) {
+    result[String(match[1] || match[3]).toLowerCase()] = decodeXml(match[2] ?? match[4]);
+  }
+  return result;
+}
+
+function ssoHintFrom(record) {
+  const ssoKeys = ['sncname', 'sncpartnername', 'sncmode', 'snc_mode', 'sncqop', 'snc_qop', 'use_sso', 'sso'];
+  if (ssoKeys.some(key => {
+    const value = text(record[key]);
+    return value && !['0', 'false', 'no', 'off'].includes(value.toLowerCase());
+  })) return true;
+  const values = [record.authentication, record.auth].map(text).filter(Boolean);
+  return values.some(value => /snc|sso|kerberos|spnego|secure\s*login/i.test(value) || ['1', 'true', 'yes'].includes(value.toLowerCase()));
+}
+
+function instanceFrom(value) {
+  const candidates = [value?.instance, value?.instancenumber, value?.instanceNumber, value?.sysnr, value?.systemnumber];
+  for (const candidate of candidates) {
+    const match = text(candidate).match(/^\d{2}$/);
+    if (match) return match[0];
+  }
+  return '';
+}
+
+function normalizeRecord(record, sourcePath) {
+  const type = text(record.type || record.kind).toLowerCase();
+  if (type && !['sapgui', 'r/3', 'sap'].some(token => type.includes(token))) return null;
+  const name = text(record.name || record.description || record.desc || record.systemid || record.sid || record.uuid);
+  const address = text(record.server || record.host || record.applicationserver || record.messageserver || record.mshost);
+  // SAP GUI ports are DIAG dispatcher ports, not HTTP ports.
+  const endpoint = address.match(/^(\[[^\]]+\]|[^:/]+):(\d+)$/);
+  const host = endpoint ? endpoint[1] : address;
+  const systemId = text(record.systemid || record.sid || record.r3name).toUpperCase();
+  if (!name || !host) return null;
+  const port = endpoint ? Number(endpoint[2]) : 0;
+  const instance = instanceFrom(record) || (port >= 3200 && port <= 3299 ? String(port - 3200).padStart(2, '0') : '');
+  const client = text(record.client || record.sapclient) || '001';
+  return {
+    source: 'sap-gui-local',
+    name,
+    serverName: name,
+    host,
+    systemId,
+    instance,
+    client,
+    authentication: ssoHintFrom(record) ? 'Basic/SSO hint' : 'Basic',
+    authMode: 'basic',
+    ssoHint: ssoHintFrom(record),
+    proxyType: 'Internet',
+    landscapePath: sourcePath,
+    probe: { status: 'needs-adt-url' }
+  };
+}
+
+function parseLandscapeXml(content, sourcePath) {
+  const records = [];
+  // Comments must not turn deleted entries into selectable systems.
+  content = content.replace(/<!--[\s\S]*?-->/g, '');
+  const messageServers = new Map();
+  for (const match of content.matchAll(/<Messageserver\b([^>]*)>/gi)) {
+    const record = attributes(match[1]);
+    if (record.uuid) messageServers.set(record.uuid, record);
+  }
+  for (const match of content.matchAll(/<Service\b([^>]*)\/?>(?:\s*<\/Service>)?/gi)) {
+    const record = attributes(match[1]);
+    if (record.msid) {
+      const messageServer = messageServers.get(record.msid);
+      // For load-balanced entries `server` is a logon group, not a host.
+      if (!messageServer?.host) continue;
+      record.server = messageServer.host;
+    }
+    const normalized = normalizeRecord(record, sourcePath);
+    if (normalized) records.push(normalized);
+  }
+  // SAP GUI for Java files may use generic Item/Connection elements.
+  for (const match of content.matchAll(/<(?:Item|Connection)\b([^>]*)\/?>(?:\s*<\/(?:Item|Connection)>)?/gi)) {
+    const normalized = normalizeRecord(attributes(match[1]), sourcePath);
+    if (normalized) records.push(normalized);
+  }
+  return records;
+}
+
+function parseSapLogonIni(content, sourcePath) {
+  const sections = new Map();
+  let section = '';
+  for (const line of content.split(/\r?\n/)) {
+    const header = line.match(/^\s*\[(.+)]\s*$/);
+    if (header) { section = header[1].toLowerCase(); if (!sections.has(section)) sections.set(section, {}); continue; }
+    const entry = line.match(/^\s*([^=]+?)\s*=\s*(.*?)\s*$/);
+    if (entry && section) sections.get(section)[entry[1].toLowerCase()] = entry[2];
+  }
+  const descriptions = sections.get('description') || sections.get('descriptions') || {};
+  const servers = sections.get('server') || sections.get('servers') || {};
+  const systems = sections.get('system') || sections.get('systems') || {};
+  const databases = sections.get('database') || sections.get('databases') || {};
+  const clients = sections.get('client') || sections.get('clients') || {};
+  const instances = sections.get('systemnumber') || {};
+  const sncNames = sections.get('sncname') || {};
+  const sncModes = sections.get('snc') || sections.get('sncmode') || {};
+  const keys = unique([...Object.keys(descriptions), ...Object.keys(servers)]);
+  return keys.map(key => normalizeRecord({
+    name: descriptions[key] || systems[key] || key,
+    server: servers[key],
+    systemid: databases[key] || systems[key],
+    client: clients[key],
+    systemnumber: instances[key],
+    sncname: sncNames[key],
+    sncmode: sncModes[key]
+  }, sourcePath)).filter(Boolean);
+}
+
+async function readGuiFile(path) {
+  const bytes = await readFile(path);
+  if (bytes[0] === 0xff && bytes[1] === 0xfe) return bytes.subarray(2).toString('utf16le');
+  if (bytes[0] === 0xfe && bytes[1] === 0xff) return bytes.subarray(2).swap16().toString('utf16le');
+  return bytes.toString('utf8').replace(/^\uFEFF/, '');
+}
+
+async function parseConnectionsFile(path) {
+  const content = await readGuiFile(path);
+  if (content.includes('<')) return parseLandscapeXml(content, path);
+  return content.split(/\r?\n/).map((line, index) => {
+    const parts = line.split(/[;,\t]/).map(text).filter(Boolean);
+    if (parts.length < 2) return null;
+    return normalizeRecord({ name: parts[0] || `SAP GUI ${index + 1}`, server: parts.find(part => /[A-Za-z]/.test(part) && part.includes('.')) || parts[1], systemid: parts.find(part => /^[A-Za-z0-9]{3}$/.test(part)) }, path);
+  }).filter(Boolean);
+}
+
+export async function discoverSapGuiSystems({ env = process.env, paths = sapGuiLandscapeCandidates(env) } = {}) {
+  const systems = [];
+  for (const path of unique(paths)) {
+    if (!path) continue;
+    try {
+      if (!await exists(path)) continue;
+      const info = await stat(path);
+      if (info.isDirectory()) {
+        for (const name of await readdir(path)) {
+          const child = join(path, name);
+          try {
+            if ((await stat(child)).isFile()) systems.push(...await parseConnectionsFile(child));
+          } catch {
+            // One unreadable child must not hide the rest of the directory.
+          }
+        }
+      } else if (/saplogon\.ini$/i.test(path)) {
+        systems.push(...parseSapLogonIni(await readGuiFile(path), path));
+      } else {
+        systems.push(...await parseConnectionsFile(path));
+      }
+    } catch {
+      // Ignore unreadable or unfamiliar SAP GUI files; discovery is best-effort.
+    }
+  }
+  const seen = new Set();
+  return systems.filter(system => {
+    const key = `${system.name}\0${system.host}\0${system.systemId}\0${system.instance}\0${system.client}`.toLowerCase();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function defaultAdtUrl(system) {
+  const host = text(system.host);
+  const instance = text(system.instance);
+  if (!host) return '';
+  // Router strings and other DIAG routes cannot be used as HTTP hosts.
+  if (/[\s/@?#]/.test(host)) return '';
+  const authority = host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;
+  return /^\d{2}$/.test(instance) ? `https://${authority}:443${instance}` : `https://${authority}`;
+}

package/src/mcp-config.mjs

@@ -1,7 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { constants } from 'node:fs';
 import { access, mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
+import { homedir, platform } from 'node:os';
 import { basename, delimiter, dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { brandedEnvValue } from './branding.mjs';
@@ -103,11 +103,22 @@ export async function resolveMcpConfigPath(env = process.env) {
     .find(value => typeof value === 'string' && value.length > 0);
   if (configuredPath) return configuredPath;
   const home = env.HOME || homedir();
-  const candidates = [
+  const appData = env.APPDATA || (env.USERPROFILE ? join(env.USERPROFILE, 'AppData', 'Roaming') : '');
+  const localVsCodeCandidates = [
+    ...(appData ? [join(appData, 'Code', 'User', 'mcp.json'), join(appData, 'Code - Insiders', 'User', 'mcp.json')] : []),
+    ...(platform() === 'darwin' ? [
+      join(home, 'Library', 'Application Support', 'Code', 'User', 'mcp.json'),
+      join(home, 'Library', 'Application Support', 'Code - Insiders', 'User', 'mcp.json')
+    ] : []),
+    join(home, '.config', 'Code', 'User', 'mcp.json'),
+    join(home, '.config', 'Code - Insiders', 'User', 'mcp.json')
+  ];
+  const basCandidates = [
     join(home, '.vscode', 'data', 'User', 'mcp.json'),
     join(home, '.vscode-server', 'data', 'User', 'mcp.json'),
     join(home, '.code-server', 'data', 'User', 'mcp.json')
   ];
+  const candidates = env.H2O_URL ? [...basCandidates, ...localVsCodeCandidates] : [...localVsCodeCandidates, ...basCandidates];
   for (const candidate of candidates) if (await exists(candidate)) return candidate;
   return candidates[0];
 }
@@ -141,15 +152,17 @@ export function buildSapDevelopmentMcpEntries(serverIds = SAP_DEVELOPMENT_MCP_SE
 
 export function buildMcpEntries(destinations, env = process.env) {
   const h2oUrl = env.H2O_URL;
-  if (!h2oUrl) throw new Error('H2O_URL is required to write SAP AI Dev Toolkit configuration');
+  const hasNonLocal = destinations.some(destination => destination?.source !== 'sap-gui-local');
+  if (destinations.length && hasNonLocal && !h2oUrl) throw new Error('H2O_URL is required to write SAP AI Dev Toolkit configuration');
   const entries = Object.create(null);
   const selected = [...destinations].sort((a, b) => String(a.serverName || a.name).localeCompare(String(b.serverName || b.name)));
   for (const destination of selected) {
     const isCf = destination.source === 'cloud-foundry';
+    const isLocalSapGui = destination.source === 'sap-gui-local';
     const name = generatedServerName(isCf ? destination.serverName : destination.name);
     if (Object.hasOwn(entries, name)) throw new Error(`Duplicate MCP destination server name: ${name} (two destination names normalize to the same lowercase server name)`);
     const entryEnv = {
-      H2O_URL: String(h2oUrl),
+      ...(h2oUrl ? { H2O_URL: String(h2oUrl) } : {}),
       SAP_ALLOW_TRANSPORTABLE_EDITS: 'true'
     };
     if (isCf) {
@@ -171,6 +184,16 @@ export function buildMcpEntries(destinations, env = process.env) {
           BAS_CF_CONNECTIVITY_KEY: String(cf.connectivityKeyName)
         });
       }
+    } else if (isLocalSapGui) {
+      if (!destination.url) throw new Error(`Local SAP GUI destination "${destination.name}" is missing an ADT URL`);
+      Object.assign(entryEnv, {
+        SAP_AI_DEV_TOOLKIT_DESTINATION_SOURCE: 'sap-gui-local',
+        SAP_AI_DEV_TOOLKIT_DESTINATION: String(destination.name),
+        SAP_URL: String(destination.url),
+        SAP_CLIENT: String(destination.client || '001'),
+        ...(destination.systemId ? { SAP_SYSTEM_ID: String(destination.systemId) } : {}),
+        ...(destination.childEnv || {})
+      });
     } else {
       entryEnv.SAP_AI_DEV_TOOLKIT_DESTINATION = String(destination.name);
     }
@@ -316,6 +339,12 @@ export async function installMcpConfig(destinationsOrOptions, options = {}) {
     ...buildMcpEntries(destinations, env),
     ...buildSapDevelopmentMcpEntries(options.sapDevelopmentServers || [], { packageVersions: companionVersions })
   };
+  const generatedInputs = new Map();
+  for (const destination of destinations) {
+    for (const input of Array.isArray(destination?.inputs) ? destination.inputs : []) {
+      if (input?.id) generatedInputs.set(input.id, input);
+    }
+  }
   const launcherCommand = options.command || (destinations.length ? await resolveMcpServerCommand(env) : null);
   if (launcherCommand) {
     for (const entry of Object.values(generated)) {
@@ -325,12 +354,19 @@ export async function installMcpConfig(destinationsOrOptions, options = {}) {
     }
   }
   const servers = Object.create(null);
+  const managedInputIds = new Set();
   for (const [name, entry] of Object.entries(config.servers)) {
     const managed = isPackageLauncher(entry)
       && typeof destinationValue(entry?.env) === 'string'
       && (destinationSource(entry.env) === 'cloud-foundry'
         ? typeof entry.env.BAS_CF_DESTINATION_KEY === 'string'
-        : destinationSource(entry.env) === undefined);
+        : (destinationSource(entry.env) === undefined || destinationSource(entry.env) === 'sap-gui-local'));
+    if (managed && destinationSource(entry.env) === 'sap-gui-local') {
+      for (const value of Object.values(entry.env || {})) {
+        const match = typeof value === 'string' ? value.match(/^\$\{input:([^}]+)}$/) : null;
+        if (match) managedInputIds.add(match[1]);
+      }
+    }
     if (!LEGACY_MCP_SERVER_PREFIXES.some(prefix => name.startsWith(prefix)) && !managed && !isCompanionServer(entry)) servers[name] = entry;
   }
   for (const name of Object.keys(generated)) {
@@ -339,6 +375,10 @@ export async function installMcpConfig(destinationsOrOptions, options = {}) {
     }
   }
   config.servers = { ...servers, ...generated };
+  if (generatedInputs.size || managedInputIds.size) {
+    const existingInputs = Array.isArray(config.inputs) ? config.inputs.filter(input => !generatedInputs.has(input?.id) && !managedInputIds.has(input?.id)) : [];
+    config.inputs = [...existingInputs, ...generatedInputs.values()];
+  }
   await writeConfig(path, config);
   return { path, servers: generated };
 }

package/src/mcp-proxy.mjs

@@ -168,6 +168,7 @@ function closeDestinationRoute(destination) {
 
 
 function useProxyAuthentication(destination) {
+  if (destination.source === 'sap-gui-local') return destination.authentication === 'WindowsSSO';
   return destination.source !== 'cloud-foundry' || destination.authentication === 'PrincipalPropagation';
 }