sap-ai-dev-toolkit 0.5.0 → 0.5.6

package/inventory.md

@@ -0,0 +1,179 @@
+# SAP AI Dev Toolkit Tool Inventory
+
+This inventory reflects the current SAP AI Dev Toolkit proxy behavior in `src/mcp-proxy.mjs`. The proxy exposes a curated VSP allowlist plus destination-scoped local workflows; it does not expose every tool registered by VSP. The live MCP `tools/list` response remains authoritative because capabilities vary by VSP mode and SAP system.
+
+## Summary
+
+| Status | Count | Notes |
+| --- | ---: | --- |
+| VSP tools | Up to 51 | Curated from the child VSP tool list and exposed with a destination prefix in lowercase snake_case, for example `<destination>_get_source`. |
+| Local lint tool | 1 per destination | `LintABAP` analyzes caller-supplied ABAP source in memory; it is exposed publicly as `<destination>_lint_abap`. |
+| Workflow tools | Up to 6 per destination | Review/apply change sets, transport evidence, Clean Core release assessment, and read-only RAP regression suites. Some are exposed only when their upstream VSP tools are registered. |
+| Convenience mapping | Dynamic | `GetApplicationLog` maps to VSP `SAP(action="analyze", type="application_log")` when the SAP router is registered. |
+| Intentionally filtered VSP tools | Dynamic | Destructive, broad-router, trace, and unsupported VSP operations are hidden from direct calls. |
+| Mode-dependent | Dynamic | Focused/expert mode and backend capabilities determine what VSP registers. |
+
+The maximum fixture surface is 59 tools per destination when expert-mode capabilities and all local workflows are available. Multiple selected destinations create separate MCP servers; this add-on cannot inspect VS Code's aggregate tool budget or per-chat tool binding.
+
+## Known upstream VSP tools
+
+These names are known from fixtures, README, and historical upstream VSP inventories. They are not a statement that the proxy exposes them; only the curated list in [tools.md](tools.md) is public through the proxy. Names absent from that allowlist are filtered even when VSP registers them.
+
+### Baseline/source inspection
+
+- `GetSource`
+- `SearchObject`
+- `GrepObjects`
+- `GrepPackages`
+- `FindDefinition`
+- `FindReferences`
+- `GetContext`
+- `CompareSource`
+- `GetClassInfo`
+- `GetPackage`
+- `GetFunctionGroup`
+- `GetMessages`
+- `GetInactiveObjects`
+- `GetAPIReleaseState`
+
+### Data, CDS, and metadata
+
+- `GetTable`
+- `GetTableContents`
+- `RunQuery`
+- `GetCDSDependencies`
+- `GetCDSImpactAnalysis`
+- `GetCDSElementInfo`
+- `GetFeatures`
+- `GetSystemInfo`
+- `GetInstalledComponents`
+
+### Create, update, activate, and quality
+
+- `WriteSource`
+- `EditSource`
+- `CreatePackage`
+- `CreateTable`
+- `SyntaxCheck`
+- `Activate`
+- `ActivateMultiple`
+- `ActivatePackage`
+- `PrettyPrint`
+- `RunUnitTests`
+- `RunATCCheck`
+
+### Transport tools
+
+- `GetTransport`
+- `GetTransportInfo`
+- `GetUserTransports`
+- `ListTransports`
+- `CreateTransport`
+- `ReleaseTransport`
+- `DeleteTransport`
+
+### Additional analysis, help, and call graph tools
+
+- `AnalyzeABAPCode`
+- `AnalyzeCallGraph`
+- `CodeCompletion`
+- `GetAbapHelp`
+- `GetCallGraph`
+- `GetCalleesOf`
+- `GetCallersOf`
+- `GetCodeCoverage`
+- `GetConnectionInfo`
+- `GetObjectStructure`
+- `GetTypeHierarchy`
+- `GetTypeInfo`
+- `GrepObject`
+- `GrepPackage`
+- `CallRFC`
+
+### Debugging, dumps, breakpoints, and trace
+
+- `DebuggerAttach`
+- `DebuggerDetach`
+- `DebuggerGetStack`
+- `DebuggerGetVariables`
+- `DebuggerListen`
+- `DebuggerStep`
+- `DeleteBreakpoint`
+- `GetBreakpoints`
+- `GetDump`
+- `GetSQLTraceState`
+- `GetTrace`
+- `ListDumps`
+- `SetBreakpoint`
+- `ListSQLTraces`
+
+### Object, source, dependency, and service operations
+
+- `CloneObject`
+- `CreateAndActivateProgram`
+- `CreateClassWithTests`
+- `CreateObject`
+- `CreateTestInclude`
+- `DeleteObject`
+- `ExecuteABAP`
+- `GetClass`
+- `GetClassComponents`
+- `GetClassInclude`
+- `GetFunction`
+- `GetInclude`
+- `GetInterface`
+- `GetProgram`
+- `GetStructure`
+- `GetTransaction`
+- `LockObject`
+- `MoveObject`
+- `RecoverFailedCreate`
+- `RenameObject`
+- `SaveToFile`
+- `UnlockObject`
+- `UpdateClassInclude`
+- `UpdateSource`
+- `WriteClass`
+- `WriteProgram`
+- `ListDependencies`
+- `PublishServiceBinding`
+- `UnpublishServiceBinding`
+
+### General VSP router
+
+- `SAP`
+
+## Enabled add-on/local tools
+
+- `LintABAP` — local add-on tool; lints caller-supplied ABAP source without contacting SAP.
+- `GetApplicationLog` — add-on convenience tool mapped to VSP `SAP` with `action="analyze"` and `type="application_log"`.
+
+These logical names are exposed through MCP in lowercase snake_case (`lint_abap`, `get_application_log`) because BAS/VS Code chat tool references bind only lowercase identifiers.
+
+## Destination workflow tools
+
+- `PrepareABAPChangeSet` — stage full-source `WriteSource` changes and return review diffs and source fingerprints.
+- `ApplyABAPChangeSet` — re-read staged objects before writing and report conflicts or partial application.
+- `CheckTransportReadiness` — collect selected transport, dependency, inactive-object, ABAP Unit, and ATC evidence.
+- `PlanABAPCloudMigration` — batch-check API release state for supplied ADT object URIs and prioritize recognized unreleased APIs.
+- `GenerateRAPRegressionSuite` — read service metadata and emit reusable GET-only smoke cases for entity sets.
+- `RunRAPRegressionSuite` — execute saved cases with status, content-type, and JSON-path assertions over the connected destination.
+
+## Notes
+
+- Runtime tool names are `<destination-slug>_<tool>`, for example `demo-abap_run_query`; `tools/call` accepts the exact name returned by `tools/list`.
+- The proxy starts VSP with `--enable-transports`; generated MCP entries set `SAP_ALLOW_TRANSPORTABLE_EDITS=true`.
+- Transport release/deletion and the general-purpose `SAP` router are intentionally hidden from direct proxy calls. `GetApplicationLog` is the bounded convenience mapping for the SAP application-log route.
+
+## Separate optional HANA Cloud inspector
+
+The HANA inspector is a standalone companion MCP process launched as `sap-ai-hana`; it is not a VSP child and is not destination-prefixed. It uses a read-only identity selected from `HANA_RO_*` variables or one unambiguous `VCAP_SERVICES` binding. Its host/schema target is fixed by process configuration; tool arguments cannot change it.
+
+| Tool | Behavior |
+| --- | --- |
+| `hana_connection_info` | Report selected endpoint, service/binding name, configured and current schema, database user, and TLS validation state. Does not return credentials. |
+| `hana_list_objects` | List tables and/or views in the configured schema, capped at 200 objects. |
+| `hana_describe_object` | Return columns for a table or view verified in the configured schema. |
+| `hana_read_rows` | Read selected catalog-verified columns with bound filter values and a hard 200-row maximum; credential-like columns are blocked. No free-form SQL. |
+
+The process exposes no DDL, DML, arbitrary SQL, procedure-call, deployment, undeploy, grant, or service-key management tools. The separate HANA identity should also be granted only the reads required for the intended HDI container.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sap-ai-dev-toolkit",
-  "version": "0.5.0",
+  "version": "0.5.6",
   "description": "SAP AI development toolkit for BAS, ABAP, RAP, CAP, HANA Cloud, Fiori, UI5, and MCP",
   "author": "Gurkan Yilmaz",
   "type": "module",
