sap-ai-dev-toolkit 0.9.9 → 0.9.91

package/dist/checksums.txt

@@ -1,5 +1,5 @@
-a5b602573f54ce3d03d161aaaeb78559fd73bd51f2ae9a3b7549cee1ddc3fbf6  vsp-linux-x64
-2e336e2999c3654e5eb1e3a8bb42616eb5d5e422ab7ae74ffbff4634be45189d  vsp-linux-arm64
-afc7fd0f2e40ae5ebfcd3ddb8ac3cb7e7501b2b66d76ac96e3b6054b09366bb5  vsp-darwin-x64
-2d28a870c4a006900eec245384b4bbc2e84651e0ba911cca6107c132ace73575  vsp-darwin-arm64
-7d0189aa7ff936a145b0e3f15bffce8de5aebc252465a720edc3a9b122bd2a28  vsp-win32-x64.exe
+02831a47fa28a1807d94f6b8485c21f1221c7b3aa0a2b9b7bf0682ab4fb5618f  vsp-linux-x64
+4398dac4c9d304d63e03abbb86523b61e5180b5b355dd1a2ed0d2405454cc8f7  vsp-linux-arm64
+356a10913b7a46a8ed67132e9b15ea7ff92b8adeb1c799111866e9af176e85fe  vsp-darwin-x64
+fb5e72a59618578187eb8e4374571b32baab34397766fc6ea8ab328c6cea849b  vsp-darwin-arm64
+50d5c74194063bc9bcc641fb580f1c1232cce0c1577cdad6dc503f41efd3344c  vsp-win32-x64.exe

package/package.json

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

package/patches/vsp-bas-proxy-auth.patch

@@ -492,3 +492,56 @@ index 0000000..80741da
 +	}
 +}
 +
