sap-ai-dev-toolkit 0.8.3 → 0.8.5

package/README.md

@@ -278,7 +278,7 @@ The installer handles VSP provisioning automatically:
 
 Setup detects where it is running. With `H2O_URL` set, it treats the environment as SAP Business Application Studio and opens a checkbox picker for BAS destinations, with no destinations selected by default. Use **Space** to choose destinations and **Enter** to confirm. Press **a** to toggle all destinations (select all if any are unchecked; otherwise clear the selection). Confirming with none selected removes this add-on's managed MCP entries. When the `cf` CLI 8.18 or newer is authenticated to a targeted space, setup first offers an optional import from that space's Destination service; type **y** then **Enter** to include it, or press **Enter** to skip. Accepted CF and BAS destinations appear together in the picker.
 
-Without `H2O_URL`, interactive setup looks for local SAP GUI system configuration on macOS and Windows (for example SAP GUI landscape XML and `saplogon.ini`). SAP GUI landscape files describe SAP GUI/DIAG connectivity, not the ADT HTTP(S) endpoint or a complete ABAP client catalog, so setup asks for the SAP client or comma-separated clients to configure for each selected system (for example `100,200`), proposes an ADT URL from the SAP GUI host and instance when it can, and asks you to confirm or edit that value. Multiple entered clients create separate isolated MCP entries, one per system/client pair. When the ADT URL uses an IP address, setup automatically inspects the SAP HTTPS certificate, extracts DNS subjectAltName entries, and offers to enable secure TLS self-healing with a simple yes/no confirmation; you do not need to type certificate names. The generated MCP entry uses VS Code input prompts for the SAP user and password at server start; raw SAP credentials are not stored in `mcp.json`. On Windows, setup can instead write an experimental `SAP_AUTH_MODE=windows-sso` entry without username/password prompts; this requires the ADT endpoint to support HTTP Negotiate/SPNEGO. Runtime uses the bundled Windows Negotiate helper by default, or a trusted custom helper configured with `SAP_AI_DEV_TOOLKIT_NEGOTIATE_HELPER`. npm may run its install hook without an interactive terminal, even when the shell is interactive; in that case, destination selection is skipped without changing MCP config, and you should run `sap-ai-dev --setup` afterwards.
+Without `H2O_URL`, interactive setup looks for local SAP GUI system configuration on macOS and Windows (for example SAP GUI landscape XML and `saplogon.ini`). SAP GUI landscape files describe SAP GUI/DIAG connectivity, not the ADT HTTP(S) endpoint or a complete ABAP client catalog, so setup asks for the SAP client or comma-separated clients to configure for each selected system (for example `100,200`), proposes an ADT URL from the SAP GUI host and instance when it can, and asks you to confirm or edit that value. Multiple entered clients create separate isolated MCP entries, one per system/client pair. Local SAP GUI MCP server keys use the SAP system ID and client (for example `t4d-100`) instead of the longer SAP GUI description, while `SAP_AI_DEV_TOOLKIT_DESTINATION` still preserves the display name. When the ADT URL uses an IP address, setup automatically inspects the SAP HTTPS certificate, extracts DNS subjectAltName entries, and offers to enable secure TLS self-healing with a simple yes/no confirmation; you do not need to type certificate names. The generated MCP entry uses VS Code input prompts for the SAP user and password at server start; raw SAP credentials are not stored in `mcp.json`. On Windows, setup can instead write an experimental `SAP_AUTH_MODE=windows-sso` entry without username/password prompts; this requires the ADT endpoint to support HTTP Negotiate/SPNEGO. Runtime uses the bundled Windows Negotiate helper by default, or a trusted custom helper configured with `SAP_AI_DEV_TOOLKIT_NEGOTIATE_HELPER`. npm may run its install hook without an interactive terminal, even when the shell is interactive; in that case, destination selection is skipped without changing MCP config, and you should run `sap-ai-dev --setup` afterwards.
 
 ### 🖥️ Local machine SAP GUI support
 
@@ -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:** 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 unless `SAP_AI_DEV_TOOLKIT_NEGOTIATE_HELPER` points to a trusted custom 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.
@@ -740,7 +740,7 @@ The MCP client discovers the schemas; callers do not need to memorize every argu
 | Add-on command options | `sap-ai-dev --help` |
 | BAS destinations and probe status | `sap-ai-dev --list-destinations --json` (BAS only) |
 | Destination availability only | `sap-ai-dev --check` |
