sap-ai-dev-toolkit 0.8.4 → 0.8.5

package/README.md

@@ -290,7 +290,7 @@ Supported discovery and runtime behavior:
 - **Client selection:** SAP GUI entries may contain one default client but cannot reliably list every ABAP client available through ADT. Setup asks for one or more 3-digit clients per selected system; enter comma-separated values such as `100,200` to create separate MCP servers for each client.
 - **ADT endpoint derivation:** SAP GUI entries usually contain DIAG/router information, not the HTTP(S) ADT endpoint. Setup derives the common ADT port from the SAP instance when possible, for example instance `00` → `https://host:44300`, and asks for confirmation only when configuring the selected entry.
 - **Credential handling:** username/password local entries use VS Code MCP input prompts (`${input:...}`) at server start. Plain SAP credentials are not written to `mcp.json`.
-- **Windows SSO / smart-card Windows logon:** local Windows entries can use `SAP_AUTH_MODE=windows-sso` instead of username/password prompts when the ABAP ADT endpoint supports HTTP Negotiate/SPNEGO. The runtime starts a loopback ADT proxy and uses the bundled Windows SSPI helper with the current Windows logon session, including smart-card-backed Windows logon. The toolkit does not prompt for, store, or accept manually pasted bearer/SAML tokens. Use `SAP_AI_DEV_TOOLKIT_NEGOTIATE_HELPER` only to point to a trusted custom SSPI/Negotiate helper. NTLM fallback is rejected.
+- **Login methods:** local entries can use password, browser SAML/web SSO, SAML username/password, silent Windows Negotiate/SPNEGO, Windows Negotiate/SPNEGO with native Windows credential UI/smartcard PIN, or Windows SSO with password fallback. Browser/SAML modes are passed to the VSP runtime through `SAP_BROWSER_AUTH` / `SAP_SAML_AUTH`. Windows credential UI mode runs the bundled SSPI helper interactively so Windows can display its native credential/smartcard prompt when the desktop session allows it. NTLM fallback is rejected.
 - **IP-address HTTPS self-healing:** if the confirmed ADT URL is `https://<ip>:<port>` and the certificate is issued to DNS names, setup reads the certificate DNS SANs automatically and stores them as `SAP_TLS_SERVER_NAMES`. At runtime a loopback proxy dials the IP address but verifies TLS against those discovered DNS names, trying them one by one. Certificate verification stays enabled; there is no `--insecure` mode.
 - **Private CAs:** if the SAP HTTPS certificate chains to an internal CA that is not trusted by the local Node runtime, set `SAP_TLS_CA_FILE` or `SAP_AI_DEV_TOOLKIT_TLS_CA_FILE` to a PEM CA bundle. This adds trust roots for the self-healing proxy without disabling certificate validation.
 - **Redirect and request safety:** local loopback proxies reject cross-origin forward-form requests and rewrite same-origin SAP redirects back through the loopback listener, so VSP stays on the safe route.
@@ -782,10 +782,14 @@ The response contains a `tools` array. A `RunQuery` entry resembles this excerpt
 | `SAP_AI_DEV_TOOLKIT_DESTINATION` | Comma-separated destination allowlist for normal runtime discovery. Setup clears this temporarily so it can display all eligible systems. |
 | `SAP_AI_DEV_TOOLKIT_MODE` | VSP child mode (`expert` by default; `focused` omits `ActivateMultiple`, `GetUserTransports`, and `GetTransportInfo`). The proxy exposes its curated tool subset and local workflow tools, including `LintABAP`. |
 | `SAP_ALLOW_TRANSPORTABLE_EDITS` | Generated MCP entries set this to `true` to permit source edits in transportable packages; VSP safety checks and SAP authorizations still apply. |
