sap-ai-dev-toolkit 0.9.4 → 0.9.6

package/README.md

@@ -262,7 +262,7 @@ Prefer a persistent global install? Install globally from SAP Business Applicati
 | --- | --- | --- |
 | **Any environment (default — no global install)** | `npx --yes --ignore-scripts sap-ai-dev-toolkit --setup` | Runs the guided setup through npm and writes generated entries that launch the pinned package through `npx` (`cmd /c npx` on Windows). Add `--npx` to force the npx launcher even when a global `sap-ai-dev` command exists. |
 | **SAP Business Application Studio dev space (global install)** | `npm install --global sap-ai-dev-toolkit`<br>`sap-ai-dev --setup` | Discovers BAS destinations, optionally imports Cloud Foundry Destination service records, and writes VS Code/BAS MCP entries. |
-| **Windows workstation with SAP GUI (global install)** | `npm install --global sap-ai-dev-toolkit`<br>`sap-ai-dev --setup` | Discovers SAP GUI landscape entries, asks for SAP client(s) and ADT URL, then writes local VS Code MCP entries. Windows SSO can be selected if the ADT endpoint supports Negotiate/SPNEGO. |
+| **Windows workstation with SAP GUI (global install)** | `npm install --global sap-ai-dev-toolkit`<br>`sap-ai-dev --setup` | Discovers SAP GUI landscape entries, asks for SAP client(s) and ADT URL, then writes local VS Code MCP entries. Windows / smart card SSO (Edge) or username/password can be selected. |
 | **macOS workstation with SAP GUI (global install)** | `npm install --global sap-ai-dev-toolkit`<br>`sap-ai-dev --setup` | Discovers SAP GUI landscape entries, asks for SAP client(s) and ADT URL, then writes local VS Code MCP entries with secure login prompts. |
 | **Any local interactive terminal, already installed** | `sap-ai-dev --setup` | Re-runs the wizard to add, update, or remove generated MCP entries. Plain `sap-ai-dev` with no arguments also starts local setup when no BAS environment is detected. |
 | **npm install hook did not show a wizard** | `sap-ai-dev --setup` | This is expected on some npm/Windows combinations because lifecycle scripts may run without an interactive console. The explicit setup command is the reliable path. |
@@ -276,7 +276,7 @@ Everything works natively on Windows — PowerShell, cmd, and Windows Terminal a
 - The pinned VSP runtime ships inside the package as a native `vsp-win32-x64.exe`; no Go toolchain, WSL, or extra downloads are required.
 - MCP entries that launch through npm are written as `cmd /c npx ...` on Windows — the form VS Code, Claude Code, and Cursor can spawn there. Entries written on Linux/macOS use plain `npx`.
 - Setup reads `mcp.json` even when Windows tools saved it with a UTF-8/UTF-16 BOM (PowerShell `>`/`Set-Content`, Notepad "UTF-8 with BOM") and rewrites it as plain UTF-8. If the existing file cannot be used as-is, setup self-heals before falling back to a reset: VS Code-style comments and trailing commas (JSONC) are recovered in place, torn reads from a concurrent editor save are re-read once, and broken `servers`/`inputs` fields are repaired individually. Every lossy change first backs up the original next to the real file as `mcp.json.healed|repaired|invalid-<timestamp>.bak` (exclusive create, so reruns never overwrite an earlier backup; symlinked configs keep their link). `sap-ai-dev --doctor` stays strict and reports such files instead of rewriting them — run `sap-ai-dev --setup` to heal.
-- Local SAP GUI discovery reads the Windows landscape files and registry, and setup can write an experimental Windows SSO (`Negotiate`/SPNEGO) entry; see the “Local machine SAP GUI support” section below.
+- Local SAP GUI discovery reads the Windows landscape files and registry, and setup can write a Windows / smart card SSO entry that signs in through Microsoft Edge; see the “Local machine SAP GUI support” section below.
 
 If you previously installed the old package, remove it first because the legacy `bas-vsp-mcp` command is no longer shipped:
 