-| Generated server names and destination mapping | **MCP: Open User Configuration**; look for lowercase slug entries (for example `demo-abap`) whose `SAP_AI_DEV_TOOLKIT_DESTINATION` names the BAS destination or local SAP GUI system. |
+| Generated server names and destination mapping | **MCP: Open User Configuration**; look for lowercase slug entries (for BAS, for example `demo-abap`; for local SAP GUI, system/client slugs such as `t4d-100`) whose `SAP_AI_DEV_TOOLKIT_DESTINATION` names the BAS destination or local SAP GUI system. |
 | Running server | **MCP: List Servers**; select the server and choose **Start Server**. |
 | Tools and exact schemas | Expand that server in the Chat tools picker. The MCP host requests `tools/list`, whose entries include `name`, `description`, and `inputSchema`; the agent should call those tools through chat, not reproduce the protocol in a terminal. |
 | Runtime and tool-call logs | Select the MCP server in the Output view. Startup, call lifecycle, and child stderr logs are written to stderr; child MCP log notifications are forwarded to the client. Tool arguments and result contents are not logged. |
@@ -782,11 +782,15 @@ 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. Runtime starts a loopback ADT proxy and does not pass SAP username/password credentials 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_AI_DEV_TOOLKIT_NEGOTIATE_HELPER` / `SAP_AI_DEV_TOOLKIT_SSPI_HELPER` | Optional trusted Windows helper executable used by the local Windows SSO proxy to convert an HTTP `WWW-Authenticate: Negotiate` challenge into a Kerberos/SPNEGO token. 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 token on stdout. |
+| `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. |
 | `SAP_AI_DEV_MCP_CONFIG` | Explicit MCP configuration path; highest precedence. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sap-ai-dev-toolkit",
-  "version": "0.8.3",
+  "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