-| `SAP_AUTH_MODE=windows-sso` | Local SAP GUI entry mode for experimental Windows Integrated Authentication over HTTP Negotiate/SPNEGO. Runtime starts a loopback ADT proxy, uses the current Windows logon session (including smart-card-backed Windows logon), and does not pass SAP username/password credentials or manual bearer/SAML tokens to VSP. |
+| `SAP_AUTH_MODE=windows-sso` | Local SAP GUI entry mode for experimental Windows Integrated Authentication over HTTP Negotiate/SPNEGO. Runtime starts a loopback ADT proxy. With `SAP_AI_DEV_TOOLKIT_WINDOWS_CREDENTIAL_UI=true`, the bundled helper is allowed to run interactively so Windows can show its native credential/smartcard PIN UI. |
 | `SAP_TLS_SERVER_NAMES` / `SAP_AI_DEV_TOOLKIT_TLS_SERVER_NAMES` | Comma-separated local SAP GUI TLS self-healing names, normally auto-discovered during setup from the SAP HTTPS certificate when `SAP_URL` uses an IP address. Runtime tries them one by one while keeping certificate validation enabled. |
 | `SAP_TLS_SERVER_NAME` / `SAP_AI_DEV_TOOLKIT_TLS_SERVER_NAME` | Single-name compatibility form of the local SAP GUI TLS self-healing override. Prefer the auto-discovered plural variable written by setup. |
 | `SAP_TLS_CA_FILE` / `SAP_AI_DEV_TOOLKIT_TLS_CA_FILE` | Optional PEM CA bundle for the local TLS self-healing proxy when the SAP HTTPS certificate chains to a private CA that is not in the OS/Node trust store. Certificate verification remains enabled. |
+| `SAP_AUTH_MODE=browser-saml` with `SAP_BROWSER_AUTH=true` / `SAP_SAML_AUTH=true` | Local browser SAML / web SSO mode. The generated entry delegates browser login handling to the VSP runtime instead of storing SAP credentials. |
+| `SAP_AUTH_MODE=saml-password` with `SAP_SAML_AUTH=true` | Local SAML username/password mode. Generated entries use MCP input prompts for `SAP_SAML_USER` and `SAP_SAML_PASSWORD`; raw credentials are not written to `mcp.json`. |
+| `SAP_AI_DEV_TOOLKIT_WINDOWS_CREDENTIAL_UI=true` / `SAP_WINDOWS_CREDENTIAL_UI=true` | Allows the bundled Windows SSPI helper to run without PowerShell `-NonInteractive`, enabling native Windows credential UI / smartcard PIN prompts when Windows and the MCP host desktop session permit them. |
+| `SAP_AUTH_FALLBACK_MODE=basic` / `SAP_AI_DEV_TOOLKIT_AUTH_FALLBACK_MODE=basic` | Enables Windows SSO self-healing fallback for local SAP GUI entries. If Negotiate/SPNEGO is unavailable or the SSPI helper cannot acquire a token, the loopback proxy retries with Basic auth using `SAP_USER`/`SAP_PASSWORD` from the MCP input prompts. |
 | `SAP_AI_DEV_TOOLKIT_NEGOTIATE_HELPER` / `SAP_AI_DEV_TOOLKIT_SSPI_HELPER` | Optional trusted Windows helper executable used by the local Windows SSO proxy to answer an HTTP `WWW-Authenticate: Negotiate` challenge with the current Windows SSPI/Kerberos/SPNEGO credentials. It is not a prompt for a user-entered token; the helper must obtain credentials from Windows. NTLM fallback is rejected because it is connection-oriented and unsafe for this proxy shape. When unset on Windows, the bundled PowerShell SSPI helper is used. A custom helper receives one JSON line on stdin (`url`, `challenge`, `mechanism`) and prints the base64 Negotiate response on stdout. |
 | `SAP_AI_DEV_TOOLKIT_HTTP_PROXY` | Egress proxy for BAS discovery and probe traffic. Takes precedence over `HTTP_PROXY`/`http_proxy`; unset means the default BAS proxy for `.dest` hosts, empty means direct. |
 | `SAP_AI_DEV_TOOLKIT_REQUEST_TIMEOUT_MS` | Per-request timeout for calls forwarded to a VSP child (default 600000 = 10 minutes; `0` disables). A stalled request fails with a timeout error; the child is left running. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sap-ai-dev-toolkit",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "SAP AI development toolkit for BAS, ABAP, RAP, CAP, HANA Cloud, Fiori, UI5, and MCP",
   "author": "Gurkan Yilmaz",
   "type": "module",

package/src/launcher.mjs

@@ -202,6 +202,22 @@ async function configuredLocalSapGuiDestination(env) {
       probe: { status: tlsRoute ? 'configured-tls-server-name' : 'configured', available: true }
     };
   }