@@ -297,12 +297,12 @@ The guided setup can also offer companion MCP entries with `sap-ai-dev --setup -
 
 The installer handles VSP provisioning automatically:
 
-- Uses the package's bundled patched VSP binary for the current platform, verified against the npm-published `dist/checksums.txt`. A checksum-anchored remote download is the fallback only when the package has no bundled asset.
+- Uses the package's bundled patched VSP binary for the current platform, verified against the npm-published `dist/checksums.txt`. When the bundled asset is missing (an interrupted install, an antivirus quarantine, or a git checkout without `dist/`), a checksum-anchored download from the matching GitHub release is the fallback; MCP server startup runs it too, because npx entries skip install scripts.
 - No Go toolchain is downloaded or required at install time; Go is only used by the repository's own `build:vsp` development script.
 
 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. 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.
+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 offers Windows / smart card SSO (the default) instead, which writes `SAP_AUTH_MODE=sso` without username/password prompts. At server start, VSP opens Microsoft Edge on the ADT URL; Edge completes the login the same way it does in your browser (smart card certificate and PIN, Kerberos, or company SAML/Entra login), and the session is cached and refreshed automatically. SSO entries need an ADT URL with a host name, not an IP address. 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
 
@@ -314,7 +314,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`.
-- **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.
+- **Login methods:** local entries use either username/password or Windows / smart card SSO. SSO sets `SAP_SSO=true` for the VSP runtime, which drives Microsoft Edge for the login and re-opens an Edge window only when the cached session can no longer be refreshed silently.
 - **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.
@@ -329,7 +329,7 @@ sap-ai-dev --setup
 2. Confirm the detected/default SAP client, or enter multiple clients such as `100,200`.
 3. Accept the proposed ADT URL when it is correct, or edit it if your landscape exposes ADT through a different HTTP(S) host/port.
 4. If setup discovers certificate DNS names for an IP-based HTTPS URL, accept the yes/no TLS self-healing prompt.
-5. Choose password or Windows SSO when the prompt is available.
+5. Choose Windows / smart card SSO or username/password when the prompt is available.
 6. Start each generated MCP server from VS Code's **MCP: List Servers** command.
 
 The same postinstall offers the bundled agents and skills for several AI coding harnesses in a checkbox picker. **GitHub Copilot** and **Claude Code** start pre-checked, so pressing **Enter** alone installs both; **Space** selects or deselects a harness, **a** toggles all seven, and confirming with none selected skips the step without changing files. When MCP setup succeeds, the generated managed MCP servers are also mirrored into selected harnesses that have a stable user-level JSON MCP configuration (Claude Code, Cursor, Gemini CLI, and Pi Coding Agent). GitHub Copilot continues to use the VS Code/BAS MCP configuration written during setup. With no interactive terminal, the assets are installed for GitHub Copilot only; set `SAP_AI_DEV_TOOLKIT_HARNESSES` to a comma-separated list of harness ids (`github-copilot`, `claude-code`, `codex`, `cursor`, `gemini-cli`, `opencode`, `pi-coding-agent`) to choose non-interactively.
@@ -808,15 +808,10 @@ 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. 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_AUTH_MODE=sso` | Local SAP GUI entry mode for Windows / smart card SSO. Runtime starts VSP with `SAP_SSO=true`, which signs in through Microsoft Edge and caches the session per system and client. Older `windows-sso`, `browser-saml`, and `saml-password` entries are treated as `sso`. |
 | `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. |
 | `SAP_AI_DEV_MCP_CONFIG` | Explicit MCP configuration path; highest precedence. |
@@ -885,7 +880,7 @@ NPM_PUBLISH_TOKEN=npm_...
 - To publish a patch bump, run `npm run publish:npm -- --patch`; it updates `package.json` and `package-lock.json` before publishing. If publishing fails after the bump, retry without `--patch`.
 - npm's `prepublishOnly` hook builds the pinned VSP binaries for all platforms (including the Go toolchain if missing) and refuses to ship a tarball whose `dist/checksums.txt` does not list all five assets; it guards `npm run publish:npm` and a plain `npm publish` alike. Pass `--skip-build` to republish an already-built `dist/` without rebuilding.
 - Preview the package without publishing, changing its version, or building with `npm run publish:npm -- --dry-run`.
-- GitHub Actions runs the test suite on pushes to `main` and pull requests. A push to `main` that changes the `package.json` version runs the same checks, builds the VSP binaries, publishes that version to npm, and creates a `v<version>` GitHub release with generated notes.
+- GitHub Actions runs the test suite on pushes to `main` and pull requests. A push to `main` that changes the `package.json` version runs the same checks, builds the VSP binaries, publishes that version to npm, and creates a `v<version>` GitHub release with generated notes and the VSP binaries plus `checksums.txt` attached for the download fallback.
 - The publish workflow uses the `NPM_PUBLISH_TOKEN` GitHub repository secret. Verify it with `gh secret list`; the token value is never stored in the repository.
 
 The token is not printed or stored in the repository.

package/dist/checksums.txt