@@ -45,11 +45,11 @@
     "scripts/",
     "patches/",
     "dist/",
-    "test/",
     "LICENSE",
     "NOTICE",
     "LICENSE-APACHE-2.0.txt",
     "tools.md",
+    "inventory.md",
     ".github/agents/",
     ".github/skills/"
   ],

package/scripts/build-vsp.mjs

@@ -5,12 +5,13 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createHash } from 'node:crypto';
 import { ensureGo } from './ensure-go.mjs';
+import { UPSTREAM_COMMIT } from '../src/binary.mjs';
 
 const exec = promisify(execFile);
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
 const source = join(root, '.build', 'vibing-steampunk');
 const dist = join(root, 'dist');
-const commit = '9886d2727f47506368b0a3c2f1c1766f1200f747';
+const commit = UPSTREAM_COMMIT;
 const upstream = 'https://github.com/oisee/vibing-steampunk.git';
 const targets = [
   ['linux', 'amd64', 'linux', 'x64', ''],

package/scripts/postinstall.mjs

@@ -2,7 +2,6 @@ import { open, readFile } from 'node:fs/promises';
 import { closeSync, openSync, realpathSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { ensureGo } from './ensure-go.mjs';
 import { installBinary } from '../src/binary.mjs';
 import { runSetup } from '../src/setup.mjs';
 import { installUserCopilotAssets } from './install-user-copilot-assets.mjs';
@@ -11,6 +10,8 @@ import { ReadStream as TTYReadStream, WriteStream as TTYWriteStream } from 'node
 import { homedir } from 'node:os';
 import { colorText, formatStatus } from '../src/terminal-ui.mjs';
 import { brandedEnvValue, withBrandedEnvironment } from '../src/branding.mjs';
+import { generatedServerName } from '../src/mcp-config.mjs';
+import { redactText } from '../src/redact.mjs';
 
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
 const pkg = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
@@ -76,10 +77,10 @@ async function runCopilotAssetInstall() {
     await announce([
       'Optional Copilot setup is waiting for your choice.',
       '',
-      'Press Enter to install the bundled agents and all skills in the path shown below; type n then press Enter to skip.',
+      'Type y then press Enter to install the bundled agents and all skills in the path shown below; press Enter alone to skip.',
       '',
-      `${colorText('✅ Press Enter', 'green', true)} to install the bundled agents and all skills.`,
-      `${colorText('⏭️  Type n then Enter', 'yellow', true)} to skip this optional step.`,
+      `${colorText('✅ Type y then Enter', 'green', true)} to install the bundled agents and all skills.`,
+      `${colorText('⏭️  Press Enter', 'yellow', true)} to skip this optional step (default).`,
       '',
       `${colorText('📁 Target folder:', 'cyan', true)}`,
       `   ${copilotRoot}`,
@@ -88,11 +89,13 @@ async function runCopilotAssetInstall() {
     const prompt = createInterface({ input: terminal.input, output: terminal.output });
     let answer;
     try {
-      answer = await prompt.question(`${colorText('🤖 Install the bundled agents and all skills?', 'magenta', terminal.output)} ${colorText('[Y/n]', 'yellow', terminal.output)} `);
+      answer = await prompt.question(`${colorText('🤖 Install the bundled agents and all skills?', 'magenta', terminal.output)} ${colorText('[y/N]', 'yellow', terminal.output)} `);
     } finally {
       prompt.close();
     }
-    if (/^n(?:o)?$/i.test(answer.trim())) {
+    // Default is skip: writing instruction files into ~/.copilot affects
+    // every Copilot session on the machine, so it needs an explicit yes.
+    if (!/^y(?:es)?$/i.test(answer.trim())) {
       await announce('Copilot agent and skills were skipped. Your files were not changed.', 'info');
       return;
     }
@@ -110,8 +113,7 @@ async function runCopilotAssetInstall() {
 function probeCell(destination) {
   const probe = destination.probe || {};
   if (probe.status === 'skipped') return { text: 'SKIPPED (probe disabled)', color: 'yellow' };
-  const error = destination.source === 'cloud-foundry' ? '' : String(probe.error || '')
-    .replace(/(authorization|cookie|password|secret|token)\s*[:=]\s*[^\s,;]+/gi, '$1=[redacted]')
+  const error = destination.source === 'cloud-foundry' ? '' : redactText(probe.error || '')
     .replace(/[\u0000-\u001f\u007f]/g, ' ')
     .replace(/\s+/g, ' ')
     .slice(0, 100);
@@ -129,7 +131,7 @@ export function destinationTable(destinations, registeredNames) {
   const headings = ['Destination', 'Source', 'Client', 'Authentication', 'ADT probe', 'MCP server'];
   const rows = destinations.map(destination => {
     const probe = probeCell(destination);
-    const registered = registeredNames.has(destination.serverName || destination.name);
+    const registered = registeredNames.has(generatedServerName(destination.serverName || destination.name));
     const source = destination.source === 'cloud-foundry'
       ? `CF ${destination.cf?.destinationInstanceName || 'unknown instance'}`
       : 'BAS';
@@ -178,7 +180,7 @@ async function announceSetup(result) {
 
   const selected = result.selected || [];
   const destinationsByServer = new Map(selected.map(destination => [
-    destination.serverName || destination.name,
+    generatedServerName(destination.serverName || destination.name),
     destination
   ]));
   const registeredNames = new Set(servers.map(([name]) => name));
@@ -218,17 +220,14 @@ async function announceSetup(result) {
 async function main() {
   if (process.env.npm_config_ignore_scripts === 'true') return;
 
+  // Go is intentionally NOT provisioned here: the installed package never
+  // runs `go` (only the repository-only build:vsp script does), so a toolchain
+  // download at install time was pure cost. The pinned, checksum-verified VSP
+  // binary ships with the package; the download below is the fallback.
   try {
     if (brandedEnvValue(runtimeEnv, 'BINARY')) {
       await announce('Using the SAP_AI_DEV_TOOLKIT_BINARY override.', 'info');
     } else {
-      await announce('Checking for Go. The supported version installs automatically if needed; this may take a few minutes.', 'progress');
-      try {
-        await ensureGo();
-        await announce('Go is ready.', 'success');
-      } catch (error) {
-        throw new Error(`Go provisioning failed: ${error.message}`);
-      }
       await announce('Preparing the pinned VSP runtime for this platform.', 'progress');
       try {
         await installBinary(pkg, { env: runtimeEnv });
@@ -239,7 +238,7 @@ async function main() {
     }
   } catch (error) {
     await announce(error.message, 'error');
-    await announce('Go is provisioned automatically. Set SAP_AI_DEV_TOOLKIT_BINARY only when supplying a trusted prebuilt VSP executable.', 'info');
+    await announce('Set SAP_AI_DEV_TOOLKIT_BINARY only when supplying a trusted prebuilt VSP executable.', 'info');
     process.exitCode = 1;
     return;
   }

package/src/bas-destination-relay.mjs

@@ -2,6 +2,7 @@ import http from 'node:http';
 import { fetch as undiciFetch, ProxyAgent } from 'undici';
 import { CookieJar } from 'tough-cookie';
 import { brandedEnvValue } from './branding.mjs';
+import { redactText } from './redact.mjs';
 
 const DEFAULT_PROXY = 'http://127.0.0.1:8887';
 const MAX_BODY_BYTES = 64 * 1024 * 1024;
@@ -15,6 +16,12 @@ const UNSAFE = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
 // Set-Cookie state SAP returned alongside it and replays both on the unsafe
 // request. Without this pairing SAP sees a token from a foreign session and
 // answers "CSRF token validation failed" with HTTP 403.
+// Tokens are session-scoped, not path-scoped, but SAP only issues them from
+// GET-capable endpoints. POST-only services (ADT data preview among them)
+// answer a same-path token fetch with 4xx, so the relay always fetches from
+// the GET-friendly discovery endpoint and accepts that session's token for
+// unsafe requests to any path.
+const CSRF_FETCH_PATH = '/sap/bc/adt/discovery';
 const TOKEN_TTL_MS = 15 * 60 * 1000;
 const DEFAULT_MAX_TOKEN_FAILURES = 3;
 const MAX_CONFIGURED_TOKEN_FAILURES = 10;
@@ -200,10 +207,10 @@ export function createBasDestinationRelay(destination, { env = process.env, fetc
     return send(target, method, headers, body);
   }
 
-  async function fetchTokenFresh(requestUrl, requestHeaders) {
-    const key = requestUrl.pathname;
+  async function fetchTokenFresh(requestHeaders) {
+    const key = CSRF_FETCH_PATH;
     stats.csrfFetches += 1;
-    const target = resolveTarget(requestUrl);
+    const target = resolveTarget(new URL(CSRF_FETCH_PATH, base));
     const cookieTarget = resolveCookieTarget(target);
     const jar = copyCookieJar(sharedCookieJar);
     await seedRequestCookies(jar, requestHeaders.cookie, cookieTarget);
@@ -229,13 +236,13 @@ export function createBasDestinationRelay(destination, { env = process.env, fetc
     return session;
   }
 
-  async function fetchToken(requestUrl, requestHeaders = {}) {
-    const key = requestUrl.pathname;
+  async function fetchToken(requestHeaders = {}) {
+    const key = CSRF_FETCH_PATH;
     const cached = tokenCache.get(key);
     if (cached && Date.now() - cached.fetchedAt < TOKEN_TTL_MS) return cached;
     const pending = tokenFetches.get(key);
     if (pending) return pending;
-    const fetching = fetchTokenFresh(requestUrl, requestHeaders);
+    const fetching = fetchTokenFresh(requestHeaders);
     tokenFetches.set(key, fetching);
     try {
       return await fetching;
@@ -244,14 +251,17 @@ export function createBasDestinationRelay(destination, { env = process.env, fetc
     }
   }
 
-  async function probeCsrfSession(path = '/sap/bc/adt/discovery') {
-    const requestUrl = new URL(path, base);
-    const session = await fetchToken(requestUrl, { accept: 'application/xml,text/xml,*/*' });
+  async function probeCsrfSession() {
+    const session = await fetchToken({ accept: 'application/xml,text/xml,*/*' });
     return {
       httpStatus: session?.httpStatus || 0,
       tokenReceived: Boolean(session?.token),
       cookieCount: session?.cookieCount || 0,
-      sessionUsable: Boolean(session?.token && session.cookieCount > 0)
+      // A token alone makes unsafe requests viable: BAS proxy routes deliver
+      // tokens but strip cookies, and the backend accepts the token on the
+      // proxy-established Basic-auth session. cookieCount stays reported for
+      // diagnosis; setup's override validation requires cookies separately.
+      sessionUsable: Boolean(session?.token)
     };
   }
 
@@ -265,7 +275,14 @@ export function createBasDestinationRelay(destination, { env = process.env, fetc
   function authHeaders(extra = {}) {
     if (!credentials?.user || !credentials?.password) return extra;
     const basic = Buffer.from(`${credentials.user}:${credentials.password}`).toString('base64');
-    return { authorization: `Basic ${basic}`, ...extra };
+    // The stored credential override wins over any inbound authorization
+    // header: the override exists precisely to pair Basic auth with the
+    // relay's CSRF session, and silently forwarding a caller-supplied header
+    // would disable that pairing without any diagnostic.
+    const headers = { ...extra };
+    delete headers.authorization;
+    delete headers.Authorization;
+    return { ...headers, authorization: `Basic ${basic}` };
   }
 
   async function forward(method, requestUrl, requestHeaders, body, session) {
@@ -291,27 +308,32 @@ export function createBasDestinationRelay(destination, { env = process.env, fetc
   // a failing destination from looping forever.
   async function forwardWithRetry(method, requestUrl, requestHeaders, body, failures = 0) {
     const unsafe = UNSAFE.has(method);
-    const session = unsafe ? await fetchToken(requestUrl, requestHeaders) : null;
-    if (unsafe && (!session?.token || !session.cookieCount)) {
+    const session = unsafe ? await fetchToken(requestHeaders) : null;
+    if (unsafe && !session?.token) {
       stats.csrfSessionFailures += 1;
-      const detail = !session?.token
-        ? 'could not obtain a CSRF token'
-        : 'received a CSRF token without a session cookie';
-      const message = `BAS destination relay ${detail} for ${requestUrl.pathname}; no unsafe request was sent`;
+      const message = `BAS destination relay could not obtain a CSRF token for ${requestUrl.pathname}; no unsafe request was sent`;
       log(`[${destination.name}] ${message}`);
       const status = session?.httpStatus >= 400 ? session.httpStatus : 503;
       const response = new Response(message, { status, headers: { 'content-type': 'text/plain; charset=utf-8' } });
       return { response, body: Buffer.from(message) };
     }
+    // A token without cookies is still sent: BAS proxy routes deliver tokens
+    // but strip Set-Cookie, and the backend accepts the token on the Basic-
+    // auth session the proxy establishes per hop. A retry cannot help there
+    // (a fresh token still arrives cookie-less), so a CSRF rejection on a
+    // cookie-less session is surfaced instead of retried.
+    const tokenOnly = unsafe && !session.cookieCount;
     const { response, body: responseBody } = await forward(method, requestUrl, requestHeaders, body, session);
     const rejected = csrfFailure(response.status, response.headers, responseBody);
-    if (unsafe && rejected && failures < maxFailures) {
+    if (unsafe && rejected && !tokenOnly && failures < maxFailures) {
       log(`[${destination.name}] BAS relay CSRF session rejected for ${requestUrl.pathname}; re-establishing token and session (attempt ${failures + 1}/${maxFailures})`);
       stats.csrfRetries += 1;
-      tokenCache.delete(requestUrl.pathname);
+      tokenCache.delete(CSRF_FETCH_PATH);
       return forwardWithRetry(method, requestUrl, requestHeaders, body, failures + 1);
     }
-    if (unsafe && rejected && failures >= maxFailures) {
+    if (unsafe && rejected && tokenOnly) {
+      log(`[${destination.name}] BAS relay CSRF token rejected without a session cookie for ${requestUrl.pathname}; not retried (route delivers no cookies; a credential override enables a paired session)`);
+    } else if (unsafe && rejected && failures >= maxFailures) {
       log(`[${destination.name}] BAS relay stopped after ${maxFailures} CSRF session retries for ${requestUrl.pathname}`);
     }
     return { response, body: responseBody };
@@ -325,11 +347,17 @@ export function createBasDestinationRelay(destination, { env = process.env, fetc
       const body = UNSAFE.has(method) ? await readRequestBody(req) : Buffer.alloc(0);
       const { response, body: responseBody } = await forwardWithRetry(method, requestUrl, req.headers, body);
       const responseHeaders = {};
+      // SAP sessions commonly set several cookies at once; a plain object
+      // assignment would collapse them to the last value. undici exposes the
+      // full list via getSetCookie, and Node's http server serializes an
+      // array as repeated headers.
+      const setCookies = response.headers.getSetCookie?.() || [];
+      if (setCookies.length) responseHeaders['set-cookie'] = setCookies;
       for (const [name, value] of response.headers) {
         const lower = name.toLowerCase();
         // undici decompresses response bodies; the stale content-encoding and
         // content-length would misdescribe the plain bytes handed to VSP.
-        if (HOP_BY_HOP.has(lower) || lower === 'content-encoding' || lower === 'content-length') continue;
+        if (lower === 'set-cookie' || HOP_BY_HOP.has(lower) || lower === 'content-encoding' || lower === 'content-length') continue;
         responseHeaders[name] = value;
       }
       responseHeaders['x-sap-ai-dev-toolkit-relay'] = 'bas-destination';
@@ -337,10 +365,18 @@ export function createBasDestinationRelay(destination, { env = process.env, fetc
       res.end(responseBody);
     })().catch(error => {
       if (!res.headersSent) res.writeHead(502, { 'content-type': 'text/plain; charset=utf-8', 'connection': 'close' });
-      res.end(`BAS destination relay failed: ${error.message}\n`);
+      // Proxy and transport errors can embed the full proxy URL including
+      // userinfo; redact before the body reaches the child (and the tool result).
+      res.end(`BAS destination relay failed: ${redactText(error.message)}\n`);
     });
   });
 
+  // Keep an error listener for the server's whole lifetime: after listen()
+  // succeeds, a later 'error' event (port collision cleanup, socket reset)
+  // with no listener would be an uncaught exception that kills the process.
+  server.on('error', error => {
+    log(`[${destination.name}] BAS relay server error: ${redactText(error.message)}`);
+  });
   // Bind eagerly and report the real port through `ready`. Callers must
   // await `ready` before handing the URL to a VSP child; binding failures
   // surface as a rejected promise instead of a silently wrong guessed port.

package/src/bas-discovery.mjs

@@ -92,9 +92,15 @@ export function sanitizeChildEnv(input = process.env) {
     if (!SECRET_KEY.test(key)) env[key] = value;
   }
   env.SAP_PROXY_CONTEXTID_GUARD = 'true';
-  const proxy = env.HTTP_PROXY || env.http_proxy || DEFAULT_PROXY;
-  if (!env.HTTP_PROXY && !env.http_proxy) env.HTTP_PROXY = proxy;
-  if (!env.HTTPS_PROXY && !env.https_proxy) env.HTTPS_PROXY = proxy;
+  // The BAS dev-space proxy (127.0.0.1:8887) is only implied inside BAS
+  // (H2O_URL present). Outside a dev space the default would route every
+  // child request — including SAP Basic credentials — to whatever local
+  // process happens to own that port, so it is not applied there.
+  const proxy = env.HTTP_PROXY || env.http_proxy || (env.H2O_URL ? DEFAULT_PROXY : undefined);
+  if (proxy) {
+    if (!env.HTTP_PROXY && !env.http_proxy) env.HTTP_PROXY = proxy;
+    if (!env.HTTPS_PROXY && !env.https_proxy) env.HTTPS_PROXY = proxy;
+  }
   const noProxyKey = env.NO_PROXY != null ? 'NO_PROXY' : (env.no_proxy != null ? 'no_proxy' : 'NO_PROXY');
   const entries = String(env[noProxyKey] || '').split(',').map(value => value.trim()).filter(Boolean).filter(value => !value.toLowerCase().includes('.dest'));
   env[noProxyKey] = entries.join(',');
@@ -203,11 +209,21 @@ export async function discoverDestinations(options = {}) {
   const configuredProxy = brandedProxy !== undefined ? String(brandedProxy) : (env.HTTP_PROXY ?? env.http_proxy);
   const proxyUrl = configuredProxy !== undefined ? configuredProxy : DEFAULT_PROXY;
   const skipProbe = String(brandedEnvValue(env, 'SKIP_PROBE') || '').toLowerCase() === 'true' || options.skipProbe;
-  const result = [];
-  for (const destination of normalized.sort((a, b) => a.name.localeCompare(b.name))) {
-    const probe = await probeADT(destination, { ...options, proxyUrl, skipProbe });
-    result.push({ ...destination, probe });
-  }
+  const sorted = normalized.sort((a, b) => a.name.localeCompare(b.name));
+  // Probes run in parallel so startup and setup pay one probe round trip
+  // instead of one per destination; the pool is capped to avoid saturating
+  // the BAS proxy with large destination counts. Workers claim destinations
+  // in index order (synchronously until the first await), which keeps the
+  // probe invocation and result order deterministic.
+  const result = new Array(sorted.length);
+  let cursor = 0;
+  const probeWorker = async () => {
+    while (cursor < sorted.length) {
+      const index = cursor++;
+      result[index] = { ...sorted[index], probe: await probeADT(sorted[index], { ...options, proxyUrl, skipProbe }) };
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(8, sorted.length) }, () => probeWorker()));
   return result;
 }