+  const childEnv = (() => {
+    if (authMode === 'browser-saml') {
+      return { SAP_BROWSER_AUTH: 'true', SAP_SAML_AUTH: 'true' };
+    }
+    if (authMode === 'saml-password') {
+      return {
+        SAP_SAML_AUTH: 'true',
+        SAP_SAML_USER: env.SAP_SAML_USER || env.SAP_USER || env.SAP_USERNAME || '',
+        SAP_SAML_PASSWORD: env.SAP_SAML_PASSWORD || env.SAP_PASSWORD || env.SAP_PASS || ''
+      };
+    }
+    return {
+      SAP_USER: env.SAP_USER || env.SAP_USERNAME || '',
+      SAP_PASSWORD: env.SAP_PASSWORD || env.SAP_PASS || ''
+    };
+  })();
   return {
     source: 'sap-gui-local',
     name,
@@ -209,11 +225,8 @@ async function configuredLocalSapGuiDestination(env) {
     backendUrl: tlsRoute ? env.SAP_URL : undefined,
     client: env.SAP_CLIENT || '001',
     systemId: env.SAP_SYSTEM_ID || '',
-    authentication: 'Basic',
-    childEnv: {
-      SAP_USER: env.SAP_USER || env.SAP_USERNAME || '',
-      SAP_PASSWORD: env.SAP_PASSWORD || env.SAP_PASS || ''
-    },
+    authentication: authMode === 'browser-saml' ? 'BrowserSAML' : authMode === 'saml-password' ? 'SAML' : 'Basic',
+    childEnv,
     close: tlsRoute?.close,
     probe: { status: tlsRoute ? 'configured-tls-server-name' : 'configured', available: true }
   };

package/src/setup.mjs

@@ -61,7 +61,11 @@ async function chooseLocalAuthMode(destination, { input = stdin, output = stdout
     defaultValue: 'basic',
     choices: [
       { name: 'password', value: 'basic', shortcut: 'p' },
-      { name: 'windows-sso (Kerberos/SPNEGO, including smart-card Windows logon)', value: 'windows-sso', shortcut: 's' }
+      { name: 'windows-sso (Kerberos/SPNEGO, silent current Windows logon)', value: 'windows-sso', shortcut: 's' },
+      { name: 'windows-sso with native Windows credential UI / smartcard PIN', value: 'windows-credential-ui', shortcut: 'w' },
+      { name: 'windows-sso with password fallback (self-heal when Negotiate/PIN is unavailable)', value: 'windows-sso-basic-fallback', shortcut: 'f' },
+      { name: 'browser SAML / web SSO (opens browser if supported by VSP)', value: 'browser-saml', shortcut: 'b' },
+      { name: 'SAML username/password', value: 'saml-password', shortcut: 'm' }
     ]
   }, { input, output });
 }
@@ -438,26 +442,56 @@ export async function runSetup({
         }
       }
       const authMode = await chooseLocalAuthMode({ ...destination, name: promptLabel }, { input, output, env });