@@ -1,5 +1,5 @@
-85333f1ac7cbc25bc10a938cea5712b43d1c7b241911f19c6794f897dbcb589c  vsp-linux-x64
-68cd2b79e7cda145135f9f516b6ba76f33839bc9226bbf58ea015ff2442b4b2d  vsp-linux-arm64
-62fd8cd8eba8d61e36813c098938a2479af68047fd2fa1c85782edb4d4b5261b  vsp-darwin-x64
-71eb9e64e292e3ac83a2ab6a630367cfb0d79fe465d62ad1cfb05ef8c6c2b6e7  vsp-darwin-arm64
-952a6d5a90265fb6a6b3494d01a5d143fd7c471f7ce560bed200c399522b180f  vsp-win32-x64.exe
+a5b602573f54ce3d03d161aaaeb78559fd73bd51f2ae9a3b7549cee1ddc3fbf6  vsp-linux-x64
+2e336e2999c3654e5eb1e3a8bb42616eb5d5e422ab7ae74ffbff4634be45189d  vsp-linux-arm64
+afc7fd0f2e40ae5ebfcd3ddb8ac3cb7e7501b2b66d76ac96e3b6054b09366bb5  vsp-darwin-x64
+2d28a870c4a006900eec245384b4bbc2e84651e0ba911cca6107c132ace73575  vsp-darwin-arm64
+7d0189aa7ff936a145b0e3f15bffce8de5aebc252465a720edc3a9b122bd2a28  vsp-win32-x64.exe

package/package.json

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

package/src/binary.mjs

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { chmod, mkdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
-import { homedir, tmpdir } from 'node:os';
+import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { brandedEnvValue } from './branding.mjs';
@@ -114,12 +114,14 @@ export async function findBinary(pkg, options = {}) {
       await stat(bundled);
       const verified = await verifyAgainstPackagedChecksums(bundled, target);
       if (verified === false) {
-        log(`bundled VSP binary ${target.asset} failed checksum verification; ignoring it`);
+        log(`bundled VSP binary ${bundled} failed checksum verification; ignoring it`);
       } else {
         if (verified === null) log(`bundled VSP binary ${target.asset} has no packaged checksum entry; using it unverified`);
         return bundled;
       }
-    } catch {}
+    } catch (error) {
+      log(`bundled VSP binary not found at ${bundled} (${error.code || error.message})`);
+    }
   }
   const path = cachedBinaryPath(pkg, options.platform, options.arch, env);
   try {
@@ -158,6 +160,11 @@ export async function installBinary(pkg, options = {}) {
       if (String(error?.message || '').includes('checksum verification')) throw error;
     }
   }