@@ -195,23 +195,38 @@ async function configuredLocalSapGuiDestination(env) {
       url: route.url,
       backendUrl: env.SAP_URL,
       client: env.SAP_CLIENT || '001',
+      systemId: env.SAP_SYSTEM_ID || '',
       authentication: 'WindowsSSO',
       childEnv: {},
       close: () => closeRoute(route),
       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,
     url: adtUrl,
     backendUrl: tlsRoute ? env.SAP_URL : undefined,
     client: env.SAP_CLIENT || '001',
-    authentication: 'Basic',
-    childEnv: {
-      SAP_USER: env.SAP_USER || env.SAP_USERNAME || '',
-      SAP_PASSWORD: env.SAP_PASSWORD || env.SAP_PASS || ''
-    },
+    systemId: env.SAP_SYSTEM_ID || '',
+    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/mcp-config.mjs

@@ -129,6 +129,15 @@ export function generatedServerName(destinationName) {
   return slugifyDestination(destinationName);
 }
 
+export function generatedDestinationServerName(destination) {
+  if (destination?.source === 'sap-gui-local') {
+    const systemId = String(destination.systemId || '').trim();
+    const client = String(destination.client || '001').trim() || '001';
+    if (systemId) return generatedServerName(`${systemId}-${client}`);
+  }
+  return generatedServerName(destination?.source === 'cloud-foundry' ? destination.serverName : destination?.name);
+}
+
 export function buildSapDevelopmentMcpEntries(serverIds = SAP_DEVELOPMENT_MCP_SERVERS.map(server => server.id), { packageVersions = {}, packageManager = 'npx' } = {}) {
   const selected = new Set(serverIds);
   const entries = Object.create(null);
@@ -159,7 +168,7 @@ export function buildMcpEntries(destinations, env = process.env) {
   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);
+    const name = generatedDestinationServerName(destination);
     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 = {
       ...(h2oUrl ? { H2O_URL: String(h2oUrl) } : {}),
@@ -402,9 +411,9 @@ export async function repairManagedMcpConfig(discoveredDestinations, { env = pro
   for (const [serverName, entry] of Object.entries(config.servers)) {
     if (!isManagedBasDestinationEntry(entry)) continue;
     const destinationName = destinationValue(entry.env);
-    const expectedName = generatedServerName(destinationName);
     const destination = basDestinations.get(destinationName);
     if (!destination) continue;
+    const expectedName = generatedDestinationServerName(destination);
     if (expectedName !== serverName) {
       // Legacy mixed-case entries migrate to the normalized lowercase key.
       // A user-owned entry on the target key blocks the rename; merging is

package/src/setup.mjs

@@ -2,7 +2,7 @@ import { createInterface } from 'node:readline/promises';
 import { stdin, stdout } from 'node:process';
 import { platform } from 'node:os';
 import { isIP } from 'node:net';
-import { checkboxPrompt, colorText, formatStatus, textPrompt } from './terminal-ui.mjs';
+import { checkboxPrompt, colorText, formatStatus, selectPrompt, textPrompt } from './terminal-ui.mjs';
 import { discoverDestinations, remediation } from './bas-discovery.mjs';
 import { defaultAdtUrl, discoverSapGuiSystems } from './local-sap-gui.mjs';
 import { discoverCloudFoundryDestinations, getCloudFoundryTarget, deleteManagedCloudFoundryServiceKeys, findOrphanedCloudFoundryServiceKeys } from './cf-destination.mjs';
@@ -56,17 +56,18 @@ function windowsSsoSetupAvailable(env = process.env) {
 
 async function chooseLocalAuthMode(destination, { input = stdin, output = stdout, env = process.env } = {}) {
   if (!windowsSsoSetupAvailable(env)) return 'basic';
-  const answer = await textPrompt({
-    message: `Authentication for ${destination.name} (password/sso)`,
-    placeholder: 'password',
-    required: false,
-    validate: value => {
-      const candidate = String(value || 'password').trim().toLowerCase();
-      return ['password', 'basic', 'sso', 'windows-sso'].includes(candidate) || 'Enter password or sso.';
-    }
+  return await selectPrompt({
+    message: `Authentication for ${destination.name}`,
+    defaultValue: 'basic',
+    choices: [
+      { name: 'password', value: 'basic', shortcut: 'p' },
+      { 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 });
-  const normalized = String(answer || 'password').trim().toLowerCase();
-  return ['sso', 'windows-sso'].includes(normalized) ? 'windows-sso' : 'basic';
 }
 
 async function confirmCloudFoundryImport({ input = stdin, output = stdout } = {}) {
@@ -387,7 +388,7 @@ export async function runSetup({
     print(output, '');
     print(output, formatStatus('SAP GUI landscapes do not contain ADT HTTP(S) endpoints or a complete client catalog. Confirm the SAP client(s), ADT URL, and authentication for each selected system.', 'step', output, 'Local SAP GUI'));
     print(output, '  Enter multiple clients as comma-separated 3-digit values, for example 100,200. Setup creates one isolated MCP server per system/client pair.');
-    if (windowsSsoSetupAvailable(env)) print(output, '  Windows SSO is experimental and only applies to ADT systems configured for HTTP Integrated Authentication. Username/password remains the default.');
+    if (windowsSsoSetupAvailable(env)) print(output, '  Windows SSO is experimental and only applies to ADT systems configured for HTTP Integrated Authentication (Negotiate/SPNEGO). It uses the current Windows logon session, including smart-card-backed Windows logon; the toolkit cannot prompt for or accept manual bearer/SAML tokens. Username/password remains the default.');
     const selectedNameCounts = selected.reduce((counts, destination) => {
       const key = String(destination.name).toLowerCase();
       counts.set(key, (counts.get(key) || 0) + 1);
@@ -441,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

@@ -115,6 +115,104 @@ function checkboxPageSize(output, choiceCount) {
   return clamp(Math.min(choiceCount, rows - 7), 1, Math.max(1, choiceCount));
 }
 
+export async function selectPrompt({ message, choices, defaultValue } = {}, { input = process.stdin, output = process.stdout } = {}) {
+  if (!Array.isArray(choices) || !choices.length) return undefined;
+  let cursor = choices.findIndex(choice => !choice.disabled && (choice.value === defaultValue || choice.checked));
+  if (cursor === -1) cursor = firstEnabledIndex(choices);
+  let top = 0;
+  let renderedLines = 0;
+  let done = false;
+  let previousRawMode;
+
+  const write = text => output.write(text);
+  const clearRendered = () => {
+    if (!renderedLines) return;
+    write(`\u001b[${renderedLines}A\u001b[J`);
+    renderedLines = 0;
+  };
+  const ensureVisible = pageSize => {
+    if (cursor < top) top = cursor;
+    if (cursor >= top + pageSize) top = cursor - pageSize + 1;
+    top = clamp(top, 0, Math.max(0, choices.length - pageSize));
+  };
+  const render = () => {
+    const columns = Number.isFinite(output?.columns) ? output.columns : 80;
+    const pageSize = checkboxPageSize(output, choices.length);
+    ensureVisible(pageSize);
+    const lines = [];
+    lines.push(truncateToColumns(`${message} (↑/↓: choose, Enter: confirm)`, columns));
+    const end = Math.min(choices.length, top + pageSize);
+    for (let index = top; index < end; index += 1) {
+      const choice = choices[index];
+      const pointer = index === cursor ? '❯' : ' ';
+      const marker = index === cursor ? colorText('●', 'green', output) : '○';
+      const disabled = choice.disabled ? ` — ${choice.disabled}` : '';
+      const label = `${pointer}${marker} ${choice.name}${disabled}`;
+      lines.push(truncateToColumns(label, columns));
+    }
+    if (choices.length > pageSize) {
+      lines.push(truncateToColumns(colorText(`  Showing ${top + 1}-${end} of ${choices.length}; use ↑/↓ to scroll.`, 'cyan', output), columns));
+    }
+    clearRendered();
+    write(`${lines.join('\n')}\n`);
+    renderedLines = physicalRows(lines, columns);
+  };
+
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      input.off('keypress', onKeypress);
+      if (typeof input.setRawMode === 'function' && previousRawMode !== undefined) input.setRawMode(previousRawMode);
+      if (typeof input.pause === 'function') input.pause();
+      write('\u001b[?25h');
+    };
+    const finish = choice => {
+      if (done) return;
+      done = true;
+      clearRendered();
+      write(`${stripAnsi(message)} ${choice?.name || choice?.value || ''}\n`);
+      cleanup();
+      resolve(choice?.value);
+    };
+    const fail = error => {
+      if (done) return;
+      done = true;
+      cleanup();
+      reject(error);
+    };
+    const onKeypress = (chunk, key = {}) => {
+      if (key.ctrl && key.name === 'c') return fail(new Error('Prompt interrupted'));
+      if (key.name === 'up' || key.name === 'k') cursor = nextEnabledIndex(choices, cursor, -1);
+      else if (key.name === 'down' || key.name === 'j') cursor = nextEnabledIndex(choices, cursor, 1);
+      else if (key.name === 'return' || key.name === 'enter') return finish(choices[cursor]);
+      else if (chunk) {
+        const typed = String(chunk).toLowerCase();
+        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;
+      render();
+    };
+
+    try {
+      readline.emitKeypressEvents(input);
+      previousRawMode = input.isRaw;
+      if (typeof input.setRawMode === 'function') input.setRawMode(true);
+      if (typeof input.resume === 'function') input.resume();
+      write('\u001b[?25l');
+      input.on('keypress', onKeypress);
+      render();
+    } catch (error) {
+      fail(error);
+    }
+  });
+}
+
 export async function checkboxPrompt({ message, choices, required = false, shortcuts = { all: 'a' }, validate } = {}, { input = process.stdin, output = process.stdout } = {}) {
   if (!Array.isArray(choices) || !choices.length) return [];
   const selectable = enabledChoices(choices);

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')]
   };
 }
 
@@ -122,7 +151,7 @@ function execHelper(helper, payload, execFileImpl = nodeExecFile, env = process.
       env: { ...process.env, ...env }
     }, (error, stdout) => {
       // execFile errors can contain helper stdout/stderr, including tokens.
-      if (error) return reject(safeError('Windows SSO helper failed; verify the helper and Windows Kerberos configuration.'));
+      if (error) return reject(safeError('Windows SSO helper failed; verify the ADT endpoint supports HTTP Negotiate/SPNEGO for the signed-in Windows identity (including smart-card-backed Windows logon) and that Kerberos/SPN configuration is correct. The toolkit cannot prompt for or accept manually pasted bearer/SAML tokens.'));
       const token = String(stdout || '').trim();
       if (!/^[A-Za-z0-9+/=_-]+$/.test(token)) return reject(safeError('Windows SSO helper returned an invalid Negotiate token'));
       if (tokenLooksLikeNtlm(token)) return reject(safeError('Windows SSO helper returned an NTLM token. ADT SSO requires Kerberos/SPNEGO; verify the backend SPN and Kerberos configuration, or rerun sap-ai-dev --setup and choose username/password.'));
@@ -135,11 +164,33 @@ function execHelper(helper, payload, execFileImpl = nodeExecFile, env = process.
 async function acquireNegotiateToken({ targetUrl, challenge, env, execFileImpl }) {
   const helper = helperCommand(env);
   if (!helper) {
-    throw safeError('Windows SSO requires an SSPI/Negotiate helper. Set SAP_AI_DEV_TOOLKIT_NEGOTIATE_HELPER to a trusted helper executable, or rerun sap-ai-dev --setup and choose username/password.');
+    throw safeError('Windows SSO requires an SSPI/Negotiate helper that uses the current Windows logon session (including smart-card-backed logon). Set SAP_AI_DEV_TOOLKIT_NEGOTIATE_HELPER to a trusted helper executable, or rerun sap-ai-dev --setup and choose username/password. Manual token entry is not supported.');
   }
   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) {