-      destination.authentication = authMode === 'windows-sso' ? 'WindowsSSO' : 'Basic';
+      destination.authentication = ['windows-sso', 'windows-credential-ui', 'windows-sso-basic-fallback'].includes(authMode) ? 'WindowsSSO' : 'Basic';
       destination.authMode = authMode;
       for (const client of clients) {
         const name = localClientDestinationName(destination, client, { multipleClients: clients.length > 1, duplicateSystemName });
         const localDestination = { ...destination, name, serverName: name, client };
+        const userInputId = `sap-ai-dev-${localDestination.serverName || localDestination.name}-user`.toLowerCase().replace(/[^a-z0-9_-]+/g, '-');
+        const passwordInputId = `sap-ai-dev-${localDestination.serverName || localDestination.name}-password`.toLowerCase().replace(/[^a-z0-9_-]+/g, '-');
+        const credentialInputs = [
+          { id: userInputId, type: 'promptString', description: `SAP user for ${localDestination.name}` },
+          { id: passwordInputId, type: 'promptString', description: `SAP password for ${localDestination.name}`, password: true }
+        ];
         if (authMode === 'windows-sso') {
           localDestination.childEnv = { SAP_AUTH_MODE: 'windows-sso' };
           localDestination.inputs = [];
+        } else if (authMode === 'windows-credential-ui') {
+          localDestination.childEnv = {
+            SAP_AUTH_MODE: 'windows-sso',
+            SAP_AI_DEV_TOOLKIT_WINDOWS_CREDENTIAL_UI: 'true'
+          };
+          localDestination.inputs = [];
+        } else if (authMode === 'windows-sso-basic-fallback') {
+          localDestination.childEnv = {
+            SAP_AUTH_MODE: 'windows-sso',
+            SAP_AUTH_FALLBACK_MODE: 'basic',
+            SAP_USER: `\${input:${userInputId}}`,
+            SAP_PASSWORD: `\${input:${passwordInputId}}`
+          };
+          localDestination.inputs = credentialInputs;
+        } else if (authMode === 'browser-saml') {
+          localDestination.childEnv = {
+            SAP_AUTH_MODE: 'browser-saml',
+            SAP_BROWSER_AUTH: 'true',
+            SAP_SAML_AUTH: 'true'
+          };
+          localDestination.inputs = [];
+        } else if (authMode === 'saml-password') {
+          localDestination.childEnv = {
+            SAP_AUTH_MODE: 'saml-password',
+            SAP_SAML_AUTH: 'true',
+            SAP_SAML_USER: `\${input:${userInputId}}`,
+            SAP_SAML_PASSWORD: `\${input:${passwordInputId}}`
+          };
+          localDestination.inputs = credentialInputs;
         } else {
-          const userInputId = `sap-ai-dev-${localDestination.serverName || localDestination.name}-user`.toLowerCase().replace(/[^a-z0-9_-]+/g, '-');
-          const passwordInputId = `sap-ai-dev-${localDestination.serverName || localDestination.name}-password`.toLowerCase().replace(/[^a-z0-9_-]+/g, '-');
           localDestination.childEnv = {
             SAP_AUTH_MODE: 'basic',
             SAP_USER: `\${input:${userInputId}}`,
             SAP_PASSWORD: `\${input:${passwordInputId}}`
           };
-          localDestination.inputs = [
-            { id: userInputId, type: 'promptString', description: `SAP user for ${localDestination.name}` },
-            { id: passwordInputId, type: 'promptString', description: `SAP password for ${localDestination.name}`, password: true }
-          ];
+          localDestination.inputs = credentialInputs;
         }
         expanded.push(localDestination);
       }

package/src/terminal-ui.mjs