+  return downloadBinary(pkg, options);
+}
+
+export async function downloadBinary(pkg, options = {}) {
+  const env = options.env || process.env;
   const target = binaryTarget(options.platform, options.arch);
   const base = releaseBaseUrl(pkg, pkg.version);
   const assetUrl = brandedEnvValue(env, 'BINARY_URL') || `${base}/${target.asset}`;
@@ -184,7 +191,8 @@ export async function installBinary(pkg, options = {}) {
   await mkdir(dir, { recursive: true, mode: 0o700 });
   await chmod(dir, 0o700);
   const destination = cachedBinaryPath(pkg, options.platform, options.arch, env);
-  const temporary = join(tmpdir(), `sap-ai-dev-toolkit-vsp-${process.pid}-${Date.now()}`);
+  // Same directory as the destination: rename fails with EXDEV across filesystems (tmpfs /tmp).
+  const temporary = `${destination}.${process.pid}-${Date.now()}.tmp`;
   await writeFile(temporary, bytes, { mode: 0o700 });
   await chmod(temporary, 0o700);
   await rename(temporary, destination);

package/src/launcher.mjs

@@ -5,12 +5,11 @@ 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 { binaryTarget, downloadBinary, findBinary } from './binary.mjs';
 import { MCPProxy } from './mcp-proxy.mjs';
 import { installMcpConfig, npxMcpLauncher, 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 { createTlsServerNameAdtProxy } from './tls-adt-proxy.mjs';
 import { withBrandedEnvironment } from './branding.mjs';
 import { redactText } from './redact.mjs';
@@ -164,10 +163,27 @@ function probeDiagnostic(destination) {
   return `[sap-ai-dev] ${destination.name}: probe=${probe.status || 'unknown'}${details.length ? ` (${details.join('; ')})` : ''}`;
 }
 
+// npx MCP entries run with --ignore-scripts, so postinstall's verified
+// download fallback never ran; a missing or corrupt bundled binary heals here.
 async function binaryOrError() {
-  const path = await findBinary(pkg, { env: runtimeEnv });
-  if (path) return path;
-  throw new Error('VSP binary is not installed. Reinstall with scripts enabled, set SAP_AI_DEV_TOOLKIT_BINARY to a trusted patched binary, or run npm run build:vsp.');
+  const notes = [];
+  const found = await findBinary(pkg, { env: runtimeEnv, log: note => notes.push(note) });
+  if (found) return found;
+  logLine(`[sap-ai-dev] ${notes.join('; ') || 'no VSP binary found'}; downloading a checksum-verified copy`);
+  try {
+    const downloaded = await downloadBinary(pkg, { env: runtimeEnv });
+    logLine(`[sap-ai-dev] VSP binary installed at ${downloaded}`);
+    return downloaded;
+  } catch (error) {
+    notes.push(`download fallback failed: ${error.message}${error.cause?.code ? ` (${error.cause.code})` : ''}`);
+  }
+  const npxDirectory = root.match(/^(.*[\\/]_npx[\\/][^\\/]+)[\\/]node_modules[\\/]/)?.[1];
+  throw new Error([
+    `VSP binary ${binaryTarget().asset} is unavailable for ${pkg.name}@${pkg.version}: ${notes.join('; ')}.`,
+    npxDirectory
+      ? `The npm package ships this binary, so an interrupted install or an antivirus quarantine usually removed it: delete ${npxDirectory} and restart the MCP server so npx reinstalls the package, or set SAP_AI_DEV_TOOLKIT_BINARY to a trusted patched VSP binary.`
+      : `Reinstall ${pkg.name} (a git checkout needs npm run build:vsp), check whether antivirus quarantined the binary, or set SAP_AI_DEV_TOOLKIT_BINARY to a trusted patched VSP binary.`
+  ].join(' '));
 }
 
 async function discoverForCommand() {
@@ -184,57 +200,41 @@ async function discoverForCommand() {
 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();
+  const client = env.SAP_CLIENT || '001';
+  const systemId = env.SAP_SYSTEM_ID || '';
+  // Older entries used windows-sso, browser-saml or saml-password; all of them now mean browser SSO.
+  if (!['', 'basic'].includes(String(env.SAP_AUTH_MODE || '').toLowerCase())) {
+    const cacheKey = `${systemId || new URL(env.SAP_URL).hostname}-${client}`.toLowerCase().replace(/[^a-z0-9.-]+/g, '-');
+    return {
+      source: 'sap-gui-local',
+      name,
+      url: env.SAP_URL,
+      client,
+      systemId,
+      authentication: 'SSO',
+      // SAP_SAML_AUTH survives sanitizeChildEnv and would make VSP demand SAML credentials.
+      childEnv: { SAP_SSO: 'true', SAP_SSO_SYSTEM: cacheKey, SAP_SAML_AUTH: '' },
+      probe: { status: 'configured', available: true }
+    };
+  }
   const tlsServerName = String(env.SAP_TLS_SERVER_NAME || env.SAP_AI_DEV_TOOLKIT_TLS_SERVER_NAME || '').trim();
   const tlsServerNames = String(env.SAP_TLS_SERVER_NAMES || env.SAP_AI_DEV_TOOLKIT_TLS_SERVER_NAMES || tlsServerName).split(',').map(value => value.trim()).filter(Boolean);
   const tlsCaFile = String(env.SAP_TLS_CA_FILE || env.SAP_AI_DEV_TOOLKIT_TLS_CA_FILE || '').trim();
   const tlsRoute = tlsServerNames.length
     ? await createTlsServerNameAdtProxy({ destinationUrl: env.SAP_URL, tlsServerNames, caFile: tlsCaFile || undefined })
     : null;
-  const adtUrl = tlsRoute?.url || env.SAP_URL;
-  const closeRoute = async route => {
-    await Promise.all([route?.close?.(), tlsRoute?.close?.()].filter(Boolean).map(close => Promise.resolve().then(close).catch(() => {})));
-  };
-  if (authMode === 'windows-sso') {
-    const route = await createWindowsSsoAdtProxy({ destinationUrl: adtUrl, env });
-    return {
-      source: 'sap-gui-local',
-      name,
-      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,
+    url: tlsRoute?.url || env.SAP_URL,
     backendUrl: tlsRoute ? env.SAP_URL : undefined,
-    client: env.SAP_CLIENT || '001',
-    systemId: env.SAP_SYSTEM_ID || '',
-    authentication: authMode === 'browser-saml' ? 'BrowserSAML' : authMode === 'saml-password' ? 'SAML' : 'Basic',
-    childEnv,
+    client,
+    systemId,
+    authentication: 'Basic',
+    childEnv: {
+      SAP_USER: env.SAP_USER || env.SAP_USERNAME || '',
+      SAP_PASSWORD: env.SAP_PASSWORD || env.SAP_PASS || ''
+    },
     close: tlsRoute?.close,
     probe: { status: tlsRoute ? 'configured-tls-server-name' : 'configured', available: true }
   };

package/src/mcp-proxy.mjs

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

package/src/setup.mjs

@@ -58,14 +58,10 @@ async function chooseLocalAuthMode(destination, { input = stdin, output = stdout
   if (!windowsSsoSetupAvailable(env)) return 'basic';
   return await selectPrompt({
     message: `Authentication for ${destination.name}`,
-    defaultValue: 'basic',
+    defaultValue: 'sso',
     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' }
+      { name: 'Windows / smart card SSO (Edge signs in automatically)', value: 'sso', shortcut: 's' },
+      { name: 'Username/password', value: 'basic', shortcut: 'p' }
     ]
   }, { input, output });
 }
@@ -125,7 +121,7 @@ function validateAdtUrlCandidate(candidate) {
 }
 
 function localAuthenticationLabel(authMode) {
-  return ['windows-sso', 'windows-credential-ui', 'windows-sso-basic-fallback'].includes(authMode) ? 'WindowsSSO' : 'Basic';
+  return authMode === 'sso' ? 'SSO' : 'Basic';
 }
 
 async function confirmPrompt(message, { input = stdin, output = stdout } = {}) {
@@ -147,38 +143,9 @@ function buildLocalClientDestination(destination, client, authMode, { multipleCl
     { 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' };
+  if (authMode === 'sso') {
+    localDestination.childEnv = { SAP_AUTH_MODE: '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 {
     localDestination.childEnv = {
       SAP_AUTH_MODE: 'basic',
@@ -422,7 +389,7 @@ async function chooseDiscoveredDestinations(destinations, { isBas, input = stdin
     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 (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.');
+    if (windowsSsoSetupAvailable(env)) print(output, '  Windows / smart card SSO signs in through Microsoft Edge (smart card, Kerberos or company login) and keeps the session refreshed; no password is stored.');
     const selectedNameCounts = selected.reduce((counts, destination) => {
       const key = String(destination.name).toLowerCase();
       counts.set(key, (counts.get(key) || 0) + 1);

package/scripts/windows-negotiate-helper.ps1

@@ -1,182 +0,0 @@
-# Windows Integrated Authentication helper for sap-ai-dev-toolkit.
-# Reads one JSON object from stdin with: url, challenge, mechanism.
-# Writes only the base64 Negotiate token to stdout.
-# Errors are written to stderr and exit non-zero.
-
-$ErrorActionPreference = 'Stop'
-
-$sspiSource = @'
-using System;
-using System.ComponentModel;
-using System.Runtime.InteropServices;
-
-public static class SapAiDevSspiNegotiate
-{
-    const int SECPKG_CRED_OUTBOUND = 2;
-    const int SECBUFFER_VERSION = 0;
-    const int SECBUFFER_TOKEN = 2;
-    const int SECURITY_NATIVE_DREP = 0x10;
-    const int SEC_E_OK = 0;
-    const int SEC_I_CONTINUE_NEEDED = 0x00090312;
-
-    [StructLayout(LayoutKind.Sequential)]
-    struct SecHandle
-    {
-        public IntPtr dwLower;
-        public IntPtr dwUpper;
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    struct SecBuffer
-    {
-        public int cbBuffer;
-        public int BufferType;
-        public IntPtr pvBuffer;
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    struct SecBufferDesc
-    {
-        public int ulVersion;
-        public int cBuffers;
-        public IntPtr pBuffers;
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    struct SECURITY_INTEGER
-    {
-        public uint LowPart;
-        public int HighPart;
-    }
-
-    [DllImport("secur32.dll", CharSet = CharSet.Unicode, SetLastError = false)]
-    static extern int AcquireCredentialsHandle(
-        string pszPrincipal,
-        string pszPackage,
-        int fCredentialUse,
-        IntPtr pvLogonID,
-        IntPtr pAuthData,
-        IntPtr pGetKeyFn,
-        IntPtr pvGetKeyArgument,
-        out SecHandle phCredential,
-        out SECURITY_INTEGER ptsExpiry);
-
-    [DllImport("secur32.dll", CharSet = CharSet.Unicode, SetLastError = false)]
-    static extern int InitializeSecurityContext(
-        ref SecHandle phCredential,
-        IntPtr phContext,
-        string pszTargetName,
-        int fContextReq,
-        int Reserved1,
-        int TargetDataRep,
-        IntPtr pInput,
-        int Reserved2,
-        out SecHandle phNewContext,
-        IntPtr pOutput,
-        out int pfContextAttr,
-        out SECURITY_INTEGER ptsExpiry);
-
-    [DllImport("secur32.dll", SetLastError = false)]
-    static extern int FreeCredentialsHandle(ref SecHandle phCredential);
-
-    [DllImport("secur32.dll", SetLastError = false)]
-    static extern int DeleteSecurityContext(ref SecHandle phContext);
-
-    static void Check(int status, string operation)
-    {
-        if (status == SEC_E_OK || status == SEC_I_CONTINUE_NEEDED) return;
-        throw new Win32Exception(status, operation + " failed with SSPI status 0x" + status.ToString("X8"));
-    }
-
-    static IntPtr BufferDesc(byte[] token, out IntPtr tokenMemory, out IntPtr bufferMemory)
-    {
-        tokenMemory = IntPtr.Zero;
-        SecBuffer buffer = new SecBuffer();
-        buffer.BufferType = SECBUFFER_TOKEN;
-        if (token != null && token.Length > 0)
-        {
-            tokenMemory = Marshal.AllocHGlobal(token.Length);
-            Marshal.Copy(token, 0, tokenMemory, token.Length);
-            buffer.cbBuffer = token.Length;
-            buffer.pvBuffer = tokenMemory;
-        }
-        bufferMemory = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(SecBuffer)));
-        Marshal.StructureToPtr(buffer, bufferMemory, false);
-        SecBufferDesc desc = new SecBufferDesc();
-        desc.ulVersion = SECBUFFER_VERSION;
-        desc.cBuffers = 1;
-        desc.pBuffers = bufferMemory;
-        IntPtr descMemory = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(SecBufferDesc)));
-        Marshal.StructureToPtr(desc, descMemory, false);
-        return descMemory;
-    }
-
-    static void FreeDesc(IntPtr descMemory, IntPtr tokenMemory, IntPtr bufferMemory)
-    {
-        if (descMemory != IntPtr.Zero) Marshal.FreeHGlobal(descMemory);
-        if (bufferMemory != IntPtr.Zero) Marshal.FreeHGlobal(bufferMemory);
-        if (tokenMemory != IntPtr.Zero) Marshal.FreeHGlobal(tokenMemory);
-    }
-
-    public static string CreateToken(string targetName, string incomingBase64)
-    {
-        SecHandle credential;
-        SECURITY_INTEGER expiry;
-        int status = AcquireCredentialsHandle(null, "Negotiate", SECPKG_CRED_OUTBOUND, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, out credential, out expiry);
-        Check(status, "AcquireCredentialsHandle");
-
-        SecHandle context = new SecHandle();
-        IntPtr inputDesc = IntPtr.Zero, inputToken = IntPtr.Zero, inputBuffer = IntPtr.Zero;
-        IntPtr outputDesc = IntPtr.Zero, outputToken = IntPtr.Zero, outputBuffer = IntPtr.Zero;
-        try
-        {
-            byte[] incoming = null;
-            if (!String.IsNullOrWhiteSpace(incomingBase64)) incoming = Convert.FromBase64String(incomingBase64);
-            if (incoming != null && incoming.Length > 0) inputDesc = BufferDesc(incoming, out inputToken, out inputBuffer);
-
-            outputDesc = BufferDesc(new byte[12288], out outputToken, out outputBuffer);
-            int attrs;
-            status = InitializeSecurityContext(ref credential, IntPtr.Zero, targetName, 0, 0, SECURITY_NATIVE_DREP, inputDesc, 0, out context, outputDesc, out attrs, out expiry);
-            Check(status, "InitializeSecurityContext");
-
-            SecBuffer outBuffer = (SecBuffer) Marshal.PtrToStructure(outputBuffer, typeof(SecBuffer));
-            if (outBuffer.cbBuffer <= 0 || outBuffer.pvBuffer == IntPtr.Zero) throw new Exception("SSPI returned an empty Negotiate token.");
-            byte[] bytes = new byte[outBuffer.cbBuffer];
-            Marshal.Copy(outBuffer.pvBuffer, bytes, 0, bytes.Length);
-            return Convert.ToBase64String(bytes);
-        }
-        finally
-        {
-            FreeDesc(inputDesc, inputToken, inputBuffer);
-            FreeDesc(outputDesc, outputToken, outputBuffer);
-            DeleteSecurityContext(ref context);
-            FreeCredentialsHandle(ref credential);
-        }
-    }
-}
-'@
-
-try {
-  $raw = [Console]::In.ReadToEnd()
-  if ([string]::IsNullOrWhiteSpace($raw)) { throw 'Missing helper request on stdin.' }
-  $request = $raw | ConvertFrom-Json
-  if (-not $request.url) { throw 'Missing target URL.' }
-
-  $uri = [Uri] [string] $request.url
-  if ($uri.Scheme -ne 'http' -and $uri.Scheme -ne 'https') { throw 'Target URL must use HTTP or HTTPS.' }
-  if ($uri.UserInfo) { throw 'Target URL must not contain user information.' }
-
-  Add-Type -TypeDefinition $sspiSource -Language CSharp
-
-  $incoming = $null
-  $challenge = [string] $request.challenge
-  if ($challenge -match '(?i)Negotiate\s+([^,\s]+)') { $incoming = $Matches[1] }
-  $targetName = 'HTTP/' + $uri.DnsSafeHost
-  $token = [SapAiDevSspiNegotiate]::CreateToken($targetName, $incoming)
-  if ([string]::IsNullOrWhiteSpace($token)) { throw 'Negotiate token generation returned an empty token.' }
-  [Console]::Out.WriteLine($token.Trim())
-  exit 0
-} catch {
-  [Console]::Error.WriteLine($_.Exception.Message)
-  exit 1
-}

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

@@ -1,257 +0,0 @@
-import http from 'node:http';
-import { once } from 'node:events';
-import { execFile as nodeExecFile } from 'node:child_process';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const MAX_HELPER_OUTPUT = 1024 * 1024;
-const HOP_BY_HOP = new Set(['connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization', 'te', 'trailer', 'transfer-encoding', 'upgrade']);
-const root = dirname(dirname(fileURLToPath(import.meta.url)));
-
-function safeError(message) { return new Error(message); }
-
-function validateTarget(value) {
-  let url;
-  try { url = new URL(value); }
-  catch { throw safeError('Windows SSO target ADT URL is invalid'); }
-  if (!['http:', 'https:'].includes(url.protocol) || !url.hostname || url.username || url.password) {
-    throw safeError('Windows SSO target ADT URL must be an HTTP(S) URL without embedded user information');
-  }
-  url.hash = '';
-  return url;
-}
-
-function hasNegotiateChallenge(headers) {
-  const value = headers.get?.('www-authenticate') || '';
-  return /(?:^|,)\s*Negotiate\b/i.test(value);
-}
-
-function headerObject(headers) {
-  const result = {};
-  for (const [name, value] of Object.entries(headers || {})) {
-    const lower = name.toLowerCase();
-    if (HOP_BY_HOP.has(lower) || lower === 'host') continue;
-    if (lower === 'authorization') continue;
-    if (value == null) continue;
-    result[name] = Array.isArray(value) ? value.join(', ') : String(value);
-  }
-  return result;
-}
-
-function copyResponseHeaders(response, { proxyOrigin, targetOrigin } = {}) {
-  const headers = {};
-  for (const [name, value] of response.headers) {
-    const lower = name.toLowerCase();
-    if (HOP_BY_HOP.has(lower) || ['content-encoding', 'content-length', 'set-cookie'].includes(lower)) continue;
-    // fetch exposes decompressed bytes, so upstream framing is no longer valid.
-    if (lower === 'location' && proxyOrigin && targetOrigin) {
-      try {
-        const location = new URL(value, targetOrigin);
-        if (location.origin === targetOrigin) {
-          headers[name] = `${proxyOrigin}${location.pathname}${location.search}${location.hash}`;
-          continue;
-        }
-      } catch {
-        // Keep unparsable Location values unchanged; the client/backend can decide.
-      }
-    }
-    headers[name] = value;
-  }
-  const cookies = setCookies(response.headers);
-  if (cookies.length) headers['set-cookie'] = cookies;
-  return headers;
-}
-
-function setCookies(headers) {
-  if (typeof headers?.getSetCookie === 'function') return headers.getSetCookie();
-  const value = headers?.get?.('set-cookie');
-  return value ? [value] : [];
-}
-
-function mergeCookieHeader(existing, cookies) {
-  const pairs = new Map();
-  for (const part of String(existing || '').split(';')) {
-    const trimmed = part.trim();
-    const index = trimmed.indexOf('=');
-    if (index > 0) pairs.set(trimmed.slice(0, index), trimmed.slice(index + 1));
-  }
-  for (const cookie of cookies || []) {
-    const first = String(cookie || '').split(';', 1)[0]?.trim();
-    const index = first.indexOf('=');
-    if (index > 0) pairs.set(first.slice(0, index), first.slice(index + 1));
-  }
-  return [...pairs].map(([name, value]) => `${name}=${value}`).join('; ');
-}
-
-async function readRequestBody(req, limit = 50 * 1024 * 1024) {
-  if (['GET', 'HEAD'].includes(req.method || 'GET')) return undefined;
-  const chunks = [];
-  let size = 0;
-  for await (const chunk of req) {
-    size += chunk.length;
-    if (size > limit) throw safeError('Windows SSO proxy request body is too large');
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks);
-}
-
-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', ...(interactiveCredentialUi ? [] : ['-NonInteractive']), '-ExecutionPolicy', 'Bypass', '-File', join(root, 'scripts', 'windows-negotiate-helper.ps1')]
-  };
-}
-
-function tokenLooksLikeNtlm(token) {
-  try {
-    return Buffer.from(token, 'base64').subarray(0, 8).toString('ascii') === 'NTLMSSP\0';
-  } catch {
-    return false;
-  }
-}
-
-function execHelper(helper, payload, execFileImpl = nodeExecFile, env = process.env) {
-  return new Promise((resolve, reject) => {
-    const child = execFileImpl(helper.command, helper.args, {
-      windowsHide: true,
-      timeout: 30_000,
-      maxBuffer: MAX_HELPER_OUTPUT,
-      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 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.'));
-      resolve(token);
-    });
-    child.stdin?.end(`${JSON.stringify(payload)}\n`);
-  });
-}
-
-async function acquireNegotiateToken({ targetUrl, challenge, env, execFileImpl }) {
-  const helper = helperCommand(env);
-  if (!helper) {
-    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 || '').toLowerCase();
-  const enabled = mode === 'basic' || env.SAP_AI_DEV_TOOLKIT_SSO_BASIC_FALLBACK === '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) {
-  const value = headers.get?.('www-authenticate') || '';
-  return /(?:^|,)\s*Basic\b/i.test(value);
-}
-
-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,
-    headers,
-    body,
-    duplex: body ? 'half' : undefined,
-    redirect: 'manual'
-  });
-}
-
-function writeFetchResponse(res, response, base, proxyOrigin) {
-  res.writeHead(response.status, response.statusText, copyResponseHeaders(response, { proxyOrigin, targetOrigin: base.origin }));
-  if (!response.body) return res.end();
-  response.body.pipeTo(new WritableStream({
-    write(chunk) { res.write(chunk); },
-    close() { res.end(); },
-    abort() { res.destroy(); }
-  })).catch(() => res.destroy());
-}
-
-export async function createWindowsSsoAdtProxy({ destinationUrl, env = process.env, fetchImpl = globalThis.fetch, execFileImpl = nodeExecFile } = {}) {
-  if (process.platform !== 'win32' && env.SAP_AI_DEV_TOOLKIT_ALLOW_SSO_PROXY_ON_NON_WINDOWS !== 'true') {
-    throw safeError('Windows SSO for local ADT destinations is only supported on Windows');
-  }
-  if (typeof fetchImpl !== 'function') throw safeError('HTTP fetch implementation is unavailable');
-  const base = validateTarget(destinationUrl);
-  const sockets = new Set();
-  let closed = false;
-  let proxyOrigin = '';
-
-  const server = http.createServer(async (req, res) => {
-    if (closed) return res.destroy();
-    let target;
-    try {
-      target = new URL(req.url || '/', base);
-      if (target.origin !== base.origin) throw safeError('Cross-origin Windows SSO proxy request rejected');
-      const headers = headerObject(req.headers);
-      const body = await readRequestBody(req);
-      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?.(() => {});
-        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 = await retryWithBasicFallback({ req, target, headers: { ...headers, ...(cookies ? { Cookie: cookies } : {}) }, body, fetchImpl, env });
-          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) {
-      if (!res.headersSent) {
-        res.writeHead(502, { 'content-type': 'text/plain; charset=utf-8', connection: 'close' });
-        res.end(`${error.message || 'Windows SSO proxy request failed'}\n`);
-      } else {
-        res.destroy();
-      }
-    }
-  });
-
-  server.on('connection', socket => {
-    sockets.add(socket);
-    socket.on('close', () => sockets.delete(socket));
-  });
-
-  server.listen(0, '127.0.0.1');
-  await once(server, 'listening');
-  const address = server.address();
-  proxyOrigin = `http://127.0.0.1:${address.port}`;
-  return {
-    url: proxyOrigin,
-    close: async () => {
-      if (closed) return;
-      closed = true;
-      for (const socket of sockets) socket.destroy();
-      server.close();
-      await once(server, 'close').catch(() => {});
-    }
-  };
-}