+diff --git a/pkg/adt/sso.go b/pkg/adt/sso.go
+index d67c4e8..4e9dc45 100644
+--- a/pkg/adt/sso.go
++++ b/pkg/adt/sso.go
+@@ -155,7 +155,7 @@ func CaptureSSOCookies(ctx context.Context, opts SSOOptions) (map[string]string,
+ 	// below is the real verdict.
+ 	if err := chromedp.Run(timeoutCtx, chromedp.Navigate(opts.TriggerURL)); err != nil {
+ 		if timeoutCtx.Err() != nil {
+-			return nil, fmt.Errorf("SSO capture timed out after %s", timeout)
++			return nil, navigationTimeout(opts.Headless, timeout)
+ 		}
+ 		if opts.Verbose {
+ 			fmt.Fprintf(os.Stderr, "[SSO] navigation reported %v (normal during SSO)\n", err)
+@@ -174,6 +174,17 @@ func CaptureSSOCookies(ctx context.Context, opts SSOOptions) (map[string]string,
+ 	return cookies, nil
+ }
+ 
++// navigationTimeout explains a first page that never finished loading. In a
++// silent browser that page is waiting on a person — a smart-card certificate
++// picker or a login prompt headless mode cannot show — so a visible window is
++// the next step, not a failed start.
++func navigationTimeout(headless bool, timeout time.Duration) error {
++	if headless {
++		return fmt.Errorf("%w: the silent sign-in page did not finish loading within %s", ErrSSOInteractiveRequired, timeout)
++	}
++	return fmt.Errorf("SSO capture timed out after %s", timeout)
++}
++
+ // DefaultSSOProfileDir returns a per-host browser profile directory under the
+ // user's cache location. Keeping one profile per host means a silent refresh
+ // for one system is never disturbed by a login to another.
+diff --git a/pkg/adt/sso_navigation_test.go b/pkg/adt/sso_navigation_test.go
+new file mode 100644
+index 0000000..c851021
+--- /dev/null
++++ b/pkg/adt/sso_navigation_test.go
+@@ -0,0 +1,16 @@
++package adt
++
++import (
++	"errors"
++	"testing"
++	"time"
++)
++
++func TestSilentNavigationTimeoutAsksForAPerson(t *testing.T) {
++	if err := navigationTimeout(true, time.Second); !errors.Is(err, ErrSSOInteractiveRequired) {
++		t.Fatalf("silent timeout = %v, want ErrSSOInteractiveRequired so a visible window opens", err)
++	}
++	if err := navigationTimeout(false, time.Second); errors.Is(err, ErrSSOInteractiveRequired) {
++		t.Fatalf("headed timeout = %v, must not ask for yet another window", err)
++	}
++}

package/src/launcher.mjs

@@ -222,7 +222,14 @@ async function rememberAdtUrl(configured, found) {
 // swept only when the configuration never named one.
 async function resolveLocalAdtUrl(name, configured, client) {
   const log = message => logLine(`[sap-ai-dev] ${name}: ${message}`);
-  const detect = target => detectLocalAdtUrl({ client, ...target }).catch(error => ({ url: '', reason: error.message, failed: true }));
+  const detect = async target => {
+    const started = Date.now();
+    // MCP output channels cannot animate, so a long scan reports that it is still running.
+    const heartbeat = setInterval(() => log(`port scan still running on ${new URL(target.url).hostname} (${Math.round((Date.now() - started) / 1000)} s)`), 20_000);
+    try { return await detectLocalAdtUrl({ client, ...target }); }
+    catch (error) { return { url: '', reason: error.message, failed: true }; }
+    finally { clearInterval(heartbeat); }
+  };
   const explicit = hasExplicitPort(configured);
   let verdict = { url: '', reason: '' };
   if (explicit) {

package/src/local-sap-gui.mjs

@@ -461,8 +461,10 @@ export function adtVerdict(result, protocol = 'https:') {
 }
 
 // A portless URL means 443, which on-premise ICMs rarely serve; VSP's `detect`
-// probes the conventional ADT ports and reports which one answers.
-export async function detectAdtUrl(binary, { url, client, instance, env = process.env, exhaustive = false, ports = [], timeoutMs = 180_000 } = {}) {
+// probes the conventional ADT ports and reports which one answers. A host that
+// accepts every port makes each probe wait out its HTTP timeouts, so the full
+// sweep gets minutes.
+export async function detectAdtUrl(binary, { url, client, instance, env = process.env, exhaustive = false, ports = [], timeoutMs = exhaustive ? 600_000 : 120_000 } = {}) {
   let configured;
   try { configured = new URL(url); } catch { return { url: '', reason: `${url} is not a valid URL` }; }
   const host = configured.hostname.replace(/^\[(.*)\]$/, '$1');

package/src/setup.mjs

@@ -141,30 +141,42 @@ export function adtCandidate(answer, baseUrl) {
 // Cheapest evidence first: named ports get one probe, then the host's usual
 // ports, then the message server's application servers, then every port.
 async function findAdtUrl(destination, label, client, { candidates = [], scan = true, output = stdout, env = process.env, detectAdtUrl } = {}) {
-  const detect = async (message, target) => {
-    print(output, formatStatus(message, 'progress', output, 'ADT'));
-    const stopProgress = startProgress(message, { output, env, label: 'ADT' });
+  const detect = async (line, activity, target) => {
+    print(output, formatStatus(line, 'progress', output, 'ADT'));
+    const started = Date.now();
+    const progress = startProgress(activity, { output, env, label: 'ADT' });
+    // A short, ticking spinner: a long line would truncate the animation away and look frozen.
+    const ticker = setInterval(() => progress.update(`${activity} (${Math.round((Date.now() - started) / 1000)} s)`), 1000);
     try { return await detectAdtUrl({ client, ...target }); }
     catch (error) { return { url: '', reason: error.message }; }
-    finally { stopProgress(); }
+    finally {
+      clearInterval(ticker);
+      progress();
+    }
   };
   let verdict = { url: '', reason: `no port was checked for ${label}` };
   for (const candidate of [...new Set([destination.url, ...candidates].filter(url => url && hasExplicitPort(url)))]) {
-    verdict = await detect(`Checking ADT at ${candidate}`, { url: candidate, ports: [adtPort(candidate)] });
+    verdict = await detect(`Checking ADT at ${candidate}`, `Checking ${candidate}`, { url: candidate, ports: [adtPort(candidate)] });
     if (verdict.url || verdict.unresolved) return verdict;
   }
   if (!scan) return verdict;
   const host = new URL(destination.url).hostname;
-  verdict = await detect(`Port scan in progress on ${host} to find the ADT port for ${label}`, { url: destination.url, ...(destination.instance ? { instance: destination.instance } : {}) });
+  verdict = await detect(`Port scan in progress on ${host} to find the ADT port for ${label}`, `Scanning the usual ADT ports on ${host}`, { url: destination.url, ...(destination.instance ? { instance: destination.instance } : {}) });
   if (verdict.url || verdict.unresolved) return verdict;
   if (destination.messageServer) {
-    print(output, formatStatus(`Asking the message server ${destination.messageServer.host}:${destination.messageServer.httpPort} for the application servers of ${label}`, 'progress', output, 'ADT'));
-    for (const server of (await messageServerAppServers({ ...destination.messageServer, systemId: destination.systemId })).slice(0, 3)) {
-      const found = await detect(`Port scan in progress on application server ${server.host} (instance ${server.instance})`, { url: `${new URL(destination.url).protocol}//${server.host}`, instance: server.instance });
+    const { host: messageHost, httpPort } = destination.messageServer;
+    print(output, formatStatus(`Asking the message server ${messageHost}:${httpPort} for the application servers of ${label}`, 'progress', output, 'ADT'));
+    const servers = (await messageServerAppServers({ ...destination.messageServer, systemId: destination.systemId })).slice(0, 3);
+    print(output, formatStatus(servers.length
+      ? `The message server lists ${servers.map(server => `${server.host} (instance ${server.instance})`).join(', ')}.`
+      : `The message server at ${messageHost}:${httpPort} listed no application servers.`, 'info', output, 'ADT'));
+    for (const server of servers) {
+      const found = await detect(`Port scan in progress on application server ${server.host} (instance ${server.instance})`, `Scanning ${server.host}`, { url: `${new URL(destination.url).protocol}//${server.host}`, instance: server.instance });
       if (found.url) return found;
     }
   }
-  return detect(`No ADT port on the usual ports for ${label} (${verdict.reason}); port scan in progress on every conventional SAP port of ${host} (this can take a minute)`, { url: destination.url, exhaustive: true });
+  print(output, formatStatus(`No ADT port on the usual ports for ${label}: ${verdict.reason}.`, 'info', output, 'ADT'));
+  return detect(`Scanning the remaining conventional SAP ports on ${host} (about 300 ports; this can take a few minutes)`, `Scanning the remaining SAP ports on ${host}`, { url: destination.url, exhaustive: true });
 }
 
 // An SSO sign-in can only start where ADT answers, so for SSO setup does not