@@ -186,11 +186,13 @@ export async function selectPrompt({ message, choices, defaultValue } = {}, { in
       else if (key.name === 'return' || key.name === 'enter') return finish(choices[cursor]);
       else if (chunk) {
         const typed = String(chunk).toLowerCase();
-        const match = choices.findIndex(choice => !choice.disabled && (
-          String(choice.shortcut || '').toLowerCase() === typed ||
-          String(choice.value || '').toLowerCase().startsWith(typed) ||
-          String(choice.name || '').toLowerCase().startsWith(typed)
-        ));
+        let match = choices.findIndex(choice => !choice.disabled && String(choice.shortcut || '').toLowerCase() === typed);
+        if (match === -1) {
+          match = choices.findIndex(choice => !choice.disabled && (
+            String(choice.value || '').toLowerCase().startsWith(typed) ||
+            String(choice.name || '').toLowerCase().startsWith(typed)
+          ));
+        }
         if (match !== -1) cursor = match;
         else return;
       } else return;

package/src/windows-sso-adt-proxy.mjs

@@ -21,9 +21,37 @@ function validateTarget(value) {
   return url;
 }
 
+function authChallengeValues(headers) {
+  const value = headers?.get?.('www-authenticate');
+  if (!value) return [];
+  const parts = [];
+  let start = 0;
+  let quoted = false;
+  let escaped = false;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (escaped) {
+      escaped = false;
+    } else if (char === '\\' && quoted) {
+      escaped = true;
+    } else if (char === '"') {
+      quoted = !quoted;
+    } else if (char === ',' && !quoted) {
+      parts.push(value.slice(start, index).trim());
+      start = index + 1;
+    }
+  }
+  parts.push(value.slice(start).trim());
+  return parts.filter(Boolean);
+}
+
+function hasAuthChallenge(headers, scheme) {
+  const pattern = new RegExp(`^${scheme}(?:\\s|$)`, 'i');
+  return authChallengeValues(headers).some(part => pattern.test(part));
+}
+
 function hasNegotiateChallenge(headers) {
-  const value = headers.get?.('www-authenticate') || '';
-  return /(?:^|,)\s*Negotiate\b/i.test(value);
+  return hasAuthChallenge(headers, 'Negotiate');
 }
 
 function headerObject(headers) {
@@ -99,9 +127,10 @@ function helperCommand(env) {
   const command = env.SAP_AI_DEV_TOOLKIT_NEGOTIATE_HELPER || env.SAP_AI_DEV_TOOLKIT_SSPI_HELPER;
   if (command) return { command, args: [] };
   if (process.platform !== 'win32') return null;
+  const interactiveCredentialUi = env.SAP_AI_DEV_TOOLKIT_WINDOWS_CREDENTIAL_UI === 'true' || env.SAP_WINDOWS_CREDENTIAL_UI === 'true';
   return {
     command: env.SystemRoot ? join(env.SystemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe') : 'powershell.exe',
-    args: ['-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', join(root, 'scripts', 'windows-negotiate-helper.ps1')]
+    args: ['-NoLogo', '-NoProfile', ...(interactiveCredentialUi ? [] : ['-NonInteractive']), '-ExecutionPolicy', 'Bypass', '-File', join(root, 'scripts', 'windows-negotiate-helper.ps1')]
   };
 }
 
@@ -140,6 +169,28 @@ async function acquireNegotiateToken({ targetUrl, challenge, env, execFileImpl }
   return execHelper(helper, { url: targetUrl, challenge, mechanism: 'Negotiate' }, execFileImpl, env);
 }
 
+function basicFallbackCredentials(env) {
+  const mode = String(env.SAP_AUTH_FALLBACK_MODE || env.SAP_AI_DEV_TOOLKIT_AUTH_FALLBACK_MODE || '').trim().toLowerCase();
+  const enabled = mode === 'basic' || String(env.SAP_AI_DEV_TOOLKIT_SSO_BASIC_FALLBACK || '').toLowerCase() === 'true';
+  const user = String(env.SAP_USER || env.SAP_USERNAME || '').trim();
+  const password = String(env.SAP_PASSWORD || env.SAP_PASS || '');
+  if (!enabled || !user || !password) return null;
+  return { user, password };
+}
+
+function hasBasicChallenge(headers) {
+  return hasAuthChallenge(headers, 'Basic');
+}
+
+async function retryWithBasicFallback({ req, target, headers, body, fetchImpl, env }) {
+  const credentials = basicFallbackCredentials(env);
+  if (!credentials) return null;
+  return forward(req, target, {
+    ...headers,
+    Authorization: `Basic ${Buffer.from(`${credentials.user}:${credentials.password}`).toString('base64')}`
+  }, body, fetchImpl);
+}
+
 async function forward(req, targetUrl, headers, body, fetchImpl) {
   return fetchImpl(targetUrl, {
     method: req.method,
@@ -181,15 +232,26 @@ export async function createWindowsSsoAdtProxy({ destinationUrl, env = process.e
       let response = await forward(req, target, headers, body, fetchImpl);
       if (response.status === 401 && hasNegotiateChallenge(response.headers)) {
         const challenge = response.headers.get('www-authenticate') || '';
+        const cookies = mergeCookieHeader(headers.cookie || headers.Cookie, setCookies(response.headers));
         const cancel = response.body?.cancel?.();
         await cancel?.catch?.(() => {});
-        const token = await acquireNegotiateToken({ targetUrl: target.href, challenge, env, execFileImpl });
-        const retryHeaders = { ...headers, Authorization: `Negotiate ${token}` };
-        const cookies = mergeCookieHeader(headers.cookie || headers.Cookie, setCookies(response.headers));
-        delete retryHeaders.cookie;
-        delete retryHeaders.Cookie;
-        if (cookies) retryHeaders.Cookie = cookies;
-        response = await forward(req, target, retryHeaders, body, fetchImpl);
+        try {
+          const token = await acquireNegotiateToken({ targetUrl: target.href, challenge, env, execFileImpl });
+          const retryHeaders = { ...headers, Authorization: `Negotiate ${token}` };
+          delete retryHeaders.cookie;
+          delete retryHeaders.Cookie;
+          if (cookies) retryHeaders.Cookie = cookies;
+          response = await forward(req, target, retryHeaders, body, fetchImpl);
+        } catch (error) {
+          response = hasBasicChallenge(response.headers)
+            ? await retryWithBasicFallback({ req, target, headers: { ...headers, ...(cookies ? { Cookie: cookies } : {}) }, body, fetchImpl, env })
+            : null;
+          if (!response) throw error;
+        }
+      } else if (response.status === 401 && hasBasicChallenge(response.headers) && basicFallbackCredentials(env)) {
+        const cancel = response.body?.cancel?.();
+        await cancel?.catch?.(() => {});
+        response = await retryWithBasicFallback({ req, target, headers, body, fetchImpl, env }) || response;
       }
       writeFetchResponse(res, response, base, proxyOrigin);
     } catch (error) {